ScraperAPI Review: Is It Actually Worth It?

Your scraper worked on Tuesday. On Thursday it returns 403s, then a page that says “Verify you are human,” then nothing at all because the content loads with JavaScript your script never runs. You add a proxy list, then a rotating proxy service, then a headless browser, then retry logic, then code that spots CAPTCHA pages that came back with a cheerful 200 status. Somewhere along the way, the scraper stopped being a ten-line script and became a small piece of infrastructure you now maintain.

That is the exact problem ScraperAPI is built for. It doesn’t write your scraper for you. It sits between your code and the website and tries to hand you back a usable page instead of a block.

The obvious questions are whether it actually works, what it really costs once you look past the headline price, and when you’d be better off with something else. This review answers those using ScraperAPI’s current documentation and pricing, independent benchmark data, and what customers report on review platforms. And if you’ve already made up your mind, don’t pay the monthly price: annual billing takes 10% off every plan, so grab the 10% discount before you subscribe.

Three ways to start for less

Before you read the rest, here are the cheapest ways in, all taken from ScraperAPI’s public pricing.

$0

Free plan

1,000 credits every month, with no time limit. Enough for small tests and side projects.

Start free

5,000

credits in a 7-day trial

No credit card needed. Test your own URLs and see what they really cost.

Try it for 7 days

Best value for ongoing projects

Save 10%

with annual billing

• Hobby$44.10/mosave $58.80 a year
• Startup$134.10/mosave $178.80 a year
• Business$269.10/mosave $358.80 a year

See annual prices

Prices checked October 2026; annual plans are paid upfront for 12 months. The smart order: test with the trial first, then switch to annual once you know which plan fits.

What Is ScraperAPI, and What Does It Actually Do?

ScraperAPI is a web scraping API: you send it the address of a page, and it returns that page’s HTML (or text, Markdown, or JSON for some sites). Behind that one request, it handles the parts of scraping that usually cause the pain: choosing and rotating IP addresses, sending realistic browser headers, retrying when a site blocks the request, running JavaScript when a page needs it, and choosing the country your request appears to come from.

What you’re really paying for is fewer failed fetches and no proxy or headless-browser infrastructure to run yourself. You still decide which pages to scrape, extract the data from the HTML, store it, and handle errors on your side.

The company has been around since roughly 2018 and has been owned since 2020 by saas.group, a group that buys and runs established software businesses (saas.group). In 2026 it acquired Traject Data, the company behind the Rainforest (Amazon) and SerpWow (Google) data APIs, and says it is folding those capabilities into its platform (announcement). So it is a mature, actively developed product rather than a side project.

How ScraperAPI Works

Here’s what happens to a single request, based on ScraperAPI’s documentation:

1. Your code sends the target URL and your API key to api.scraperapi.com.
2. ScraperAPI picks an IP address from its proxy pools and sets browser-like headers. Its FAQ says residential IPs are used as a fallback when a request keeps failing (FAQ).
3. If you ask for it with render=true, it loads the page in a headless browser so JavaScript content appears.
4. If the response looks like a block or a known CAPTCHA, it retries with different IPs for up to 70 seconds (status codes).
5. You get the page back with a 200 status, or a 500 if every retry failed. Failed requests aren’t charged.

In Python, the basic call looks like this:

import requests

payload = {
    "api_key": "YOUR_API_KEY",
    "url": "https://example.com/category/shoes",
    "country_code": "us",   # optional: request from a US IP
    # "render": "true",      # optional: run JavaScript (costs more credits)
}

# ScraperAPI retries for up to 70 seconds, so don't time out sooner
response = requests.get("https://api.scraperapi.com/", params=payload, timeout=70)

print(response.status_code)                     # 200 = success, 500 = failed after retries
print(response.headers.get("sa-credit-cost"))   # credits this request used
html = response.text                            # your parser takes it from here

Two details in that snippet matter more than they look. The 70-second timeout is there because ScraperAPI bills requests your code cancels before it finishes retrying. And the sa-credit-cost header tells you exactly how many credits each request consumed, which is the easiest way to keep costs under control.

You can also use ScraperAPI as a proxy port (useful if you already have a Scrapy or Puppeteer setup), through its official Python SDK, or through an asynchronous endpoint for large batches.

What stays your job

ScraperAPI handles	You still handle
Proxy rotation and banned IPs	Choosing URLs and how often to fetch them
Headless browser for JavaScript pages	Parsing the HTML (except on its structured-data endpoints)
Retrying blocked requests	Retrying ScraperAPI’s own 500 errors
Many CAPTCHA and bot checks	Spotting a block page that slipped through as a 200
Country-level IP location	Storage, scheduling, and whether scraping that site is allowed

ScraperAPI’s Most Useful Features

Most features switch on with a single URL parameter. The thing to watch with each one isn’t complexity; it’s how many credits it adds. (Credit costs below come from ScraperAPI’s credit documentation.)

Automatic proxy rotation and retries 1 credit

This is the core product, charged at the base rate per ordinary page. You never see an IP list or write rotation code. When a request is blocked, ScraperAPI retries with different IPs for up to 70 seconds, and if it still can’t get through you receive a 500 that isn’t billed. The practical benefit is that your own retry logic shrinks to “if 500, try once more.”

The trade-off is opacity. You can’t see which IPs were used or why a request failed, so debugging a stubborn site often means trying stronger settings or opening a support ticket.

JavaScript rendering 10 credits

Add render=true and ScraperAPI loads the page in a headless browser before returning it. That’s what you need for single-page apps, product grids that load after the page appears, or infinite-scroll listings. You can add wait_for_selector to wait until a specific element exists.

It’s available on every plan, but it costs ten times a plain page and it’s slower. There’s no scripting comparable to clicking, typing, or scrolling through a multi-step flow, so if you need to interact with a page before scraping it, a browser automation tool or a competitor with scripted actions fits better.

Premium and ultra-premium proxies 10–75 credits

Some sites block datacenter IPs on sight. premium=true switches to residential and mobile IPs for 10 credits (25 with rendering). ultra_premium=true is the strongest tier for the hardest sites, at 30 credits (75 with rendering), on paid plans only.

The useful way to think about these is as a ladder: start every new target on the cheapest setting, and only climb when you get blocked. Paying 25 credits for a page that would have worked at 1 is the most common way to waste money with any scraping API.

Built-in handling for common bot protection +10 credits

ScraperAPI has named bypass mechanisms for Cloudflare, Cloudflare Turnstile, DataDome, PerimeterX (HUMAN) and Akamai. When a target uses one of them, the request costs an extra 10 credits.

Geotargeting no extra credits

Add country_code=us (or another code) and the request comes from that country, which matters for local prices, availability and search results. It is gated by plan: Hobby and Startup can choose only the US or a general EU region, and individual countries start on the $299 Business plan (geotargeting docs). There’s no city or state targeting; ZIP-code targeting exists only for Amazon US.

Structured data endpoints 5–25 credits

For a handful of high-demand sites, ScraperAPI returns clean JSON instead of HTML: Google (search, shopping, news, jobs, maps), Amazon (products, search, offers), Walmart, eBay and Redfin. You skip writing and maintaining a parser for those sites, which is often the most fragile part of a scraper. They cost the same as the site’s normal rate (5 credits for Amazon, Walmart and eBay; 25 for Google). With the Traject Data acquisition, this is the area most likely to grow.

Async API with webhooks

Instead of holding a connection open for each page, you submit jobs to async.scraperapi.com/jobs and collect results by polling or by having them sent to a webhook. For batches of thousands of URLs, this is more robust than firing synchronous requests, and it lets slow pages take as long as they need. You’ll need somewhere to receive the results.

Sessions, devices, headers and output formats

session_number keeps the same IP across pages for up to 15 minutes after last use (handy for pagination), though it can’t be combined with premium proxies. device_type=mobile fetches mobile versions. keep_headers=true sends your own headers. output_format=markdown returns Markdown, which is convenient if the pages are headed into an AI or LLM pipeline. None of these add credits; screenshots cost 10.

Cost controls

This is the most underrated part of the product. The dashboard’s domain cost estimator and the account/urlcost endpoint tell you a URL’s credit cost before you scrape it, every response includes an sa-credit-cost header, and max_cost caps what any single request may spend.

DataPipeline and no-code tools

DataPipeline lets you schedule recurring jobs and export results from the dashboard without writing code. It’s useful for simple recurring collection, but it isn’t a full replacement for a ready-made scraper marketplace like Apify.

Real-World Use Cases

The examples below are illustrative scenarios built from ScraperAPI’s published credit rules, not customer case studies. They’re meant to help you picture the workload and the bill.

Monitoring competitor prices on Amazon

Say you track 5,000 Amazon products once a day. Without an API, you’d be juggling residential proxies and a headless browser while Amazon tightens its defenses. With ScraperAPI, you can call the Amazon structured endpoint and get price, stock and offer data back as JSON, with optional ZIP-code targeting for US delivery locations.

The maths: 5,000 × 30 days = 150,000 requests. At 5 credits each, that’s 750,000 credits, which fits the $149 Startup plan. You’d still build the scheduling, the database, and the alerts when a price changes, but you wouldn’t maintain an Amazon parser. Independent testing found near-perfect success on Amazon specifically (Proxyway research), which is why this is one of the product’s strongest use cases.

Tracking search rankings

An agency checking 500 keywords a day on Google makes 15,000 searches a month. At 25 credits per Google request, that’s 375,000 credits: again the Startup plan, or roughly $10 per 1,000 searches at that usage level. The Google endpoint returns structured results, so the work left is ranking logic and reporting. Two caveats: tracking rankings outside the US means the $299 Business plan, and dedicated SERP APIs or rank trackers can be cheaper per search at high volume, so compare before committing.

A one-off research dataset

A data analyst needs 20,000 pages from a few ordinary websites for a market study. That’s 20,000 credits, comfortably inside one month of the $49 Hobby plan, which can then be cancelled. The analyst still writes the parsing code. If those sites don’t block simple requests, a free library like Requests plus BeautifulSoup would do the same job for nothing, so it’s worth trying that first.

Feeding pages into an AI pipeline

A team collecting 50,000 pages of public documentation and articles for a retrieval system can request output_format=markdown and submit the URLs through the async API. If half the pages need JavaScript, the bill is 25,000 × 1 + 25,000 × 10 = 275,000 credits on the Startup plan. Chunking, deduplication and checking content licences remain the team’s job. Tools built specifically for crawling whole sites into Markdown, such as Firecrawl, are worth comparing here.

Large-scale crawling of easy sites

At 10 million plain pages a month, the Professional plan ($975, 10.5 million credits, 300 concurrent requests) works out to about $0.09 per 1,000 pages. That’s competitive for a managed service, but at this scale an in-house crawler on cheap datacenter proxies is usually cheaper still, if you have engineers to run it.

How Easy Is ScraperAPI to Use?

For anyone who can make an HTTP request, it’s easy. This is the most consistent theme in user feedback: reviewers on Capterra rate ease of use 4.9 out of 5, and Trustpilot reviewers repeatedly mention getting a working integration in minutes. The documentation covers cURL, Python, Node.js, PHP, Ruby and Java, with Scrapy examples, and there’s an official Python SDK.

The learning curve isn’t in the API; it’s in everything around it:

• Parsing still needs code. Unless you’re on one of the structured endpoints, you get HTML back and need to extract the data yourself.
• Choosing settings takes experimentation. Knowing when a site needs render, premium or ultra_premium comes from testing, and each step up costs more.
• Error handling is still yours. You need to retry 500s, respect your plan’s concurrency limit (excess requests return 429 rather than queueing), and check that a 200 actually contains the data you expected.

Complete beginners who have never written code will find the API itself out of reach. DataPipeline lowers the bar for simple scheduled jobs, but non-programmers are generally better served by ready-made scraper marketplaces.

ScraperAPI Pricing: Is It Worth the Money?

ScraperAPI sells monthly credits. One credit equals one ordinary page; harder pages cost more credits. Here are the current plans, verified on the pricing page in October 2026:

Plan	Monthly price	Annual billing (per month)	Credits	Concurrent requests	Geotargeting
Free	$0	—	1,000 per month	5	—
Hobby	$49	$44.10	100,000	20	US or EU region
Startup	$149	$134.10	1,000,000	50	US or EU region
Business	$299	$269.10	3,000,000	100	Individual countries
Scaling	$475	$427.50	5,000,000	200	Individual countries
Professional	$975	$877.50	10,500,000	300	Individual countries
Advanced	$1,975	$1,777.50	21,500,000	500	Individual countries
Enterprise	Custom	Custom	22M+	500+	Individual countries

Annual billing takes 10% off. New accounts get a 7-day trial with 5,000 credits, no card required, and paid plans have a 7-day refund window. Credits reset each billing cycle and don’t roll over.

What a credit really buys

The headline numbers only make sense once you apply the credit costs:

Type of page	Credits each	Pages on Hobby ($49)	Per 1,000 on Hobby	Per 1,000 on Business
Ordinary page	1	100,000	$0.49	$0.10
Amazon, Walmart or eBay	5	20,000	$2.45	$0.50
JavaScript-rendered page	10	10,000	$4.90	$1.00
Page behind Cloudflare or similar	1 + 10	about 9,000	$5.39	$1.10
Google search	25	4,000	$12.25	$2.49
Ultra-premium with rendering	75	about 1,300	$36.75	$7.48

Cost-per-1,000 figures assume you use the plan’s full allowance.

So the same $49 can buy 100,000 simple pages or roughly 1,300 of the hardest ones. Neither number is misleading on its own; the point is that your mix of targets decides the price, not the plan name.

Costs that are easy to overlook

How to pay less for ScraperAPI

• Start on the free plan or the trial. The free plan gives you 1,000 credits a month, and the 7-day trial gives you 5,000 with no card. Use them to measure what your real targets cost before choosing a plan.
• Switch to annual billing once you’re sure. It takes 10% off every plan: $58.80 a year on Hobby, $178.80 on Startup and $358.80 on Business. The catch is that you pay for 12 months upfront, so only do it after your trial results look good.
• Pick the plan for your page mix, not your page count. Rendered, Google and protected pages use far more credits than plain pages, so estimate in credits.
• Climb the settings ladder slowly. Start every new site on the cheapest settings and only add render or premium when you get blocked.
• Stop paying for avoidable requests. Clean out dead URLs (404s are billed), set your timeout to 70 seconds, and use max_cost to cap expensive requests.

So, is it worth it?

For ordinary pages and mainstream targets, yes, the pricing is reasonable, particularly on Startup and above, where plain pages cost around 10 to 15 cents per thousand. Failed requests being free also makes it fairer than proxy services that bill bandwidth whether or not the request worked. It becomes poor value when most of your targets need ultra-premium settings, or when you’re paying $299 only to unlock a single country.

What I Like About ScraperAPI

• It removes a whole category of work quickly. Proxy management, browser rendering and retry logic are the parts of scraping that eat weekends. Replacing them with one request is the reason most customers choose ScraperAPI, and it shows up in review after review.
• You don’t pay for failure. Only successful (200) and not-found (404) responses are billed. If a request fails after 70 seconds of retries, it’s free. Compared with proxy services that charge for bandwidth whether or not you got the page, that’s a meaningful difference on difficult sites.
• It’s strong where a lot of commercial demand is. Independent per-site testing by Proxyway found near-100% success on Amazon and about 99% on Google (Proxyway research). Add the structured JSON endpoints for those sites, and price monitoring and search tracking are where ScraperAPI makes the most sense.
• The cost controls are genuinely useful. The per-URL cost estimator, the sa-credit-cost header and the max_cost cap make it possible to budget precisely, which matters because credit costs vary so much.
• Support has a good reputation. Responsive support is the second most common theme in reviews, and ScraperAPI’s docs invite you to open a ticket when a specific site keeps blocking you.
• Low lock-in. Because the integration is essentially a URL change, trying it (or leaving it) costs little engineering effort.

What Could Be Better?

• Heavily protected sites are a weak spot. In Proxyway’s 2026 web scraping API report, which tested 15 protected websites in October 2025, ScraperAPI’s overall success rate was 68.95%, the lowest of the six vendors in its comparison table. Zyte (93.14%), Decodo (85.88%), Oxylabs (85.82%) and ScrapingBee (84.47%) all scored higher (Proxyway). Proxyway itself describes ScraperAPI as cost-efficient for unprotected websites. One caveat on the source: Proxyway earns affiliate commissions from vendors in this space, though its methodology is published.
• Credit multipliers make costs harder to predict. Pages cost anywhere from 1 to 75 credits, and the confusion this causes appears even in otherwise positive reviews. One detailed one-star Trustpilot review from August 2025 describes a customer expecting 1 credit per Amazon request and being charged 5; ScraperAPI replied that the older account had a legacy custom rate (Trustpilot).
• Geotargeting is limited on cheaper plans. No individual countries below $299, and no city or state targeting on any plan.
• No scripted browser actions. If you need to click a button, fill a search box or scroll through a flow before scraping, ScraperAPI’s rendering won’t do it.
• A 200 isn’t always a success. Block pages can occasionally slip through as billed 200s. That’s true of every scraping API to some degree, but it means content validation in your code isn’t optional.
• Marketing claims run ahead of the evidence. ScraperAPI’s enterprise page advertises a 99.99% success rate, while its own FAQ tells users to expect 1–3% of requests to fail, and independent tests on protected sites show far lower figures. Treat the headline numbers as best cases.
• The public review base is small. About 120 reviews across Trustpilot, Capterra and G2, with a cluster of 5-star Trustpilot reviews in mid-2024. The overall picture is positive, but it’s thinner than for some competitors.

ScraperAPI vs. Other Web Scraping Tools

ScraperAPI is a solid middle-of-the-market choice rather than the category leader. Where it sits depends on what you scrape.

Tool	Entry price	Success on protected sites*	Best at	Main drawback
ScraperAPI	$49 / 100K credits	68.95%	Simple setup; Amazon and Google JSON; async jobs	Hard targets; countries locked to $299+
ScrapingBee	$49 / 250K credits	84.47%	More credits at entry; scripted browser actions	Slower average response in testing
ZenRows	$69 / 250K basic requests	70.39%	Wide country coverage on all plans	Protected pages use up the allowance fast
Bright Data	From $0.98 per 1,000 results	Not in latest test	Very hard targets; huge proxy network; datasets	Complex, and overkill for easy sites
Zyte	From about $1 per 1,000 responses	93.14%	Best measured success; Scrapy ecosystem	Costs harder to predict on difficult sites
Apify	Free tier, paid from $19	Not comparable	Ready-made scrapers for non-coders	Different model; costs vary by scraper

*Proxyway, 15 protected sites, tested October 2025 (source). Prices from vendors and Proxyway; check current rates.

ScraperAPI vs ScrapingBee

This is the closest like-for-like comparison. Both are developer-friendly APIs starting at $49. ScrapingBee gives you more credits at that price, scored higher on protected sites in Proxyway’s test, and offers JavaScript scenarios for clicking and scrolling. ScraperAPI responded faster on average in the same test (13.9 seconds versus 24.5), has broader structured-data coverage for Amazon, Walmart and eBay, and its async API with webhooks suits large batches. If your work centres on e-commerce data from those marketplaces, ScraperAPI has the edge. If you need page interactions or your targets are better protected, ScrapingBee is worth testing first.

ScraperAPI vs ZenRows

The two scored similarly on protected sites. ZenRows’ clear advantage is geography: country targeting is available on its entry plans, whereas ScraperAPI makes you move to Business. For non-US local data on a small budget, ZenRows is likely the better fit.

ScraperAPI vs Bright Data

Bright Data is built for scale and difficulty: an enormous proxy network, city-level targeting, and ready-made datasets. It is the stronger option for very hard targets and enterprise compliance requirements. For ordinary sites and teams that want to be running in an afternoon, it’s more platform than they need.

What about building it yourself?

Requests or Scrapy for simple pages, Playwright for JavaScript, plus a proxy provider, gives you total control and the lowest per-page cost at high volume on easy sites. You pay in engineering time: ban detection, rotation, browser maintenance and retries are all yours. ScraperAPI makes sense when that time costs more than the subscription.

Who Should Use ScraperAPI?

• Developers whose scraper has started getting blocked on ordinary or moderately protected sites, and who would rather pay $49–$149 a month than maintain proxies and browsers.
• E-commerce teams monitoring Amazon, Walmart or eBay, especially in the US, who can use the structured JSON endpoints instead of maintaining parsers.
• SEO teams tracking US Google results at moderate volume.
• Startups and data teams running recurring batch jobs that benefit from async requests, webhooks and paying only for successful pages.
• Analysts or researchers with a one-off dataset that fits inside the free tier or a single month of Hobby.
• AI teams collecting mostly unprotected pages as Markdown.

Who Should Probably Skip It?

• Anyone whose key targets are heavily protected. Test Zyte, Oxylabs or Bright Data alongside it, because the success-rate gap on hard sites is large.
• Small budgets needing specific countries. ZenRows or ScrapingBee include country targeting at lower prices.
• Projects that need logins or page interactions. ScraperAPI’s terms prohibit scraping behind logins and scraping in breach of a site’s own terms of service, and it doesn’t script browser actions (Terms of Use, §3.3).
• Non-programmers. Ready-made scrapers on Apify or no-code tools will get you further.
• Very high volume on easy sites, where a self-hosted crawler on cheap proxies costs less.
• Low-volume scraping of sites that don’t block you. Free libraries already solve that.
• Sites with an official API or data export. Use that first; it’s more reliable and avoids terms-of-service questions.

Is ScraperAPI Worth It? My Final Verdict

ScraperAPI does one thing well: it turns the most tedious part of scraping into a single API call, and it charges you only when that call succeeds. On ordinary websites and the marketplaces and search engines where much commercial scraping happens, the evidence shows it works reliably, and its structured endpoints for Amazon, Google and Walmart save real parser maintenance. The documentation is clear, support has a good reputation, and the cost tools let you budget properly.

Its limits are just as clear. On heavily protected sites, independent testing puts it behind several competitors. The credit system means the price you pay depends heavily on what you scrape, and geotargeting beyond the US and a general EU region needs the $299 plan. If your critical targets are the web’s hardest, or you need specific countries on a small budget, start your comparison elsewhere.

The sensible way to decide is to let your own targets answer the question. Pick five to ten real URLs, including your hardest one, and check the success rate, whether each response actually contains your data, and the sa-credit-cost header. If the numbers work, you’ll know which plan fits. If they don’t, you’ll have lost nothing but an afternoon.

Frequently Asked Questions