# Super Stealth Scraper v3 — Fetch Pages Behind Any Anti-Bot Wall (`apricot_blackberry/super-stealth-scraper-v3`) Actor

Fetch-any-page API for AI agents and RAG: typed JSON (url, title, h1, clean content, links) from sites behind Cloudflare, DataDome, PerimeterX, Akamai. HTTP → stealth browsers → unblocker → residential, automatically. One start fee per run covers your first page; batch URLs to pay less per page.

- **URL**: https://apify.com/apricot_blackberry/super-stealth-scraper-v3.md
- **Developed by:** [Creator Fusion](https://apify.com/apricot_blackberry) (community)
- **Categories:** Developer tools, Agents, AI
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 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. |

```json
{
  "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)

```json
{
  "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)

```bash
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

```bash
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"] }'
```

```js
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();
```

```python
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](https://apify.com/apricot_blackberry) — OSINT tools that actually work.

# Actor input Schema

## `startUrls` (type: `array`):

URLs to fetch. Each URL returns one typed JSON record.

## `url` (type: `string`):

Alias for a single page. Merged with startUrls.

## `urls` (type: `array`):

Alias: plain array of URL strings. Merged with startUrls.

## `mode` (type: `string`):

auto: fast HTTP first, browser only when needed. browser: always render in the stealth browser. http: never launch a browser.

## `country` (type: `string`):

Two-letter country code for proxy exits. Browser timezone, locale and geolocation follow it.

## `maxBrowserAttempts` (type: `integer`):

First attempt uses a datacenter IP, the rest use a fresh residential IP each.

## `maxConcurrency` (type: `integer`):

URLs processed in parallel.

## `includeHtml` (type: `boolean`):

Add the full page HTML to each record.

## `maxContentChars` (type: `integer`):

Truncate the extracted text content to this many characters.

## `debug` (type: `boolean`):

Save a screenshot and HTML of every blocked attempt to the key-value store (DEBUG-\* keys).

## `warmup` (type: `string`):

Visit the site's homepage before the target page on later browser attempts (auto), always, or never.

## `engine` (type: `string`):

auto alternates Camoufox and real Chrome; or force one engine.

## `useUnblocker` (type: `boolean`):

Allow the anti-bot unblocker tier (charged as page-unblocked when it delivers the page).

## `maxUrls` (type: `integer`):

Safety cap on how many input URLs are processed.

## `callbackUrl` (type: `string`):

When the run finishes, POST a JSON summary (counts, failures, dataset ID, run ID) to this URL. For per-event webhooks use Apify's run webhooks instead.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "mode": "auto",
  "country": "US",
  "maxBrowserAttempts": 4,
  "maxConcurrency": 3,
  "includeHtml": false,
  "maxContentChars": 20000,
  "debug": false,
  "warmup": "auto",
  "engine": "auto",
  "useUnblocker": true,
  "maxUrls": 500
}
```

# Actor output Schema

## `pages` (type: `string`):

Dataset with one JSON record per delivered page.

## `summary` (type: `string`):

Counts plus every URL that could not be delivered, with attempts and the wall detected.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apricot_blackberry/super-stealth-scraper-v3").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://example.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("apricot_blackberry/super-stealth-scraper-v3").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ]
}' |
apify call apricot_blackberry/super-stealth-scraper-v3 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apricot_blackberry/super-stealth-scraper-v3"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hhoDEjm3eRIX313YR/builds/9xckAo8uAmcCnND9N/openapi.json