# Amazon Keywords Discovery Tool (`maximedupre/amazon-keywords-discovery-tool`) Actor

Discover Amazon autocomplete keyword suggestions from seed terms. Export source-ranked suggestions, marketplace context, expansion queries, dedupe keys, source URLs, and scrape timestamps.

- **URL**: https://apify.com/maximedupre/amazon-keywords-discovery-tool.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** E-commerce, SEO tools
- **Stats:** 17 total users, 13 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 found suggestions

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

### 🔎 Amazon keywords discovery tool for autocomplete suggestions

Amazon Keywords Discovery Tool collects public autocomplete keyword suggestions from [Amazon](https://www.amazon.com/) search. Add seed terms such as `laptop stand`, `coffee grinder`, or `dog bed`, choose an Amazon marketplace, and export source-ranked keyword ideas for listing SEO, PPC research, product niche research, and ecommerce content planning.

The Actor saves one row per accepted Amazon autocomplete suggestion. Each row keeps the seed keyword, marketplace, locale, exact query variant, expansion mode, suggestion text, accepted rank, Amazon source position, and thumbnail image URL when Amazon returns one. You can download the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or use it through the Apify API, schedules, webhooks, and integrations.

For a first run, keep the prefilled seeds `laptop stand`, `coffee grinder`, `office chair`, `wireless earbuds`, and `water bottle`, leave **Discovery depth** on `Full expansion`, and keep **Total suggestions** at `5000`. That gives you a broad sample before you add your own seeds or switch to custom suffixes.

### ✅ What this Actor does

- Searches Amazon autocomplete with one or more seed keywords.
- Supports Amazon marketplaces for the US, UK, Germany, France, Italy, Spain, Canada, Mexico, Australia, Japan, and India.
- Expands seeds with alphabet, number, buyer-modifier, full, or custom suffix discovery.
- Saves one dataset item per accepted autocomplete suggestion.
- Keeps Amazon source order by default, with an alphabetical order option.
- Deduplicates repeated suggestions across the run.
- Adds marketplace, locale, query variant, expansion token, accepted rank, source position, and thumbnail image URL when available.
- Stops at your per-seed and total suggestion limits.
- Runs without Amazon login, cookies, or a user-provided API key.

This Actor is focused on Amazon search autocomplete suggestions. It does not scrape Amazon products, ASIN rankings, reviews, seller profiles, ads, search-volume metrics, keyword difficulty, or CPC estimates.

### 📦 Amazon keyword data you can export

Each output item represents one Amazon autocomplete suggestion. Fields include:

- `seedKeyword` - the seed phrase you entered.
- `marketplace` - the Amazon marketplace used for the source request.
- `locale` - the Amazon locale used for autocomplete, or `null` when unavailable.
- `query` - the exact autocomplete query, such as `laptop stand b`.
- `expansionMode` - the discovery mode that produced the query.
- `expansionToken` - the suffix or modifier used to expand the seed, or `null` for seed-only rows.
- `suggestion` - the Amazon autocomplete keyword suggestion.
- `rank` - the accepted output rank for the seed after cleanup, ordering, and limits.
- `sourcePosition` - the position Amazon returned for the suggestion within that query.
- `thumbnailImageUrl` - an Amazon thumbnail image URL when Amazon returns one, otherwise `null`.

The `rank` field helps you work with the final cleaned export. The `sourcePosition` field helps you audit where the suggestion appeared in Amazon autocomplete for the exact query.

### 🧭 Common use cases

#### 🛒 Amazon listing SEO

Start with product phrases, collect autocomplete suggestions, and use the returned buyer language to shape listing titles, bullet points, backend search terms, and A+ content briefs.

#### 📣 PPC keyword research

Expand converting product terms into long-tail Amazon search ideas. Export the suggestions to a spreadsheet, remove irrelevant phrases, and compare them with your existing campaign terms.

#### 🌍 Marketplace localization

Run the same seed list across marketplaces such as `amazon.com`, `amazon.co.uk`, `amazon.de`, or `amazon.com.mx` to compare regional wording before localizing listings or ad groups.

#### 🔁 Repeat keyword monitoring

Schedule the same seed list weekly or monthly and compare exported suggestions over time. Amazon autocomplete can change by marketplace, season, and source behavior.

### 🚀 How to run

1. Add one or more product or niche phrases in **Seed keywords**.
2. Choose the **Amazon marketplace** you want to research.
3. Choose **Discovery depth**. `Full expansion` is the default for a broad first run.
4. Use **Custom suffixes** when Discovery depth is set to `Custom suffixes`.
5. Keep **Suggestion order** on `Amazon source order` unless you want alphabetized suggestions.
6. Set **Suggestions per seed** and **Total suggestions** to control output size and cost.
7. Start the Actor and open the dataset.

For larger jobs, add related seeds and use the per-seed and total limits to keep the run predictable.

### ⚙️ Input

```json
{
  "keywords": [
    "laptop stand",
    "coffee grinder",
    "office chair",
    "wireless earbuds",
    "water bottle"
  ],
  "marketplace": "amazon.com",
  "expansionMode": "full",
  "customExpansions": ["best", "for kids", "under 50"],
  "resultOrder": "source",
  "maxSuggestionsPerKeyword": 1000,
  "maxTotalResults": 5000
}
````

#### 🎯 Seed keywords

Enter plain Amazon search seeds. Good examples:

- `laptop stand`
- `coffee grinder`
- `dog bed`
- `protein powder`
- `desk organizer`

Each seed is checked separately. Empty and duplicate seed values are cleaned up before the run.

#### 🌍 Marketplace

Choose the Amazon marketplace that matches your research target. Suggestions can differ by marketplace because Amazon localizes autocomplete.

#### 🔎 Discovery depth

`expansionMode` controls how many autocomplete queries are generated from each seed:

- `seedOnly`: checks the seed only.
- `alphabet`: checks the seed plus `a` through `z`.
- `numbers`: checks the seed plus `0` through `9`.
- `buyerModifiers`: checks common shopping modifiers.
- `full`: combines alphabet, number, and buyer-modifier expansion.
- `custom`: checks the seed plus your **Custom suffixes**.

Use custom suffixes for buyer phrases such as `best`, `for kids`, `under 50`, `with lid`, or `for travel`.

#### 📏 Limits and order

Use `maxSuggestionsPerKeyword` to control how many suggestions can be saved for each seed. Use `maxTotalResults` when you want a hard cap across the whole run. `resultOrder` can keep Amazon source order or sort suggestions alphabetically within each seed.

### 🧾 Output example

```json
{
  "seedKeyword": "laptop stand",
  "marketplace": "amazon.com",
  "locale": "en_US",
  "query": "laptop stand b",
  "expansionMode": "alphabet",
  "expansionToken": "b",
  "suggestion": "laptop stand bed",
  "rank": 7,
  "sourcePosition": 2,
  "thumbnailImageUrl": "https://m.media-amazon.com/images/I/41qf2y61sSL.__AC_SL75__.jpg"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each Amazon autocomplete keyword suggestion that is found and saved. There is no Actor-start charge, and no charge for empty or failed queries.

### ⚠️ Limits and caveats

- Amazon autocomplete suggestions can change over time and by marketplace.
- Some seeds or query variants can return fewer suggestions than your requested limit.
- Thumbnail image URLs appear only when Amazon returns them.
- Locale can be `null` if the source response does not expose it.
- The Actor returns source-backed autocomplete suggestions, not search volume, CPC, keyword difficulty, popularity, or ranking metrics.

### ❓ FAQ

#### 🔐 Does this require an Amazon account?

No. It collects public Amazon autocomplete suggestions. You do not need to provide an Amazon account, cookies, or an API key.

#### 🧺 Can I run many seed keywords at once?

Yes. Add multiple seed keywords and use the per-seed and total suggestion limits to control the run size.

#### 🌎 Can I compare Amazon marketplaces?

Yes. Run the same seed list with different marketplace values, then compare the exported suggestions and locales.

#### 📈 Does it return search volume or CPC?

No. The output contains Amazon autocomplete suggestions and source-order context. It avoids inventing metrics that Amazon does not expose through autocomplete.

#### 🛒 Can it scrape products or ASIN rankings?

No. This Actor is only for Amazon keyword suggestions. Use an Amazon product, search, seller, or rank-tracking scraper when you need product rows or ranking positions.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~amazon-keywords-discovery-tool/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Etsy Keywords Research Tool ↗](https://apify.com/maximedupre/etsy-keywords-research-tool) - Extract Etsy autocomplete keyword suggestions for listing SEO.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - Export Pinterest autocomplete keyword ideas for content planning.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Discover TikTok autocomplete keywords for social search research.
- [Youtube Keywords Discovery Tool ↗](https://apify.com/maximedupre/youtube-keywords-discovery-tool) - Collect YouTube autocomplete suggestions for video SEO.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Collect live paid Shopping ad product rows for PPC research.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `keywords` (type: `array`):

Enter product or niche phrases to expand with Amazon autocomplete.

## `marketplace` (type: `string`):

Choose the marketplace whose autocomplete suggestions you want.

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

Choose how many query variants to collect for each seed.

## `customExpansions` (type: `array`):

Add suffixes such as best, for kids, or under 50 when using Custom suffixes.

## `resultOrder` (type: `string`):

Choose how suggestions are ordered within each seed.

## `maxSuggestionsPerKeyword` (type: `integer`):

Limit saved suggestions for each seed keyword.

## `maxTotalResults` (type: `integer`):

Limit saved suggestions across the whole run.

## Actor input object example

```json
{
  "keywords": [
    "laptop stand",
    "coffee grinder",
    "office chair",
    "wireless earbuds",
    "water bottle"
  ],
  "marketplace": "amazon.com",
  "expansionMode": "full",
  "customExpansions": [
    "best",
    "for kids",
    "under 50"
  ],
  "resultOrder": "source",
  "maxSuggestionsPerKeyword": 1000,
  "maxTotalResults": 5000
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with one item per accepted Amazon autocomplete keyword suggestion.

# 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 = {
    "keywords": [
        "laptop stand",
        "coffee grinder",
        "office chair",
        "wireless earbuds",
        "water bottle"
    ],
    "customExpansions": [
        "best",
        "for kids",
        "under 50"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/amazon-keywords-discovery-tool").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 = {
    "keywords": [
        "laptop stand",
        "coffee grinder",
        "office chair",
        "wireless earbuds",
        "water bottle",
    ],
    "customExpansions": [
        "best",
        "for kids",
        "under 50",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/amazon-keywords-discovery-tool").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 '{
  "keywords": [
    "laptop stand",
    "coffee grinder",
    "office chair",
    "wireless earbuds",
    "water bottle"
  ],
  "customExpansions": [
    "best",
    "for kids",
    "under 50"
  ]
}' |
apify call maximedupre/amazon-keywords-discovery-tool --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/amazon-keywords-discovery-tool",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Keywords Discovery Tool",
        "description": "Discover Amazon autocomplete keyword suggestions from seed terms. Export source-ranked suggestions, marketplace context, expansion queries, dedupe keys, source URLs, and scrape timestamps.",
        "version": "0.1",
        "x-build-id": "aJptzLV9rK4gOahqg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~amazon-keywords-discovery-tool/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-amazon-keywords-discovery-tool",
                "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/maximedupre~amazon-keywords-discovery-tool/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-amazon-keywords-discovery-tool",
                "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/maximedupre~amazon-keywords-discovery-tool/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-amazon-keywords-discovery-tool",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Seed keywords",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Enter product or niche phrases to expand with Amazon autocomplete.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "marketplace": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "amazon.com",
                            "amazon.co.uk",
                            "amazon.de",
                            "amazon.fr",
                            "amazon.it",
                            "amazon.es",
                            "amazon.ca",
                            "amazon.com.mx",
                            "amazon.com.au",
                            "amazon.co.jp",
                            "amazon.in"
                        ],
                        "type": "string",
                        "description": "Choose the marketplace whose autocomplete suggestions you want.",
                        "default": "amazon.com"
                    },
                    "expansionMode": {
                        "title": "Discovery depth",
                        "enum": [
                            "seedOnly",
                            "alphabet",
                            "numbers",
                            "buyerModifiers",
                            "full",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Choose how many query variants to collect for each seed.",
                        "default": "full"
                    },
                    "customExpansions": {
                        "title": "Custom suffixes",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add suffixes such as best, for kids, or under 50 when using Custom suffixes.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "resultOrder": {
                        "title": "Suggestion order",
                        "enum": [
                            "source",
                            "alphabetical"
                        ],
                        "type": "string",
                        "description": "Choose how suggestions are ordered within each seed.",
                        "default": "source"
                    },
                    "maxSuggestionsPerKeyword": {
                        "title": "Suggestions per seed",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Limit saved suggestions for each seed keyword.",
                        "default": 1000
                    },
                    "maxTotalResults": {
                        "title": "Total suggestions",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Limit saved suggestions across the whole run.",
                        "default": 5000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```