String vs Context.dev (2026): 100 protected sites
Which is better, String or Context.dev?
Context.dev remains the cheapest flat-rate option in this comparison, though it slipped between benchmark runs. It placed eighth for coverage in the September 16, 2026 Web Data Frontier Benchmark at 72.0%, down from third at 79.2% in August, and it still includes JavaScript rendering, anti-bot bypass, and premium proxies in one credit per standard page. String passed 97.0%, finished 9.26 seconds ahead on the failure-aware latency score, and turned 20 of Context.dev's 22 complete misses into usable pages. Pick Context.dev when a broad agent-data API and predictable prepaid credits matter most. Pick String when protected-page coverage matters most.
- Choose String if protected retail, real estate, review, and news pages have to return. String returned 97.0% of requests and Context.dev 72.0%.
- Choose Context.dev if you want one flat credit per page with protection included, or crawl, extraction, brand data, and monitors in the same API.
- Do not switch if Context.dev already returns your pages. It has the lower monthly bill at 100,000 calls and a flat protected-page rate.
TL;DR
- Success rate: String 97.0% (485/500), Context.dev 72.0% (360/500), down from 79.2% in August
- Latency score: String 7.06s (first of 16), Context.dev 16.32s (sixth)
- Clean targets: String 93 of 100, Context.dev 67
- Sites where nothing came back: String 2, Context.dev 22
- Context.dev's clean win: Foot Locker, 5/5 against String's 4/5
- Context.dev includes JavaScript rendering, anti-bot bypass, and premium proxies in its standard one-credit page price
- Every benchmark number comes from a public harness you can run with your own keys
| String | Context.dev | |
|---|---|---|
| Product type | Fetch, search, sitemap, and remote browser | Web scraping, crawling, extraction, monitors, and brand intelligence |
| Benchmark success rate | 97.0% (485/500) | 72.0% (360/500) |
| Latency score | 7.06s, first of 16 | 16.32s, sixth of 16 |
| Per-target outcome | 93 clean, 5 partial, 2 blank | 67 clean, 11 partial, 22 blank |
| Anti-bot highlights | 100% Cloudflare, PerimeterX, AWS WAF and Fastly | 96.0% Cloudflare, 100% Fastly, 83.0% on sites with no named vendor |
| Billing | Per successful request, with credits that roll over | Prepaid monthly credits; standard page scrape is one credit, and most failed requests are free, though a target 404 bills |
| Entry paid plan | $19/month, all of it usage credit | $20/month for 10,000 credits |
| Agent tooling | Hosted MCP, HTTP API | Hosted OAuth MCP, CLI, SDKs, API |
| Where it wins | Protected-page coverage, latency score, pay-as-you-go standard fetch | Flat protected-page rate and a broader enrichment surface |
How we tested, and our conflict of interest
We built the Web Data Frontier Benchmark and sell the product that ranks first. The answer to that conflict is reproducibility: the targets and pass criteria, every provider adapter, and the raw results are public. The harness uses real API keys and a request passes only when the response contains an expected marker from the real page. A captcha page with HTTP 200 fails.
The Context.dev adapter calls its Scrape HTML endpoint with the target URL and maxAgeMs: 0, which forces a live scrape. Context.dev automatically escalates proxies and bypass handling on that endpoint. The adapter did not set a country, selectors, wait time, or browser actions. That tests Context.dev's automatic standard path, not every manual control its current endpoint supports.
If Context.dev believes another configuration is fairer, the adapter is one file and a pull request changes the next run. That process has precedent: a Firecrawl engineer corrected its adapter in benchmark pull request 6, and the following run raised Firecrawl's result by 7.7 points.
Context.dev pricing and billing were checked against its live pricing page on October 27, 2026, and other product claims against first-party pages on August 31, 2026. Benchmark figures are from the September 16, 2026 run.
What Context.dev is
Context.dev has grown beyond a page scraper. Its web surface includes raw HTML, clean Markdown, image extraction, screenshots, sitemap discovery, site crawling, web search, structured extraction, document parsing, and batch processing. The same account also exposes brand, product, people, news, NAICS, and SIC data.
Its hosted MCP server exposes those operations to Claude, Codex, ChatGPT, Cursor, and other clients through OAuth. It can also create and run website monitors, so Context.dev is a broader context and enrichment platform than String.
String is narrower. Send one URL to the fetch endpoint and get Markdown, HTML, or JSON back. Proxy rotation, rendering, retries, and captcha handling escalate behind that endpoint. String also has live search, asynchronous sitemap crawling, a remote browser over CDP, and MCP. The product is built around one promise: get the requested page back, and bill only when content returns.
The same request in Context.dev 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.context.dev/v1/web/scrape \
--request POST \
--header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
--header "Content-Type: application/json" \
--data '{"url": "https://www.example.com/product/123", "formats": {"markdown": true}, "maxAgeMs": 0}'
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"}'
The two requests are the same shape: one POST, a bearer key, a URL, and a format. Context.dev renders JavaScript and uses managed proxies on every request, with no way to turn them off. It can serve a cached copy up to three days old, so the example sends maxAgeMs: 0. Each output carries its own success flag, so a 200 response can still hold a failed page. 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.
Success rate: String 97.0%, Context.dev 72.0%
The benchmark sent 16 providers the same 100 URLs five times each. Most targets are protected retail, travel, news, real-estate, and social pages.
| Provider | Successful requests | Success rate | Latency score |
|---|---|---|---|
| String | 485/500 | 97.0% | 7.06s |
| Scrapfly | 431/500 | 86.2% | 19.79s |
| ScraperAPI | 420/500 | 84.0% | 12.97s |
| Firecrawl | 401/500 | 80.2% | 9.11s |
| Context.dev | 360/500 | 72.0% | 16.32s |
Context.dev placed eighth for success, 25.0 points behind String and 14.2 behind Scrapfly. Its 16.32-second latency score placed sixth of 16, behind String at 7.06, Firecrawl at 9.11, ScraperAPI at 12.97, Bright Data at 15.62 and Oxylabs at 15.86.
The latency score does not reward fast failures. For each target it uses the p75 of successful attempts. A complete miss inherits that target's p75 from providers that returned content, or the 90-second timeout when nobody succeeded. That is why coverage and speed can be read together.
Context.dev wins on one target
Context.dev's clearest result deserves the same space as its misses. It passed Foot Locker on all five attempts. String passed four. That made Foot Locker the only target where Context.dev beat String outright.
Context.dev also went 5/5 on every jobs and hiring, grocery and food, gaming and betting, and government target. Those are strong results for a standard one-credit scrape with no premium-mode switch.
The coverage gap is 20 rescued targets
Per-target outcomes make the 25.0-point gap concrete.
| Outcome across 100 sites | String | Context.dev |
|---|---|---|
| Passed all 5 attempts | 93 | 67 |
| Passed 1 to 4 attempts | 5 | 11 |
| Passed none | 2 | 22 |
Context.dev returned nothing on Temu, Mouser, Trustpilot, Realtor.com, Skyscanner, Home Depot, Expedia, AutoZone, Louis Vuitton, Yelp, Hyatt, Neiman Marcus, Saks Fifth Avenue, G2, Idealista, Etsy, Allegro, WSJ, Reddit, GoodRx, CarGurus and arXiv. String passed 18 of those 22 on all five attempts and four of five on Yelp and Allegro. Temu and Idealista stopped both providers.
The anti-bot split explains much of it. Context.dev reached 96.0% on Cloudflare, second only to String's 100%, and it is the column it should be judged on. Everything else fell. DataDome dropped from 74.7% to 43.2% against String's 92.6%, Akamai from 83.0% to 70.0% against 98.0%, and PerimeterX from 73.3% to 66.7% against String's 100%.
Pricing: Context.dev wins on a flat protected-page rate
Context.dev's pricing is unusually clean. Developer costs $20 per month for 10,000 credits. Pro costs $90 for 100,000, Growth $300 for 500,000, and Scale $500 for 1 million. Standard HTML or Markdown scraping costs one credit per page, with JavaScript rendering, anti-bot bypass, and premium proxies included. Most failed requests are not billed, but a target that returns 404 is billed at the request's base price, and a scrape that returns at least one successful output is charged. Browser-action calls cost two credits.
Paid overage arrives in 1,000-credit blocks: $3.00 on Developer, $2.00 on Pro, $1.50 on Growth, and $1.00 on Scale. The free tier includes 1,000 credits a month with no card.
String's pricing starts at $19 per month. Growth is $99 per month, which includes $99 of usage at $0.16 per 1,000 successful standard fetches or $0.90 per 1,000 successful premium fetches. Usage above that bills at the same rates, and browser paths cost more. Unused credit rolls over and a blocked request is free.
At 100,000 calls against the benchmark target mix, the published terms produce this comparison:
| Assumption | Monthly cost | Cost per 1,000 usable pages | |
|---|---|---|---|
| Context.dev Pro | 72,000 successful pages fit inside 100,000 included credits | $90.00 | $1.25 |
| String Growth, standard fetch | 97,000 successful pages at $0.16/1k ($15.52), inside the $99 fee | $99.00 | $1.02 |
| String Growth, premium fetch | 97,000 successful pages at $0.90/1k ($87.30), inside the $99 fee | $99.00 | $1.02 |
This table is a model, not a bill. The Context.dev row counts only successful pages; target 404s and partial results also bill, so a real Context.dev bill can run higher. String chooses a request path based on what the target needs, so a real workload mixes standard and premium rates. Context.dev's major pricing advantage is that protected handling does not change the one-credit standard-page price. At this volume both String paths sit under the $99 fee, which covers them; any of it you do not use rolls over. Context.dev has the lower monthly bill in this model, $90.00 against $99.00, but String is cheaper per usable page on either path, $1.02 against $1.25, because it returns more pages. Context.dev's Pro allowance gets more efficient as usage approaches 100,000 successful pages.
Product breadth: Context.dev does more around the page
For an agent that needs more than page content, Context.dev has the broader toolbox. Its Markdown endpoint can strip page chrome, its crawl endpoint follows same-domain links, and its AI query endpoint crawls a site to fill requested data points. The platform also offers brand profiles, styleguides, fonts, products, people enrichment, news, monitors, and document parsing.
The MCP server turns that breadth into agent tools for scraping, searching, extracting, parsing, enriching, and monitoring. Context.dev also documents zero-data-retention controls, and its changelog lists SOC 2 Type I compliance.
String is the better fit when page retrieval is the bottleneck and the surrounding enrichment belongs in your own pipeline. Context.dev is the better fit when one vendor should supply page content and a catalog of higher-level context operations.
Which one should you pick?
- Choose String for protected retail, luxury, real-estate, local-review, and news pages. The benchmark gap appears in the exact targets those workloads depend on.
- Choose Context.dev for predictable protected-page pricing. One credit includes JavaScript rendering, anti-bot bypass, and premium proxies.
- Choose String when retry-free coverage matters. It returned at least one usable page on 98 of 100 sites, against 78 for Context.dev.
- Choose Context.dev when your agent also needs crawling, structured extraction, brand intelligence, document parsing, or website monitors through one API and MCP surface.
- Test both on your own URLs. The benchmark repository accepts either provider key and can run a subset before you spend on the full suite.
Switching from Context.dev to String
What carries over. The request shape carries over almost unchanged. formats: {"markdown": true} maps to "format": "markdown", a JSON output with a schema to jsonSchema, sharedParams.mainContentOnly to mainContentOnly, sharedParams.country to countryCode, and browser actions to String's actions. Keep the URL list.
What you rebuild. Batches of up to 25,000 URLs with webhooks, Monitors, Crawl, Answers, Parse, the prebuilt parsers, browser profiles with saved logins, and the brand, people, and news data. String's /search endpoint and sitemap crawl cover search and URL discovery. Everything above the page itself stays with Context.dev, or moves into your own pipeline.
Integrations to reconnect. Context.dev publishes SDKs for TypeScript, Python, Ruby, Go, and PHP, a CLI, an MCP server, and integrations for Zapier, Make, LangChain, Composio, and others. 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 come back empty from Context.dev and run them through String, with maxAgeMs: 0 on the Context.dev side so both sides fetch live. In this run Context.dev returned nothing on 22 of the 100 sites, and String returned usable pages on 20 of them. 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 Context.dev better than String?
Context.dev is better for a broad context platform and a flat protected-page credit. String is better for fetch reliability in this benchmark: 97.0% against 72.0%, with 2 complete misses against 22. Context.dev won one target outright in the September run, Foot Locker.
Is Context.dev cheaper than String?
It depends on String's request path. Context.dev Pro is $90 for 100,000 credits, and a standard page costs one credit with protected handling included. String Growth is $99 a month, which includes $99 of usage at $0.16 per 1,000 standard fetches or $0.90 per 1,000 premium fetches. At 100,000 calls on the benchmark mix, Context.dev has the lower monthly bill and String the lower cost per usable page on either path.
Does Context.dev charge for blocked requests?
Mostly not. Its pricing page says most failed requests are not billed, but a target 404 is billed at the request's base price, and a scrape that returns at least one successful output is charged. String bills only successful requests.
Does Context.dev bypass Cloudflare?
Often. Context.dev passed 96.0% of requests across 15 Cloudflare-protected targets. String passed 100%. Against Akamai the result was 70.0% to 98.0%, and against Kasada it was 66.7% to 93.3%.
What Context.dev configuration did the benchmark use?
The public adapter called GET /v1/web/scrape/html with the target URL and maxAgeMs: 0. It used Context.dev's automatic proxy escalation and bypass path, without country selection, wait time, selectors, or browser actions.
Does Context.dev have an MCP server?
Yes. Context.dev runs a hosted OAuth MCP server for Claude, Codex, ChatGPT, Cursor, VS Code, and other compatible clients. It exposes scraping, crawling, search, extraction, parsing, enrichment, and monitor tools.
When should I use Context.dev instead of String?
Use Context.dev when you want predictable prepaid credits and one API for scraping, crawling, structured extraction, brand intelligence, documents, and monitoring. Use String when the core job is getting difficult public pages back at the highest measured coverage.
How can I verify the benchmark numbers?
Run the open-source benchmark with your own keys. The results file, target markers, and both adapters are public. Start with your own target subset because a full run makes thousands of billable calls.