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

Discover Amazon autocomplete keyword suggestions by marketplace for listing SEO, PPC research, and ecommerce content planning.

- **URL**: https://apify.com/automation-lab/amazon-keywords-discovery-tool.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Amazon Keywords Discovery Tool

Discover Amazon autocomplete keyword suggestions from seed phrases for marketplace SEO, product listing optimization, PPC research, and ecommerce content planning.

The actor calls Amazon's public autocomplete suggestion endpoint and returns ranked keyword ideas by marketplace, locale, seed keyword, and expansion query.

### What does Amazon Keywords Discovery Tool do?

It turns a small list of seed keywords into Amazon search suggestions.

For example, a seed such as `wireless mouse` can be expanded into queries like `wireless mouse a`, `wireless mouse b`, and `wireless mouse c`.

Each query returns suggestions that Amazon exposes to shoppers in the search box.

### Who is it for?

#### Amazon sellers and brand owners

Use the actor before writing or refreshing a listing. Start from a product phrase such as `wireless mouse`, expand it with alphabet mode, and export buyer-language variants for titles, bullets, backend search terms, A+ content briefs, and competitor listing reviews.

#### Ecommerce and marketplace agencies

Run repeatable keyword discovery for multiple client categories without manually typing every seed into Amazon. Agencies can save one Apify task per client or marketplace, compare results over time, and deliver CSV keyword briefs with source URLs and timestamps.

#### Amazon PPC and growth teams

Use autocomplete suggestions as a lightweight source of campaign expansion ideas. The output can be clustered into exact, phrase, and broad-match research lists, then checked against existing search-term reports before adding new campaign targets.

#### SEO and content teams

Map marketplace search intent before writing buying guides, comparison pages, or category content. The marketplace and locale fields make it easier to separate US, UK, DE, FR, and other regional wording.

#### Product researchers and category managers

Spot buyer modifiers such as size, color, audience, use case, bundle terms, and price-sensitive phrases. Re-running the same seeds on a schedule can reveal how category language changes around seasons and promotions.

### Why use this actor?

Amazon autocomplete is close to buyer intent.

Suggestions can reveal product attributes, use cases, sizes, audiences, and modifiers that shoppers actually type.

The actor keeps the workflow simple: provide seeds, choose a marketplace, export suggestions.

### What data can you extract?

| Field | Description |
| --- | --- |
| `seedKeyword` | Original keyword provided in input |
| `expandedQuery` | Query sent to Amazon autocomplete |
| `marketplace` | Marketplace preset such as US, UK, or DE |
| `locale` | Locale parameter used for the request |
| `suggestion` | Autocomplete keyword suggestion |
| `suggestionType` | Amazon suggestion type |
| `rank` | Suggestion order in the response |
| `refTag` | Amazon ref tag when returned |
| `strategyId` | Amazon strategy identifier when returned |
| `sourceUrl` | Request URL used for traceability |
| `fetchedAt` | Timestamp of extraction |
| `metadata` | Optional raw response metadata |

### How much does it cost to discover Amazon keyword suggestions?

This actor uses pay-per-event pricing: a small one-time run start charge plus a per-suggestion charge for each saved dataset item. You only pay for keyword suggestions that are actually written to the dataset.

Current launch pricing is:

| Plan tier | Start event | Saved suggestion |
| --- | ---: | ---: |
| FREE | $0.005 | $0.000024099 |
| BRONZE | $0.005 | $0.000020956 |
| SILVER | $0.005 | $0.000016346 |
| GOLD | $0.005 | $0.000012574 |
| PLATINUM | $0.005 | $0.000010000 |
| DIAMOND | $0.005 | $0.000010000 |

Example estimates before Apify platform fees or plan-specific credits:

- A quick seed-only check that saves 10 suggestions costs about $0.00524 on FREE or $0.00521 on BRONZE.
- A small alphabet run that saves 250 suggestions costs about $0.01102 on FREE or $0.01024 on BRONZE.
- A broader research run that saves 1,000 suggestions costs about $0.02910 on FREE, $0.02596 on BRONZE, $0.02135 on SILVER, or $0.01757 on GOLD.

Start with one or two seeds and `maxSuggestionsPerQuery` around 10. After the output quality looks useful, increase the number of seeds or switch from `none` to `alphabet` / `alphanumeric` expansion.

### Input overview

The main input is `seedKeywords`.

You can also configure the marketplace, expansion strategy, deduplication, metadata inclusion, and request delay.

### Example input

```json
{
  "seedKeywords": ["wireless mouse", "standing desk"],
  "marketplace": "US",
  "maxSuggestionsPerQuery": 10,
  "expansionMode": "alphabet",
  "dedupe": true,
  "includeMetadata": true,
  "delayMs": 150
}
````

### Expansion modes

`none` queries only the seed keyword.

`alphabet` queries the seed and suffixes `a` through `z`.

`alphanumeric` queries the seed, suffixes `a` through `z`, and suffixes `0` through `9`.

`custom` uses the suffixes you provide in `customExpansions`.

### Marketplace support

The actor includes presets for these marketplaces:

- United States
- United Kingdom
- Germany
- France
- Italy
- Spain
- Canada
- Mexico
- Australia
- Japan
- India

### How to run it

1. Open the actor on Apify.
2. Enter one or more seed keywords.
3. Select the Amazon marketplace.
4. Choose an expansion mode.
5. Start the run.
6. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Output example

```json
{
  "seedKeyword": "wireless mouse",
  "expandedQuery": "wireless mouse a",
  "marketplace": "US",
  "locale": "en_US",
  "suggestion": "wireless mouse and keyboard",
  "suggestionType": "KEYWORD",
  "rank": 1,
  "strategyId": "p13n-expert-pd-ops-ranker",
  "sourceUrl": "https://completion.amazon.com/api/2017/suggestions?...",
  "fetchedAt": "2026-06-21T00:00:00.000Z"
}
```

### Tips for better Amazon keyword research

Start with category-level terms.

Run alphabet expansion for broad discovery.

Use custom suffixes for buyer modifiers such as `for kids`, `for women`, `for travel`, or `under 50`.

Keep deduplication enabled for clean exports.

Compare marketplaces when localizing listings.

### Integrations

Send output to Google Sheets for keyword clustering.

Export CSV into PPC tools for campaign planning.

Use Apify webhooks to trigger downstream enrichment after each run.

Connect the dataset to BI tools for recurring marketplace monitoring.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/amazon-keywords-discovery-tool').call({
  seedKeywords: ['wireless mouse'],
  marketplace: 'US',
  expansionMode: 'alphabet'
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/amazon-keywords-discovery-tool').call(run_input={
    'seedKeywords': ['wireless mouse'],
    'marketplace': 'US',
    'expansionMode': 'alphabet',
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~amazon-keywords-discovery-tool/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"seedKeywords":["wireless mouse"],"marketplace":"US","expansionMode":"alphabet"}'
```

### MCP integration

Use the actor from Claude Desktop or Claude Code through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/amazon-keywords-discovery-tool
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/amazon-keywords-discovery-tool
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-amazon-keywords": {
      "url": "https://mcp.apify.com/?tools=automation-lab/amazon-keywords-discovery-tool"
    }
  }
}
```

Example prompts for MCP usage:

- Via MCP, use the Amazon Keywords Discovery Tool to find autocomplete suggestions for wireless mouse in the US marketplace.
- Via MCP, run Amazon keyword discovery for standing desk with alphabet expansion and dedupe the results.
- Via MCP, compare Amazon autocomplete keyword suggestions for lunch box in US and UK marketplaces.

### Data quality notes

Amazon may personalize, localize, or reorder suggestions.

Suggestions can change over time.

The actor stores the fetch timestamp and source URL for traceability.

### Troubleshooting: I got fewer results than expected

Autocomplete suggestions are not guaranteed for every expanded query.

Try broader seed keywords, disable dedupe, or use custom suffixes.

### Troubleshooting: Some metadata fields are empty

Amazon does not return every metadata field for every suggestion.

Core fields such as suggestion, rank, seed keyword, expanded query, marketplace, and timestamp remain available.

### Legality and responsible use

This actor extracts public autocomplete suggestions visible through Amazon search experiences.

Use the data responsibly and comply with applicable laws, platform terms, and your internal policies.

Do not use the actor to collect private account data.

### Related scrapers and tools

Related Automation Lab actors:

- https://apify.com/automation-lab/amazon-scraper
- https://apify.com/automation-lab/amazon-reviews-scraper
- https://apify.com/automation-lab/amazon-sellers-scraper
- https://apify.com/automation-lab/amazon-bestsellers-scraper

### FAQ

#### Can I choose a marketplace?

Yes. Use the `marketplace` input to choose a preset such as US, UK, DE, FR, IT, ES, CA, MX, AU, JP, or IN.

#### Does the actor need cookies?

No. The MVP uses Amazon's public autocomplete endpoint without login cookies.

#### Does it use a browser?

No. It is an HTTP/API actor, so runs are lightweight.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, HTML, or RSS.

#### Can I monitor keywords repeatedly?

Yes. Schedule the actor in Apify and compare datasets over time.

### Changelog

Initial version: Amazon autocomplete keyword discovery with marketplace presets, expansion modes, dedupe, and metadata export.

### Practical workflow: listing refresh

1. Export the current listing title, bullets, and backend keyword seeds.
2. Run the actor with 5-20 seed phrases and `alphabet` expansion.
3. Deduplicate suggestions and group them by modifier, use case, audience, and attribute.
4. Compare the groups against your existing listing copy.
5. Add relevant missing phrases to listing copy, backend terms, or a content brief.

### Practical workflow: PPC expansion

1. Start from converting product terms or search-term report winners.
2. Use `alphabet` expansion to discover long-tail variants.
3. Remove brand names, irrelevant products, and terms you already target.
4. Cluster the remaining suggestions by intent.
5. Test shortlisted terms in exact, phrase, or broad campaigns.

### Practical workflow: marketplace localization

Run the same seed set across two or more marketplaces, for example US and UK or DE and FR. Compare the `suggestion` and `locale` fields to find regional spelling, category wording, and buyer modifiers before localizing listing copy or PPC campaigns.

### Practical workflow: recurring monitoring

Schedule the actor weekly or monthly with the same seeds. Store each dataset and compare suggestion lists over time to catch new modifiers, seasonal searches, and disappearing terms. The `fetchedAt` and `sourceUrl` fields make exports auditable.

### Cost-control tips

Use `none` mode for quick checks and `alphabet` mode for deeper discovery. Keep `maxSuggestionsPerQuery` at 10 unless you have a specific reason to request more. Enable deduplication for most research exports so repeated suggestions are charged and stored only once.

# Actor input Schema

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

Amazon search phrases to expand with autocomplete suggestions.

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

Marketplace locale used for Amazon autocomplete MID/locale parameters.

## `maxSuggestionsPerQuery` (type: `integer`):

Maximum Amazon suggestions to request for each expanded query. Amazon normally returns up to 10.

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

How to expand each seed before querying Amazon autocomplete.

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

Suffixes used when expansion mode is custom. Example: best, for kids, under 50.

## `dedupe` (type: `boolean`):

When enabled, each suggestion is emitted once per marketplace even if multiple expansions return it.

## `includeMetadata` (type: `boolean`):

Include non-core Amazon response fields such as thumbnail/complementary info when available.

## `delayMs` (type: `integer`):

Conservative delay between Amazon autocomplete requests to reduce throttling risk.

## Actor input object example

```json
{
  "seedKeywords": [
    "wireless mouse",
    "standing desk"
  ],
  "marketplace": "US",
  "maxSuggestionsPerQuery": 10,
  "expansionMode": "alphabet",
  "customExpansions": [
    "best",
    "for kids",
    "under 50"
  ],
  "dedupe": true,
  "includeMetadata": true,
  "delayMs": 150
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "seedKeywords": [
        "wireless mouse",
        "standing desk"
    ],
    "marketplace": "US",
    "maxSuggestionsPerQuery": 10,
    "expansionMode": "alphabet",
    "customExpansions": [
        "best",
        "for kids",
        "under 50"
    ],
    "dedupe": true,
    "includeMetadata": true,
    "delayMs": 150
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "seedKeywords": [
        "wireless mouse",
        "standing desk",
    ],
    "marketplace": "US",
    "maxSuggestionsPerQuery": 10,
    "expansionMode": "alphabet",
    "customExpansions": [
        "best",
        "for kids",
        "under 50",
    ],
    "dedupe": True,
    "includeMetadata": True,
    "delayMs": 150,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "seedKeywords": [
    "wireless mouse",
    "standing desk"
  ],
  "marketplace": "US",
  "maxSuggestionsPerQuery": 10,
  "expansionMode": "alphabet",
  "customExpansions": [
    "best",
    "for kids",
    "under 50"
  ],
  "dedupe": true,
  "includeMetadata": true,
  "delayMs": 150
}' |
apify call automation-lab/amazon-keywords-discovery-tool --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/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 by marketplace for listing SEO, PPC research, and ecommerce content planning.",
        "version": "0.1",
        "x-build-id": "En2peDb1BEezfiay6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~amazon-keywords-discovery-tool/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~amazon-keywords-discovery-tool/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~amazon-keywords-discovery-tool/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": [
                    "seedKeywords"
                ],
                "properties": {
                    "seedKeywords": {
                        "title": "Seed keywords",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Amazon search phrases to expand with autocomplete suggestions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplace": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "CA",
                            "MX",
                            "AU",
                            "JP",
                            "IN"
                        ],
                        "type": "string",
                        "description": "Marketplace locale used for Amazon autocomplete MID/locale parameters.",
                        "default": "US"
                    },
                    "maxSuggestionsPerQuery": {
                        "title": "Max suggestions per query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum Amazon suggestions to request for each expanded query. Amazon normally returns up to 10.",
                        "default": 10
                    },
                    "expansionMode": {
                        "title": "Expansion mode",
                        "enum": [
                            "none",
                            "alphabet",
                            "alphanumeric",
                            "custom"
                        ],
                        "type": "string",
                        "description": "How to expand each seed before querying Amazon autocomplete.",
                        "default": "alphabet"
                    },
                    "customExpansions": {
                        "title": "Custom suffixes",
                        "type": "array",
                        "description": "Suffixes used when expansion mode is custom. Example: best, for kids, under 50.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dedupe": {
                        "title": "Deduplicate suggestions",
                        "type": "boolean",
                        "description": "When enabled, each suggestion is emitted once per marketplace even if multiple expansions return it.",
                        "default": true
                    },
                    "includeMetadata": {
                        "title": "Include raw metadata",
                        "type": "boolean",
                        "description": "Include non-core Amazon response fields such as thumbnail/complementary info when available.",
                        "default": true
                    },
                    "delayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Conservative delay between Amazon autocomplete requests to reduce throttling risk.",
                        "default": 150
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
