# Amazon Best Sellers Scraper - Top 100 Ranked Products (`thirdwatch/amazon-bestsellers-scraper`) Actor

Scrape Amazon Best Sellers and New Releases charts for any category or browse node across 18 marketplaces. Returns rank, ASIN, title, numeric price, rating, review count, and image for up to 100 ranked products per chart.

- **URL**: https://apify.com/thirdwatch/amazon-bestsellers-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.60 / 1,000 results

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Best Sellers Scraper — Top 100 Ranked Products by Category

Pull Amazon's own ranked charts — **Best Sellers** and **New Releases** — for any category or browse node, on 18 Amazon marketplaces, as clean structured rows.

Amazon publishes a live sales-rank chart for every browse category it operates. Those charts are the single best public signal of what is actually selling on Amazon right now: they are recomputed hourly from real order volume, they cover every department from Electronics to Grocery, and they drill all the way down into thousands of narrow subcategories. This Actor turns any of those charts into a dataset with rank, ASIN, title, numeric price, star rating, review count, and image URL for up to 100 ranked positions per chart.

### What you get

Each row is one ranked product on one chart, on one marketplace, at one point in time. Prices are parsed into real numbers with an explicit currency code, ratings and review counts are integers/floats rather than display strings, and every URL is absolute — so the output drops straight into a spreadsheet, a BI tool, or a pandas DataFrame with no cleanup step.

### Use cases

- **Product research / sourcing** — find what is ranking in a category before you commit inventory, and watch how the top 100 shuffles week over week.
- **Competitive monitoring** — track whether your ASIN is entering or falling out of the chart for its category and node.
- **Demand and trend detection** — schedule a daily run and diff the chart to see which products are climbing.
- **Pricing intelligence** — capture the current buy-box or lowest-offer price of every product on a chart in one pass.
- **New-product discovery** — the New Releases chart surfaces launches within days, long before they accumulate reviews.
- **Category benchmarking** — compare the same category across the US, UK, India, Germany and 14 other marketplaces.
- **Content and affiliate feeds** — generate "top 50 in Kitchen" lists that stay current automatically.

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `categories` | array of strings | `["electronics"]` | One entry per chart. Accepts a category slug, a `slug/nodeId` pair, or a full Amazon Best Sellers / New Releases URL. |
| `listType` | string | `bestSellers` | `bestSellers` (ranked by sales) or `newReleases` (ranked newest first). |
| `country` | string | `us` | Marketplace to read charts from. Ignored for entries that are already full URLs. |
| `maxResults` | integer | `10` | Ranked products to return per category, 1–100. |
| `proxyConfiguration` | object | residential, matching country | Proxy settings. Residential proxies matching the marketplace are strongly recommended. |

#### Accepted `categories` formats

````

electronics                                        # slug on the selected marketplace
electronics/172623                                 # slug + browse-node ID (subcategory chart)
https://www.amazon.com/gp/bestsellers/kitchen      # full URL (marketplace + list type inferred)
https://www.amazon.co.uk/gp/new-releases/grocery   # full URL, New Releases

````

A full URL overrides both `country` and `listType` for that entry, so you can mix marketplaces in a single run.

#### Example input

```json
{
  "categories": ["electronics", "kitchen", "electronics/172623"],
  "listType": "bestSellers",
  "country": "us",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

#### Popular US category slugs

`electronics`, `books`, `kitchen`, `beauty`, `grocery`, `pet-supplies`, `toys-and-games`, `videogames`, `sporting-goods`, `office-products`, `home-garden`, `lawn-garden`, `automotive`, `appliances`, `fashion`, `hpc` (health & personal care), `baby-products`, `industrial`, `musical-instruments`, `software`, `wireless`, `amazon-devices`, `arts-crafts`, `movies-tv`, `music`, `photo`, `pc`.

Slugs are marketplace-specific. `amazon.de`, for example, uses `computers` where `amazon.com` uses `electronics`. The safest approach on a non-US marketplace is to open the chart in a browser and paste the URL.

#### Supported marketplaces

United States, United Kingdom, Canada, India, Germany, France, Italy, Spain, Netherlands, Sweden, Poland, Japan, Australia, Singapore, United Arab Emirates, Saudi Arabia, Mexico, Brazil.

### Output fields

One dataset item per ranked product.

| Field | Type | Description |
|---|---|---|
| `rank` | integer | Position on the chart, 1–100. Taken from Amazon's own rank data, not from render order. |
| `asin` | string | Amazon Standard Identification Number. |
| `title` | string | Product title as shown on the chart. |
| `by_line` | string | Author / artist / brand line. Populated on Books, Music and Video charts; empty on most hard-goods charts. |
| `product_format` | string | Binding or edition line, e.g. `Paperback`, `Kindle Edition`. Media charts only. |
| `price` | number | null | Displayed price as a number. `null` when the chart shows no price for that product. |
| `price_text` | string | Price exactly as displayed, including the local symbol. |
| `price_type` | string | `list` for a straight price, `from` when Amazon shows "N offers from …". |
| `offers_count` | integer | null | Number of competing offers, when Amazon shows an "N offers from" line. |
| `currency` | string | ISO currency code of the marketplace, e.g. `USD`, `GBP`, `INR`. |
| `currency_symbol` | string | Local currency symbol, e.g. `$`, `£`, `₹`. |
| `rating` | number | null | Star rating as a number, e.g. `4.6`. |
| `rating_text` | string | Rating as displayed, e.g. `4.6 out of 5 stars`. |
| `reviews_count` | integer | null | Review/rating count as an integer, e.g. `278492`. |
| `reviews_count_text` | string | Review count as displayed, e.g. `278,492`. |
| `product_url` | string | Canonical absolute product URL (`https://{marketplace}/dp/{asin}`). |
| `image_url` | string | Absolute product image URL. |
| `reviews_url` | string | Absolute URL of the product's reviews page. |
| `list_type` | string | `bestSellers` or `newReleases`. |
| `category_slug` | string | Category slug the chart was read from. |
| `category_node_id` | string | null | Browse-node ID when a subcategory chart was requested. |
| `category_url` | string | Absolute URL of the chart page this row came from. |
| `page` | integer | `1` for ranks 1–50, `2` for ranks 51–100. |
| `marketplace` | string | Amazon domain, e.g. `www.amazon.com`. |
| `country` | string | Marketplace country code, e.g. `us`. |
| `source_query` | string | The exact `categories` entry that produced this row. |
| `scraped_at` | string | ISO 8601 UTC timestamp of the fetch. |

### Example output

```json
{
  "rank": 1,
  "asin": "1668236516",
  "title": "Theo of Golden: A Novel",
  "by_line": "Allen Levi",
  "product_format": "Paperback",
  "price": 14.98,
  "price_text": "$14.98",
  "price_type": "list",
  "offers_count": null,
  "currency": "USD",
  "currency_symbol": "$",
  "rating": 4.7,
  "rating_text": "4.7 out of 5 stars",
  "reviews_count": 153523,
  "reviews_count_text": "153,523",
  "product_url": "https://www.amazon.com/dp/1668236516",
  "image_url": "https://images-na.ssl-images-amazon.com/images/I/81P0NvoRrWL._AC_UL300_SR300,200_.jpg",
  "reviews_url": "https://www.amazon.com/product-reviews/1668236516",
  "list_type": "bestSellers",
  "category_slug": "books",
  "category_node_id": null,
  "category_url": "https://www.amazon.com/gp/bestsellers/books",
  "page": 1,
  "marketplace": "www.amazon.com",
  "country": "us",
  "source_query": "books",
  "scraped_at": "2026-07-27T22:55:24+00:00"
}
```

### Limitations

Please read these before you plan a large job — they are properties of Amazon's charts, not of this Actor.

- **100 ranks per chart, hard cap.** Amazon itself only publishes the top 100 positions of any chart; requesting a third page returns an error. `maxResults` is capped at 100 per category for this reason. To go deeper, pass subcategory browse nodes — each node has its own independent top 100.
- **Chart data only, not full product detail.** Rows contain what the chart itself exposes: rank, ASIN, title, one price, rating, review count, image. There is no description, bullet points, variant list, seller name, buy-box breakdown, stock level, or category-specific attribute set. Pair this Actor with a product-detail scraper if you need those.
- **Price is the chart price.** Where Amazon shows "N offers from $X" instead of a single price, `price` is that lowest-offer figure and `price_type` is `from`. Some products — subscriptions, certain grocery and marketplace items — show no price at all on the chart; those rows carry `price: null` rather than being dropped.
- **Rating and review coverage varies by chart.** On mature Best Sellers charts, ratings are present on ~98–100% of rows. On New Releases charts many products are days old and have no reviews yet — in live testing a UK New Releases chart returned ratings on 56% of rows. This is real chart data, not a parsing gap.
- **`by_line` and `product_format` are media-only.** Books, Music and Video charts populate them on ~98–100% of rows; Electronics, Kitchen and similar hard-goods charts do not carry an author/format line at all, so those fields are empty there.
- **Category slugs are marketplace-specific.** A slug that works on `amazon.com` may not exist on `amazon.de` or `amazon.co.jp`. Unknown slugs produce a warning and zero rows for that entry, not a failed run. When in doubt, paste the full chart URL.
- **Occasional empty renders.** A small share of requests return a valid page with an empty grid. The Actor retries once with a fresh session, which resolves it in most cases; a chart that is empty on both attempts is reported as having no results.
- **Movers & Shakers is not supported.** That third chart type is not delivered in the server-rendered response and is deliberately out of scope.
- **Charts are point-in-time.** Amazon recomputes Best Sellers roughly hourly. Two runs minutes apart can legitimately differ. Schedule runs and store snapshots if you want a trend series.
- **Residential proxies recommended.** Amazon throttles datacenter address space aggressively. Run with residential proxies in the marketplace's own country for consistent results.

### Legal

This Actor collects only publicly available information from Amazon's public best-seller charts. It does not log in, does not access personal data, and does not bypass any paywall. You are responsible for ensuring your use of the data complies with Amazon's terms and with applicable law in your jurisdiction.

### Compared to alternatives

- **vs. junglee/Amazon-crawler**: This actor is focused on ranked Best Sellers and New Releases charts, including chart position and point-in-time category context.
- **vs. general Amazon product scrapers**: Use this actor for category rankings; use a product-detail actor when you need offers, variants, sellers, or descriptions.

### FAQ

**Can I collect more than 100 products from one chart?**
No. Amazon publishes a maximum of 100 positions per chart. Use narrower subcategory nodes for broader coverage.

**Does it support New Releases?**
Yes. Set `listType` to `newReleases`.

**Can one run cover multiple marketplaces?**
Yes. Full chart URLs can be mixed in `categories`; each URL determines its marketplace.

Last verified: 2026-07

More e-commerce actors at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

## `categories` (type: `array`):

One entry per chart. Accepts a category slug ("electronics"), a slug with a browse-node ID ("electronics/172623"), or a full Amazon Best Sellers / New Releases URL ("https://www.amazon.com/gp/bestsellers/kitchen"). A full URL overrides the Marketplace and List Type settings below. Popular US slugs: electronics, books, kitchen, beauty, grocery, pet-supplies, toys-and-games, videogames, sporting-goods, office-products, home-garden, automotive, appliances, fashion, hpc, baby-products, industrial, musical-instruments, software, wireless. Slugs differ between marketplaces (amazon.de uses "computers", not "electronics").

## `listType` (type: `string`):

Which Amazon chart to read. Best Sellers ranks by sales volume; New Releases ranks the newest products in the category.

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

Amazon marketplace to read the charts from. Ignored for entries that are already full URLs.

## `maxResults` (type: `integer`):

How many ranked products to return per category. Amazon publishes at most 100 ranks per chart, so values above 100 are capped at 100.

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

Proxy settings. Residential proxies matching the chosen marketplace country are strongly recommended — Amazon throttles datacenter IPs.

## Actor input object example

```json
{
  "categories": [
    "electronics"
  ],
  "listType": "bestSellers",
  "country": "us",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "categories": [
        "electronics"
    ],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/amazon-bestsellers-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 = {
    "categories": ["electronics"],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/amazon-bestsellers-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 '{
  "categories": [
    "electronics"
  ],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call thirdwatch/amazon-bestsellers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Best Sellers Scraper - Top 100 Ranked Products",
        "description": "Scrape Amazon Best Sellers and New Releases charts for any category or browse node across 18 marketplaces. Returns rank, ASIN, title, numeric price, rating, review count, and image for up to 100 ranked products per chart.",
        "version": "1.0",
        "x-build-id": "u3RfdknRhClZvDBhj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thirdwatch~amazon-bestsellers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thirdwatch-amazon-bestsellers-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/thirdwatch~amazon-bestsellers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thirdwatch-amazon-bestsellers-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/thirdwatch~amazon-bestsellers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thirdwatch-amazon-bestsellers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "categories": {
                        "title": "Categories / Chart URLs",
                        "type": "array",
                        "description": "One entry per chart. Accepts a category slug (\"electronics\"), a slug with a browse-node ID (\"electronics/172623\"), or a full Amazon Best Sellers / New Releases URL (\"https://www.amazon.com/gp/bestsellers/kitchen\"). A full URL overrides the Marketplace and List Type settings below. Popular US slugs: electronics, books, kitchen, beauty, grocery, pet-supplies, toys-and-games, videogames, sporting-goods, office-products, home-garden, automotive, appliances, fashion, hpc, baby-products, industrial, musical-instruments, software, wireless. Slugs differ between marketplaces (amazon.de uses \"computers\", not \"electronics\").",
                        "default": [
                            "electronics"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "listType": {
                        "title": "List Type",
                        "enum": [
                            "bestSellers",
                            "newReleases"
                        ],
                        "type": "string",
                        "description": "Which Amazon chart to read. Best Sellers ranks by sales volume; New Releases ranks the newest products in the category.",
                        "default": "bestSellers"
                    },
                    "country": {
                        "title": "Marketplace",
                        "enum": [
                            "us",
                            "uk",
                            "ca",
                            "in",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "nl",
                            "se",
                            "pl",
                            "jp",
                            "au",
                            "sg",
                            "ae",
                            "sa",
                            "mx",
                            "br"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace to read the charts from. Ignored for entries that are already full URLs.",
                        "default": "us"
                    },
                    "maxResults": {
                        "title": "Max Results Per Category",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many ranked products to return per category. Amazon publishes at most 100 ranks per chart, so values above 100 are capped at 100.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies matching the chosen marketplace country are strongly recommended — Amazon throttles datacenter IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
