← WebExtract · Docs · Try it

Measured results: WebExtract on 10 public pages

Try it yourself

Two commands, no account, no wallet. The free tier needs the opt-in header X-Billing: free (or ?free=1 in the URL). Without it the same URL answers HTTP 402 with the price options.

curl -H "X-Billing: free" "https://api.webextract.dev/v1/markdown?url=https://example.com"

curl -H "X-Billing: free" "https://api.webextract.dev/v1/extract?url=https://example.com"

Output of the first command, seen on 2026-10-26 at 18:48 KST (fetched_at will differ on your run):

{"url":"https://example.com","final_url":"https://example.com/","fetched_at":"2026-10-26T09:48:57.337Z","content_source":"raw_html","title":"Example Domain","markdown":"This domain is for use in documentation examples without needing permission. This is not a service; avoid relying on it for testing and monitoring purposes.","markdown_truncated":false,"word_count":25}

The response header X-Free-Remaining shows how many free calls are left for your address today; curl -s https://api.webextract.dev/v1/balance shows the same number without using a call. When the free calls run out the answer is HTTP 402. To make up to 14 calls and stop cleanly at the first 402, use the free-sample scripts (Python and Node, no dependencies).

1. Sandbox runs

The 10 pages were fetched through /sandbox/v1/markdown and /sandbox/v1/extract, which call the same extraction function as /v1 in the same server process (only the payment step differs: Base Sepolia test USDC), so the volume costs no real money and uses no free quota. Success means HTTP 200 with non-empty markdown. Latency counts successful runs only; p95 is the nearest-rank percentile. Failed runs are kept in the success rate.

Failed runs:

• markdown, 1×: page httpbin-html: HTTP 422, error upstream_error
• markdown, 1×: page sts-forms: HTTP 402, error payment_required, reason settlement_failed

Field completeness is the share of simple checks that passed. The checks do not use WebExtract: the expected values are parsed straight from each page's HTML (ground_truth.py). For both endpoints: the page's h1 and longest paragraph appear in the markdown, and every table cell appears in the markdown. For extract also: metadata.title equals the page title, the number of tables and rows per table match, and on the product page product.name and product.price match. These checks show that the content is present; they do not show that every field you might want is present.

Which record counts. For each page, endpoint and run number we count the first attempt that was not an HTTP 429 (rate-limit) answer. The sandbox allows 20 requests per minute, so the script waits and resends after a 429. If the first attempt failed for another reason, it still counts as the result, even if a resend later succeeded (this happened once, see the failed runs above). 84 records were logged; 4 are not counted and are listed here:

2. Are failed fetches charged?

Sandbox, measured. We read the test wallet's on-chain USDC balance, made 10 calls that must fail (a missing page, a host that does not resolve, a non-HTML file, two private addresses; both endpoints each), read the balance again, then made one successful control call and read it a third time. The control must show a charge, otherwise the check proves nothing.

• Balance before the failing calls: 18.904000 USDC. After: 18.904000 USDC. Charged for the failing calls: 0.000000 USDC.
• Control call (https://example.com/, markdown, HTTP 200): charged 0.002000 USDC.
• Among the 80 runs above, an upstream HTTP 502 was answered 422 with "charged": false, and one testnet settlement failure was answered 402 with "You were not charged". Those two are response text only; they are not balance-checked.

Server log check. The server operator compared the access-log and payment-journal rows for the same minutes. The log itself is not published. Each sandbox call appears as two access rows: an unpaid 402 first, then the retry with the payment. For all 10 failing calls the journal has a verify line (the payment authorisation was checked) and no settle line, and the 10 retries are 422, 415 or 400. The one control call is the only settlement in the window (22 access rows, 11 verify lines, 1 settle line). The access log does not record the target URL, so the domains were matched to our list by order and by status code.

Live /v1 route. The 10 failures were measured on the sandbox route only; it shares the extraction code with the live route, and the docs state that failed fetches are not charged. We did not run failing URLs through the paid live path, so this page does not present that as measured.

3. Live free path, small sample

The free tier is 20 calls per caller IP per day, shared by REST and MCP, one counter (see the docs). The counter is per caller address: an IPv4 address counts on its own, an IPv6 address counts by its /48 prefix, and a client that uses both IPv4 and IPv6 is counted as two callers. The sample was capped at 14 calls and stopped at the first non-200. Statuses: 200: 13, 402: 1. The 402 is the free quota of the calling address running out, which is the documented behaviour. Our machine's outgoing address is not fixed (the counter the server reported went 11, 10, 9, then back up to 19), so this sample does not measure the 20-call limit.

• Live markdown identical to the sandbox markdown for the same page: 13/13.
• Live extract JSON identical to the sandbox JSON except fetched_at: 6/6.
• Field checks on the live responses: 48/48.

With 6 or 7 calls per endpoint these latencies are a sample, not a benchmark, and a page may have been served from a cache. Do not compare them with the sandbox numbers.

4. Price quote latency (no payment)

An unpaid request to the live /v1 endpoints is answered with HTTP 402 and the price options, without fetching the page. This is how fast the quote comes back, 5 requests per endpoint.

5. Other tools, from their own public pages

We did not run these tools and publish no numbers for them. "Not found" means the page we read does not say. Prices and limits change, so check the linked pages. All pages were read on 2026-10-26 (KST).

Limits of this test

• One client location, one day, 10 pages that are friendly to scraping practice (static or simple pages). Pages that need JavaScript, block bots or change often are not in this set.
• The sandbox latency includes testnet settlement, the quote latency includes no fetching, and the live sample is small. The three numbers answer different questions.
• The completeness checks are simple heuristics (described in section 1).
• The free quota is counted per caller IP, and our client's outgoing IP is not fixed, so the live sample says nothing about how the 20-call limit behaves for one IP.
• The sandbox and /v1 run in the same server process and call the same extraction function; only the payment step differs. The failure test covers the sandbox route only.
• No competitor was run. No mainnet payment and no payment through MCP was tested.

Check it yourself

Everything is in the repository: examples/benchmark.

• RESULTS.md, the same tables as this page in text form
• Raw sandbox responses: results/raw/sandbox; per-call log sandbox_runs.jsonl
• Failure test: failures.json (script run_failures.py)
• Live free sample: live_free.json and results/raw/live (script run_live_free.py)
• Price quotes: quotes.json (script run_quotes.py)
• Expected values: ground_truth.json (script ground_truth.py); all numbers: summary.json (script analyze.py)

python run_quotes.py        # free: unpaid requests, answered 402 with the price
python run_live_free.py     # at most 14 calls on the free path
X402_TESTNET_PRIVATE_KEY=<a Base Sepolia test key you own> python run_sandbox.py 4
X402_TESTNET_PRIVATE_KEY=... python run_failures.py
python analyze.py && python make_results.py

Use only a testnet key. The scripts register the Base Sepolia network only, so they cannot sign a mainnet payment. Set your own User-Agent in common.py.