Wolfpack | Armored Stealth Scraper for AI Agents

The web fights back. Send the pack.

Bot walls. Slow-drip traps. Endless link mazes. Invisible token bloat. Instructions hiding inside “data.” These are the places where a scrape can become a dataset killer.

Wolfpack combines Super Stealth’s retrieval engines with Armored’s inspection pipeline. It pursues the page, checks what came back, and gives your autonomous agent structured text with a retrieval trail and security telemetry. Bring difficult public websites into research, RAG and agent-memory workflows with budgets you control.

Stealth gets you to the content. Armor checks what comes home.

What the pack brings

• Three retrieval engines: Impit for HTTP, Patchright Chrome and Camoufox for JavaScript rendering. Auto mode can escalate when an HTTP response is blocked or looks like a client-rendered shell.
• Optional proxy escalation: Apify datacenter and residential routes. Pick a tier or let auto mode try configured browser fallbacks.
• Bounded pursuit: sliding-window throughput checks for HTTP streams; hard navigation/process deadlines and aggregate network limits for browsers. A troublesome page has a finite budget.
• Crawl-maze detection: structural SimHash plus text similarity across a branch’s ancestors prunes repetitive traversal while global depth, page and link limits cap the run.
• Content inspection before delivery: removes hidden elements and invisible Unicode noise, preserves contextual language joiners by default, and quarantines recognized instruction-injection patterns.
• An audit trail your agent can use: source hashes, final URLs, retrieval attempts, detected protection signals, security flags and exact token counts for the selected encoding.

No LLM API key is required. Retrieval runs inside this Actor; it does not call a separate paid scraper Actor.

Start with one URL

{
  "url": "https://docs.python.org/3/tutorial/datastructures.html",
  "mode": "auto",
  "maxDepth": 0,
  "maxPages": 1
}

For pages that require JavaScript:

{
  "url": "https://docs.python.org/3/tutorial/datastructures.html",
  "mode": "browser",
  "engine": "chrome",
  "requestTimeoutSecs": 45,
  "maxDepth": 0,
  "maxPages": 1
}

For a bounded run with premium fallbacks enabled:

{
  "urls": ["https://docs.python.org/3/tutorial/datastructures.html"],
  "mode": "auto",
  "proxyMode": "auto",
  "maxBrowserAttempts": 4,
  "requestTimeoutSecs": 60,
  "maxRunSecs": 180,
  "maxDepth": 0,
  "maxPages": 5
}

proxyMode: "auto" starts with datacenter retrieval and can try residential browsers. engine: "auto" tries Chrome then Camoufox. Four browser attempts permit both engines at both proxy tiers.

One page shares one deadline across all attempts. The default is 20 seconds; use 45–60 seconds for browser startup and difficult pages. Earlier attempts can consume the budget before later fallbacks run. Supply url, urls or Apify-style startUrls; duplicates are merged. Discovered links stay within the starting origins.

Browser output waits for nonloading main content (or your selected element) to settle. Image, media and font downloads are blocked to preserve the text-retrieval network budget; scripts and stylesheets still load. Set waitForSelector to a visible, nonempty content element for site-specific readiness. browserWaitSecs defaults to 8 (maximum 30), within requestTimeoutSecs; stalled loading shells return BROWSER_NOT_READY without a page charge. HTTP-only mode returns CLIENT_RENDERED_SHELL for detected JavaScript shells. The default response/DOM ceiling is 2 MB.

Transparent pricing

Pay once for a nonempty, inspected page delivered with status: "OK", at the tier that delivered it.

Delivered page	Per page	Per 1,000 pages
HTTP, direct or datacenter	$0.01	$10
Browser, direct or datacenter	$0.03	$30
Residential, HTTP or browser	$0.09	$90

Standard platform usage and the selected proxy usage are included in these prices. Failed attempts, empty content, quarantined pages, robots exclusions and pruned maze pages have no page charge. A small run-start fee is $0.00005 per GB of allocated memory, with a one-event minimum: $0.0001 at the default 2 GB, including runs that deliver no page.

Examples at default memory: 10 HTTP pages cost $0.1001; 10 browser pages cost $0.3001. Use Apify’s maximum charge setting, or API maxTotalChargeUsd, to cap a run. If a delivery tier exceeds the remaining charge budget, its content is withheld and that URL remains unprocessed in the summary.

For straightforward HTTP extraction with the same inspection layer, choose Armored AI Web Scraper, at $5 per 1,000 delivered pages.

Built for autonomous agents

Choose Wolfpack when your agent needs JavaScript rendering or stealth retrieval together with inspection, traceable sources and explicit failure states. It fits research agents, RAG ingestion, document collection, agent memory, competitive intelligence and public-web extraction workflows.

Each run exposes a Dataset, an OUTPUT summary, an INTEGRATIONS kit and an AGENT-TOOL contract. Keep status, url, sourceSha256 and both telemetry objects alongside the text. Treat retrieved content as untrusted evidence when passing it to a model.

MCP

Connect an MCP client using Apify’s server and your Apify token:

{
  "mcpServers": {
    "wolfpack": {
      "url": "https://mcp.apify.com?tools=apricot_blackberry/wolfpack",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}

MCP clients differ in configuration syntax. Use the URL and authorization header with your client’s HTTP transport. The tool exposes the Actor input schema and returns run/output links through Apify MCP.

REST API

curl -X POST \
  'https://api.apify.com/v2/acts/apricot_blackberry~wolfpack/run-sync-get-dataset-items?memory=2048&timeout=180&maxTotalChargeUsd=0.25' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://docs.python.org/3/tutorial/datastructures.html","mode":"auto","maxDepth":0,"maxPages":1}'

Use asynchronous Actor runs and completion webhooks for jobs that can exceed your client’s HTTP timeout. The OpenAPI schema describes the live input interface.

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("apricot_blackberry/wolfpack").call(
    run_input={"url": "https://docs.python.org/3/tutorial/datastructures.html", "maxDepth": 0, "maxPages": 1},
    max_total_charge_usd=0.25,
)
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
documents = [r for r in rows if r["status"] == "OK" and r["sanitizedContent"]]

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('apricot_blackberry/wolfpack').call(
  { url: 'https://docs.python.org/3/tutorial/datastructures.html', maxDepth: 0, maxPages: 1 },
  { maxTotalChargeUsd: 0.25 },
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const documents = items.filter(row => row.status === 'OK' && row.sanitizedContent);

n8n, Make, Zapier, LangChain and CrewAI

• n8n: download the run’s INTEGRATIONS output and import its n8nWorkflow object. Select your own HTTP Header Auth credential with Authorization: Bearer YOUR_APIFY_TOKEN, edit the URL input and execute. The supplied workflow starts inactive.
• Make / Zapier: select Apify’s Run Actor action, choose apricot_blackberry/wolfpack, map url or urls, and read the finished Dataset. The integration kit includes the input mapping and completion-event recipe.
• Webhooks: use Apify’s ACTOR.RUN.SUCCEEDED event and the run’s Dataset ID for asynchronous ingestion. Inspect row statuses before indexing; a finished run can contain unsuccessful pages.
• LangChain / CrewAI / custom agents: wrap the API call as a tool. Map sanitizedContent to document text and preserve the URL, hash, status and telemetry as metadata. The supplied AGENT-TOOL contract includes machine-readable selection guidance and the input schema.

Know exactly what came back

Status	Meaning
OK	Inspection completed; text is available. Nonempty text is billable.
QUARANTINED	A recognized instruction pattern matched; text and outgoing links were withheld.
MAZE_PRUNED	Repetitive branch detected; further traversal stopped.
ROBOTS_DISALLOWED	The robots policy excludes this page.
ROBOTS_UNAVAILABLE	The robots policy could not be checked reliably.
FETCH_FAILED	Retrieval stopped or failed; the error code explains why.
INSPECTION_LIMIT	The inspection safety limit was reached.

securityTelemetry includes tarpitDetected, mazeDetected, spongesStripped, hiddenElementsRemoved, instructionSignals, quotedInstructionBlocksRedacted, quotedInstructionSignals, token accounting and limit indicators. retrievalTelemetry records the successful method, attempted engines/tiers, elapsed times, detected protection signals, blocked subresources and the scope of the network guards.

OUTPUT reports attempted pages, row statuses, stopReason, unprocessed URLs, aggregate token accounting and billablePagesByTier. complete: true means the bounded queue was exhausted; it does not mean every page succeeded.

Content quality and token budgets

maxOutputTokens defaults to 8,192 tokens in the selected tokenEncoding (maximum 50,000), alongside maxOutputChars. outputTokens, tokenLimitApplied and contentTruncated report the delivered budget. Truncation is never counted as normalization savings. Unicode tag payloads and excessive invisible runs are removed while recognized subdivision flags, linguistic joiners and ordinary emoji remain intact.

Inline HTML words remain continuous. JSON strings are decoded once into readable JSON; screening also checks bounded decoded representations and overlapping text windows. Recognized multilingual directives are covered by explicit rules, not a universal language or semantic classifier. Benign credential-storage guidance and negative safety policies are retained. Recognized attacks inside HTML quotations, Markdown quotes/fences and explicitly labeled JSON example fields are redacted; any separate unquoted directive still screens. Quote-only payloads are quarantined. All delivered content remains untrusted.

Maze novelty uses visibility-filtered normalized text, so changing hidden words cannot create apparent useful novelty. Visibility cleanup distinguishes hidden subtrees from inherited text visibility, preserving explicitly visible descendants. Empty extraction returns FETCH_FAILED with EMPTY_CONTENT; detected stalled HTML returns CLIENT_RENDERED_SHELL, without a page charge.

Auto retrieval checks main/selected content before accepting HTTP output. Long navigation cannot make a loading main region billable. A missing or CSS-hidden waitForSelector triggers bounded browser fallback; challenge detection uses active response evidence rather than vendor words in documentation.

Protection boundaries

Target connections are limited to public HTTP(S) destinations on ports 80 and 443. DNS answers are validated and connections use the validated IP. Browser workers do not inherit the Actor token or upstream proxy credentials. Browser subresources and redirects pass through the guarded retrieval path.

Hidden-element cleanup uses HTML attributes and inline and unconditional embedded CSS in HTTP mode. Browser mode also applies computed visibility to a cloned DOM, including loaded external styles. Conditional CSS and dynamic behavior require browser mode.

The HTTP watchdog measures decoded response-body chunks after its grace period. Browser TLS remains end-to-end: browser protection uses navigation/process deadlines and aggregate network-byte limits, not a decoded-body velocity measurement. maxResponseBytes caps decoded HTTP content or the serialized rendered DOM; maxNetworkBytes caps gateway ingress, including headers and TLS overhead, per attempt.

sourceSha256 hashes the inspected response bytes for HTTP and the serialized rendered DOM for browsers. Token counts are exact for the named tokenizer encoding and the extracted text being compared. Dollar savings are estimates only when you supply your input-token price; removed or quarantined content is not credited as normalization savings.

Injection and maze detection use documented heuristics. Recognized instructions inside HTML quotations and code blocks are redacted, with counts and signals in telemetry; matching unquoted instructions are quarantined. These heuristics can miss attacks or flag benign text and repetitive pages. Wolfpack does not certify factual accuracy, identify every form of dataset poisoning or guarantee access through every bot wall or CAPTCHA. Site behavior, proxy availability and access policies affect results. All returned text remains untrusted. Checkpoint/resume across Actor migrations is outside this version.

Support

Use the Issues tab or contact contact@creatorfusion.net with the run ID, URL and expected result. Keep API tokens and private data out of support messages.