Scrape.do Web Scraping Review: Pricing, Credits, Ready APIs and Tradeoffs

What Is Scrape.do, and Who Should Use It?

The service offers several access paths. The generic API retrieves a URL; proxy mode integrates with compatible clients; Ready APIs produce target-specific parsed fields; async jobs process work in the background. None of those removes the need to define what a valid record means. Your application still needs to detect missing values, wrong locales and duplicates before publishing or analyzing the data.

SCRAPE.DO — MANAGED RETRIEVAL & READY APIS

A focused API with browser and proxy options

Use a standard request first, then enable the options the target requires. For a supported structured endpoint, compare its returned schema with your required fields before deciding whether you need a custom parser.

HTTP APIProxy modeRenderingReady APIsAsync jobsWebhooks

Check Scrape.do free-plan availability

Existing provider homepage image for context. Its design and promotional copy may differ from the current product.

Shortlist Scrape.do if maintaining page access is the largest burden in your project. If the larger burden is running a complete scraper or authoring extraction rules without code, compare a hosted program platform or visual builder. Our Scrape.do vs Apify guide explains that workflow choice.

Scrape.do Pricing: Plans, Annual Billing and Terms

The current public lineup includes Free, Hobby, Pro, Business, Advanced and custom Enterprise arrangements. Credits measure billable consumption; concurrency limits how much work can execute simultaneously. Higher tiers add capacity and support, rather than making ordinary rendering or residential access exclusive to Business.

Pricing page and current async reference agree on the listed main limits. The async pool is additional and uses the same credit subscription. Enterprise infinity symbols are marketing presentation, not a verified promise of unlimited free usage. Confirm contracted limits and tax.

Annual prices: a stated offer and its actual arithmetic

The pricing FAQ says annual billing is currently arranged manually through support. It advertises “up to 20%,” but the named offers charge ten monthly payments for twelve months: a 16.7% reduction against twelve payments. Do not treat the monthly equivalent as a month-to-month subscription. Confirm the invoice, renewal amount, annual credit allocation and additional-credit terms in writing before committing.

A monthly pilot can be the better initial purchase if your targets are untested. An annual discount has limited value if an endpoint lacks essential fields or most credits go unused. First estimate the real collection schedule, including revisits and pagination, then compare the annual commitment against the amount of work you can confidently use.

Free testing, exhaustion and subscription renewal

Free provides a small credit allowance for testing core capabilities. Use it to inspect response types and required options; it is too small to prove sustained production reliability on every mode. The monthly pricing FAQ says requests stop when the allowance is exhausted unless you upgrade or buy additional credits. Set your own usage alert before that point so collection does not stop halfway through a time-sensitive batch.

API Credits: Mode Costs, Domain Rules and Real Value

The standard cost table is useful for an initial estimate, but it applies to ordinary domains without special profiles. Scrape.do can enable residential routing or rendering automatically on a named target. That means omitting expensive options from your own request does not necessarily produce a one-credit response.

Named targets can have different costs and response types

These are examples from the current cost reference, not a complete or permanent target list. Test the exact URL and inspect Scrape.do-Request-Cost on every response. Pair it with Scrape.do-Remaining-Credits to reconcile usage. If a target needs a stricter combination than its default profile, the higher rate can apply. Do not silently assume that a target’s output remains raw HTML when a specialized route returns parsed data.

“Successful” for billing does not always mean useful data

The request-cost reference counts 2XX and target 400, 404 and 410 responses as successful for billing. The status-code reference distinguishes a non-billable bad request to Scrape.do from a billable bad request returned by the target. It lists concurrency 429, failed 502 and client-cancelled 510 as non-billable. Judge the origin and meaning of a status, rather than treating every non-200 response the same.

A page with no required price, the wrong product or duplicate content can still need review after retrieval. Scrape.do’s pricing FAQ invites users to contact support about invalid content and claim consumed credits; the technical reference mentions custom account rules. This is a support process, not proof that every rejected record is automatically free. Record sample responses and the affected URL patterns to make a useful request.

Cost per credit is only the starting point

For Hobby, $29 divided by 250,000 credits gives $0.116 per 1,000 included credits. At 25 credits per response, that allocates $2.90 per 1,000 billable responses when the whole allowance is used. Pro allocates $1.98 per 1,000 such responses at full utilization. Higher tiers can improve nominal rates, but unused commitments can reverse the practical saving. These calculated values are more precise than rounded promotional per-credit labels.

Proxy, Rendering and Browser Features

Scrape.do advertises core features on every plan: datacenter and residential/mobile access, rendering, browser interactions, geo-targeting and sticky sessions. That broad access makes a small pilot useful. It does not remove mode costs, target restrictions or the need to confirm a specialized pool or location.

Wait for meaningful content, not just a loaded document

Browser options include load conditions and additional waits. A document can load before the product card or API response is complete, so validate the specific element or response you need. Prefer a bounded selector or request-completion condition over a long fixed sleep when possible. Resource blocking can reduce unnecessary work, but blocking an essential script or API call can also remove the fields you intended to collect.

The browser-interaction reference supports actions such as click, fill, scroll, selector waits, JavaScript execution and navigation-aware clicks. Instructions run in order through playWithBrowser. Encode the instruction list correctly and keep it as short as the extraction requires. Test action sequences against a representative sample; selectors and navigation behavior can change when the target redesigns its page.

ReturnJSON, screenshots and Markdown solve different problems

returnJSON=true requires rendering and exposes browser network information, including XHR and Fetch responses; screenshot output can appear as base64. That can be helpful when a page obtains its data from a background endpoint, but it is not a universal structured product extractor. Separately, output=markdown converts supported HTML responses into Markdown. Choose based on the downstream job: debugging, field extraction or readable text ingestion.

Network size and feature labels need context

Current marketing advertises 150M+ IPs and geo-targeting in 160+ countries. Those are provider-reported network figures, not independently audited inventory or a guarantee that a particular postal area has an available exit. The standalone proxy and scraping-browser products shown as “Coming Soon” are also different from the rendering and proxy-routing features already available through the API.

Ready APIs: Structured Data for Supported Targets

The current product catalog expands Scrape.do beyond generic page retrieval. Ready APIs return parsed data for selected ecommerce, search, maps, travel and other targets. That can reduce the amount of custom extraction code you maintain. It also changes what you evaluate: field coverage, identifiers, pagination and locale handling become as important as whether the page can be fetched.

A selected catalog snapshot, not exhaustive coverage. Use the endpoint’s actual reference and request-cost accounting. Different endpoint families may have different constraints.

The request-cost documentation specifically says Amazon-domain requests are routed through the Amazon Scraper API and return structured JSON. If you are migrating an existing HTML parser, inspect the response before wiring it into that parser. A generic URL interface does not guarantee that every target always returns the same content type.

Build a small schema check around a Ready API response. Validate required identifiers and values, preserve missing fields rather than inventing them, and retain collection time and source. A provider-maintained parser can reduce breakage after layout changes, but your acceptance rules remain necessary. Ask about an unsupported target’s availability rather than assuming the existing catalog can parse arbitrary websites.

Async plugins enable supported structured workloads in background jobs. Plugin keys and parameters are endpoint-specific, so confirm the selected family is available through Async before designing a bulk workflow around it. Keep the generic HTML, browser-network and Ready API routes distinct in your application’s data model.

Async Jobs, Concurrency and Result Delivery

The Async API accepts jobs and returns identifiers so your application can continue working while tasks run. It supports job/task inspection, cancellation and webhook delivery. Use it for batches or slow targets when keeping a user-facing request open would be impractical. A batch submission still needs a credit budget and a reliable ingestion path.

The current Async table agrees with the pricing page’s main limits. For paid tiers it lists an extra pool equal to 30% of main concurrency. That pool is not deducted from main execution slots. It is also not a separate free credit allowance. Queuing many targets does not mean all of them run immediately, and a larger pool does not establish a universal completion rate.

Async authenticates with an X-Token header, while generic synchronous examples use a token parameter. Results are temporary: retrieve each task before its ExpiresAt timestamp, then persist accepted records in your own database or object storage. Use backoff if polling, or an idempotent webhook receiver that validates job identity, survives duplicate delivery and tracks partial failures.

Do not count a delivered webhook as a completed dataset until ingestion and validation succeed. Save enough progress to replay one failed task rather than resubmitting the entire batch. Confirm cancellation behavior for in-flight tasks, especially if you are stopping a job because its observed cost is higher than planned.

Performance Claims and a Practical Evaluation Plan

Scrape.do currently advertises a 99.98% success rate. We have not independently reproduced that figure, and it should not be read as the acceptance rate for your fields or every website. A request-level success measure, a service-availability commitment and a complete-record rate describe different outcomes. The review therefore does not rank providers using invented response times or unsupported success percentages.

Actual latency depends on target response time, browser execution, retries, geography and the amount of content returned. For illustration, ten fully occupied main slots with an assumed five-second average duration could complete roughly two responses per second before client overhead. At twenty seconds, the same capacity drops to half a response per second. These assumptions are arithmetic, not a measured Scrape.do result.

Choose easy and difficult pages, missing pages, pagination and each needed locale. Compare modes on the same sample and repeat under comparable conditions. Avoid a sample made entirely of one easy page: it can hide problems with variants, delayed fields or location-specific layouts. Record the configuration so a later result can be compared meaningfully.

Setup and Production Integration

Start with a server-side request and inspect the result

Create an account, get a token and test a permitted URL in the playground. Keep credentials on your server. In API mode the target URL must be encoded as a parameter, so use your HTTP client’s parameter support or URLSearchParams instead of concatenating a target containing its own query string. Inspect the content type, status, final URL and credit headers before writing extraction logic.

import { writeFile } from 'node:fs/promises';

const token = process.env.SCRAPEDO_TOKEN;
if (!token) throw new Error('Missing SCRAPEDO_TOKEN');

const params = new URLSearchParams({
  token,
  url: 'https://example.com/',
  timeout: '60000',
  transparentResponse: 'true',
});

const response = await fetch(
  'https://api.scrape.do/?' + params.toString(),
  { signal: AbortSignal.timeout(65000) },
);

console.log({
  status: response.status,
  contentType: response.headers.get('content-type'),
  credits: response.headers.get('Scrape.do-Request-Cost'),
  remaining: response.headers.get('Scrape.do-Remaining-Credits'),
});

// Some target error responses can still consume credits.
if (!response.ok) {
  throw new Error('Collection returned status ' + response.status);
}

const content = await response.text();
// Validate target identity and required fields before accepting records.
await writeFile('collected-page.txt', content, 'utf8');

Illustrative Node.js code using native fetch; not executed against an authenticated account. The client timeout allows a margin beyond the configured 60-second service timeout. Named-domain routing can change cost and content type even without super or render.

Parameters worth choosing deliberately

The documented default service timeout is 60 seconds, with a configurable range of 5 to 120 seconds. Your client and hosting environment need enough execution time for the chosen service timeout plus transport overhead. If a serverless function cannot wait that long, switch to background collection and result delivery rather than repeatedly aborting valid work.

Production controls that make the API useful

1. Define the record contract. Specify required IDs, fields, units and acceptable missing values. Keep source URL, retrieval time and locale with each record so downstream users can judge provenance.
2. Bound requests and spend. Limit both simultaneous work and total batch size. Sample observed cost before increasing volume; named-domain profiles can make a seemingly basic job more expensive.
3. Classify failures. Fix bad tokens and parameters before retrying. Back off on concurrency errors, retry transient failures only a limited number of times, and treat genuine removed pages as a documented outcome.
4. Make ingestion repeatable. Use stable keys to deduplicate records and idempotent writes for repeated delivery. Save progress and retry failed tasks instead of replaying already accepted data.
5. Monitor quality with usage. Alert on missing-field rate, locale changes and credits per accepted record. A job can finish without errors while silently producing the wrong dataset.
6. Keep secrets out of logs. Avoid logging the full authenticated request URL. Store a safe target identifier and usage metadata separately from the token, including in exception and tracing systems.

Proxy mode requires a certificate decision

Proxy mode uses the same subscription and can simplify migration for a client that already supports an HTTP(S) proxy. Its documentation requires trusting the Scrape.do CA or disabling SSL verification. For production, review and scope certificate trust explicitly; do not copy a verification-disabled example into a general-purpose client. The direct HTTPS API is usually simpler when your application can use it.

If your own browser performs rendering through proxy mode, the provider recommends disabling its managed rendering to avoid layering two rendering workflows. Decide which component owns browser state, cookies and interactions, then test that configuration consistently rather than turning on overlapping options without a reason.

Use Cases and Workload Selection

Scrape.do is less compelling when a tiny occasional job leaves most of a recurring plan unused, or when you need a complete hosted scraper but have no extraction code. A visual builder can fit a nontechnical authoring workflow better. A programmable platform can host the whole scraper, including storage and scheduling, while a retrieval API fits code you already operate.

Define collection boundaries before running a crawler or repeating jobs. Respect applicable target rules and access restrictions, minimize personal data and choose reasonable request rates. The IETF Robots Exclusion Protocol specification explains robots.txt preferences for crawlers. It is not access authorization; the permitted scope and retention of your data still require their own decisions.

Scrape.do Pros and Cons

Compare Workflows Before Comparing Headline Prices

The useful question is which product removes the work you do not want to maintain. Retrieval APIs, programmable scraper platforms and desktop visual builders expose different resources and responsibilities. A cheap entry plan or a large credit number is not a controlled comparison of the same dataset.

Entry commitments from reviewed public materials, before tax and additional usage. Different billing units and resources; no equivalent-workload cost or speed ranking is implied.

If your parser and scheduler already work, compare access APIs on the same target sample. Our ScraperAPI vs Scrape.do comparison and ScrapingAnt vs Scrape.do comparison examine those choices. For a new project without extraction code, include the time saved by ready-made scrapers or visual authoring in your decision.

Our cheapest web scraping providers guide separates entry commitments from usage. Price the same URLs, fields, locales and collection frequency, then add parsing, storage, engineering and unused subscription capacity. A lower nominal credit price is helpful only when those credits generate the records you actually need.

Alternative Provider Guides

Retrieval with crawler and pipeline tools

ScraperAPI

Consider ScraperAPI if discovery and scheduled input lists are important alongside page retrieval. Compare supported structured endpoints, exact credit combinations, country-targeting entitlement and final job usage. Its workflow tools may reduce orchestration work for a compatible dataset.

Read the detailed reviewCompare with Scrape.do

Hosted custom programs and marketplace Actors

Apify

Consider Apify if you want the scraper program itself to run in a hosted environment, with task scheduling, datasets and integrations. Check the selected Actor’s fields, maintenance and fees; platform compute and storage are separate parts of the workload estimate.

Read the detailed reviewCompare with Scrape.do

Visual authoring and cloud extraction

Octoparse

Consider Octoparse if visual rule creation is more valuable than integrating an HTTP API into existing code. Confirm desktop support, current cloud-process limits and template or proxy charges. Check the extraction workflow before comparing a subscription total with request credits.

Read the detailed reviewCompare with Scrape.do

Existing homepage images provide visual context and may contain historical offers. Use the written plan details and the current checkout for purchasing decisions.

Frequently Asked Questions

How We Researched This Review

Final Verdict: Is Scrape.do Worth It?

Scrape.do is a useful shortlist candidate for developers who want managed retrieval, browser controls and residential routing without reserving those core features for a large plan. Ready APIs add value when their schemas fit your targets, and independent async capacity supports batches alongside immediate requests. Those strengths justify evaluation, not an unsupported claim that it is universally fastest or cheapest.

Begin with representative pages, verify actual credit costs and count accepted records. Confirm geography, content type, session behavior and result ingestion before scaling. Move to annual billing only after usage and quality become predictable. If your project needs complete hosted programs or visual extraction authoring, compare the alternative workflows before choosing an API subscription.