Super Stealth Scraper v3 — Fetch Pages Behind Any Anti-Bot Wall, Typed JSON Out

Fetch-any-page API for AI agents and RAG pipelines, rebuilt for the sites that fight back. Give it URLs, get back typed JSON — url, title, h1, clean readable content, links — from pages behind Cloudflare, DataDome, PerimeterX, Akamai and friends. One row per page, nothing to parse.

v3 does not try one trick and hope. It escalates, cheapest first, until a real page comes back: a browser-grade HTTP client, then Camoufox and real Google Chrome headed in a virtual display, then Apify's anti-bot Unblocker, then fresh residential IPs. It identifies the wall it is facing and jumps straight to the tier that beats it, and it checks the final page before it counts — a challenge page is never a result.

Keywords: stealth web scraper, Cloudflare bypass, DataDome scraper, PerimeterX scraper, anti-bot scraping API, residential proxy scraper, clean content extraction for LLM/RAG.

Why agents use this actor

• It gets the page. On a 16-site benchmark of protected pages (G2, TripAdvisor, Zillow, Walmart, Crunchbase, Indeed, Glassdoor, Realtor, Ticketmaster…) v3 delivered real content from 15, including pages the v1 engine could not open at all. One site (Yelp) is intermittent.
• Deterministic typed output. Every row conforms to the dataset schema below. content is already clean text, ready for a RAG chunker; method and protectionDetected tell your agent how hard the page was.
• One start fee per run, first page included. Then a low per-page price by tier. Batch 50 URLs in one run and the start fee spreads across all of them — this is built to be batched, not called once per URL.
• You pay for pages, not attempts. A URL that fails every tier costs nothing and lands in SUMMARY.failures with the wall named, so the agent knows why.
• No auth, no cookies, no proxies to bring. Datacenter, residential and unblocker proxies are included in the price.
• Never a broken run. Bad input, timeouts, blocked sites — the run still ends SUCCEEDED with a status message and a summary. Set Max total charge and it stops cleanly at the cap.
• An HTTP endpoint when you want one. Standby mode serves GET /?url=… straight from a warm instance.

How it escalates

Tier	What	When
1	Browser-TLS HTTP fetch on a datacenter IP (~1 s)	Always first; enough for most pages
2	Camoufox, then real Chrome, headed in Xvfb, datacenter IP	Client-rendered pages and most Cloudflare / PerimeterX walls
3	Apify Unblocker	DataDome and other walls the browsers can't clear
4	Both browsers on fresh residential IPs, with a homepage warm-up	Last resort

Once a tier works for a hostname, later URLs on that host start there.

Input schema

Field	Type	Required	Default	Description
startUrls	array	no*	[]	URLs to scrape (requestListSources editor).
url	string	no*	—	Single page, agent-friendly "fetch this page". Merged with startUrls.
urls	array of strings	no*	—	Plain array of URL strings. Merged with startUrls.
mode	auto | browser | http	no	auto	http never launches a browser (cheapest); browser always renders.
country	string	no	US	Proxy exit country; browser timezone, locale and geolocation follow it.
maxBrowserAttempts	1–8	no	4	Browser launches per URL across tiers 2 and 4.
maxConcurrency	1–10	no	3	URLs in parallel (capped by memory).
includeHtml	boolean	no	false	Add full page HTML to each row.
maxContentChars	integer	no	20000	Truncate content.
callbackUrl	string	no	—	POST a JSON summary here when the run finishes.
engine, warmup, useUnblocker, debug, maxUrls	advanced	no	auto, auto, true, false, 500	Force one engine, control the homepage warm-up, disable the unblocker tier, save screenshots of blocked attempts, cap URLs per run.

* At least one of startUrls, url, or urls must resolve to a valid http(s) URL; otherwise the run ends with a guidance row and a status message (nothing billed).

Output schema

One dataset row per delivered page.

Field	Type	Description
url	string	The URL requested.
finalUrl	string	Where the page ended up after redirects.
status	integer	HTTP status of the delivered page.
title	string | null	document.title.
h1	string | null	First <h1> text.
content	string	Readable text of main/article/body, block structure preserved, truncated to maxContentChars.
contentLength	integer	Untruncated length in characters.
links	array of strings	Up to 100 absolute http(s) links.
method	string	Tier that delivered the page: http, camoufox-datacenter, chrome-datacenter, unblocker, chrome-residential, camoufox-residential.
protectionDetected	string | null	Wall identified on the way: cloudflare, datadome, perimeterx, akamai, imperva, kasada, aws-waf, unknown, or null.
attempts	integer	Attempts made, including the successful one.
html	string	Only when includeHtml is true.
scrapedAt	string	ISO 8601 timestamp.

{
  "url": "https://www.g2.com/products/apify/reviews",
  "finalUrl": "https://www.g2.com/products/apify/reviews",
  "status": 200,
  "title": "Apify Reviews 2026: Details, Pricing, & Features | G2",
  "h1": "Apify Reviews & Product Details",
  "content": "Apify Reviews & Product Details\nVisit Website\n...",
  "contentLength": 28836,
  "links": ["https://www.g2.com/products/apify/pricing", "..."],
  "method": "unblocker",
  "protectionDetected": "datadome",
  "attempts": 2,
  "scrapedAt": "2026-10-11T18:00:00.000Z"
}

Error semantics

• Bad input: guidance row + status message, run SUCCEEDED, nothing billed.
• Partial failure: URLs that fail every tier go to the SUMMARY record ({ requested, scraped, failed, skipped, failures[{ url, protectionDetected, attempts[] }], finishedAt }), never to the dataset, never billed. Each attempt is listed with its tier and the wall that stopped it.
• Plain 404/410: reported after one attempt, not retried.
• Time budget / max total charge reached: the run stops cleanly with what it has and says so in the status message.

Use from AI agents (MCP)

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=apricot_blackberry/super-stealth-scraper-v3",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}

Works in Claude, Cursor, ChatGPT connectors and any MCP client; the input schema above is the tool's parameter schema. Tip for agents: collect the URLs first, then make one call with urls — one start fee, many pages.

Use as an HTTP endpoint (Standby)

curl "https://apricot-blackberry--super-stealth-scraper-v3.apify.actor/?url=https://example.com" \
  -H "Authorization: Bearer $APIFY_TOKEN"

POST the JSON input instead for batches (up to 50 URLs per request). GET /health answers {"ok":true}.

Use from code

curl -X POST "https://api.apify.com/v2/acts/apricot_blackberry~super-stealth-scraper-v3/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "urls": ["https://www.zillow.com/homes/for_sale/", "https://www.indeed.com/jobs?q=python"] }'

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('apricot_blackberry/super-stealth-scraper-v3').call({ urls: ['https://www.g2.com/products/apify/reviews'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();

from apify_client import ApifyClient
client = ApifyClient(token="<YOUR_APIFY_TOKEN>")
run = client.actor("apricot_blackberry/super-stealth-scraper-v3").call(run_input={"urls": ["https://www.crunchbase.com/organization/apify"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["method"])

Use from automation platforms

• n8n / Make / Zapier: pick this actor by name ("Super Stealth Scraper v3") in the native Apify integration and map the dataset items downstream.
• LangChain / LlamaIndex: each row is a document with content as the text field — straight into RAG.
• Webhooks: callbackUrl in the input, or an Apify webhook on ACTOR.RUN.SUCCEEDED.

Pricing

One start fee per run, first page included, then pay per page by tier. Pay-per-event; failures and challenge pages are free.

Event	Price
Run start (per GB of memory; 4 GB default = $0.18)	$0.045 / GB
Page via plain HTTP	$0.02
Page via stealth browser (datacenter IP)	$0.06
Page via unblocker	$0.07
Page via residential browser	$0.09

The start fee covers the first page delivered in the run; page events begin with the second page. So:

• 1 URL per run → $0.18, whatever tier it took.
• 50 protected pages in one run (say 30 by browser, 10 by unblocker, 9 by HTTP) → $0.18 + 29 × $0.06 + 10 × $0.07 + 9 × $0.02 ≈ $2.80, about $0.056/page.
• 500 pages in one run at the same mix → roughly $26, about $0.05/page — half of what the same pages cost on v1, with four tiers instead of one.

Run at 2 GB (memory run option) and the start fee halves to $0.09; 3 parallel browsers fit comfortably in 4 GB.

Cost note: datacenter, Unblocker and residential proxy traffic are included in the per-page price — there is no separate proxy bill for this actor.

FAQ

• Why not call it once per URL? You can, at $0.18 a page. Batching is the point: the start fee is paid once and every further page is $0.02–$0.09.
• Do I need residential proxies or an unblocker subscription? No. The actor escalates to them itself, and they are in the price.
• Does it solve captchas? No. It clears interstitials and JS challenges that resolve in a real browser and routes around captchas with a different tier or identity; a site that insists on a captcha for every visitor is reported as failed, not billed.
• What about pages that are not protected at all? Those come back in about a second over plain HTTP and cost $0.02 after the first.
• Can I force a country? Yes, country applies to every tier (the Unblocker chooses its own exit when a country isn't required).

Changelog

• 2026-10-11 — v3. Start fee now covers the first page of the run; per-page prices cut below v1 and priced by tier. Charging only from the second delivered page. Same four-tier engine as the 2026-10-06 build: browser-TLS HTTP → Camoufox + real Chrome → Apify Unblocker → residential browsers; wall identification and routing; verified results; Standby HTTP endpoint; callback webhook; input validation that never fails a run.

---

Built by Creator Fusion — OSINT tools that actually work.