Super Stealth Scraper

Fetch-any-page API for AI agents and RAG pipelines. Give it a URL, get back typed JSON — url, title, h1, clean readable content, and links — even from sites with active bot detection. Returns typed JSON rows (schema below), one row per page.

It renders each page in a real Chromium browser with per-session fingerprints, WebRTC-leak prevention, human-like delays, and CDP geo-sync, so pages that block plain HTTP fetches still return usable content. Keywords: stealth web scraper, anti-detection scraping, residential proxy scraper, headless browser scraping, clean content extraction for LLM/RAG.

Why agents use this actor

• Deterministic typed output. Every row conforms to the dataset schema below (url, title, h1, content, links, scrapedAt). No HTML parsing on your side — content is already clean text, capped at ~5000 chars, ready for a RAG chunker.
• Cost-predictable, per-event pricing. Priced per page/event, so an autonomous agent can budget a crawl up front.
• Datacenter-first proxy, residential only on block. The first attempt uses cheap datacenter/automatic proxy; residential (user-billed) is used only when a target actually blocks the request. See Pricing.
• No auth or cookies needed. Just URLs in, JSON out.
• Clear error semantics. Failures are per-URL and never pollute the dataset (they go to the SUMMARY record); a run that scrapes zero pages exits non-zero instead of returning a silent empty success.
• Rate-limit / block handling built in. Blocked responses retire the session and retry on an escalated proxy automatically.

Input schema

Field	Type	Required	Default	Description
startUrls	array	no*	[]	URLs to scrape (requestListSources editor — objects { "url": "..." } or plain strings).
url	string	no*	—	Alias for a single page. Agent-friendly "fetch this page". Merged with startUrls.
urls	array of strings	no*	—	Alias: plain array of URL strings. Merged with startUrls.
proxyConfiguration	object	no	{ useApifyProxy: true }	Datacenter-first; retries escalate to RESIDENTIAL on block. Set apifyProxyGroups: ["RESIDENTIAL"] to force residential from the start, or useApifyProxy: false for a direct connection.
maxRequests	integer	no	100	Max pages to scrape per run (1–10000).
maxConcurrency	integer	no	3	Parallel browsers (1–20). Lower = stealthier, higher = faster.
delayMean	integer	no	4500	Center of the gaussian inter-request delay, ms (1000–30000).
delayStdDev	integer	no	1500	Spread of the gaussian delay, ms (500–10000).

* At least one of startUrls, url, or urls must resolve to a valid http(s) URL, or the run fails fast (exit 1).

Output schema

One dataset row per successfully scraped page. All modes emit the same shape (this actor has a single mode).

Field	Type	Nullable	Description
url	string	no	The URL that was scraped.
title	string	yes	document.title (may be an empty string).
h1	string	yes	Trimmed text of the first <h1>, or null/absent if none.
content	string	yes	Clean readable text from main/article/.content/body, truncated to ~5000 chars. RAG-ready. Null/absent if no text node matched.
links	array of strings	yes	Up to 50 absolute http(s) links found on the page.
scrapedAt	string	no	ISO 8601 timestamp of the scrape.

status, headers, and data are reserved in the schema (legacy) and are not currently emitted; additionalProperties is true, so future fields will not break validation.

Example row:

{
  "url": "https://example.com",
  "title": "Example Domain",
  "h1": "Example Domain",
  "content": "Example Domain. This domain is for use in illustrative examples in documents...",
  "links": ["https://www.iana.org/domains/example"],
  "scrapedAt": "2026-08-14T10:30:00.000Z"
}

Error semantics

• Bad input (no valid http(s) URL in startUrls/url/urls): the run fails fast with exit code 1 and a status message — nothing is pushed.
• Partial failure: individual URLs that fail (block, timeout, nav error) are retried on an escalated proxy; if they still fail they are recorded in the SUMMARY key-value record ({ requested, scraped, failed, failures[], finishedAt }), not in the dataset. The run still succeeds if at least one page scraped.
• Zero results: if no page scraped, the run exits non-zero (exit 1) with a status message. Agents should treat a non-zero exit as "retry / escalate", never as empty data.

Use from AI agents (MCP)

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

Works in Claude, Cursor, ChatGPT deep-research connectors, and any MCP client; the input schema above is the tool's parameter schema.

Use from code

curl (run and get rows in one call):

curl -X POST "https://api.apify.com/v2/acts/apricot_blackberry~super-stealth-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "url": "https://example.com" }'

JavaScript (apify-client):

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('apricot_blackberry/super-stealth-scraper').call({
  url: 'https://example.com',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python (apify_client):

from apify_client import ApifyClient
client = ApifyClient(token="<YOUR_APIFY_TOKEN>")
run = client.actor("apricot_blackberry/super-stealth-scraper").call(
    run_input={"url": "https://example.com"}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Use from automation platforms

• n8n / Make / Zapier: use the native Apify integration and pick this actor by name ("Super Stealth Scraper"); map the run's dataset items downstream.
• LangChain / LlamaIndex: wrap it with the Apify tool/loader — each dataset row becomes a document with content as the text field, ideal for RAG ingestion.

Pricing

Per-event pricing (unchanged). A typical run of ~500 pages on a site with advanced bot detection takes ~45 minutes for roughly $8.75 including proxies — about $0.0175 per page.

Cost note (2026-08 change): proxy now defaults to datacenter/automatic first, escalating to residential only when a target blocks the request. Residential bandwidth is user-billed; targets that don't fight back are scraped on cheap datacenter IPs, which cuts proxy cost for most pages. To force residential from the first request, set apifyProxyGroups: ["RESIDENTIAL"] in proxyConfiguration.

FAQ

• Do I need residential proxies? No — datacenter is tried first and works for most sites. Residential kicks in automatically only on a block.
• Do I need to handle cookies or logins? No. URLs in, JSON out.
• Is the content clean enough for RAG? Yes — content is extracted text (no markup), truncated to ~5000 chars per page.
• What happens if a site blocks me? The session is retired and the request retries on residential proxy. If it still fails, it lands in SUMMARY.failures, not the dataset.

Changelog

• 2026-08-14 — Output dataset schema added (typed fields + overview view) and agent-first README. Input aliases url / urls added for single-page agent calls. Proxy restructured to datacenter-first with automatic residential fallback on block (cost-saving; residential is user-billed). Fail-loud on invalid input and zero results (exit 1); per-URL failures moved to the SUMMARY key-value record instead of the billed dataset.

---

Built by Creator Fusion — OSINT tools that actually work.