Web Scraping API Cost: Credits, Requests and Usable Results

A web scraping API price is useful only when you know what its unit buys. One HTTP request, one submitted task, one credit and one usable result are different quantities. Budget for the data your application can accept, while keeping the money you actually spend visible.

This guide explains the MIYAIP asynchronous crawler workflow and the current Browser/MCP task-start guidance. All dollar amounts and success counts in the worked examples are hypothetical, not current package prices or measured performance. No refund is assumed.

1. Count the right unit

For example, one Invoke followed by five TaskResult queries produces six HTTP requests, but only one task creation. Do not multiply the per-task estimate by six. The current crawler contract does not publish a separate polling tariff; it also does not justify a blanket claim that every HTTP call is free. Read the task charge and your account records.

2. Estimate credits, then inspect the returned charge

The interface definition exposes CreditCostBase, CreditCostParam and CreditCostMultiplier. Where a variable parameter and multiplier are configured, the console estimate is base + parameter value × multiplier. Otherwise it uses the base. This is multiplication, not base + 1 / parameter.

estimatedCredits = CreditCostBase + Params[CreditCostParam] * CreditCostMultiplier
Example only: base 1 + parameter value 3 * multiplier 1 = 4 credits

Use the current ParamSchema to choose the actual parameter name and permitted value. Do not assume all interfaces share a page-count parameter or cost the same. After submission and completion, inspect costCredits. CallLogPage also exposes requestJson, resultJson, status, errorMessage, totalCostMs and refunded.

The refunded boolean records a status; it is not a published promise that every failed or timed-out task is refunded. Only subtract a refund after its amount and accounting effect have been confirmed. Task retention, refund timing and automatic retry charging are not fully specified by this frontend contract.

Read the authentication, parameter and task-result reference →

3. Separate allocated cost from cash outlay

For one fully priced package, allocated cost assigns part of the package price to the credits consumed. Cash outlay is the amount paid to obtain the package, including allowance you have not used. These answer different questions: what did this workload consume, and how much money did I have to spend?

allocatedCost = packagePrice * netCreditsConsumed / purchasedCredits
allocatedCostPerUsableResult = allocatedCost / usableResults
cashCostPerUsableResult = actualCashOutlay / usableResults

Use these formulas only with a positive purchased-credit count. When usableResults is zero, per-result cost is undefined, not zero. Report the spend and the fact that no usable data was produced. If you buy multiple packages, use the actual purchases and an explicit allocation method; do not silently apply one package’s rate to all consumption.

4. Worked example: the unused package matters

Assume a hypothetical $100 package with 10,000 credits. You submit 2,000 tasks at two credits each. Of those, 1,800 report success and 1,600 pass your content checks. In this example one accepted task equals one usable result. This is an assumed dataset, not a service benchmark.

The $0.025 allocation is not the amount you needed to pay to start this workload. You paid $100. If you stop using the package now, cash cost remains $0.0625 per accepted result. Future use may improve utilization, but it should not be counted as completed work today.

5. Change one assumption at a time

Lower acceptance rates increase both costs per useful result. Higher credit use raises allocated cost, but cash outlay may remain unchanged while an existing package covers the workload. Once it no longer fits, calculate the additional purchase rather than extending the old cash figure.

6. Retries, concurrency and cleanup are separate costs

Query an existing task after a local waiting timeout instead of immediately calling Invoke again. A timeout does not prove that creation failed or cancel work on the server. Record each submitted task ID to avoid duplicate jobs, duplicate charges and duplicate data. Limit any deliberate retry policy and measure what it adds.

Concurrency describes how many tasks may run simultaneously; it is not a discount or a guaranteed throughput rate. Task duration, target behavior and parameter choices affect elapsed time. Keep totalCostMs for diagnostics, and do not convert a concurrency limit into a promised number of pages per minute.

Credits also omit your application’s storage, validation, deduplication and maintenance costs. A cheaper response that requires substantial cleanup can cost more than useful structured output. Accept a result only after checking required fields, freshness, duplicate identifiers and whether it is an error page.

7. Browser/MCP counts task starts

Current MIYAIP Browser/MCP guidance says a successful browser_start_task or browser_run_test start uses one crawler call. Observe, click, type, extract, screenshot and takeover operations within that task do not add calls. Each running task occupies one concurrency slot. This task-start model must not be substituted for the Crawler API’s interface-and-parameter estimate.

An AI client can create more than one browser task while completing a broader user request. Count actual task starts, not natural-language prompts or individual clicks. Use the dedicated MCP key for MCP; the REST crawler examples use a console login token.

See Browser/MCP capabilities and setup →

8. Reproduce the calculation

This standard-library Python example covers a single package and returns None for per-result cost when no results are usable. It rejects invalid or overspent package inputs so a missing purchase is not silently hidden.

import math

def costs(price, purchased, consumed, usable):
    values = (price, purchased, consumed, usable)
    if not all(math.isfinite(v) for v in values):
        raise ValueError("Use finite numbers")
    if price < 0 or purchased <= 0 or consumed < 0 or consumed > purchased or usable < 0:
        raise ValueError("Invalid package or result count")
    allocated = price * consumed / purchased
    return {
        "allocated": allocated,
        "allocated_per_result": allocated / usable if usable else None,
        "cash_per_result": price / usable if usable else None,
    }

# Hypothetical single-package example, no assumed refunds.
print(costs(100, 10000, 4000, 1600))
# allocated=40, allocated_per_result=0.025, cash_per_result=0.0625

9. Choose a package using your own sample

Run a small, permitted target sample with the actual parameters you need. Record task IDs, credits, statuses, accepted results, elapsed times and confirmed refunds. Estimate the full workload from that sample, then compare both package outlay and allocated cost. Reserve budget for uncertainty without inventing a universal success rate.

Current Crawler API packages →

Crawler API capabilities and output →

Compare scraping API, proxy and Browser/MCP approaches →

Sources

The MIYAIP-specific field names and lifecycle here follow the current crawler and MCP page implementation reviewed on 2026-09-05. Pricing is linked rather than copied as a live quote. The numbers above are explicit assumptions; no production crawl benchmark or refund guarantee is claimed.

Public API documentation: definitions, responses and error handling →