# Keyword Research Tool: Volume, CPC, Fan-out, FAQ & GEO (`aitorsm/keyword-fanout`) Actor

Keyword research at scale: expand one seed into hundreds of keyword ideas with real Google search volume, CPC and competition, an opportunity score, and AI-Overview (GEO) flags. Includes People Also Ask, clustering, and paste-ready FAQ + FAQPage schema for SEO and generative-engine content.

- **URL**: https://apify.com/aitorsm/keyword-fanout.md
- **Developed by:** [Aitor Sanchez-Mansilla](https://apify.com/aitorsm) (community)
- **Categories:** SEO tools, AI, Automation
- **Stats:** 5 total users, 5 monthly users, 97.1% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 keyword results

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Keyword Fan-out & FAQ Generator — Autocomplete, People-Also-Ask & Schema

**Turn one seed keyword (or a page URL) into hundreds of the real long-tail queries, questions, and "People also ask" searches your audience actually types — across Google, YouTube, and Bing, in any country.** Then get it back grouped and ready to paste into your content: an FAQ, page headings, comparison pages, and a valid **schema.org `FAQPage` JSON-LD** block.

> **Also a FAQ generator.** Every run writes a ready-to-publish `FAQ.md` and a `FAQPage` JSON-LD file to the key-value store — paste a topic or URL, get an SEO/GEO-optimized FAQ + schema you can drop straight onto a page. It's the AnswerThePublic-style question list *and* the publishable schema in one run.

This is the **discovery + content** engine for SEO and **GEO (Generative Engine Optimization / AI search)**. A search-volume tool tells you *how many* people search a term you already know. This tells you *what* they actually type and ask — the exact strings to write against so your page ranks and gets cited by Google, ChatGPT, and Perplexity. Want both? Turn on volume enrichment and get discovered keywords *with* their monthly demand in one run.

### What it does

For every seed, it fans out into hundreds of autocomplete probes (seed + a–z, question prefixes like *how to / what is / is there a*, and intent suffixes like *api / tool / free / alternative*), keeps the on-topic suggestions, and sorts each into a **content bucket** — one row per keyword:

| Bucket | Use it for |
|---|---|
| `question` | FAQ blocks — the questions Google's "People also ask" and AI engines cite |
| `comparison` | "X vs Y" and alternatives pages |
| `commercial` | high-intent page headings (H2/H3) and product pages |
| `longtail` | body copy and use-case bullets |

### Features

- **🔎 Multi-engine** — fan out across **Google, YouTube, and Bing** autocomplete at once. YouTube surfaces how-to/tutorial intent; Bing adds commercial phrasing Google misses. Results are unioned and de-duplicated, with each keyword tagged by the engines that found it.
- **🌍 Multi-region / multi-language (GEO)** — run every seed across markets (`us`, `gb`, `es`, `mx`, `de`, `fr`, `br`… or explicit `en-us` / `es-mx` locales). Every keyword is tagged with the region(s) it came from — perfect for localized and per-city content.
- **❓ Real "People also ask" + related searches** — optionally pull Google's actual PAA questions and "Related searches" (via the Google Search Results Scraper) — the highest-quality question source for FAQ and AI-answer optimization.
- **📊 Prominence ranking** — every keyword carries its best autocomplete position, a free popularity signal even without volume data.
- **🧭 Recursive depth** — depth 2 re-expands the top discovered keywords for far deeper long-tail coverage.
- **🔗 Seed from a URL** — give a page URL and it reads the title/H1/meta to seed itself: "optimize *this* page" with no manual keyword picking.
- **🧹 Near-duplicate clustering** — collapses reworded variants so your FAQ isn't five versions of one question.
- **📄 Paste-ready output** — writes `FAQ.md`, a **schema.org `FAQPage` JSON-LD** file, and `SUMMARY.md` to the key-value store, ready to drop straight into a page.
- **📈 Volume enrichment (optional)** — chain to the [Keyword Search Volume](https://apify.com/aitorsm/keyword-volume) actor to attach real monthly search volume, CPC, and competition to every keyword.

### Use cases

- **SEO content & FAQ planning** — discover the exact headings and questions a page needs to rank.
- **GEO / AI-search optimization** — capture the sub-questions ChatGPT and Perplexity fan a query into, and pre-answer them so your content gets cited.
- **Localized / international SEO** — build per-country keyword sets in one run.
- **YouTube & video SEO** — mine how-to/tutorial phrasing from YouTube autocomplete.
- **PPC & ad groups** — find long-tail, lower-competition variants around a core term.

### Example

Seed `event organizer software` across Google + YouTube + Bing, US + ES → 400+ keywords: questions (`what is event management software`, `which event management software is best for small business`), comparisons (`event organizer vs event planner`, `eventbrite alternatives`), and long-tail tools you'd never brainstorm. Turn on PAA and you also get Google's real "People also ask" questions; turn on volume and every one gets a monthly-search number.

### Output

- **Dataset** — one row per keyword: `seed`, `keyword`, `bucket`, `sources`, `regions`, `best_rank`, `depth`, `cluster_id`, `is_cluster_representative` (+ `search_volume`, `cpc`, `competition` when enriched).
- **Key-value store** — `FAQ` (markdown FAQ skeleton), `FAQPAGE_JSONLD` (schema.org FAQPage), `SUMMARY` (per-seed overview).

### FAQ

**Do I need an API key or account?** No. Discovery runs on public autocomplete from any IP. PAA and volume enrichment are optional add-ons.

**How is this different from a keyword volume tool?** Volume tools rank terms you already have. This *discovers* the terms — the questions and long-tail you didn't know to look for. Combine them with the volume-enrichment option.

**Does it work for non-English markets?** Yes — set `regions` (e.g. `es`, `mx`, `de`, `br`) and it fans out per locale and tags each keyword with its region.

**What are the FAQ artifacts for?** Drop `FAQ.md` and the `FAQPAGE_JSONLD` schema block straight onto a page to win FAQ rich-results and AI citations. PAA supplies real questions; write the answers (or fill from your own content).

### Support

Questions or a custom keyword/GEO workflow? **business@aitorsm.com**

# Actor input Schema

## `seeds` (type: `array`):

One or more seed keywords/phrases to expand. Each is fanned out into hundreds of real search queries. Tip: feed several SPECIFIC seeds (e.g. "eventbrite api", "event organizer contact list") rather than one broad phrase — vague seeds pull off-topic drift.
## `seedUrls` (type: `array`):

Optional. Give a page URL and the actor reads its title / H1 / meta keywords and uses them as seeds — 'optimize THIS page' without hand-picking keywords.
## `sources` (type: `array`):

Which autocomplete engines to fan out across. Google = web intent, YouTube = how-to/tutorial intent, Bing = alternate commercial phrasing. Using several broadens coverage and de-duplicates automatically.
## `regions` (type: `array`):

Fan out per market. Use country codes (us, gb, es, mx, de, fr, br…) or explicit hl-gl locales (en-us, es-mx). Empty = single language set by 'Language' below. Each keyword is tagged with the region(s) that surfaced it.
## `language` (type: `string`):

Autocomplete language code (hl) when 'Regions' is empty, e.g. en, es, fr, de.
## `includeAlphabet` (type: `boolean`):

Append each letter a–z to grow the long-tail. Biggest source of variety.
## `includeQuestions` (type: `boolean`):

Prefix question words to surface FAQ-ready queries.
## `includeSuffixes` (type: `boolean`):

Append commercial-intent suffixes to surface high-intent variants.
## `customModifiers` (type: `array`):

Extra words applied as BOTH prefix and suffix to every seed (e.g. "london", "2026", "cheap").
## `depth` (type: `integer`):

1 = expand the seeds only. 2 = also re-expand the top discovered keywords (recursive), for much deeper long-tail coverage.
## `subSeedsPerSeed` (type: `integer`):

How many top discovered keywords to re-expand when depth = 2.
## `maxKeywordsPerSeed` (type: `integer`):

Cap the output per seed (0 = unlimited). Keeps the most prominent keywords first.
## `maxProbes` (type: `integer`):

Hard ceiling on total autocomplete requests, to bound cost/time on big seed × source × region grids.
## `cluster` (type: `boolean`):

Group reworded variants of the same query and flag one representative, so your FAQ isn't five versions of one question.
## `generateArtifact` (type: `boolean`):

Write FAQ.md, a schema.org FAQPage JSON-LD file, and SUMMARY.md to the key-value store — ready to drop into a page.
## `serpEnrich` (type: `boolean`):

Pull Google's real 'People also ask' questions and 'Related searches' via the Google Search Results Scraper. The highest-quality question source. Adds that actor's per-page cost.
## `serpActorId` (type: `string`):

Actor used for PAA / related searches.
## `serpMaxQueries` (type: `integer`):

How many queries (seeds + top questions) to send to the SERP actor. Controls SERP cost.
## `serpCountryCode` (type: `string`):

Two-letter country for the SERP search (defaults to the first region's country).
## `enrichVolume` (type: `boolean`):

After discovery, attach real monthly search volume + CPC + competition to every keyword via the Keyword Search Volume actor. Adds that actor's cost.
## `volumeActorId` (type: `string`):

Primary actor to call for volume enrichment.
## `volumeFallbackActorId` (type: `string`):

Called only when the primary volume actor returns no data (e.g. before Google Ads credentials are wired). Third-party, charged per keyword batch. Set empty to disable.
## `volumeGeo` (type: `string`):

Country code/name or geoTargetConstant id passed to the volume actor.
## `volumeLanguage` (type: `string`):

Language code/name or languageConstant id passed to the volume actor.
## `maxConcurrency` (type: `integer`):

Parallel autocomplete probes. Lower it if you hit rate-limits on large runs.
## `proxyConfiguration` (type: `object`):

Optional proxy. Autocomplete works from datacenter IPs; add a proxy only if you hit rate-limits at scale.

## Actor input object example

```json
{
  "seeds": [
    "eventbrite api",
    "event organizer contact list"
  ],
  "seedUrls": [
    "https://example.com/pricing"
  ],
  "sources": [
    "google",
    "youtube",
    "bing"
  ],
  "regions": [
    "us",
    "gb",
    "es"
  ],
  "language": "en",
  "includeAlphabet": true,
  "includeQuestions": true,
  "includeSuffixes": true,
  "depth": 1,
  "subSeedsPerSeed": 5,
  "maxKeywordsPerSeed": 0,
  "maxProbes": 6000,
  "cluster": true,
  "generateArtifact": true,
  "serpEnrich": false,
  "serpActorId": "apify/google-search-scraper",
  "serpMaxQueries": 10,
  "enrichVolume": false,
  "volumeActorId": "aitorsm/keyword-volume",
  "volumeFallbackActorId": "iskander/google-keyword-search-volume-api",
  "maxConcurrency": 8
}
````

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "seeds": [
        "event organizer software"
    ],
    "sources": [
        "google",
        "youtube",
        "bing"
    ],
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("aitorsm/keyword-fanout").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 = {
    "seeds": ["event organizer software"],
    "sources": [
        "google",
        "youtube",
        "bing",
    ],
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("aitorsm/keyword-fanout").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 '{
  "seeds": [
    "event organizer software"
  ],
  "sources": [
    "google",
    "youtube",
    "bing"
  ],
  "language": "en"
}' |
apify call aitorsm/keyword-fanout --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=aitorsm/keyword-fanout",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Keyword Research Tool: Volume, CPC, Fan-out, FAQ & GEO",
        "description": "Keyword research at scale: expand one seed into hundreds of keyword ideas with real Google search volume, CPC and competition, an opportunity score, and AI-Overview (GEO) flags. Includes People Also Ask, clustering, and paste-ready FAQ + FAQPage schema for SEO and generative-engine content.",
        "version": "0.0",
        "x-build-id": "yPo3CNbMboOKay3mR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/aitorsm~keyword-fanout/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-aitorsm-keyword-fanout",
                "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/aitorsm~keyword-fanout/runs": {
            "post": {
                "operationId": "runs-sync-aitorsm-keyword-fanout",
                "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/aitorsm~keyword-fanout/run-sync": {
            "post": {
                "operationId": "run-sync-aitorsm-keyword-fanout",
                "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",
                "properties": {
                    "seeds": {
                        "title": "Seed keywords",
                        "type": "array",
                        "description": "One or more seed keywords/phrases to expand. Each is fanned out into hundreds of real search queries. Tip: feed several SPECIFIC seeds (e.g. \"eventbrite api\", \"event organizer contact list\") rather than one broad phrase — vague seeds pull off-topic drift.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "seedUrls": {
                        "title": "Seed URLs (auto-extract seeds from a page)",
                        "type": "array",
                        "description": "Optional. Give a page URL and the actor reads its title / H1 / meta keywords and uses them as seeds — 'optimize THIS page' without hand-picking keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sources": {
                        "title": "Search engines",
                        "type": "array",
                        "description": "Which autocomplete engines to fan out across. Google = web intent, YouTube = how-to/tutorial intent, Bing = alternate commercial phrasing. Using several broadens coverage and de-duplicates automatically.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "google",
                                "youtube",
                                "bing"
                            ],
                            "enumTitles": [
                                "Google",
                                "YouTube",
                                "Bing"
                            ]
                        },
                        "default": [
                            "google"
                        ]
                    },
                    "regions": {
                        "title": "Regions / locales",
                        "type": "array",
                        "description": "Fan out per market. Use country codes (us, gb, es, mx, de, fr, br…) or explicit hl-gl locales (en-us, es-mx). Empty = single language set by 'Language' below. Each keyword is tagged with the region(s) that surfaced it.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language (used when no regions given)",
                        "type": "string",
                        "description": "Autocomplete language code (hl) when 'Regions' is empty, e.g. en, es, fr, de.",
                        "default": "en"
                    },
                    "includeAlphabet": {
                        "title": "Alphabet expansion (seed + a…z)",
                        "type": "boolean",
                        "description": "Append each letter a–z to grow the long-tail. Biggest source of variety.",
                        "default": true
                    },
                    "includeQuestions": {
                        "title": "Question expansion (how/what/is…)",
                        "type": "boolean",
                        "description": "Prefix question words to surface FAQ-ready queries.",
                        "default": true
                    },
                    "includeSuffixes": {
                        "title": "Intent-suffix expansion (api/tool/free…)",
                        "type": "boolean",
                        "description": "Append commercial-intent suffixes to surface high-intent variants.",
                        "default": true
                    },
                    "customModifiers": {
                        "title": "Custom modifiers",
                        "type": "array",
                        "description": "Extra words applied as BOTH prefix and suffix to every seed (e.g. \"london\", \"2026\", \"cheap\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "depth": {
                        "title": "Expansion depth",
                        "minimum": 1,
                        "maximum": 2,
                        "type": "integer",
                        "description": "1 = expand the seeds only. 2 = also re-expand the top discovered keywords (recursive), for much deeper long-tail coverage.",
                        "default": 1
                    },
                    "subSeedsPerSeed": {
                        "title": "Sub-seeds per seed (depth 2)",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many top discovered keywords to re-expand when depth = 2.",
                        "default": 5
                    },
                    "maxKeywordsPerSeed": {
                        "title": "Max keywords per seed",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the output per seed (0 = unlimited). Keeps the most prominent keywords first.",
                        "default": 0
                    },
                    "maxProbes": {
                        "title": "Max probes (safety cap)",
                        "minimum": 50,
                        "type": "integer",
                        "description": "Hard ceiling on total autocomplete requests, to bound cost/time on big seed × source × region grids.",
                        "default": 6000
                    },
                    "cluster": {
                        "title": "Cluster near-duplicates",
                        "type": "boolean",
                        "description": "Group reworded variants of the same query and flag one representative, so your FAQ isn't five versions of one question.",
                        "default": true
                    },
                    "generateArtifact": {
                        "title": "Generate paste-ready FAQ artifacts",
                        "type": "boolean",
                        "description": "Write FAQ.md, a schema.org FAQPage JSON-LD file, and SUMMARY.md to the key-value store — ready to drop into a page.",
                        "default": true
                    },
                    "serpEnrich": {
                        "title": "Add Google 'People also ask' + related searches ($)",
                        "type": "boolean",
                        "description": "Pull Google's real 'People also ask' questions and 'Related searches' via the Google Search Results Scraper. The highest-quality question source. Adds that actor's per-page cost.",
                        "default": false
                    },
                    "serpActorId": {
                        "title": "SERP actor",
                        "type": "string",
                        "description": "Actor used for PAA / related searches.",
                        "default": "apify/google-search-scraper"
                    },
                    "serpMaxQueries": {
                        "title": "Max SERP queries",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many queries (seeds + top questions) to send to the SERP actor. Controls SERP cost.",
                        "default": 10
                    },
                    "serpCountryCode": {
                        "title": "SERP country code",
                        "type": "string",
                        "description": "Two-letter country for the SERP search (defaults to the first region's country)."
                    },
                    "enrichVolume": {
                        "title": "Enrich with real search volume ($)",
                        "type": "boolean",
                        "description": "After discovery, attach real monthly search volume + CPC + competition to every keyword via the Keyword Search Volume actor. Adds that actor's cost.",
                        "default": false
                    },
                    "volumeActorId": {
                        "title": "Volume actor",
                        "type": "string",
                        "description": "Primary actor to call for volume enrichment.",
                        "default": "aitorsm/keyword-volume"
                    },
                    "volumeFallbackActorId": {
                        "title": "Volume fallback actor ($)",
                        "type": "string",
                        "description": "Called only when the primary volume actor returns no data (e.g. before Google Ads credentials are wired). Third-party, charged per keyword batch. Set empty to disable.",
                        "default": "iskander/google-keyword-search-volume-api"
                    },
                    "volumeGeo": {
                        "title": "Volume geo",
                        "type": "string",
                        "description": "Country code/name or geoTargetConstant id passed to the volume actor."
                    },
                    "volumeLanguage": {
                        "title": "Volume language",
                        "type": "string",
                        "description": "Language code/name or languageConstant id passed to the volume actor."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Parallel autocomplete probes. Lower it if you hit rate-limits on large runs.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional proxy. Autocomplete works from datacenter IPs; add a proxy only if you hit rate-limits at scale."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
