We priced out every major scraping API at four volume tiers—1K, 10K, 100K, and 1M requests per month—with real numbers from ScraperAPI, SerpApi, Apify, ScrapingBee, DataForSEO, Bright Data, and the new x402 micropayment model. The answer depends on your volume, your use case, and whether your scraper is a human or an AI agent.
7
Providers Compared
4
Volume Tiers
3
Pricing Models
Yes
Break-Even Analysis
The scraping API market in 2026 is a $2.4 billion industry with a confusing pricing problem. Some providers charge monthly subscriptions with credit-based systems where a single request can burn anywhere from 1 to 75 credits. Others charge per task with no monthly commitment. And now, a third model has emerged: per-request micropayments using the x402 protocol and USDC stablecoins, where you literally pay fractions of a cent per API call without an account, credit card, or subscription.
This article breaks down the real cost of each model at every volume tier. We will compare the actual dollars-per-thousand-requests you will pay, not the headline credit counts that providers use to obscure effective pricing. We will show you the break-even points where subscriptions beat pay-per-use, and explain why AI agents are making the entire subscription model obsolete for certain workloads.
If you are deciding between scraping API providers or evaluating whether to move from a subscription to pay-per-use (or vice versa), this is the guide you need. Every number in this article comes from publicly listed pricing pages as of February 2026.
Before comparing providers, understand the three fundamentally different ways scraping APIs charge you.
Fixed monthly fee. You receive a pool of credits. Each API request consumes 1 to 75 credits depending on features (JavaScript rendering, geo-targeting, premium proxies). Unused credits expire at month-end.
Examples: ScraperAPI, SerpApi, Apify, ScrapingBee
No monthly fee. You deposit funds and pay per task or per record. Price varies by task complexity. Balance carries over indefinitely (with some providers). Still requires an account and deposit.
Examples: DataForSEO, Bright Data Datasets
No account. No deposit. No credit card. Your script pays per-request using USDC stablecoins via the x402 protocol. Settlement in 400ms on Solana. Network fees under $0.001.
Examples: Proxies.sx x402, Firecrawl x402
The subscription model dominates the scraping API market. Here is what each major provider actually costs after credit multipliers.
Plans
$49 / $149 / $299 / $475
Included
100K-5M credits/mo
Credit Cost
JS render = 5 credits; geo = 10-25 credits
Effective Per 1K Requests
$0.49-$0.10
Annual Minimum
$588
Overage
Must upgrade plan
Credits expire monthly. JS rendering unavailable on lower tiers.
Plans
$75 / $200 / $500 / $2,500
Included
5K-100K searches/mo
Credit Cost
1 search = 1 credit
Effective Per 1K Requests
$15.00-$2.50
Annual Minimum
$900
Overage
$7.50/1K on-demand
Searches do not roll over. SERP-specific, not general scraping.
Plans
$39 / $199 / $999
Included
Platform credits for compute
Credit Cost
Varies by actor complexity
Effective Per 1K Requests
$0.39-$2.00+
Annual Minimum
$468
Overage
Overage billed per compute-unit
Cost unpredictable; depends on actor RAM, runtime, and proxy usage.
Plans
$49 / $99 / $249 / $599
Included
250K-8M credits/mo
Credit Cost
JS render = 5 credits; premium proxy = 10-75 credits
Effective Per 1K Requests
$0.20-$0.07
Annual Minimum
$588
Overage
Must upgrade plan
Geo-targeting and JS only on Business ($249+). Credit multipliers hide true cost.
Credit multipliers are the most misunderstood aspect of subscription scraping APIs. ScraperAPI's Hobby plan advertises 100,000 credits for $49/month. But if you use JavaScript rendering (required for most modern websites), each request costs 5 credits. That means your “100,000 credits” only covers 20,000 actual JS-rendered requests, making the effective cost $2.45 per 1,000 requests—not $0.49. Add geo-targeting (10+ credits) and you are down to 10,000 requests or less. Always ask: how many real requests does this plan cover for my use case?
No monthly commitments. You pay for exactly what you consume. Here is what the leading pay-per-use providers charge.
Price Per Unit
$0.0006-$0.01/task
Minimum
$50 deposit
Credit Expiry
Credits never expire
Effective Per 1K
$0.60-$10.00
Best for: SEO data, SERP results
No monthly commitment. Volume discounts at scale.
Price Per Unit
$2.50/1K records
Minimum
$250/mo minimum
Credit Expiry
Monthly commitment
Effective Per 1K
$2.50+
Best for: Structured datasets, marketplace data
Up to 80% volume discounts on annual plans. Deep Lookup: $0.05/column/record.
Price Per Unit
$0.003-$0.01/request
Minimum
None (any amount of USDC)
Credit Expiry
Never expires
Effective Per 1K
$3.00-$10.00
Best for: AI agents, autonomous scraping, no-account access
No signup. Pay with USDC on Solana (400ms) or Base (2s). Zero minimums.
Traditional payment processors charge a minimum of approximately $0.30 per transaction (Stripe's fee structure: 2.9% + $0.30). This means a $0.003 scraping request would cost 100 times more in processing fees than the service itself. This is exactly why subscription models exist—they batch thousands of tiny transactions into a single monthly charge to amortize the payment processing overhead.
Crypto micropayments on Solana cost roughly $0.0002 in network fees per transaction, making true per-request billing economically viable. The x402 protocol leverages this with instant settlement (400ms on Solana, 2 seconds on Base) and zero chargebacks. For the first time, a scraping API can charge $0.003 per request and still receive $0.003—not $0.003 minus $0.30 in fees.
Here is what you would actually pay each provider at four different monthly volumes. All figures assume standard scraping requests (not JS-rendered; multiply subscription costs by 5x for JS rendering).
| Provider | Monthly Cost | Effective / 1K req | Notes |
|---|---|---|---|
| ScraperAPI | $49 | $49.00/1K | Locked to $49 minimum plan |
| SerpApi | $75 | $75.00/1K | Locked to $75 minimum plan |
| Apify | $39 | $39.00/1K | Starter plan minimum |
| DataForSEOCHEAPEST | $0.60 | $0.60/1K | Pay only for what you use |
| Proxies.sx x402 | $3-$10 | $3-10/1K | No minimum, no waste |
| Provider | Monthly Cost | Effective / 1K req | Notes |
|---|---|---|---|
| ScraperAPI | $49 | $4.90/1K | Still on Hobby plan (100K credits) |
| SerpApi | $200 | $20.00/1K | Need Pro plan (15K searches) |
| Apify | $39-$60 | $3.90-6.00/1K | Depends on compute |
| DataForSEOCHEAPEST | $6-$100 | $0.60-10.00/1K | Scales linearly with usage |
| Proxies.sx x402 | $30-$100 | $3-10/1K | Zero waste, zero lock-in |
| Provider | Monthly Cost | Effective / 1K req | Notes |
|---|---|---|---|
| ScraperAPICHEAPEST | $149 | $1.49/1K | Startup plan = 1M credits |
| SerpApi | $500+ | $5.00/1K | Business or higher |
| Apify | $199 | $1.99/1K | Scale plan covers this |
| DataForSEO | $60-$1,000 | $0.60-10.00/1K | Depends on task type |
| Proxies.sx x402 | $300-$1,000 | $3-10/1K | Higher per-req but zero overhead |
| Provider | Monthly Cost | Effective / 1K req | Notes |
|---|---|---|---|
| ScraperAPICHEAPEST | $475 | $0.48/1K | Scaling plan = 5M credits (JS uses 5x) |
| SerpApi | $3,750+ | $3.75/1K | Enterprise minimum |
| Apify | $999+ | $1.00/1K | Business plan + overage |
| DataForSEO | $600-$10,000 | $0.60-10.00/1K | Volume discounts available |
| Proxies.sx x402 | $3,000-$10,000 | $3-10/1K | Best for agent autonomy, not raw volume |
Pay-per-use (DataForSEO) wins decisively. Subscription minimums of $39-$75/month mean you are overpaying by 5x to 75x at low volumes. x402 is competitive and has the advantage of zero minimums.
Subscription plans (ScraperAPI, ScrapingBee) pull ahead due to volume discounts. At 1M requests, ScraperAPI's effective cost drops to $0.48/1K—hard to beat with any pay-per-use model.
Pay-per-use or x402 micropayments. You never waste money on unused credits, and you do not get throttled mid-month when your subscription runs out.
x402 is the only model where an agent can autonomously discover, pay for, and consume an API without human-provisioned credentials. The per-request premium is the price of full autonomy.
The exact point where a subscription becomes cheaper than pay-per-use depends on the providers and task types you are comparing.
| Comparison | Break-Even Point | Below Break-Even | Above Break-Even |
|---|---|---|---|
| ScraperAPI vs DataForSEO | ~82K req/mo | DataForSEO wins | ScraperAPI wins |
| ScrapingBee vs DataForSEO | ~70K req/mo | DataForSEO wins | ScrapingBee wins |
| ScraperAPI vs x402 | ~16K req/mo | x402 wins | ScraperAPI wins |
At $0.003/request (x402 low end) vs ScraperAPI Hobby ($49/mo for 100K credits at 1 credit/request), break-even is approximately 16,333 requests. Below that, x402 is cheaper. Above that, the subscription discount kicks in.
| Comparison | Break-Even Point | Below Break-Even | Above Break-Even |
|---|---|---|---|
| ScraperAPI (JS) vs DataForSEO | ~16K req/mo | DataForSEO wins | ScraperAPI wins |
| ScraperAPI (JS) vs x402 | ~3,300 req/mo | x402 wins | ScraperAPI wins |
With JS rendering, ScraperAPI's 100K credits become only 20K actual requests ($49/20K = $2.45/1K). The break-even against x402 at $0.01/request drops dramatically to around 3,300 requests per month. At 5x multipliers, the subscription advantage evaporates for most teams.
Break-even calculations assume you use 100% of your subscription credits every month. In reality, most teams use 60-80% of their allotted credits. If you use 70% of a $149/month ScraperAPI plan, your effective cost increases by 43%—from $0.15/1K to $0.21/1K. Pay-per-use models have zero waste by definition. For teams with variable monthly scraping volumes (seasonal e-commerce monitoring, campaign-based data collection, or experimental research), the waste factor alone can make pay-per-use cheaper even above the theoretical break-even point.
For autonomous AI agents, the pricing model is not just about cost—it is about capability. Subscriptions create dependencies that agents cannot manage alone.
Instant Settlement
400ms on Solana, 2s on Base. No 30-day net terms, no invoice delays. The provider receives funds before the HTTP response returns.
Zero Chargebacks
On-chain payments are irreversible. No fraud disputes, no chargeback fees. API providers can offer lower prices because they eliminate payment risk.
Global Access
USDC works in every country. No credit card approval, no banking restrictions, no currency conversion. Anyone with a wallet can pay any x402 API.
The Proxies.sx x402 Service Marketplace lists scraping, proxy, and data services that AI agents can consume autonomously. Each service publishes its price in the x402 response, so an agent building a multi-step research pipeline can dynamically choose the cheapest available provider for each step without any pre-configured API keys or account setup.
See the actual implementation difference between using a subscription API key and the x402 micropayment approach.
Requires a human to sign up, choose a plan, enter a credit card, and provide the API key to the agent.
// Subscription model: Requires pre-provisioned API key
const SCRAPERAPI_KEY = process.env.SCRAPERAPI_KEY; // Human must set up
async function scrapeWithSubscription(url: string) {
// Check remaining credits (another API call)
const usage = await fetch(
`https://api.scraperapi.com/account?api_key=${SCRAPERAPI_KEY}`
);
const { requestCount, requestLimit } = await usage.json();
if (requestCount >= requestLimit) {
throw new Error("Monthly credit limit reached. Must upgrade plan.");
}
// Make the scraping request
const res = await fetch(
`https://api.scraperapi.com?api_key=${SCRAPERAPI_KEY}&url=${encodeURIComponent(url)}`
);
if (res.status === 403) {
throw new Error("API key invalid or expired");
}
return await res.text();
}
// Problems:
// - Agent cannot create its own account
// - Credit limit = hard stop mid-pipeline
// - Key rotation = human intervention
// - Monthly bill regardless of usageAgent needs only a USDC wallet. Discovers price at runtime. Pays autonomously. No human in the loop.
import { Connection, Keypair, Transaction } from "@solana/web3.js";
import { getAssociatedTokenAddress, createTransferInstruction } from "@solana/spl-token";
const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
const SOLANA_RPC = "https://api.mainnet-beta.solana.com";
async function scrapeWithX402(targetUrl: string) {
// Step 1: Request scrape — no API key needed
const res = await fetch("https://api.proxies.sx/v1/x402/scrape", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ url: targetUrl, render_js: true }),
});
if (res.status === 402) {
// Step 2: Server tells us the price
const terms = await res.json();
console.log(`Price: ${terms.amount} ${terms.currency} on ${terms.network}`);
// => "Price: 0.005 USDC on solana"
// Step 3: Agent pays autonomously
const wallet = Keypair.fromSecretKey(
Buffer.from(process.env.AGENT_WALLET_KEY!, "base64")
);
const connection = new Connection(SOLANA_RPC);
const txHash = await payUSDC(
connection, wallet, terms.address, terms.amount
);
// Step 4: Retry with payment proof
const paidRes = await fetch("https://api.proxies.sx/v1/x402/scrape", {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-PAYMENT-PROOF": txHash,
"X-PAYMENT-NETWORK": "solana",
},
body: JSON.stringify({ url: targetUrl, render_js: true }),
});
return await paidRes.json(); // Scraped data
}
return await res.json();
}
// Advantages:
// - Zero account setup; wallet IS identity
// - Agent discovers price at runtime
// - No credit limits; pays per request
// - Works across ANY x402-enabled provider
// - 400ms payment settlement on SolanaWith the subscription model, the human is the bottleneck: creating accounts, managing API keys, monitoring credits, and upgrading plans. With x402, the agent handles everything: discovering prices, evaluating budget constraints, making payments, and consuming resources. This is not just a pricing difference—it is an architectural shift from human-managed credentials to agent-managed wallets. For teams building autonomous agent pipelines, this eliminates an entire class of operational overhead.
Use this framework to determine which pricing model fits your specific situation.
If YES:
Subscription
Volume discounts make subscriptions 3-10x cheaper at scale. ScraperAPI at $0.48/1K (1M tier) is hard to beat.
If NO:
Pay-Per-Use or x402
Variable volumes mean wasted credits with subscriptions. Pay only for what you use.
If YES:
Depends on Volume
JS rendering uses 5x credits on subscriptions, eroding the volume discount. Compare effective JS-rendered cost, not headline credits.
If NO:
Subscription at scale
Simple HTTP scraping gets maximum value from credit-based plans where 1 request = 1 credit.
If YES:
x402 Micropayments
Agents cannot create accounts or manage API keys. x402 lets them pay autonomously with their own wallets.
If NO:
Subscription or Pay-Per-Use
Humans can manage accounts, so choose based on volume and cost.
If YES:
Pay-Per-Use
Subscriptions charge every month regardless. DataForSEO deposits never expire. x402 has zero idle cost.
If NO:
Subscription
Consistent usage maximizes the value of monthly credit allotments.
If YES:
x402 Micropayments
USDC wallets work globally without credit cards or bank accounts. No geographic restrictions.
If NO:
Any model works
Standard payment infrastructure is available; choose based on cost.
Solo Developer / Hobbyist
DataForSEO or x402
Under 10K requests. Pay-per-use avoids wasting $39+/month minimums.
Scraping Team / Startup
ScraperAPI or ScrapingBee
100K+ predictable requests. Subscription volume discounts win at scale.
AI Agent Pipeline
Proxies.sx x402
Autonomous access, no credentials, per-request payment from agent wallet.
Most sophisticated scraping operations in 2026 do not choose exclusively. They combine models strategically.
Subscription base layer
Use ScraperAPI ($149/mo) or ScrapingBee ($249/mo) for your predictable, high-volume workloads. This covers 80% of your monthly scraping at the lowest per-request cost.
Pay-per-use overflow
Use DataForSEO for specialized SEO data tasks and as overflow when your subscription credits run out mid-month. No waste, no forced plan upgrade.
x402 for agent workloads
Use Proxies.sx x402 for AI agent pipelines, experimental crawls, and any workload where autonomous payment is needed. Browse the x402 service marketplace for available services.
This hybrid approach gives you the volume discount of subscriptions for your core operations, the flexibility of pay-per-use for variable workloads, and the agent-native capabilities of x402 for autonomous systems. Most teams find that this combination reduces their total scraping costs by 20-35% compared to using a single model exclusively, because they stop overpaying for unused subscription credits and stop under-utilizing pay-per-use volume discounts.
Proxies.sx offers both traditional bandwidth pricing and x402 micropayments. Start with our free trial or pay per request with USDC—no account required.
PROXIES.SX Team
Building AI-native proxy infrastructure