# Amazon Autocomplete Scraper (`automation-lab/amazon-autocomplete-scraper`) Actor

Scrape Amazon autocomplete keyword suggestions across marketplaces with A-Z expansion, department aliases, ranks, source URLs, and deduped output.

- **URL**: https://apify.com/automation-lab/amazon-autocomplete-scraper.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 Autocomplete Scraper

Collect Amazon autocomplete keyword suggestions from the same public completion endpoint that powers Amazon search boxes.

Use this actor to expand product ideas, advertising seeds, SEO terms, and category keywords across Amazon marketplaces.

### What does Amazon Autocomplete Scraper do?

Amazon Autocomplete Scraper turns seed keywords into structured Amazon search suggestions.

It sends lightweight HTTP requests to Amazon completion endpoints and saves each suggestion as a clean dataset row.

The actor supports marketplace presets, department aliases, A-Z expansion, A-Z plus 0-9 expansion, custom suffixes, and deduplication.

### Who is it for?

- 🛒 Amazon sellers researching product listing keywords.
- 📈 PPC agencies building Sponsored Products keyword lists.
- 🔎 Ecommerce SEO teams expanding long-tail product phrases.
- 🧰 Marketplace research tools that need repeatable keyword exports.
- 📦 Private label operators validating product naming language.
- 🧪 Growth teams monitoring new buyer search intents.

### Why use it?

Amazon's autocomplete suggestions are direct signals from marketplace search behavior.

Instead of manually typing every keyword into Amazon, you can collect hundreds or thousands of suggestions in one run.

The output is normalized for spreadsheets, BI tools, databases, and API workflows.

### Key features

- 🌍 Marketplace presets for US, UK, DE, FR, IT, ES, CA, IN, AU, and JP.
- 🏬 Department alias support such as `aps`, `electronics`, `fashion`, and `grocery`.
- 🔤 Seed-only, A-Z, A-Z + 0-9, and custom suffix expansion.
- 🧹 Deduped keyword rows across all expanded prefixes.
- 🧾 Rank, type, source URL, marketplace ID, and timestamp fields.
- ⚡ HTTP-only implementation with no browser overhead.

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

This actor uses pay-per-event pricing.

You pay a small run start event plus a per-suggestion event for each saved autocomplete row.

The default input is intentionally small so the first run is inexpensive.

Larger A-Z and A-Z + 0-9 jobs cost more because they query more prefixes and save more suggestions.

### Input

The most important input field is `keywords`.

Add one or more seed terms such as:

```json
{
  "keywords": ["laptop stand", "coffee grinder"],
  "marketplace": "US",
  "alias": "aps",
  "expansionMode": "a-z",
  "maxSuggestionsPerPrefix": 10,
  "maxPrefixes": 100,
  "dedupeSuggestions": true,
  "requestDelayMs": 100
}
````

### Input fields explained

| Field | Description |
| --- | --- |
| `keywords` | Seed Amazon search keywords to expand. |
| `marketplace` | Amazon marketplace preset and locale. |
| `alias` | Amazon department alias. Use `aps` for all departments. |
| `expansionMode` | Query seed only, A-Z, A-Z + 0-9, or custom suffixes. |
| `customSuffixes` | Suffixes used when expansion mode is custom. |
| `maxSuggestionsPerPrefix` | Maximum suggestions saved from each prefix. |
| `maxPrefixes` | Safety limit for prefix requests. |
| `dedupeSuggestions` | Removes repeated suggestions in the same run. |
| `requestDelayMs` | Delay between autocomplete requests. |

### Output

Each dataset item is one Amazon autocomplete suggestion.

```json
{
  "seed": "laptop stand",
  "expandedPrefix": "laptop stand a",
  "suggestion": "laptop stand adjustable",
  "rank": 1,
  "type": "KEYWORD",
  "suggType": "KeywordSuggestion",
  "marketplace": "US",
  "domain": "completion.amazon.com",
  "mid": "ATVPDKIKX0DER",
  "alias": "aps",
  "refTag": "nb_sb_ss_i_1_12",
  "strategyId": "organic",
  "sourceUrl": "https://completion.amazon.com/api/2017/suggestions?...",
  "fetchedAt": "2026-06-25T00:00:00.000Z"
}
```

### Data table

| Column | Meaning |
| --- | --- |
| `seed` | Original keyword supplied by the user. |
| `expandedPrefix` | Exact prefix queried against Amazon. |
| `suggestion` | Autocomplete suggestion text. |
| `rank` | Order returned by Amazon for that prefix. |
| `type` | Amazon suggestion type when present. |
| `suggType` | Amazon suggestion subtype when present. |
| `marketplace` | Marketplace code such as US or DE. |
| `domain` | Completion endpoint domain. |
| `mid` | Amazon marketplace ID. |
| `alias` | Department alias used in the request. |
| `refTag` | Optional Amazon reference tag. |
| `strategyId` | Optional strategy metadata. |
| `sourceUrl` | Traceable request URL. |
| `fetchedAt` | ISO timestamp of collection. |

### How to scrape Amazon autocomplete suggestions

1. Open the actor on Apify.
2. Add one or more seed keywords.
3. Pick the Amazon marketplace.
4. Keep `alias` as `aps` unless you need a specific department.
5. Choose an expansion mode.
6. Set `maxPrefixes` to control run size.
7. Start the run.
8. Export the dataset as CSV, JSON, Excel, or through the API.

### Expansion examples

Seed-only mode queries exactly the seed keyword.

A-Z mode queries `seed a`, `seed b`, `seed c`, and so on.

A-Z + 0-9 mode also queries numeric suffixes such as `seed 1`.

Custom mode uses your own suffixes, for example `best`, `for women`, and `under 50`.

### Department alias tips

Use `aps` for all departments.

Try Amazon-specific aliases when you want a category context.

Examples include `electronics`, `fashion`, `stripbooks`, `grocery`, `hpc`, and `toys-and-games`.

Amazon aliases can vary by marketplace, so unsupported aliases may return fewer suggestions.

### Marketplace tips

Use US when you need broad English keyword ideas.

Use UK, CA, AU, or IN for English-language marketplace differences.

Use DE, FR, IT, ES, or JP when researching localized product phrases.

Run separate jobs per marketplace if you need independent exports.

### Deduplication

Autocomplete expansion often returns the same suggestion for multiple prefixes.

When `dedupeSuggestions` is enabled, the actor keeps only one row per marketplace, alias, and suggestion value.

Disable deduplication if you want to analyze which prefixes surfaced the same suggestion.

### Integrations

- Send CSV exports to Google Sheets for product research.
- Push JSON results into Airtable for keyword planning.
- Combine with Amazon product scrapers to compare keywords and listing copy.
- Feed suggestions into PPC campaign builders.
- Store daily runs in a data warehouse to monitor new long-tail terms.

### 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-autocomplete-scraper').call({
  keywords: ['laptop stand'],
  marketplace: 'US',
  expansionMode: 'a-z',
  maxPrefixes: 26,
});
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-autocomplete-scraper').call(run_input={
    'keywords': ['coffee grinder'],
    'marketplace': 'US',
    'expansionMode': 'a-z',
    'maxPrefixes': 26,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~amazon-autocomplete-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["desk lamp"],"marketplace":"US","expansionMode":"a-z","maxPrefixes":26}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or any MCP-compatible client through Apify MCP.

MCP URL:

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

Add it to Claude Code:

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

Claude Desktop JSON configuration:

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

Example prompts:

- "Scrape Amazon autocomplete suggestions for `wireless earbuds` in the US marketplace."
- "Get A-Z Amazon keyword ideas for `standing desk` and return a CSV-ready table."
- "Compare US and UK autocomplete suggestions for `protein powder`."

### Quality and reliability notes

The actor uses Amazon's public completion endpoint.

It does not log in, use a browser, or collect private account data.

Large jobs should use a modest delay to avoid unnecessary request spikes.

If a marketplace returns no results, try a simpler seed or the `aps` alias.

### FAQ

#### Why did I get fewer suggestions than expected?

Amazon may return fewer than the requested maximum for niche prefixes, unsupported aliases, or localized marketplaces.

#### Why are some metadata fields null?

Amazon does not always include `refTag` or `strategyId`. The actor keeps those fields nullable for consistency.

#### Why do I see duplicate-looking keywords?

If deduplication is disabled, the same suggestion can appear under multiple expanded prefixes. Enable `dedupeSuggestions` to collapse them.

### Legality

This actor collects publicly available autocomplete suggestions from Amazon's public completion endpoint.

You are responsible for using the data in compliance with Amazon's terms, applicable laws, and your own business policies.

Do not use the actor to collect personal data or private account information.

### Related scrapers

- [Google Autocomplete Scraper](https://apify.com/automation-lab/google-autocomplete-scraper)
- [YouTube Autocomplete Keywords Scraper](https://apify.com/automation-lab/youtube-autocomplete-keywords-scraper)
- [Amazon Keywords Discovery Tool](https://apify.com/automation-lab/amazon-keywords-discovery-tool)
- [Amazon Product Scraper](https://apify.com/automation-lab/amazon-product-scraper)

### Changelog

Initial version supports Amazon autocomplete suggestions, marketplace presets, A-Z expansion, custom suffixes, deduplication, and typed dataset output.

### Support

If a run returns unexpected output, share the run ID, marketplace, seed keywords, and alias so the issue can be reproduced.

### Summary

Amazon Autocomplete Scraper is built for repeatable keyword discovery workflows.

It helps sellers, agencies, and ecommerce teams turn seed terms into structured Amazon search suggestion datasets.

# Actor input Schema

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

Amazon search terms to expand into autocomplete suggestions.

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

Marketplace preset used for the public Amazon completion endpoint.

## `alias` (type: `string`):

Amazon search department alias. Use aps for All Departments, or values such as electronics, fashion, stripbooks, grocery, hpc, toys-and-games.

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

Choose whether to query each seed once, append A-Z, append A-Z and 0-9, or use custom suffixes.

## `customSuffixes` (type: `array`):

Suffixes to append after each seed when expansion mode is custom, for example best, for women, under 50.

## `maxSuggestionsPerPrefix` (type: `integer`):

Maximum autocomplete suggestions saved from each prefix request.

## `maxPrefixes` (type: `integer`):

Safety limit for the number of prefix requests across all seeds.

## `dedupeSuggestions` (type: `boolean`):

Remove duplicate suggestion values within the same marketplace and department.

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

Optional polite delay between autocomplete requests. Increase for very large jobs.

## Actor input object example

```json
{
  "keywords": [
    "laptop stand",
    "coffee grinder"
  ],
  "marketplace": "US",
  "alias": "aps",
  "expansionMode": "a-z",
  "customSuffixes": [
    "best",
    "for women",
    "under 50"
  ],
  "maxSuggestionsPerPrefix": 10,
  "maxPrefixes": 20,
  "dedupeSuggestions": true,
  "requestDelayMs": 100
}
```

# 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 = {
    "keywords": [
        "laptop stand",
        "coffee grinder"
    ],
    "marketplace": "US",
    "alias": "aps",
    "expansionMode": "a-z",
    "customSuffixes": [
        "best",
        "for women",
        "under 50"
    ],
    "maxSuggestionsPerPrefix": 10,
    "maxPrefixes": 20,
    "dedupeSuggestions": true,
    "requestDelayMs": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/amazon-autocomplete-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "laptop stand",
        "coffee grinder",
    ],
    "marketplace": "US",
    "alias": "aps",
    "expansionMode": "a-z",
    "customSuffixes": [
        "best",
        "for women",
        "under 50",
    ],
    "maxSuggestionsPerPrefix": 10,
    "maxPrefixes": 20,
    "dedupeSuggestions": True,
    "requestDelayMs": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/amazon-autocomplete-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "laptop stand",
    "coffee grinder"
  ],
  "marketplace": "US",
  "alias": "aps",
  "expansionMode": "a-z",
  "customSuffixes": [
    "best",
    "for women",
    "under 50"
  ],
  "maxSuggestionsPerPrefix": 10,
  "maxPrefixes": 20,
  "dedupeSuggestions": true,
  "requestDelayMs": 100
}' |
apify call automation-lab/amazon-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Autocomplete Scraper",
        "description": "Scrape Amazon autocomplete keyword suggestions across marketplaces with A-Z expansion, department aliases, ranks, source URLs, and deduped output.",
        "version": "0.1",
        "x-build-id": "dMKub3zkw9lloIGYT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~amazon-autocomplete-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-amazon-autocomplete-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~amazon-autocomplete-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-amazon-autocomplete-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~amazon-autocomplete-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-amazon-autocomplete-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Seed keywords",
                        "type": "array",
                        "description": "Amazon search terms to expand into autocomplete suggestions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplace": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "CA",
                            "IN",
                            "AU",
                            "JP"
                        ],
                        "type": "string",
                        "description": "Marketplace preset used for the public Amazon completion endpoint.",
                        "default": "US"
                    },
                    "alias": {
                        "title": "Amazon department alias",
                        "type": "string",
                        "description": "Amazon search department alias. Use aps for All Departments, or values such as electronics, fashion, stripbooks, grocery, hpc, toys-and-games.",
                        "default": "aps"
                    },
                    "expansionMode": {
                        "title": "Expansion mode",
                        "enum": [
                            "seed",
                            "a-z",
                            "a-z-0-9",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Choose whether to query each seed once, append A-Z, append A-Z and 0-9, or use custom suffixes.",
                        "default": "a-z"
                    },
                    "customSuffixes": {
                        "title": "Custom suffixes",
                        "type": "array",
                        "description": "Suffixes to append after each seed when expansion mode is custom, for example best, for women, under 50.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSuggestionsPerPrefix": {
                        "title": "Max suggestions per prefix",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum autocomplete suggestions saved from each prefix request.",
                        "default": 10
                    },
                    "maxPrefixes": {
                        "title": "Max prefix requests",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Safety limit for the number of prefix requests across all seeds.",
                        "default": 20
                    },
                    "dedupeSuggestions": {
                        "title": "Deduplicate suggestions",
                        "type": "boolean",
                        "description": "Remove duplicate suggestion values within the same marketplace and department.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Optional polite delay between autocomplete requests. Increase for very large jobs.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
