ScraperAPI alternative in 2026: credits, free plan, real cost

ScraperAPI is a proxy-and-render API with a long history and a wide plan list. You send a URL, it rotates IPs, optionally renders JavaScript, and returns the page. Its buyers are teams with a parser already written who want the fetching handled, and its newer async API and DataPipeline product push it toward scheduled bulk jobs. Spider Cloud is a research lab for web data quality. It returns pages already converted to markdown or JSON, crawls sites rather than URLs, and bills bandwidth and compute instead of a credit table.

The verdict: ScraperAPI is fine at one credit a page and gets expensive fast once the page needs rendering or sits behind bot protection, because those options multiply the credit cost by 10 to 75. Spider has no multiplier, so its price for a hard page is the bytes and CPU minutes that page took. If most of your targets are plain HTML and you have a parser you like, ScraperAPI’s Hobby plan is a reasonable buy. If you scrape rendered or protected pages, or feed an LLM pipeline, Spider costs less and removes the parsing step.

Side by side

ScraperAPI’s column is from its documentation as read on September 2, 2026. Spider’s is from the pricing and plans guide.

Pricing

ScraperAPI’s plans

A note on sourcing. ScraperAPI’s pricing page did not render past its navigation on two fetches on September 2, 2026, so the monthly and annual prices below are from Thunderbit’s review updated in April 2026, cross-checked against Capterra. The Professional and Advanced tiers are confirmed by ScraperAPI’s own May 2026 release notes. Treat the dollar figures as third-party until the vendor page renders for you.

Prices as of September 2026; the vendor page is scraperapi.com/pricing. The free plan is 1,000 credits a month with 5 concurrent connections, and new accounts also get a 5,000 request trial for their first seven days. Scaling and above can buy overage “at a fixed, predictable rate” that the docs do not print. There is a seven day refund policy.

The credit table is where the plan sizes stop meaning what they appear to mean. From the docs:

Country code, session number, device type, output format, autoparse and wait-for-selector are free. Only 200 and 404 responses are charged. Note that rendering is 10 credits, not the 5 that ScrapingBee charges, so ScraperAPI’s plans shrink faster than a like-for-like credit count suggests.

At the 75 credit rate for a rendered page behind bot protection:

Those are arithmetic on ScraperAPI’s own credit table and the listed plan prices, not measurements. The free plan at that rate is about 13 pages a month, which is enough to see the response shape and not enough to test anything.

Spider’s worked example

Spider bills bandwidth at $1 per GB of content transferred, measured before transformation, and compute at $0.001 per minute of server-side processing. JavaScript rendering rolls into compute, standard proxy rotation is included, and residential and ISP pools and AI extraction are priced separately. Failed requests cost $0. Credits never expire.

The pricing guide estimates about $8 to $15 per 100,000 pages in smart mode, from $1/GB plus $0.001 per CPU minute; failed requests cost nothing. At 10,000 pages the estimate is about $0.80 to $1.00, and at 1,000,000 pages in chrome mode with markdown and metadata it is about $80 to $160.

Compare 100,000 pages that need rendering: 1,000,000 ScraperAPI credits, which is the $149 Startup plan used to the last credit, against roughly $8 to $15 on Spider, because rendering is a compute cost rather than a tenfold multiplier. For 100,000 rendered pages behind bot protection, ScraperAPI needs 7.5 million credits, which is the $975 Professional plan; Spider’s bill is the bytes and CPU minutes those pages took, and the pages that failed are free.

Teams that prefer a flat bill can use the Unlimited plan from $40 a month for two units of concurrency. Unlimited routes through a smaller flat-rate proxy pool and does not offer geo-targeting yet.

Benchmarks

ScraperAPI does not publish a success-rate methodology. Scrapeway, which runs a weekly panel of scraping APIs against fixed real targets, put ScraperAPI at a 58% success rate, a 6.3 second mean response and $3.20 per 1,000 scrapes in its August 2026 window, ranking it fifth of nine services tested. That is Scrapeway’s panel and Scrapeway’s cost model, and its plan list for ScraperAPI is older than the one above.

We have not benchmarked ScraperAPI ourselves. Our published crawl benchmark covers Firecrawl and Crawl4AI on a separate corpus, and the Spider Browser dataset (100% pass rate on 999 URLs across 254 domains, February 2026, dataset at https://github.com/spider-rs/spider-browser-dataset) is our own benchmark, not independently verified. Neither is a ScraperAPI comparison, and the earlier version of this post quoted a search-engine success figure we could not trace to a source, so it is gone.

Where ScraperAPI wins

Breadth of the plan list. Six priced tiers from $49 to $1,975 plus pay as you go overage from Scaling upward means a team can size a subscription to its volume without going to sales. Spider’s pay-as-you-go model is simpler but does not offer that kind of pre-purchased tier discount below its credit bonus thresholds.

The async API. Submit up to 50,000 URLs in a batch, get a webhook or poll a status URL, and collect results for 72 hours. Spider’s crawl endpoint covers the same-site case in one call, but for a list of unrelated URLs ScraperAPI’s batch model is well built and the per-job max_cost cap is a thoughtful touch.

Structured endpoints for the big retail and search domains. Amazon, Walmart, Google and Bing pages come back parsed as JSON with autoparse=true, and DataPipeline has been “priced exactly like the standard API” since July 2026 for scheduled runs. If those domains are most of your traffic, that is a lot of parser code you do not write.

SDK coverage. Python, Node, PHP, Ruby and Java. Spider has Python, JavaScript and Rust.

Where Spider wins

Data quality first. Spider returns markdown, text or JSON from the request itself, converted before it reaches you, with navigation and scripts already stripped. ScraperAPI added output_format=markdown and text, which narrows the gap for single pages, and its HTML default still means most integrations carry a parsing and cleaning step.

Sites, not URLs. Spider’s crawl endpoint takes a start URL and a limit and returns every page it finds. ScraperAPI needs a URL list, which means you discover the pages first, and its async API is the tool for that list rather than for the site.

No multiplier table. A rendered page is compute at $0.001 a minute. Sites behind common bot-protection services go through stealth mode or the unblocker endpoint at the cost of their bytes and CPU time, not 75 times a base rate. On a plan where one option can cost as much as 74 plain pages, budgeting is guesswork; on a bandwidth and compute bill it is a multiplication.

Concurrency. Every Spider account starts at 10,000 requests per minute. ScraperAPI’s threads run from 5 on the free plan to 500 on Advanced. Credits on Spider never expire, where ScraperAPI’s reset each month.

Open engine. The crawler is spider-rs/spider, MIT licensed, and can be self-hosted. ScraperAPI is closed.

Migration: the same task in both SDKs

Fetch a rendered product page behind bot protection and get markdown back.

ScraperAPI

import os
import requests

response = requests.get(
    "https://api.scraperapi.com/",
    params={
        "api_key": os.getenv("SCRAPERAPI_KEY"),
        "url": "https://example.com/products/123",
        "render": "true",          # 10 credits
        "ultra_premium": "true",   # 30 credits; 75 combined with render
        "output_format": "markdown",
    },
    timeout=70,
)
# 75 credits consumed on a 200 or 404.
markdown = response.text

Spider

import os
from spider import Spider

client = Spider(api_key=os.getenv("SPIDER_API_KEY"))

pages = client.scrape_url(
    "https://example.com/products/123",
    params={
        "request": "smart",
        "return_format": "markdown",
    },
)
# Billed on bytes and CPU minutes; $0 if it fails.
markdown = pages[0]["content"]

Set "request": "chrome" to force rendering. To do the whole catalog, swap scrape_url for crawl_url and add "limit": 500.

For the LLM pipeline case, the crawl output drops straight into an embedding loop:

pages = client.crawl_url(
    "https://docs.example.com/",
    params={"return_format": "markdown", "limit": 200, "request": "smart"},
)

for page in pages:
    vector_db.upsert(page["url"], embed(page["content"]))

With ScraperAPI the same job starts with a URL discovery step, and if you stay on the HTML default, a parse and clean step before the embed call.

When to pick which

Pick ScraperAPI when your targets are plain pages at one credit each, when Amazon, Walmart or Google results are the bulk of your traffic and the parsed endpoints save you real work, or when you need a batch API for a long list of unrelated URLs with a webhook at the end.

Pick Spider when the pages need rendering or sit behind bot protection, when you want markdown or JSON without a parser, when the job is a site rather than a list, or when the idea of one request costing 75 plain ones bothers you. Start pay as you go; the Unlimited plan is there if the bill settles into a steady number.

The compare page holds every vendor we have written up in one table, and the ScrapingBee and ZenRows posts cover the two APIs with the closest credit models to ScraperAPI’s.

Then run the same URL through the playground. It shows the returned markdown, the mode that served it, and what that one request cost, which settles the question faster than any table.