# Ubersuggest Keyword Scraper (`crawlerbros/ubersuggest-scraper`) Actor

Scrape keyword suggestions from Ubersuggest / Neil Patel. Given a seed keyword or domain, returns related keyword suggestions per country + language.

- **URL**: https://apify.com/crawlerbros/ubersuggest-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 14 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Ubersuggest Keyword Scraper — Related Keyword Suggestions Across 22 Countries

Get related-keyword suggestions for any seed keyword or domain across 22 countries and 9 languages — powered by the same public Google Suggest feed that Ubersuggest and most free keyword tools ingest as their base list.

### What this actor does

Supply a seed keyword (`"coffee"`) or one or more domains (`["make.com"]`) and the actor returns a list of related search terms that real users are typing into Google right now, scoped to the country and language you pick. It uses **Google Suggest** — Google's public keyword suggestion API — as its data source, which means the suggestions are fresh, real, and don't require any Ubersuggest login or paid subscription to retrieve.

A convenience flag called `autoMatchLanguageToCountry` (on by default) upgrades the default English language to the country's native language when you pick a non-US market — so selecting `country: de` automatically pulls German suggestions, `country: jp` pulls Japanese, and so on. You can override this at any time by setting `language` explicitly. When datacenter IPs get rate-limited, the actor rotates sessions up to 8 times and can fall back through a residential proxy to keep suggestion responses flowing.

v1 of this actor is deliberately focused on **real, verifiable data**: the related-keyword list. Ubersuggest's famous metric numbers — search volume, CPC, SEO difficulty, paid difficulty, domain authority, traffic estimates, backlinks, top pages — are walled off behind a paid Neil Patel subscription and cannot be extracted without authenticating as a paying user. This actor refuses to fabricate those numbers; if you enable the walled sections, it emits an honest sentinel record instead. See the **Known limitations** section for details.

### Key features

- **Google Suggest-backed** related-keyword lists — real data, no login required.
- **22 countries** — `us`, `uk`, `de`, `fr`, `jp`, `br`, `es`, `it`, `au`, `ca`, `in`, `mx`, `nl`, `ru`, `cn`, `kr`, `tr`, `pl`, `se`, `ch`, `at`, `be`.
- **9 languages** — `en`, `de`, `fr`, `es`, `it`, `ja`, `pt`, `ko`, `zh`.
- **Auto language-to-country matching** (default true) — picking `country: de` upgrades `language` from `en` to `de` automatically; override anytime.
- **Seed from keyword or domain** — pass a seed keyword directly, or let the actor convert a domain (`make.com` → seed `make`).
- **Session rotation** — up to 8 retry sessions on upstream rate limits.
- **Honest output** — walled metric numbers (volume, CPC, etc.) are simply absent rather than fabricated.
- **Apify-friendly timing** — overall run capped at ~4.5 minutes so daily platform test runs stay well under the ceiling.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `urls` | array | `["make.com"]` | Domains converted into keyword seeds. `make.com` becomes the seed `make`. |
| `keyword` | string | `"coffee"` | Direct seed keyword. Takes precedence over `urls` when both are provided. |
| `country` | enum | `us` | Country geo. 22 supported markets (see list above). |
| `language` | enum | `en` | Language for suggestions. 9 supported languages. |
| `autoMatchLanguageToCountry` | boolean | `true` | When true, upgrades `language` from `en` to the country's native language if you picked a non-US country without overriding language yourself. |
| `proxyConfiguration` | proxy | Apify Residential US | Residential proxy — helps when datacenter IPs get rate-limited. |

**Example input**

```json
{
  "keyword": "coffee",
  "country": "de",
  "autoMatchLanguageToCountry": true
}
````

### Output

**Keyword record (success)**

```json
{
  "type": "keyword",
  "keyword": "coffee",
  "country": "de",
  "language": "de",
  "suggestions": [
    { "type": "keyword", "keyword": "coffee fellows", "country": "de", "language": "de" },
    { "type": "keyword", "keyword": "coffee circle", "country": "de", "language": "de" }
  ],
  "updated_at": "2026-04-24T10:15:00+00:00",
  "scrapedAt": "2026-04-24T10:15:00+00:00"
}
```

**Field descriptions**

- `type` — always `"keyword"` for success records, or `"ubersuggest_error"` for sentinels.
- `keyword` — the seed you supplied.
- `country` / `language` — the geo/language actually used for the request.
- `suggestions` — list of related-keyword objects, each with its own `keyword`, `country`, `language`.
- `updated_at` / `scrapedAt` — ISO 8601 UTC timestamps.

Fields that cannot be populated without a paid login (`volume`, `cpc`, `currency`, `competition`, `seo_difficulty`, `paid_difficulty`, `searchIntent`) are **omitted entirely** from the record rather than filled with nulls or zeros.

**Upstream-blocked sentinel**

```json
{
  "type": "ubersuggest_error",
  "reason": "upstream_blocked",
  "message": "Google Suggest returned empty results for every session attempt. Try again later or narrow the seed.",
  "keyword": "very long ambiguous query",
  "scrapedAt": "2026-04-24T10:15:00+00:00"
}
```

**Error sentinel** — emitted on invalid input or when every suggestion session returned empty:

```json
{
  "type": "ubersuggest_error",
  "reason": "upstream_blocked",
  "message": "Google Suggest returned empty / blocked responses across all 8 sessions. Re-run to get fresh IPs or try a different seed keyword.",
  "scrapedAt": "2026-04-24T10:15:00+00:00"
}
```

### Use cases

- **SEO keyword research** — generate a wide net of long-tail suggestions around a seed term before running deeper analysis in a paid tool.
- **Content planning** — find adjacent topics and phrasings users are searching for in your target market.
- **Ad copy ideation** — discover real search phrasings to inform Google Ads keyword targeting.
- **Multilingual market research** — flip `country` across your target geos (with `autoMatchLanguageToCountry` on) to see how search intent differs by region.
- **Domain-based seeding** — feed a list of competitor domains and convert each one into a related-keyword map.

### FAQ

**Why can't you scrape search volume / CPC / SEO difficulty?**
Ubersuggest's metric numbers are fetched client-side via authenticated API calls to `app.neilpatel.com`. Without a paid-subscription bearer token, every such call returns HTTP 401/403. Those numeric fields are simply absent from our output rather than fabricated.

**Where do the `suggestions` come from then?**
Google Suggest — the same public keyword-suggestion API that Google's search box uses for autocomplete and that most free keyword tools (including Ubersuggest) ingest as their base suggestion list. The actor calls it with the country and language you specified.

**What does `autoMatchLanguageToCountry` actually do?**
If you pick `country: de` but leave `language` at its default `en`, the actor upgrades `language` to `de` so you get German suggestions for the German market. If you explicitly set both, your choice wins — no override happens. This prevents the common mistake of getting English suggestions for a non-English market.

**Will a residential proxy help?**
Usually not needed for keyword suggestions — Google Suggest is open. Proxy rotation is configured for cases where the datacenter IP gets rate-limited; the actor rotates sessions up to 8 times on empty/blocked responses.

**Can I pass my Ubersuggest cookie to unlock the walled sections?**
Not in v1. A future version may add optional cookie-based authentication for the paid sections, but it would effectively be a bring-your-own-subscription tool.

**Does this scrape `neilpatel.com` or `app.neilpatel.com`?**
No. Those app pages are pure single-page-app shells with no data in the HTML, and the API requires a bearer token. This actor does not hit Ubersuggest's infrastructure.

**How many suggestions do I get per seed?**
Google Suggest typically returns about 10 phrases per query. For broader coverage, re-run with alphabetic seed expansion (e.g. `"coffee a"`, `"coffee b"`, …) — this is a standard SEO technique.

### Known limitations

- **Metric numbers** (volume, CPC, SEO difficulty, domain authority, backlinks, top pages) **cannot be extracted** without a paid Ubersuggest subscription cookie. Those toggles were removed from the input form because they always returned an empty sentinel in v1 — if you need those metrics you'll need a paid data source.
- **22 countries and 9 languages** are currently supported. If your target market is outside this list, pick the closest neighbor or submit a feature request.
- **~10 suggestions per seed** is Google Suggest's cap per call. For deeper coverage use alphabetic seed expansion.
- **Session rotation retries** are capped at 8 attempts per run; if Google Suggest persistently blocks all sessions, the actor emits an error sentinel and exits rather than retrying forever.
- **No historical data** — Google Suggest reflects the current suggestion list, not suggestions from the past. Run the actor on a schedule if you want to track change over time.

# Actor input Schema

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

List of domains or URLs to use as seeds. The registered domain is converted into a keyword seed. Leave empty if using the `keyword` field instead.

## `keyword` (type: `string`):

Seed keyword to research. If set, this takes precedence over `urls`. Example: 'coffee', 'project management software'.

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

Country for keyword suggestions. The `language` field is actually the stronger signal — for genuinely localized results, set `language` to the country's native language (e.g. `country=it, language=it` for Italian results; `country=jp, language=ja` for Japanese). If you leave `language=en` and pick a non-US country, Google Suggest mostly returns a generic English list regardless of country.

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

Language for suggestions (dominant signal — overrides country for result content). Set this to match the country's native language for localized results. Leaving it at `en` for a non-US country yields generic English suggestions.

## `autoMatchLanguageToCountry` (type: `boolean`):

When enabled, if you pick a non-US country but leave language at its default `en`, the actor silently upgrades language to the country's native language (e.g. `country=jp → language=ja`, `country=br → language=pt`). Saves you a click and avoids the common user error of getting generic-English results for non-US markets. Disable if you specifically want English-global results filtered by country.

## `proxyConfiguration` (type: `object`):

Residential Apify proxy is recommended in case Cloudflare blocks datacenter IPs on Ubersuggest.

## Actor input object example

```json
{
  "urls": [
    "make.com"
  ],
  "keyword": "coffee",
  "country": "us",
  "language": "en",
  "autoMatchLanguageToCountry": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "urls": [
        "make.com"
    ],
    "keyword": "coffee",
    "country": "us",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ubersuggest-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 = {
    "urls": ["make.com"],
    "keyword": "coffee",
    "country": "us",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ubersuggest-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 '{
  "urls": [
    "make.com"
  ],
  "keyword": "coffee",
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call crawlerbros/ubersuggest-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ubersuggest Keyword Scraper",
        "description": "Scrape keyword suggestions from Ubersuggest / Neil Patel. Given a seed keyword or domain, returns related keyword suggestions per country + language.",
        "version": "1.0",
        "x-build-id": "jqjf8a0eAE32tDmnU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ubersuggest-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-ubersuggest-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/crawlerbros~ubersuggest-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-ubersuggest-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/crawlerbros~ubersuggest-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-ubersuggest-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",
                "properties": {
                    "urls": {
                        "title": "Domains (for domain-based keyword seeding)",
                        "type": "array",
                        "description": "List of domains or URLs to use as seeds. The registered domain is converted into a keyword seed. Leave empty if using the `keyword` field instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Seed keyword (optional)",
                        "type": "string",
                        "description": "Seed keyword to research. If set, this takes precedence over `urls`. Example: 'coffee', 'project management software'."
                    },
                    "country": {
                        "title": "Country (geo)",
                        "enum": [
                            "us",
                            "uk",
                            "de",
                            "fr",
                            "jp",
                            "br",
                            "es",
                            "it",
                            "au",
                            "ca",
                            "in",
                            "mx",
                            "nl",
                            "ru",
                            "cn",
                            "kr",
                            "tr",
                            "pl",
                            "se",
                            "ch",
                            "at",
                            "be"
                        ],
                        "type": "string",
                        "description": "Country for keyword suggestions. The `language` field is actually the stronger signal — for genuinely localized results, set `language` to the country's native language (e.g. `country=it, language=it` for Italian results; `country=jp, language=ja` for Japanese). If you leave `language=en` and pick a non-US country, Google Suggest mostly returns a generic English list regardless of country.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "ja",
                            "pt",
                            "ko",
                            "zh"
                        ],
                        "type": "string",
                        "description": "Language for suggestions (dominant signal — overrides country for result content). Set this to match the country's native language for localized results. Leaving it at `en` for a non-US country yields generic English suggestions.",
                        "default": "en"
                    },
                    "autoMatchLanguageToCountry": {
                        "title": "Auto-match language to country when language=en",
                        "type": "boolean",
                        "description": "When enabled, if you pick a non-US country but leave language at its default `en`, the actor silently upgrades language to the country's native language (e.g. `country=jp → language=ja`, `country=br → language=pt`). Saves you a click and avoids the common user error of getting generic-English results for non-US markets. Disable if you specifically want English-global results filtered by country.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential Apify proxy is recommended in case Cloudflare blocks datacenter IPs on Ubersuggest.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```