# YouTube Autocomplete Keywords Scraper (`automation-lab/youtube-autocomplete-keywords-scraper`) Actor

🎬 Find public YouTube autocomplete keyword suggestions by seed, market, language, and expansion modifiers for video SEO research.

- **URL**: https://apify.com/automation-lab/youtube-autocomplete-keywords-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## YouTube Autocomplete Keywords Scraper

Find public YouTube autocomplete keyword suggestions from seed keywords, markets, languages, and expansion modifiers.

Use this actor to turn a small list of video ideas into keyword suggestions that real YouTube searchers are likely to type.

### What does YouTube Autocomplete Keywords Scraper do?

YouTube Autocomplete Keywords Scraper queries the public Google suggestions endpoint for YouTube search.

It returns autocomplete suggestions for each seed keyword you provide.

It can also expand each seed with alphabet, numeric, or custom modifiers.

For example, the seed `youtube seo` can be checked directly and as `youtube seo a`, `youtube seo b`, `youtube seo tutorial`, or any custom modifier you choose.

The actor is HTTP-only and does not open a browser.

It does not need a YouTube account.

It does not scrape private YouTube data.

### Who is it for?

🎬 YouTube creators use it to find video title ideas.

📈 SEO specialists use it to discover search phrases for YouTube optimization.

🧑‍💻 Content marketers use it to build keyword lists before publishing videos.

🏢 Agencies use it to research different markets and languages for clients.

🧪 Product teams use it to monitor search demand around brands, tutorials, and comparisons.

### Why use this actor?

YouTube autocomplete is useful because it reflects search phrases suggested to users while they type.

This actor makes those suggestions exportable.

You can run it from the Apify Console, API, scheduler, or MCP.

You can save results as JSON, CSV, Excel, HTML, XML, or RSS through Apify datasets.

You can combine it with other Apify actors for video research, channel research, and content planning.

### What data can you extract?

| Field | Description |
| --- | --- |
| `seed` | Original seed keyword from your input |
| `query` | Exact query sent to the autocomplete endpoint |
| `suggestion` | YouTube autocomplete suggestion text |
| `rank` | Position in the response for that query |
| `expansion` | Direct, alphabet, alphanumeric, or custom expansion mode |
| `modifier` | Modifier appended to the seed, if any |
| `language` | Language parameter used for the request |
| `market` | Country / market parameter used for the request |
| `sourceUrl` | Exact public endpoint URL used |
| `fetchedAt` | ISO timestamp for the fetch batch |

### How much does it cost to scrape YouTube autocomplete keywords?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a low per-suggestion fee for each saved autocomplete record.

The formula-derived BRONZE price is about $0.05 per 1,000 suggestion records after applying the platform pricing floor.

Actual billing is shown by Apify before and after each run.

Small first runs are inexpensive because the input prefill limits expansions.

### Input overview

The most important input is `seedKeywords`.

Add one or more base keywords such as:

- `youtube seo`
- `apify`
- `how to edit videos`
- `best microphone`

Then choose language, market, and expansion mode.

### Seed keywords

Seed keywords are the base terms you want to research.

The actor trims duplicate whitespace and ignores empty strings.

Duplicate seed keywords are removed before requests are made.

Each seed is processed independently.

Suggestions are deduplicated per seed so one seed does not output the same suggestion many times.

### Locale options

The `language` input maps to the public endpoint `hl` parameter.

Examples:

- `en` for English
- `es` for Spanish
- `de` for German
- `fr` for French

The `market` input maps to the public endpoint `gl` parameter.

Examples:

- `US`
- `GB`
- `DE`
- `FR`

Locale settings can change suggestions.

Test a few markets if your content has an international audience.

### Expansion modes

`none` fetches only the exact seed keyword.

`alphabet` fetches the seed plus `a` through `z` modifiers.

`alphanumeric` fetches the seed plus `a` through `z` and `0` through `9` modifiers.

`custom` uses the modifiers you provide.

Custom modifiers are useful for words such as:

- `tutorial`
- `review`
- `price`
- `2026`
- `vs`

### Limits and performance

`maxSuggestionsPerSeed` controls how many suggestions are kept from each endpoint response.

YouTube usually returns up to 10 suggestions for a request.

`maxExpansionsPerSeed` controls how many modifier requests are made for each seed.

Use a low value for first runs.

Increase it when you are ready to build a larger keyword list.

`requestDelayMs` adds a small delay between requests.

The actor is designed for practical keyword research, not aggressive high-volume crawling.

### How to use YouTube Autocomplete Keywords Scraper

1. Open the actor on Apify.

2. Enter your seed keywords.

3. Choose language and market.

4. Choose expansion mode.

5. Keep expansion limits low for the first run.

6. Start the run.

7. Export the dataset in your preferred format.

8. Use the suggestions for titles, tags, briefs, or topic clusters.

### Example input

```json
{
  "seedKeywords": ["youtube seo", "apify"],
  "language": "en",
  "market": "US",
  "expansionMode": "alphabet",
  "maxSuggestionsPerSeed": 10,
  "maxExpansionsPerSeed": 5,
  "requestDelayMs": 100
}
````

### Example output

```json
{
  "seed": "youtube seo",
  "query": "youtube seo a",
  "suggestion": "youtube seo ai",
  "rank": 1,
  "expansion": "alphabet",
  "modifier": "a",
  "language": "en",
  "market": "US",
  "sourceUrl": "https://suggestqueries.google.com/complete/search?...",
  "fetchedAt": "2026-06-03T08:00:00.000Z"
}
```

### Tips for better YouTube keyword research

Start broad, then run again with promising suggestions as new seeds.

Use custom modifiers for commercial or tutorial intent.

Compare markets when planning multilingual content.

Export CSV for quick spreadsheet clustering.

Run the actor regularly to monitor changes around your niche.

### Integrations

Use Apify schedules to refresh keyword lists weekly.

Send dataset exports to Google Sheets through Apify integrations.

Use webhooks to trigger downstream content brief generation.

Combine results with YouTube video or channel scrapers for deeper research.

Feed suggestions into your internal SEO dashboards.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/youtube-autocomplete-keywords-scraper').call({
  seedKeywords: ['youtube seo'],
  language: 'en',
  market: 'US',
  expansionMode: 'alphabet',
  maxExpansionsPerSeed: 5,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/youtube-autocomplete-keywords-scraper').call(run_input={
    'seedKeywords': ['youtube seo'],
    'language': 'en',
    'market': 'US',
    'expansionMode': 'alphabet',
    'maxExpansionsPerSeed': 5,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~youtube-autocomplete-keywords-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"seedKeywords":["youtube seo"],"language":"en","market":"US","expansionMode":"alphabet","maxExpansionsPerSeed":5}'
```

### MCP usage

You can use this actor through Apify MCP with Claude Code or Claude Desktop.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/youtube-autocomplete-keywords-scraper
```

Claude Code setup:

```bash
claude mcp add apify-youtube-keywords "https://mcp.apify.com/?tools=automation-lab/youtube-autocomplete-keywords-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-youtube-keywords": {
      "url": "https://mcp.apify.com/?tools=automation-lab/youtube-autocomplete-keywords-scraper"
    }
  }
}
```

Example prompts:

- "Run YouTube Autocomplete Keywords Scraper for `video editing` in the US market."
- "Find YouTube keyword suggestions for `apify` using alphabet expansion."
- "Export the suggestions as a table and group them by modifier."

### Data quality notes

Autocomplete suggestions are returned by a public endpoint.

Results may change by time, market, language, and YouTube/Google backend behavior.

Some seeds return fewer suggestions than others.

Rank is the rank in the specific endpoint response, not a search volume metric.

The actor does not estimate monthly search volume.

### Troubleshooting

If you receive few suggestions, try a broader seed keyword.

If suggestions look unexpected, verify your `language` and `market` inputs.

If a run is too large, reduce `maxExpansionsPerSeed` or use `custom` expansion.

If duplicate-looking results appear, remember that different seeds can produce similar suggestions.

### Legality and responsible use

This actor fetches public autocomplete suggestion data.

It does not access private user data.

It does not require a YouTube login.

You are responsible for using the output in compliance with Apify terms, YouTube/Google terms, and applicable laws.

Use reasonable request volumes and avoid abusive automation patterns.

### Related scrapers

Use these automation-lab actors with this keyword scraper:

- https://apify.com/automation-lab/youtube-scraper
- https://apify.com/automation-lab/youtube-channel-scraper
- https://apify.com/automation-lab/google-search-results-scraper
- https://apify.com/automation-lab/google-trends-scraper

### FAQ

#### Does this actor require a YouTube account?

No. It uses a public autocomplete endpoint and does not log in.

#### Does it return search volume?

No. It returns autocomplete suggestions and ranks inside each endpoint response.

#### Can I research non-English keywords?

Yes. Set the `language` and `market` fields to match the region you want to inspect.

#### Can I use my own modifiers?

Yes. Select `custom` expansion mode and provide `customModifiers`.

#### Why are there fewer than 10 suggestions?

Some queries simply return fewer public suggestions.

#### Why did two seeds produce the same suggestion?

Deduplication is per seed so you can still see which seeds lead to similar phrases.

### Changelog

Initial version extracts seed, query, suggestion, rank, expansion provenance, locale parameters, source URL, and fetch timestamp.

# Actor input Schema

## `seedKeywords` (type: `array`):

Base YouTube search keywords to expand into autocomplete suggestions.

## `language` (type: `string`):

Google/YouTube language code used by the autocomplete endpoint, for example en, es, de, fr.

## `market` (type: `string`):

Two-letter country code used by the autocomplete endpoint, for example US, GB, DE, FR.

## `expansionMode` (type: `string`):

Choose whether to fetch only the seed keyword or also seed + alphabet/numeric/custom modifiers.

## `customModifiers` (type: `array`):

Used only when Expansion mode is custom. Each modifier is appended after the seed keyword.

## `maxSuggestionsPerSeed` (type: `integer`):

Maximum autocomplete suggestions kept from each seed/modifier request. YouTube usually returns up to 10.

## `maxExpansionsPerSeed` (type: `integer`):

Maximum alphabet/numeric/custom modifiers to request per seed. Keep low for first runs.

## `requestDelayMs` (type: `integer`):

Optional polite delay between autocomplete requests.

## Actor input object example

```json
{
  "seedKeywords": [
    "apify",
    "youtube seo"
  ],
  "language": "en",
  "market": "US",
  "expansionMode": "alphabet",
  "customModifiers": [
    "tutorial",
    "review",
    "2026"
  ],
  "maxSuggestionsPerSeed": 10,
  "maxExpansionsPerSeed": 5,
  "requestDelayMs": 100
}
```

# Actor output Schema

## `suggestions` (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 = {
    "seedKeywords": [
        "apify",
        "youtube seo"
    ],
    "language": "en",
    "market": "US",
    "expansionMode": "alphabet",
    "customModifiers": [
        "tutorial",
        "review",
        "2026"
    ],
    "maxSuggestionsPerSeed": 10,
    "maxExpansionsPerSeed": 5,
    "requestDelayMs": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/youtube-autocomplete-keywords-scraper").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 = {
    "seedKeywords": [
        "apify",
        "youtube seo",
    ],
    "language": "en",
    "market": "US",
    "expansionMode": "alphabet",
    "customModifiers": [
        "tutorial",
        "review",
        "2026",
    ],
    "maxSuggestionsPerSeed": 10,
    "maxExpansionsPerSeed": 5,
    "requestDelayMs": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/youtube-autocomplete-keywords-scraper").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 '{
  "seedKeywords": [
    "apify",
    "youtube seo"
  ],
  "language": "en",
  "market": "US",
  "expansionMode": "alphabet",
  "customModifiers": [
    "tutorial",
    "review",
    "2026"
  ],
  "maxSuggestionsPerSeed": 10,
  "maxExpansionsPerSeed": 5,
  "requestDelayMs": 100
}' |
apify call automation-lab/youtube-autocomplete-keywords-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/youtube-autocomplete-keywords-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Autocomplete Keywords Scraper",
        "description": "🎬 Find public YouTube autocomplete keyword suggestions by seed, market, language, and expansion modifiers for video SEO research.",
        "version": "0.1",
        "x-build-id": "7v605d5QuHcfTdwR9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~youtube-autocomplete-keywords-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-youtube-autocomplete-keywords-scraper",
                "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/automation-lab~youtube-autocomplete-keywords-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-youtube-autocomplete-keywords-scraper",
                "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/automation-lab~youtube-autocomplete-keywords-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-youtube-autocomplete-keywords-scraper",
                "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": [
                    "seedKeywords"
                ],
                "properties": {
                    "seedKeywords": {
                        "title": "Seed keywords",
                        "type": "array",
                        "description": "Base YouTube search keywords to expand into autocomplete suggestions.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "language": {
                        "title": "Language (hl)",
                        "type": "string",
                        "description": "Google/YouTube language code used by the autocomplete endpoint, for example en, es, de, fr.",
                        "default": "en"
                    },
                    "market": {
                        "title": "Market / country (gl)",
                        "type": "string",
                        "description": "Two-letter country code used by the autocomplete endpoint, for example US, GB, DE, FR.",
                        "default": "US"
                    },
                    "expansionMode": {
                        "title": "Expansion mode",
                        "enum": [
                            "none",
                            "alphabet",
                            "alphanumeric",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Choose whether to fetch only the seed keyword or also seed + alphabet/numeric/custom modifiers.",
                        "default": "alphabet"
                    },
                    "customModifiers": {
                        "title": "Custom modifiers",
                        "type": "array",
                        "description": "Used only when Expansion mode is custom. Each modifier is appended after the seed keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSuggestionsPerSeed": {
                        "title": "Max suggestions per request",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum autocomplete suggestions kept from each seed/modifier request. YouTube usually returns up to 10.",
                        "default": 10
                    },
                    "maxExpansionsPerSeed": {
                        "title": "Max expansions per seed",
                        "minimum": 0,
                        "maximum": 36,
                        "type": "integer",
                        "description": "Maximum alphabet/numeric/custom modifiers to request per seed. Keep low for first runs.",
                        "default": 26
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Optional polite delay between autocomplete requests.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
