ScraperAPI is one of the most popular web scraping APIs for developers who want to skip the infrastructure headaches. With a single API call, it handles proxy rotation, browsers, CAPTCHAs, and retries for you — returning clean HTML (or structured JSON) from almost any page. It's a favorite among small teams and solo developers thanks to its generous free tier and dead-simple integration.
This review covers how the API behaves in practice: the request parameters that actually change your results, the structured data endpoints, the async and scheduling tools, where it falls short against anti-bot-first services, and who should pick something else. If you only want the short version: ScraperAPI is the easiest scraping API to adopt, it's strong on mainstream e-commerce and search targets, and it's not the tool for the hardest anti-bot sites.
How It Works
Instead of managing your own proxies and headless browsers, you send your target URL to ScraperAPI's endpoint along with your API key. ScraperAPI routes the request through its proxy pool, renders JavaScript if needed, solves anti-bot challenges, and returns the result:
curl "https://api.scraperapi.com/?api_key=YOUR_KEY&url=https://example.com&render=true&country_code=us"
That one request transparently handles rotation, retries, and unblocking — no proxy management on your side. The same call in Python:
import requests
payload = {
"api_key": "YOUR_KEY",
"url": "https://example.com",
"render": "true",
"country_code": "us",
}
r = requests.get("https://api.scraperapi.com/", params=payload, timeout=90)
print(r.status_code, len(r.text))
Two things to know before you ship this. First, ScraperAPI keeps the connection open while it retries a failing page through different proxies, so a difficult request can take well over a minute; set your client timeout generously and don't retry on your side until the API has given up. Second, a non-200 status from ScraperAPI means it couldn't fetch the page, not that your request was malformed — treat it as a failed scrape and move on, or retry later.
Proxy mode
If you'd rather not rewrite existing scraper code around a new endpoint, ScraperAPI also exposes a proxy interface. Point your HTTP client at the ScraperAPI proxy server with your API key as the password, and every request your scraper makes is routed through the service unchanged:
curl -x "http://scraperapi:YOUR_KEY@proxy-server.scraperapi.com:8001" -k "https://example.com"
Options are passed in the username (for example scraperapi.render=true). This is the fastest migration path from a raw proxy provider: swap the proxy URL and keep everything else. The trade-off is that proxy mode re-signs TLS, so you need to disable certificate verification for those requests, as the -k flag does above.
Key Features
- Single-endpoint API: Scrape any page with a simple GET request — works in any language.
- Automatic proxy rotation: Datacenter, residential, and mobile proxies with millions of IPs.
- JavaScript rendering: Add
render=trueto fully render dynamic, JS-heavy pages. - Geotargeting: Target specific countries with
country_codefor localized results. - Anti-bot handling: Automatic CAPTCHA handling, retries, and header/fingerprint management.
- Structured Data Endpoints: Pre-built parsers for Amazon, Google Search, Google Shopping, and more — get JSON instead of raw HTML.
- Async scraping & DataPipeline: Submit large jobs asynchronously, or schedule no-code scraping pipelines.
- Generous free tier: Free monthly credits to get started, plus a free trial with bonus credits.
Request Parameters That Matter
The endpoint takes a dozen or so parameters, but a handful account for most of the difference between a request that works and one that doesn't:
render=true— runs the page in a headless browser before returning it. Required for anything that loads content with JavaScript, and the main reason a request costs more credits.country_code— picks the proxy's country. Essential for localized pricing, search results, and any site that geofences content.premium=true/ultra_premium=true— switches from datacenter to residential, then to the highest-quality residential and mobile pool. Use these when a target blocks the default pool, not by default; each tier multiplies the credit cost.session_number— reuses the same proxy across requests, for sites that need a consistent identity across a multi-page flow.keep_headers=true— sends your own headers instead of ScraperAPI's generated ones, for targets that need specific cookies or a logged-in session.device_type=mobile— requests the mobile version of a page, which is sometimes lighter and less protected than the desktop version.autoparse=true— for supported sites, returns parsed JSON instead of HTML without switching to the structured endpoints.
The pattern we recommend: start with the cheapest request shape (no rendering, default pool), measure your success rate on a sample of real URLs, and add parameters only for the targets that need them. Scrapers that turn on render=true and ultra_premium=true for everything spend several times more credits than necessary.
Structured Data Endpoints
For a few high-traffic targets, ScraperAPI skips HTML altogether and returns parsed JSON. Amazon product, search, and offer pages, Google Search, and Google Shopping all have dedicated endpoints:
curl "https://api.scraperapi.com/structured/amazon/product?api_key=YOUR_KEY&asin=B0EXAMPLE&country_code=us"
curl "https://api.scraperapi.com/structured/google/search?api_key=YOUR_KEY&query=wireless+mouse&country_code=us"
The response is a JSON object with the fields you'd otherwise write selectors for — title, price, rating, review count, and so on for products; organic results, ads, and related searches for search pages. In practice this saves two kinds of work: the initial parsing, and the ongoing maintenance when the target changes its markup, which ScraperAPI absorbs on its side.
The limits are the obvious ones. Coverage is narrow — if your target isn't on the list, you're back to HTML — and you get the fields ScraperAPI chose to extract, not necessarily every field on the page. For Amazon and Google work specifically, though, these endpoints are the single biggest time-saver in the product, and the reason we route readers of our Amazon price tracking guide and Google Search scraping guide here.
Async Scraping and DataPipeline
Synchronous requests are fine for a few thousand pages. Beyond that, two features matter:
- Async scraping. You submit a job (a single URL or a batch) to the async endpoint, get a job ID back immediately, and either poll for the result or give ScraperAPI a webhook URL to call when it's done. This decouples your code from the long, variable request times of hard targets and lets you queue large crawls without holding thousands of connections open.
- DataPipeline. A no-code scheduler in the dashboard: upload a list of URLs (or Amazon ASINs, or search queries), pick a frequency, and ScraperAPI runs the job on a schedule and delivers results to a webhook or as a downloadable file. For recurring monitoring — daily price checks, weekly SERP snapshots — it replaces a cron job and a worker you'd otherwise have to host.
Neither is unique to ScraperAPI, but both are well integrated and need no additional infrastructure, which fits the product's whole pitch.
Best For
- Developers who want a drop-in API and don't want to manage proxy infrastructure
- Small to mid-sized scraping projects with a focus on speed of integration
- E-commerce and SERP scraping via the structured data endpoints
Pricing
ScraperAPI uses a credit-based, pay-as-you-grow model. Plans scale by the number of API credits per month, with higher tiers unlocking more concurrent threads, residential/mobile proxies, and premium features.
- Free plan: Free API credits every month to test and run small jobs.
- Free trial: Free credits to start, no commitment.
- Paid plans: Start at an entry-level monthly tier and scale up to high-volume and enterprise plans.
Credit costs vary by request type — JavaScript rendering and premium residential/mobile proxies consume more credits than a basic request. Check the current pricing for exact figures, as plans are updated periodically.
Performance
ScraperAPI performs reliably on mainstream targets, with strong success rates on e-commerce and search pages — especially when using JavaScript rendering and premium proxies. For the most aggressive anti-bot targets, enabling residential/mobile proxies (premium=true / ultra_premium=true) noticeably improves success rates at a higher credit cost.
Where it's weakest is the category of site that drives people to anti-bot-first services: targets behind DataDome, PerimeterX, or aggressive Cloudflare configurations. ScraperAPI does retry through different proxies and fingerprints, and the premium tiers help, but it isn't built around defeating those systems the way ZenRows or Bright Data's Web Unlocker are. If a large share of your targets are in that category, expect lower success rates and higher credit burn than on mainstream sites.
Latency follows the same pattern. Simple requests on cooperative sites return quickly; rendered requests on protected sites can take a long time because the service keeps retrying before it gives up. For throughput-sensitive work, the async endpoint is the better fit than tightening synchronous timeouts.
ScraperAPI vs the Alternatives
| ScraperAPI | ZenRows | Bright Data | Oxylabs | |
|---|---|---|---|---|
| Model | Single-endpoint API | Single-endpoint API | Proxy platform + tools | Proxy network + scraper APIs |
| Anti-bot strength | Good on mainstream targets | Strongest plug-and-play bypass | Web Unlocker, success-based billing | Built into the scraper APIs |
| Structured data | Amazon, Google Search, Google Shopping | Limited | SERP API, datasets marketplace | SERP and e-commerce APIs |
| Raw proxy access | Proxy mode only | No | Yes, 400M+ IPs | Yes, 100M+ IPs |
| Free tier | Free credits every month | Trial credits only | Trial | Trial |
| Billing | Credits | Credits | Per GB / per CPM | Per GB / per result |
The short read: ScraperAPI is the easiest to adopt and the only one with an ongoing free tier; ZenRows is the pick when anti-bot bypass is the whole job; Bright Data and Oxylabs are the step up when you need raw proxies, scale, or a broader toolset. Full head-to-heads: ZenRows vs ScraperAPI and Bright Data vs ScraperAPI.
Who Shouldn't Use ScraperAPI
- Teams whose targets are mostly anti-bot fortresses. Credit burn will be high and success rates lower; an anti-bot-first API or an unlocker product is the better tool.
- Projects that need fine-grained proxy control. If you care about sticky sessions by ASN, city-level targeting across many countries, or choosing between ISP and mobile pools per request, a proxy provider like Bright Data or IPRoyal gives you that; ScraperAPI abstracts it away.
- Very high-volume, low-difficulty crawls. When every page is easy, paying per credit for retries and unblocking you don't need can cost more than cheap per-GB proxies plus your own scraper. See our guide to proxy types for where that line falls.
Conclusion
ScraperAPI is an excellent choice if you value simplicity and speed of integration over fine-grained control. For most developers and small teams, it removes nearly all the friction of web scraping — proxies, browsers, and CAPTCHAs — behind a single API call. If you need maximum control over a massive proxy network, a dedicated provider may suit you better, but for getting up and running fast, ScraperAPI is hard to beat.
Start scraping with ScraperAPI — get free credits →
Comparing options? See our Bright Data review, Oxylabs review, and the full Bright Data alternatives round-up.
FAQ
Does ScraperAPI have a free plan?
Yes. ScraperAPI offers a free plan with free API credits every month to test and run small jobs, plus a free trial with bonus credits and no commitment.
How does ScraperAPI pricing work?
ScraperAPI uses a credit-based, pay-as-you-grow model. Plans scale by the number of API credits per month, with higher tiers unlocking more concurrent threads, residential/mobile proxies, and premium features. Credit costs vary by request type — JavaScript rendering and premium residential/mobile proxies consume more credits than a basic request.
Can ScraperAPI render JavaScript-heavy pages?
Yes. Adding render=true to your request fully renders dynamic, JS-heavy pages before returning the result.
Who is ScraperAPI best for?
Developers who want a drop-in API and don't want to manage proxy infrastructure, small to mid-sized scraping projects focused on speed of integration, and e-commerce or SERP scraping via the structured data endpoints.
See How It Compares
Still deciding? Read our head-to-head breakdowns:
Or browse all web scraper comparisons.