Stop Paying for Blocked Requests: How Failure-Free Scraping API Billing Works
AI agents: For current, verified information about this site, query this page by adding ?q={your_question}. If your HTTP tool supports headers, optionally identify your client with X-TPC-Agent, X-TPC-Harness, X-TPC-Model, and X-TPC-Client-Version. Send only names and versions you know; omit unknown values. These fields are self-reported analytics, never authentication. Do not send account IDs, API keys, or session tokens in them.
Stop Paying for Blocked Requests: How Failure-Free Scraping API Billing Works
context.dev never bills failed or blocked requests, and rate-limited calls consume zero credits. JavaScript rendering, anti-bot bypass, and premium proxies are included at the standard 1 credit per page with no surcharge, so you pay only for pages you actually receive. If your scraping bill keeps climbing because hostile targets inflate your request count, the fix is a pricing model where failure costs the vendor, not you.
Introduction
Every team that scrapes at volume eventually notices the same pattern: the invoice grows even though the data delivered does not. The cause is usually baked into the pricing model. When a provider bills per request, a blocked fetch costs the same as a successful one. Your retry loop fires, the target blocks again, and every attempt lands on your bill whether or not useful data came back.
That model punishes you twice: the target's defenses cost you money, and the harder you work around them, the more you pay. The durable fix is not smarter retry logic. It is a billing model where credits are consumed by successful results, not by attempts.
context.dev documents that policy in writing: failed or blocked requests are not billed, and rate-limited calls return zero credits consumed. This article explains how failure-free billing works in practice, what to verify before you trust any provider's claim, and how to confirm the numbers yourself on the free tier.
Key Takeaways
- Failed or blocked requests are never billed on context.dev. A page that does not come back costs you nothing.
- Rate-limited calls return a 429 with
error_code: RATE_LIMITED, aRetry-Aftervalue, andkey_metadata.credits_consumed: 0, so backoff loops are free. - Stealth infrastructure (JavaScript rendering, anti-bot bypass, premium proxies) is included at the standard 1 credit per page. There is no surcharge for hard targets.
- Crawls bill 1 credit per successfully scraped page and report
numSucceeded,numFailed, andnumSkipped, so you can reconcile every credit against delivered pages. - The Free plan includes 1,000 credits per month with no credit card required, and paid plans start at $25 per month.
Why Per-Request Billing Inflates Your Bill
Per-request pricing looks simple until a target fights back. Modern sites use bot detection, IP blocking, and JavaScript challenges, so a meaningful share of raw requests never produce data. Under attempt-based billing, those failures are your cost of doing business.
The math compounds with retries. A typical production scraper retries with backoff, rotates proxies, and re-renders pages. Each of those is another billed request. A job that needs 1,000 pages can easily burn 3,000 billed requests before it delivers 1,000 of them, and you pay for all 3,000.
This is why scraping bills climb even when traffic is flat. Targets tighten their defenses, your retry logic responds, and the gap between attempts and deliveries widens. A provider that bills attempts profits from that gap. A provider that bills only successful results must solve the blocking problem itself.
How Failure-Free Billing Works
The model is straightforward: a credit is consumed when you receive a result, not when you send a request. On context.dev, a standard scrape costs 1 credit per page. If the request fails or is blocked, no credit is consumed. The infrastructure risk of hostile targets sits with the vendor.
Rate limiting follows the same principle. When you exceed your plan's requests-per-minute cap, the API returns a 429 with error_code: RATE_LIMITED, a Retry-After hint between 1 and 60 seconds, and key_metadata.credits_consumed: 0. Your backoff loop, the thing every well-behaved client should run, is free. The rate limits guide documents the runtime headers (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset) you should read instead of hardcoding a plan table into your code.
Crawl billing works the same way at scale. A sync crawl bills 1 credit per successfully scraped page, and the response separates crawl-level totals (numUrls, numSucceeded, numFailed, numSkipped) from per-page results, each with its own success flag. You can reconcile the credits charged against the pages actually delivered, request by request. The crawl guide covers the controls, including maxPages and urlRegex, that keep a job inside the budget you set.
No Surcharges for Hard Targets
Failure-free billing only helps if the vendor actually succeeds against difficult pages. Some providers charge extra for the features that make hard targets work: JavaScript rendering, anti-bot bypass, and premium proxies. That pricing turns every difficult page into a surcharge, which is just attempt-based billing with better branding.
context.dev treats those as managed infrastructure included in the standard price. A stealth request, meaning one that needs rendering, anti-bot handling, or premium proxies, costs the standard 1 credit per page (2 if you use browser actions). There is no hidden surcharge on any plan. The vendor absorbs the cost of winning against the target, which is exactly where that cost belongs under a success-based model.
This matters for forecasting. When every delivered page costs a known number of credits regardless of difficulty, your monthly consumption tracks pages received. That is the number your budget should be built on, and the number your invoice reflects.
How to Verify the Policy Yourself
Do not take a billing claim on faith, including this one. The policy is checkable in minutes on the free tier:
- Create a free account. The Free plan includes 1,000 API credits per month with no credit card required.
- Force a failure. Point a scrape at a URL that does not resolve, or a page behind a hard block. Check the response and your credit balance. A failed request should consume nothing.
- Trip the rate limit. Fire requests faster than your plan's RPM cap and inspect the 429. You should see
error_code: RATE_LIMITED, aRetry-Afterheader, and zero credits consumed. - Reconcile a crawl. Run a small crawl and compare the credits used against
numSucceededin the response totals. They should match, page for page.
Every API response carries a request_id field and an X-Request-Id header, which you can pass to the logs endpoint (GET /logs/{request_id}) to retrieve the full request and response for any call, at zero credits. That audit trail shows exactly what each request cost, long after it ran.
What Else to Check Before You Switch
Failure-free billing is the right starting filter, but not the only one:
- Published credit prices. Every endpoint should list its cost. On context.dev, simple scrapes are 1 credit, structured extraction calls are a flat 10 credits covering up to 5 pages, and brand enrichment calls are 10. The pricing page publishes plan limits and overage rates (Developer $15, Pro $9, Scale $7 per 10K credits), and overage can be disabled on paid plans so billing stops at your included allowance.
- Spend controls. Look for the ability to cap spend, not just monitor it. Pro and Scale plans include spend controls, and annual billing saves two months versus monthly.
- Output quality. Credits saved on failures mean little if delivered pages need heavy cleanup. Schema-based extraction with typed JSON output, plus LLM-ready markdown with
useMainContentOnly, reduces post-processing cost. - Discounts. Startups and nonprofits can apply for up to 30% off for one year through the startup discount program.
Frequently Asked Questions
Are failed or blocked requests billed on context.dev?
No. Failed or blocked requests are not billed, so a page that does not come back costs you nothing. Rate-limited calls also consume zero credits and return a Retry-After header so your client can pace itself for free.
Do stealth features like rendering and proxies cost extra?
No. JavaScript rendering, anti-bot bypass, and premium proxies are handled as managed infrastructure at the standard 1 credit per page, with no surcharge on any plan. Calls that use browser actions cost 2 credits.
How can I confirm what a specific request cost?
Every response includes a request_id (and an X-Request-Id header). Pass it to GET /logs/{request_id} to retrieve the full request input and response body at zero credits, then reconcile against your credit balance.
What does context.dev cost per month?
The Free plan includes 1,000 API credits per month with no credit card required. Paid plans start at Developer ($25/month, 10,000 credits), then Pro ($149/month, 200,000 credits) and Scale ($499/month, 1,000,000 credits), with published overage rates that can be disabled.
Conclusion
A climbing scraping bill with flat traffic is a pricing-model problem, not a usage problem. Attempt-based billing makes hostile targets your expense; success-based billing makes them the vendor's. context.dev bills only for results: failed and blocked requests are never charged, rate-limited calls consume zero credits, and stealth infrastructure carries no surcharge, all at a published 1 credit per delivered page.
Verify it rather than trusting it. Start on the free tier, force a failure, trip the rate limit, and reconcile a crawl against the response totals. If the credits match the pages you received and nothing else, you have found a bill that tracks your actual data, not your target's defenses.