# 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:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.65 / 1,000 keyword 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 autocomplete keyword suggestions from Amazon search. Add seed terms such as `laptop stand`, `coffee grinder`, or `dog bed`, choose a marketplace, and export source-ranked Amazon keyword suggestions with query expansion context, source URLs, normalized text, and scrape timestamps.

Use this Actor for Amazon SEO research, listing optimization, PPC seed discovery, product niche research, and repeatable keyword exports. It turns manual Amazon search-box checks into a structured Apify dataset you can download as JSON, CSV, Excel, XML, RSS, or HTML, or send to an API, webhook, scheduler, or integration.

For a small first run, keep the prefilled seeds `laptop stand` and `coffee grinder`. The default run is capped so you can inspect the row shape before adding a larger keyword list.

### ✅ What this Actor does

- Searches Amazon autocomplete with one or more seed keywords.
- Supports major Amazon marketplaces such as US, UK, Germany, France, Italy, Spain, Canada, Australia, Japan, and India.
- Expands seeds with alphabet, number, or buyer-modifier variants.
- Saves one keyword suggestion row per accepted autocomplete phrase.
- Keeps Amazon's source order by default.
- Can sort suggestions alphabetically within each query.
- Can remove duplicate suggestions across the run.
- Adds marketplace, query used, expansion token, source URL, word count, and scrape time to every row.
- Stops at your per-keyword and total result 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, or CPC estimates.

### 📦 Data you can extract

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

- `searchKeyword` and `keywordIndex`
- `marketplace`
- `suggestion` and `normalizedSuggestion`
- `type`
- `rank` and `sourceRowNumber`
- `queryUsed`, `queryIndex`, `expansionMode`, and `expansionToken`
- `containsSeed`, `wordCount`, and `dedupeKey`
- `sourceUrl`, `sourceMarketplace`, and `sourceQuery`
- `thumbnailImageUrl` and `refTag` when Amazon returns them
- `scrapedAt`

The `rank` field reflects the accepted output order for the seed keyword after deduplication and limits. `sourceRowNumber` preserves the position Amazon returned for the specific autocomplete query.

### 🚀 Common use cases

- Build Amazon keyword research exports for listings and PPC planning.
- Find long-tail autocomplete phrases around products, niches, and buyer problems.
- Compare Amazon suggestions across marketplaces.
- Discover listing title, bullet, and backend keyword ideas.
- Feed Amazon keyword suggestions into spreadsheets, dashboards, or AI workflows.
- Schedule repeat checks for the same keyword set.
- Collect clean source-ranked suggestions for Amazon SEO research.

### ▶️ How to run it

1. Add one or more seed keywords in **Seed keywords**.
2. Choose the Amazon marketplace.
3. Keep **Suggestions per seed** at `50` for a quick first run.
4. Choose an expansion mode.
5. Set **Total suggestions** if you want a hard cap across the whole run.
6. Start the Actor and open the dataset.

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

### 🛠️ Input

#### 🧪 Example input

```json
{
	"keywords": ["laptop stand", "coffee grinder"],
	"marketplace": "amazon.com",
	"maxSuggestionsPerKeyword": 50,
	"maxTotalResults": 500,
	"expansionMode": "alphabet",
	"resultOrder": "source",
	"deduplicateSuggestions": true,
	"includeSeedSuggestion": false
}
````

#### 🎯 Seed keywords

Enter plain Amazon search seeds. Good examples:

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

Each seed is queried separately. Empty and duplicate seed values are ignored during normalization.

#### 🌍 Marketplace

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

#### 📏 Limits

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.

#### 🔬 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.

#### 🧹 Sorting and cleanup

`resultOrder` can keep Amazon's source order or sort each query's suggestions alphabetically. `deduplicateSuggestions` removes repeated normalized suggestions across the run. `includeSeedSuggestion` controls whether to keep a suggestion when Amazon returns the same text as the seed keyword.

### 📊 Output example

```json
{
	"searchKeyword": "laptop stand",
	"keywordIndex": 1,
	"marketplace": "amazon.com",
	"suggestion": "laptop stand for desk",
	"normalizedSuggestion": "laptop stand for desk",
	"type": "keyword",
	"rank": 1,
	"sourceRowNumber": 2,
	"queryUsed": "laptop stand",
	"queryIndex": 1,
	"expansionMode": "alphabet",
	"expansionToken": null,
	"containsSeed": true,
	"wordCount": 4,
	"dedupeKey": "amazon.com:laptop stand for desk",
	"sourceUrl": "https://www.amazon.com/s?k=laptop+stand+for+desk",
	"sourceMarketplace": "amazon.com",
	"sourceQuery": "laptop stand",
	"thumbnailImageUrl": "https://m.media-amazon.com/image.jpg",
	"refTag": "ref-2",
	"scrapedAt": "2026-06-01T00:00:00.000Z"
}
```

### 💳 Pricing

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

### ⚠️ Limits and caveats

- Amazon autocomplete can change over time and by marketplace.
- Some seeds can return fewer suggestions than your requested limit.
- The Actor does not provide search volume, CPC, popularity scores, or ranking data.
- Marketplace is a source hint; Amazon may still personalize or vary suggestions.
- Amazon may temporarily return fewer suggestions or no suggestions for a seed.

### ❓ 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 API key.

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

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

#### 📈 Does it return search volume?

No. The output contains suggestions and source order, not search-volume or popularity metrics. This avoids inventing metrics that Amazon does not expose through this autocomplete surface.

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

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

### 📝 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.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Discover TikTok autocomplete keyword suggestions.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Collect paid Google Shopping ad products for keyword research.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - Export Pinterest keyword suggestions.
- [Quora Search Scraper ↗](https://apify.com/maximedupre/quora-search-scraper) - Find public Quora question pages from search terms or direct URLs.

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

# Actor input Schema

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

Enter one or more Amazon search seeds such as laptop stand, coffee grinder, or dog bed. Each seed is checked separately.

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

Amazon marketplace to use for autocomplete suggestions.

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

Maximum Amazon autocomplete suggestions to save for each seed keyword. Keep 50 for a small first run.

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

Maximum Amazon keyword suggestions to save across the whole run.

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

Choose how broadly to expand each seed before collecting Amazon autocomplete suggestions.

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

Keep Amazon's source order for each query, or sort each query's suggestions alphabetically.

## `deduplicateSuggestions` (type: `boolean`):

Save each normalized Amazon suggestion only once per marketplace across the run.

## `includeSeedSuggestion` (type: `boolean`):

Keep suggestions even when Amazon returns the exact seed keyword text.

## Actor input object example

```json
{
  "keywords": [
    "laptop stand",
    "coffee grinder"
  ],
  "marketplace": "amazon.com",
  "maxSuggestionsPerKeyword": 50,
  "maxTotalResults": 500,
  "expansionMode": "alphabet",
  "resultOrder": "source",
  "deduplicateSuggestions": true,
  "includeSeedSuggestion": false
}
```

# Actor output Schema

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

Open the dataset with one item per Amazon autocomplete 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"
    ]
};

// 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",
    ] }

# 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"
  ]
}' |
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": "XRvNjrd9vd5Vg08sp"
    },
    "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 one or more Amazon search seeds such as laptop stand, coffee grinder, or dog bed. Each seed is checked separately.",
                        "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.au",
                            "amazon.co.jp",
                            "amazon.in"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace to use for autocomplete suggestions.",
                        "default": "amazon.com"
                    },
                    "maxSuggestionsPerKeyword": {
                        "title": "Suggestions per seed",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum Amazon autocomplete suggestions to save for each seed keyword. Keep 50 for a small first run.",
                        "default": 50
                    },
                    "maxTotalResults": {
                        "title": "Total suggestions",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Amazon keyword suggestions to save across the whole run.",
                        "default": 500
                    },
                    "expansionMode": {
                        "title": "Expansion mode",
                        "enum": [
                            "seedOnly",
                            "alphabet",
                            "numbers",
                            "buyerModifiers",
                            "full"
                        ],
                        "type": "string",
                        "description": "Choose how broadly to expand each seed before collecting Amazon autocomplete suggestions.",
                        "default": "alphabet"
                    },
                    "resultOrder": {
                        "title": "Suggestion order",
                        "enum": [
                            "source",
                            "alphabetical"
                        ],
                        "type": "string",
                        "description": "Keep Amazon's source order for each query, or sort each query's suggestions alphabetically.",
                        "default": "source"
                    },
                    "deduplicateSuggestions": {
                        "title": "Remove duplicate suggestions",
                        "type": "boolean",
                        "description": "Save each normalized Amazon suggestion only once per marketplace across the run.",
                        "default": true
                    },
                    "includeSeedSuggestion": {
                        "title": "Keep seed suggestions",
                        "type": "boolean",
                        "description": "Keep suggestions even when Amazon returns the exact seed keyword text.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```