# SEO Keyword & Search-Demand Intel (`seibs.co/keyword-demand-intel`) Actor Bundles Google autosuggest expansion, logged-out SERP features, People-Also-Ask, related searches, and Trends seasonality into one normalized keyword record with intent, an estimated volume + difficulty model, and topic clusters. The layer Keyword Planner gates and Ahrefs/SEMrush charge for. - **URL**: https://apify.com/seibs.co/keyword-demand-intel.md - **Developed by:** [Seibs.co](https://apify.com/seibs.co) (community) - **Categories:** SEO tools, Marketing, Developer tools - **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $3.00 / 1,000 keyword records This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## SEO Keyword & Search-Demand Intel > **TL;DR for SEO freelancers, agencies, content and growth teams, and AI research agents:** Bundles the public Google surfaces that gate exact search volume - **autosuggest** (the long-tail expansion + demand-rank engine), the **logged-out SERP** (features, top results, "People also ask", related searches, difficulty), and **Trends** (seasonality) - into one normalized keyword record. On top of the raw signals it ships the value layer the gated tools charge for: a **transparent, versioned volume + difficulty estimation model**, search-intent classification, and **topic clustering**. Google Keyword Planner hides exact volume behind active ad spend, and Ahrefs ($29-$1,499/mo) / SEMrush ($139-$499/mo) sell the clean numbers - this delivers an honest estimate plus live SERP enrichment, per keyword, pay-per-use. Logged-out public data, rate-limited, no PII. Free Apify plan covers exploration runs on your $5 platform credit. ### Run it in 30 seconds ```python ## Via the Apify Python SDK from apify_client import ApifyClient client = ApifyClient("") run = client.actor("seibs.co/keyword-demand-intel").call(run_input={ "mode": "keyword_expansion", "seeds": ["crm software", "project management tool"] }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ```` Or via curl: ```bash curl -X POST "https://api.apify.com/v2/acts/seibs.co~keyword-demand-intel/run-sync-get-dataset-items?token=" \ -H "Content-Type: application/json" \ -d '{"mode": "keyword_expansion", "seeds": ["crm software"]}' ``` Or click "Try for free" on this page if you prefer the no-code UI. ### What you get Each run produces: - A clean dataset, filterable in the Apify console and downloadable as CSV or JSON - An OUTPUT.html dashboard preview of your top keywords - A `keywords.csv` + per-keyword content worksheet artifact - A sample-output preview at [`.actor/sample-output.json`](./.actor/sample-output.json) - An `access_notes` record up top documenting the sources, the estimation model, and the legal-safety posture ### What does Keyword & Search-Demand Intel do? It assembles search-demand intelligence from the free Google surfaces and normalizes everything into one keyword schema: `term`, `intent` (informational / commercial / transactional / navigational / local), `monthly_searches_estimate` + `volume_band`, `difficulty_score` + `difficulty_band`, `expansion_source`, `serp_features`, `people_also_ask`, `related_searches`, and `seasonality`. Then it runs the **value layer**: - **Long-tail expansion** - fans each seed across Google autosuggest (the bare seed, intent modifiers like *best / vs / price / near me*, and the a-z "alphabet soup") into the real queries people type, deduped and ranked. - **Volume + difficulty estimation model** (`estimation.py`, versioned `kdi-demand-v1`) - a transparent, deterministic model that turns the signals we *can* collect (autosuggest rank + ubiquity, query shape, live SERP competition) into a banded volume estimate with an explicit confidence and a 0-100 difficulty score. The honesty is the product: these are clearly-labeled estimates, **not** Google's gated Keyword Planner figures or any third-party clickstream. - **Live SERP enrichment** - for the terms you choose, parses the logged-out SERP for top results, SERP features (featured snippet, PAA, knowledge panel, image/video/shopping/local packs, ads), and the related/PAA expansion, then scores difficulty from who actually ranks. - **Topic clustering** - collapses a 400-row long-tail expansion into the handful of distinct topics a content team plans around, with summed volume and the easiest member's difficulty. ### Modes | Mode | What it returns | Charges | |---|---|---| | `keyword_expansion` (default) | Seed -> long-tail universe via autosuggest, with intent + estimated volume + proxy difficulty per keyword, plus topic clusters. No SERP fetch (fast + cheap). | `keyword_record` + `volume_estimate` per keyword | | `serp_analysis` | Per seed term, the logged-out SERP: features, top results, PAA, related searches, and SERP-backed difficulty - plus the PAA/related mined into bonus keyword records. | `serp_snapshot` + `keyword_record` + `volume_estimate` per term | | `keyword_metrics` | The flagship bundle: expansion + volume + difficulty + live SERP features (top N terms) + optional seasonality per keyword, then topic clusters. | per-keyword + `serp_snapshot` per SERP-enriched term | | `trend_signal` | Per seed, the Google Trends seasonality signal (trend direction, peak/trough month, spikiness). Best-effort, fails soft. | `keyword_record` + `volume_estimate` per seed | ### The estimation model (read this - it's the point) Exact volume is gated; we do not pretend to reproduce Google's or Ahrefs' proprietary numbers. Instead `estimation.py` is a **published, versioned, deterministic model** you can audit: - **Volume** composes a log-scale demand score from autosuggest rank (rank 0 = the top completion Google offers for a prefix), ubiquity (how many prefixes surface the term), query word count (head vs. long-tail), and SERP corroboration (PAA/related presence, result count), then maps it to a band (`very_low` -> `very_high`) with a confidence that rises with the number of signals. - **Difficulty** scores 0-100 from the live SERP - the share of high-authority domains in the top 10, ad competition, and featured-snippet pressure - or, without a SERP, a transparent proxy from intent + query shape (marked `proxy: true`). Every estimate carries `model_version` and `signals_used` so you can pin, diff, or override it. If you need Google's exact gated number, this is not that; if you need a defensible, free, queryable demand-and-difficulty signal at scale, this is. ### Anti-bot escalation (for the SERP leg) Autosuggest is a lightweight public JSON endpoint that almost always clears on the first httpx pass. The **SERP** is the surface Google fingerprints: a datacenter IP often gets a consent / "unusual traffic" interstitial. The client escalates automatically: `httpx (datacenter)` -> `curl_cffi Chrome TLS impersonation (residential)` -> `Playwright stealth browser (residential)` -> **fail-soft** If every tier is blocked, the term emits a documented `fetch_error` and the run still finishes SUCCEEDED with whatever it collected. Set `browser_cdp_url` (or the `BROWSER_CDP_URL` env var) to a warm anti-detect browser to clear the toughest interstitials. The expansion (autosuggest) leg keeps working regardless, so a run is never empty. ### Legal-safety posture Per the gated-data playbook (Section B): **logged-out public Google surfaces only** (autosuggest, the public SERP, public Trends), rate-limited, no accounts, no user-supplied cookies, no paywalls. Keyword and SERP data carry **no personal data** - PII-minimized by construction. Volume and difficulty are presented as clearly-labeled model estimates, never as Google's gated figures. ### Cost control Five-layer defense shared across the portfolio: pre-flight input caps, a top-level try/except that routes any failure to demo mode (so the run finishes SUCCEEDED with no "Under maintenance" scar), an in-run `_RunBudget` guard that aborts cleanly if compute outruns pay-per-event revenue, in-loop budget checks before each expensive SERP fetch, and hardcoded PPE prices that keep the guard accurate without an API round-trip. **A run that returns nothing costs nothing.** ### Monitor mode Save this actor as an Apify **task** and put it on a **schedule** to track a keyword set over time. On scheduled runs it emits a change digest (rank movement, difficulty shifts, new/lost SERP features) and can POST it to a Slack-compatible `monitor_webhook_url`. Charges one `scheduled_delta_run` per scheduled run. ### Pricing (pay-per-event) | Event | Price | What it is | |---|---|---| | `keyword_record` | $0.003 | One normalized keyword (term, intent, word count, expansion source, proxy difficulty) | | `volume_estimate` | $0.006 | The demand-model output for a term (banded volume + confidence) - the layer Keyword Planner gates | | `serp_snapshot` | $0.008 | Top results + SERP features + PAA + related + SERP-backed difficulty for a term | | `scheduled_delta_run` | $0.050 | One scheduled monitor-mode change digest | For comparison: Ahrefs is $29-$1,499/mo and SEMrush $139-$499/mo, both subscription-gated. ### AI agents / MCP There's a paired **MCP server** (`mcp-keyword-demand-intel`) exposing `expand_keywords`, `keyword_metrics`, `analyze_serp`, `keyword_difficulty`, and `trend_signal` as agent tools, with x402 (USDC on Base) and Skyfire agentic-payment support. The `overview` dataset view and the MCP-compatible output link are built for direct tool-call wiring (Claude, GPT, LangChain, LlamaIndex). ### Related actors Part of the [seibs.co](https://apify.com/seibs.co) intel portfolio. Pairs well with **shopify-store-discovery** (find a store, then size its keyword demand) and **b2b-sales-triggers** (keyword -> intent -> account). See the full portfolio for the public-records and lead-gen actors. # Actor input Schema ## `mode` (type: `string`): keyword\_expansion = fan each seed into its long-tail universe via Google autosuggest, with intent + estimated volume + proxy difficulty per keyword (no SERP fetch, fast + cheap). serp\_analysis = fetch the logged-out SERP for each seed and extract features, top results, People-Also-Ask, related searches, and SERP-backed difficulty. keyword\_metrics = the full bundle: expansion + volume + difficulty + SERP features + seasonality per keyword, then topic clusters. trend\_signal = the Google Trends seasonality signal (trend direction, peak month, spikiness) per seed. ## `seeds` (type: `array`): Seed terms to expand and analyze, e.g. \['crm software', 'project management tool']. In keyword\_expansion / keyword\_metrics each seed fans out into its long-tail universe; in serp\_analysis / trend\_signal each seed is analyzed directly. Hard cap of 30. ## `max_expansions_per_seed` (type: `integer`): Cap on autosuggest expansions kept per seed (keyword\_expansion / keyword\_metrics). Default 120. Higher = a deeper long-tail universe but more keyword\_record charges. ## `max_serp_terms` (type: `integer`): In keyword\_metrics, how many of the highest-estimated-volume keywords get a live SERP fetch (features + SERP-backed difficulty + PAA/related mining). Charges one serp\_snapshot each. Default 10. Set 0 to skip SERP enrichment and run volume/difficulty estimates only. ## `serp_results` (type: `integer`): How many organic results to request per SERP (drives the difficulty model's domain-authority signal). Default 10. ## `alphabet_expansion` (type: `boolean`): Append a-z to each seed in autosuggest ('seed a', 'seed b', ...) to surface the long-tail fan-out. On by default. Turn off for a faster, narrower expansion (bare seed + intent modifiers only). ## `modifier_expansion` (type: `boolean`): Append commercial/intent modifiers (best, vs, price, near me, alternative, ...) to each seed in autosuggest to surface higher-intent long-tail keywords. On by default. ## `include_seasonality` (type: `boolean`): In keyword\_metrics, enrich the seeds with a best-effort Google Trends seasonality signal (trend direction, peak month, spikiness). Trends is unofficial and rate-limited, so it fails soft (seasonality=null) rather than failing the run. Always on for trend\_signal mode. ## `language` (type: `string`): Google interface language code for autosuggest + SERP, e.g. 'en', 'es', 'de'. Default 'en'. ## `country` (type: `string`): Two-letter country code for SERP geo-targeting + Trends region, e.g. 'US', 'GB', 'CA'. Default 'US'. ## `monitor_webhook_url` (type: `string`): When this actor runs under an Apify Schedule (monitor mode), post the change digest (rank movement, difficulty shifts, new/lost SERP features) to this Slack-compatible webhook URL. ## `use_apify_proxy` (type: `boolean`): Route requests through Apify Proxy. The DATACENTER tier handles the first (httpx) autosuggest pass; a RESIDENTIAL tier is provisioned for the SERP anti-bot escalation legs. ## `use_browser_fallback` (type: `boolean`): When the logged-out SERP serves a consent / 'unusual traffic' interstitial to a datacenter IP, automatically escalate: switch to the RESIDENTIAL proxy and retry with curl\_cffi Chrome TLS impersonation, then (if available) a headless browser. Autosuggest rarely needs this. Turn off to use plain httpx only. ## `browser_cdp_url` (type: `string`): Optional. CDP/WebSocket endpoint of an already-running, anti-detect (UC-mode / real Chrome) browser. When set, the SERP browser tier connects to it (inheriting its session + fingerprint) so it passes Google's consent/abuse interstitial. Without it a plain headless Chromium is launched. Can also be set as the BROWSER\_CDP\_URL env var. ## `apify_proxy_groups` (type: `array`): Override the auto-selected proxy group for the first httpx pass. Leave empty to let the actor pick DATACENTER. ## `concurrency` (type: `integer`): Parallel autosuggest/SERP fetches. Google is rate-sensitive; default 4. ## Actor input object example ```json { "mode": "keyword_expansion", "seeds": [ "crm software", "project management tool" ], "max_expansions_per_seed": 80, "max_serp_terms": 10, "serp_results": 10, "alphabet_expansion": true, "modifier_expansion": true, "include_seasonality": false, "language": "en", "country": "US", "monitor_webhook_url": "", "use_apify_proxy": true, "use_browser_fallback": true, "browser_cdp_url": "", "apify_proxy_groups": [], "concurrency": 4 } ``` # Actor output Schema ## `datasetItems` (type: `string`): Narrow, token-efficient slice of every record. Consumer: LLM agents (Claude, GPT, LangChain tools), MCP hosts, SEO dashboards. ## `datasetItemsKeywords` (type: `string`): Full normalized keywords with volume, difficulty, intent, SERP features, and seasonality. Consumer: content planning, RAG ingest, keyword databases. ## `datasetItemsClusters` (type: `string`): One row per topic cluster with summed volume and easiest difficulty. Consumer: content-cluster planning, editorial calendars. ## `datasetItemsMcp` (type: `string`): First 50 overview records as a clean JSON array. Wrap on the agent side in an MCP tool-call envelope. Consumer: MCP servers, Claude Desktop, Cursor, OpenAI Assistants tool calls. ## `datasetItemsCsv` (type: `string`): Spreadsheet-friendly export of the overview view. Consumer: SEO analysts, Excel / Google Sheets users. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "mode": "keyword_expansion", "seeds": [ "crm software", "project management tool" ], "max_expansions_per_seed": 80, "language": "en", "country": "US" }; // Run the Actor and wait for it to finish const run = await client.actor("seibs.co/keyword-demand-intel").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "mode": "keyword_expansion", "seeds": [ "crm software", "project management tool", ], "max_expansions_per_seed": 80, "language": "en", "country": "US", } # Run the Actor and wait for it to finish run = client.actor("seibs.co/keyword-demand-intel").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "mode": "keyword_expansion", "seeds": [ "crm software", "project management tool" ], "max_expansions_per_seed": 80, "language": "en", "country": "US" }' | apify call seibs.co/keyword-demand-intel --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=seibs.co/keyword-demand-intel", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "SEO Keyword & Search-Demand Intel", "description": "Bundles Google autosuggest expansion, logged-out SERP features, People-Also-Ask, related searches, and Trends seasonality into one normalized keyword record with intent, an estimated volume + difficulty model, and topic clusters. The layer Keyword Planner gates and Ahrefs/SEMrush charge for.", "version": "0.1", "x-build-id": "itxBv2UpCiJ62XwQK" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/seibs.co~keyword-demand-intel/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-seibs.co-keyword-demand-intel", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/seibs.co~keyword-demand-intel/runs": { "post": { "operationId": "runs-sync-seibs.co-keyword-demand-intel", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/seibs.co~keyword-demand-intel/run-sync": { "post": { "operationId": "run-sync-seibs.co-keyword-demand-intel", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "mode" ], "properties": { "mode": { "title": "Mode", "enum": [ "keyword_expansion", "serp_analysis", "keyword_metrics", "trend_signal" ], "type": "string", "description": "keyword_expansion = fan each seed into its long-tail universe via Google autosuggest, with intent + estimated volume + proxy difficulty per keyword (no SERP fetch, fast + cheap). serp_analysis = fetch the logged-out SERP for each seed and extract features, top results, People-Also-Ask, related searches, and SERP-backed difficulty. keyword_metrics = the full bundle: expansion + volume + difficulty + SERP features + seasonality per keyword, then topic clusters. trend_signal = the Google Trends seasonality signal (trend direction, peak month, spikiness) per seed.", "default": "keyword_expansion" }, "seeds": { "title": "Seed keywords", "maxItems": 30, "type": "array", "description": "Seed terms to expand and analyze, e.g. ['crm software', 'project management tool']. In keyword_expansion / keyword_metrics each seed fans out into its long-tail universe; in serp_analysis / trend_signal each seed is analyzed directly. Hard cap of 30.", "default": [], "items": { "type": "string" } }, "max_expansions_per_seed": { "title": "Max long-tail keywords per seed", "minimum": 1, "maximum": 300, "type": "integer", "description": "Cap on autosuggest expansions kept per seed (keyword_expansion / keyword_metrics). Default 120. Higher = a deeper long-tail universe but more keyword_record charges.", "default": 120 }, "max_serp_terms": { "title": "Max terms to SERP-enrich (keyword_metrics)", "minimum": 0, "maximum": 50, "type": "integer", "description": "In keyword_metrics, how many of the highest-estimated-volume keywords get a live SERP fetch (features + SERP-backed difficulty + PAA/related mining). Charges one serp_snapshot each. Default 10. Set 0 to skip SERP enrichment and run volume/difficulty estimates only.", "default": 10 }, "serp_results": { "title": "Organic results per SERP", "minimum": 1, "maximum": 20, "type": "integer", "description": "How many organic results to request per SERP (drives the difficulty model's domain-authority signal). Default 10.", "default": 10 }, "alphabet_expansion": { "title": "Alphabet-soup expansion", "type": "boolean", "description": "Append a-z to each seed in autosuggest ('seed a', 'seed b', ...) to surface the long-tail fan-out. On by default. Turn off for a faster, narrower expansion (bare seed + intent modifiers only).", "default": true }, "modifier_expansion": { "title": "Intent-modifier expansion", "type": "boolean", "description": "Append commercial/intent modifiers (best, vs, price, near me, alternative, ...) to each seed in autosuggest to surface higher-intent long-tail keywords. On by default.", "default": true }, "include_seasonality": { "title": "Include Google Trends seasonality (keyword_metrics)", "type": "boolean", "description": "In keyword_metrics, enrich the seeds with a best-effort Google Trends seasonality signal (trend direction, peak month, spikiness). Trends is unofficial and rate-limited, so it fails soft (seasonality=null) rather than failing the run. Always on for trend_signal mode.", "default": false }, "language": { "title": "Language (hl)", "type": "string", "description": "Google interface language code for autosuggest + SERP, e.g. 'en', 'es', 'de'. Default 'en'.", "default": "en" }, "country": { "title": "Country (gl / geo)", "type": "string", "description": "Two-letter country code for SERP geo-targeting + Trends region, e.g. 'US', 'GB', 'CA'. Default 'US'.", "default": "US" }, "monitor_webhook_url": { "title": "Monitor webhook URL (Slack / email, optional)", "type": "string", "description": "When this actor runs under an Apify Schedule (monitor mode), post the change digest (rank movement, difficulty shifts, new/lost SERP features) to this Slack-compatible webhook URL.", "default": "" }, "use_apify_proxy": { "title": "Use Apify Proxy", "type": "boolean", "description": "Route requests through Apify Proxy. The DATACENTER tier handles the first (httpx) autosuggest pass; a RESIDENTIAL tier is provisioned for the SERP anti-bot escalation legs.", "default": true }, "use_browser_fallback": { "title": "Anti-bot escalation (curl_cffi + browser)", "type": "boolean", "description": "When the logged-out SERP serves a consent / 'unusual traffic' interstitial to a datacenter IP, automatically escalate: switch to the RESIDENTIAL proxy and retry with curl_cffi Chrome TLS impersonation, then (if available) a headless browser. Autosuggest rarely needs this. Turn off to use plain httpx only.", "default": true }, "browser_cdp_url": { "title": "Warm browser CDP endpoint (optional)", "type": "string", "description": "Optional. CDP/WebSocket endpoint of an already-running, anti-detect (UC-mode / real Chrome) browser. When set, the SERP browser tier connects to it (inheriting its session + fingerprint) so it passes Google's consent/abuse interstitial. Without it a plain headless Chromium is launched. Can also be set as the BROWSER_CDP_URL env var.", "default": "" }, "apify_proxy_groups": { "title": "Proxy groups (optional override)", "type": "array", "description": "Override the auto-selected proxy group for the first httpx pass. Leave empty to let the actor pick DATACENTER.", "default": [], "items": { "type": "string" } }, "concurrency": { "title": "Max concurrent requests", "minimum": 1, "maximum": 8, "type": "integer", "description": "Parallel autosuggest/SERP fetches. Google is rate-sensitive; default 4.", "default": 4 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```