String vs Scrapfly (2026): 100 sites compared
Which is better, String or Scrapfly?
String returned verified content on 97.0% of requests in the open Web Data Frontier Benchmark. Scrapfly returned 86.2%, second among the 16 providers tested. The run covered 100 real sites with five attempts each on September 16, 2026.
- Choose String if a missing page breaks your dataset. String returned 97.0% of requests and Scrapfly 86.2%, with 93 perfect targets to Scrapfly's 71.
- Choose Scrapfly if your pages clear on a datacenter IP and rate-card cost matters most, or you want screenshot, extraction, crawler, and cloud-browser APIs in one account.
- Do not switch if Idealista is central to your list. Scrapfly returned it on 5 of 5 attempts and String on none.
Scrapfly is the closest competitor in the benchmark. Its rate card is cheaper on a datacenter IP. The residential configuration we tested costs more than String's premium fetch. String is 10.8 points ahead on success, and its failure-aware latency score is under half of Scrapfly's. Pick Scrapfly for a broad scraping platform with low credit weights. Pick String when the page has to come back.
TL;DR
- String passed 485 of 500 requests, or 97.0%. Scrapfly passed 431, or 86.2%.
- Scrapfly ranked second of 16 providers, up 4.2 points on August. It is the strongest alternative in this benchmark.
- String's latency score was 7.06 seconds. Scrapfly's was 19.79 seconds.
- Scrapfly returned nothing on 5 of 100 sites, the second-lowest count in the run. String returned nothing on 2.
- Scrapfly beat String on Idealista, Yelp, AutoTrader, and Allegro. Idealista was 5/5 for Scrapfly and 0/5 for String.
- At full use, Scrapfly Pro costs $0.50 per 1,000 requests with the Unblocker on a datacenter IP. The residential configuration we tested costs $2.50 to $3.00. String Growth's premium fetch is $0.90 per 1,000 successful requests.
- Scrapfly offers five APIs, including cloud browsers, screenshots, extraction, and crawling. String is focused on reliable web access.
- The benchmark harness is public and accepts your own API keys.
| String | Scrapfly | |
|---|---|---|
| Product type | Unblocker: fetch, search, sitemap, remote browser | Platform: web scraping, cloud browser, screenshot, extraction, and crawler APIs |
| Benchmark success | 97.0% (485/500), 1st of 16 | 86.2% (431/500), 2nd of 16 |
| Latency score | 7.06s, 1st of 16 | 19.79s, 11th of 16 |
| Sites with no successful attempt | 2 of 100 | 5 of 100 |
| Protected-page price at $100/mo | Growth: $0.90 per 1,000 successful premium requests | Pro at full use: $0.50 per 1,000 with the Unblocker on a datacenter IP; $2.50 to $3.00 in the residential configuration we tested |
| Failure billing | Blocked requests are free; a site's 404 bills; credits roll over | Failed scrapes are free; a 404 bills; self-serve credits do not roll over |
| Browser support | Browser fetch path and remote Chrome over CDP | Cloud Browser over CDP plus JavaScript rendering in the scrape API |
| MCP and SDKs | MCP registry entry, API clients | Hosted MCP, Python, TypeScript, Go, and Scrapy |
| Where it wins | Coverage, latency, fewer shutouts, automatic path selection | Lower datacenter and Unblocker rates, broader product surface, Idealista, Yelp, AutoTrader, and Allegro in this run |
How we tested, and our conflict of interest
We built the benchmark and sell the product that ranks first. The answer to that conflict is reproducibility. The target definitions, pass criteria, provider adapters, and raw results are public. Run a subset against your own targets before buying either product.
The benchmark sent both providers the same 100 URLs five times. A request passed only when its response contained a marker from the real page. A captcha or block page that returned HTTP 200 failed.
Scrapfly ran in a strong fetch configuration. Its adapter set asp: true, pinned proxy_pool to the residential pool, and set render_js: false. ASP is Scrapfly's anti-bot mode, now called the Unblocker. The result measures the Unblocker on Scrapfly's residential pool without a forced browser. Turning on rendering for every request might help on JavaScript-heavy misses. It is a different and more expensive configuration, and it would not prove that all five shutouts disappear.
What each product is
Scrapfly's platform puts five products behind one account: a Web Scraping API, Cloud Browser, Screenshot API, Extraction API, and an early-access Crawler API. The scrape endpoint can rotate proxies, render JavaScript, run browser actions, cache results, capture screenshots, and return clean content. The Extraction API supports predefined models, LLM prompts, and rule-based templates. This is the broader toolbox.
String is a narrower product. Send a URL to the fetch endpoint and receive markdown, HTML, or JSON. Proxy selection, fingerprints, captchas, retries, and escalation happen behind the request. String also has /search, asynchronous sitemap discovery, a remote browser over CDP, and MCP tools. It does not have Scrapfly's dedicated screenshot or extraction APIs. Its main advantage is the result on hard pages.
The same request in Scrapfly and String
One job, done both ways: fetch a JavaScript-heavy product page and get its content back. Each request follows the vendor's own docs for that job, checked against those docs on October 15, 2026. Each one reads its key from an environment variable, such as $STRING_API_KEY.
curl "https://api.scrapfly.io/scrape?key=$SCRAPFLY_API_KEY&url=https%3A%2F%2Fwww.example.com%2Fproduct%2F123&unblocker=true&render_js=true"
curl https://request.usestring.ai/v1/fetch \
-H "Authorization: Bearer $STRING_API_KEY" \
-H "Content-Type: application/json" \
-d '{"url": "https://www.example.com/product/123", "format": "markdown"}'
Scrapfly takes the key in the query string and returns a JSON envelope with the page in result.content. The caller names the protection: unblocker=true (the old asp name still works) and render_js=true, and both change the credit cost. String takes the key in a header, picks the fetch path and proxy class for each request, and bills the path it used. Add "executeJS": true if you want to force a browser. Both requests are one call.
Success rate: String 97.0%, Scrapfly 86.2%
String passed 485 of 500 requests. Scrapfly passed 431. The 10.8-point difference is 54 additional successful requests across the same target list.
| Per-target outcome | String | Scrapfly |
|---|---|---|
| Passed all 5 attempts | 93 | 71 |
| Passed 1 to 4 attempts | 5 | 24 |
| Passed no attempts | 2 | 5 |
Scrapfly is not a weak baseline. Its 86.2% was 2.2 points ahead of third-place ScraperAPI and 6.0 ahead of Firecrawl.
The latency score is the per-target p75 of successful attempts. A provider that fails a target inherits the p75 of providers that succeeded, so fast blocks do not improve the score. String placed first at 7.06 seconds. Scrapfly placed eleventh at 19.79 seconds.
Where Scrapfly wins
Scrapfly beat String on four targets in the September run:
| Target | Scrapfly | String |
|---|---|---|
| Idealista | 5/5 | 0/5 |
| Yelp | 5/5 | 4/5 |
| AutoTrader | 5/5 | 4/5 |
| Allegro | 5/5 | 4/5 |
Idealista is one of only two sites String failed entirely, and Scrapfly returned it on every attempt. On Yelp, AutoTrader, and Allegro the margin is one attempt. A buyer concentrated on Spanish property listings should prefer Scrapfly from this run, then repeat the test with the exact URLs needed in production. Scrapfly is also cheaper on pages that clear on a datacenter IP, and its separate browser, screenshot, extraction, and crawling products can replace several integrations.
The three targets Scrapfly won in August did not survive the rerun: String now returns Mouser, Neiman Marcus and Skyscanner on all five attempts, and Scrapfly returns four of five on Mouser and Skyscanner.
Where String wins
Scrapfly returned no verified content on Temu, Best Buy, Ralph Lauren, Zara and Google Search. String also failed Temu, but passed every attempt on the other four.
The practical difference is not only five shutouts against two. Scrapfly was partial on 24 sites, while String was partial on five. A scraper that succeeds intermittently can leave quiet gaps in a scheduled dataset. String's 93 perfect targets against Scrapfly's 71 means fewer retries and less missing data.
Anti-bot coverage
Both products are strong across the named anti-bot systems. String led every category except DataDome and Kasada, where the two tied.
| Anti-bot system | Sites | String | Scrapfly |
|---|---|---|---|
| Cloudflare | 15 | 100% | 90.7% |
| DataDome | 19 | 92.6% | 92.6% |
| Akamai | 20 | 98.0% | 81.0% |
| PerimeterX | 9 | 100% | 84.4% |
| AWS WAF | 6 | 100% | 96.7% |
| Kasada | 3 | 93.3% | 93.3% |
| Fastly | 1 | 100% | 20.0% |
| No named vendor | 27 | 96.3% | 83.0% |
Scrapfly's profile is unusually even. It did not collapse against any multi-site anti-bot group, and 90.7% on Cloudflare is excellent. Its one weak result is the single Fastly site. String's edge is consistency above that level, especially on Akamai.
Pricing: the proxy pool decides which is cheaper
Scrapfly Pro is $100 per month for 1,000,000 credits. A plain datacenter HTTP request costs one credit. The Unblocker on a datacenter IP costs five. Residential proxies cost 25. A screenshot costs 60. The billing docs add five credits for browser rendering on top of the proxy cost, so a datacenter request with a browser is 6 credits and a residential one is 30. At full monthly use, that is $0.10 per 1,000 plain requests, $0.50 per 1,000 Unblocker requests on a datacenter IP, $0.60 with a browser on a datacenter IP, $2.50 per 1,000 residential requests, $3.00 residential with a browser, and $6.00 per 1,000 screenshots.
The configuration that scored 86.2% ran the Unblocker on the residential pool, so it starts at $2.50 per 1,000. The Unblocker docs say the credit cost can change by target, and some shield fees are not published. Failed scrapes are free, with two limits in the billing docs. A 404 is excluded from that protection and bills. If 30% or more of your scrapes in 24 hours are blocked without the Unblocker, failed scrapes start to bill.
Discovery is $30 for 200,000 credits. Pro includes 20 concurrent requests and pay-as-you-go overflow at $3.50 per 10,000 credits. Monthly credits do not roll over, so the per-request figures assume the full allowance is consumed.
String Growth is $99 per month, and the fee is added to your balance as usage. Its rates per 1,000 successful requests are $0.16 for a request path on a standard proxy, $0.90 on a premium proxy, $0.80 for a browser on a standard proxy, and $3.25 for a browser on a premium proxy. Blocked requests and errors on String's side are free. A 404 from the site bills, because it is the site's real answer. Two other requests bill: a blocked request that sent custom headers, and a request to a site with an invalid certificate. Unused credit rolls over.
| Typical path at the $100 tier | String Growth | Scrapfly Pro |
|---|---|---|
| Plain HTTP request | $0.16 per 1,000 successes | $0.10 per 1,000 requests |
| Anti-bot path on a datacenter IP | $0.90 per 1,000 premium successes | $0.50 per 1,000 Unblocker requests |
| Browser rendering | $0.80 to $3.25 per 1,000 successes | $0.60 on a datacenter IP, $3.00 on residential |
| Configuration tested in the benchmark | $0.90 premium fetch, $3.25 with a browser | $2.50 Unblocker on residential, $3.00 with a browser |
The table splits by proxy pool. On a page that clears on a datacenter IP, Scrapfly is cheaper: $0.10 against $0.16, and $0.50 with the Unblocker against String's $0.90 premium fetch. In the residential configuration that scored 86.2%, Scrapfly costs $2.50 to $3.00, so String's $0.90 premium fetch is cheaper. With a browser on a premium proxy, String's $3.25 is above Scrapfly's $3.00. Which rate a Scrapfly request lands on depends on what the Unblocker decides for that target.
Do not divide either list rate by its benchmark success rate. Neither product bills a blocked request in the benchmark's setup, so a block costs coverage rather than usage money. The cost is the missing page, the retry, and the engineering needed to fill the gap.
MCP, SDKs, and browser work
Scrapfly's hosted MCP server exposes page fetch, advanced scrape, screenshot, account information, and an instruction tool. The simple page tool renders JavaScript and returns markdown by default. Scrapfly also publishes SDKs for four ecosystems and supports browser scenarios with click, fill, wait, scroll, and custom JavaScript actions in the scrape API.
String's hosted MCP server exposes fetch, search, and sitemap tools. Its remote browser is a Chrome DevTools Protocol endpoint for Playwright or Puppeteer. Use Scrapfly when one vendor should cover scraping, extraction, screenshots, crawling, and browser automation. Use String when the core requirement is reliable retrieval from a protected URL.
Which should you pick?
- Pick String for retail, automotive, travel, and ticketing datasets where a missing page breaks the product. The 97.0% result, 93 perfect targets, and 7.06-second latency score are the strongest case.
- Pick Scrapfly when your pages clear on a datacenter IP and rate-card cost matters most. Pro costs $0.10 per 1,000 there, or $0.50 with the Unblocker.
- Pick Scrapfly for Idealista. It passed five of five attempts while String passed none.
- Pick Scrapfly when you need a dedicated screenshot, extraction, crawler, or cloud-browser API in the same account.
- Pick String when you want the fetch path selected automatically and do not want to budget credit multipliers.
- Test both on your target list. The first 20,000 String standard fetches are free, and Scrapfly gives 1,000 free credits.
Switching from Scrapfly to String
What carries over. A GET to api.scrapfly.io/scrape becomes a POST to String's /v1/fetch with the key in a header. Keep the URL list. The page moves from result.content to data in String's JSON envelope, or comes back as the whole body with "format": "raw" or "format": "markdown". render_js=true maps to "executeJS": true, country to countryCode, and js_scenario to String's browser actions. unblocker and proxy_pool have no String equivalent, because String picks the path.
What you rebuild. The Extraction API's templates and product, article, and review models, the Crawler API, schedules, webhook jobs, and Cloud Browser's session tools. String's jsonSchema covers extraction into fields you name, /v1/fetch takes screenshots, and its remote browser takes Playwright or Puppeteer over CDP. Crawls and schedules stay with Scrapfly or move to a job runner you already operate.
Integrations to reconnect. Scrapfly publishes SDKs for Python, TypeScript, Go, and Rust, a Scrapy integration, a hosted MCP server, and integrations for Zapier, Make, n8n, LangChain, LlamaIndex, and CrewAI. String ships no language SDK, so an SDK call becomes one HTTP POST. Its hosted MCP server runs at mcp.usestring.ai, n8n calls String through the HTTP Request node, and Zapier, LangChain, and the Vercel AI SDK have setup guides in String's docs.
Test on your own failing URLs first. Take the URLs that fail or escalate to expensive credits on Scrapfly today and run them through String. In this run Scrapfly returned nothing on Best Buy, Ralph Lauren, Zara, or Google Search, and String passed all four on every attempt. Keep Idealista on Scrapfly. Compare pages returned and cost per usable page, then move only the targets that improve. Leave custom headers off for the test: String does not bill a blocked request unless that request sent custom headers. The first 20,000 String standard fetches are free with no card. If you are weighing more than two tools, the ranking of 16 web scraping APIs uses the same benchmark.
FAQ
Is String better than Scrapfly?
For broad retrieval coverage, yes in this benchmark. String returned verified content on 97.0% of 500 requests against Scrapfly's 86.2%, and String's latency score was 7.06 seconds against 19.79. On the 67 sites both returned in full, Scrapfly took twice as long or worse on 56. Scrapfly is better on datacenter-tier price, broader API surface, and four individual targets, led by Idealista.
Is Scrapfly cheaper than String?
It depends on the proxy pool. At full use of Scrapfly Pro, a plain datacenter request is $0.10 per 1,000 against String Growth's $0.16, and the Unblocker on a datacenter IP is $0.50 against String's $0.90 premium fetch. In the residential configuration that scored 86.2%, Scrapfly costs $2.50 to $3.00, and String's premium fetch is cheaper. Scrapfly credits reset monthly, while String credit rolls over.
Which sites did Scrapfly beat String on?
Idealista, Yelp, AutoTrader, and Allegro. Scrapfly passed all five attempts on each. String passed none on Idealista and four of five on the other three.
Which sites did Scrapfly fail on?
Scrapfly returned no verified content on Temu, Best Buy, Ralph Lauren, Zara, and Google Search. Its benchmark adapter ran the Unblocker on the residential pool with JavaScript rendering off, so this is not proof that every Scrapfly mode fails those sites.
Does Scrapfly charge for failed requests?
Mostly no. Scrapfly's pricing page says failed requests are never charged. Its billing docs exclude a 404 from that protection, and failed scrapes start to bill if 30% or more of your scrapes in 24 hours are blocked without the Unblocker. String does not bill blocked requests, but a site's 404 bills. For both products, a block costs coverage and time rather than request credits.
Does Scrapfly have an MCP server?
Yes. Scrapfly runs a hosted MCP server with simple and advanced scraping, screenshot, and account tools. String also runs a hosted MCP server with fetch, search, and sitemap tools.
Does Scrapfly render JavaScript?
Yes. Browser rendering adds five credits to the proxy cost, so it is 6 credits on a datacenter IP and 30 on the residential pool. Scrapfly also supports browser scenarios and a separate cloud browser. The benchmark ran the Unblocker on the residential pool with JavaScript rendering off.
How can I verify the benchmark?
Use the public benchmark repository. It contains the targets, adapters, pass markers, methodology, and raw September results. Add your own keys, start with the sites that matter to you, and compare the returned content rather than HTTP status alone.