# Amazon BSR Scraper (`marketplace-scrapers/amazon-bsr-scraper`) Actor

Scrape Amazon BSR rank, Buy Box winner, price, and offer count for any list of ASINs across the US, UK, DE, and JP marketplaces. Time-series snapshots accumulate in a named Apify dataset keyed by date. PA-API sunset replacement; no seller account needed; bring your own cookies.

- **URL**: https://apify.com/marketplace-scrapers/amazon-bsr-scraper.md
- **Developed by:** [Market Place Scrapers](https://apify.com/marketplace-scrapers) (community)
- **Categories:** E-commerce, Automation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 bsr snapshot scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Track **Amazon Best Seller Rank (BSR)**, **Buy Box winner**, **price**, and **offer count** for any list of ASINs across 10 [Amazon](https://www.amazon.com/) marketplaces (US, UK, DE, FR, IT, ES, NL, JP, CA, AU). Each run appends a time-stamped snapshot to a named Apify dataset, so you build a growing time series — never overwrite. A drop-in **Amazon Product Advertising API (PA-API) replacement**: no seller account, no PA-API key, no affiliate gate. Just public `/dp/{ASIN}` page extraction with residential-proxy rotation.

### What can this Amazon BSR scraper do?

- 📈 **Best Seller Rank (BSR) tracking** — primary rank + category, plus the full list of all BSR sub-categories
- 🥇 **Buy Box monitoring** — winner type (Amazon / FBA / FBM), seller name, and ships-from
- 💰 **Price + currency** — localized price string with currency symbol and ISO-4217 code
- 🌍 **10 Amazon marketplaces** — US, UK, DE, FR, IT, ES, NL, JP, CA, AU (Cartesian product over ASIN × marketplace)
- ⏱️ **Time-series accumulation** — snapshots append-only to a named Apify dataset, queryable by date
- 🔁 **Schedule daily / hourly** with Apify's built-in scheduler — no cron server needed
- 🌐 **Residential-proxy rotation** with per-marketplace country pinning (handled automatically)
- 🆓 **Free trial** — first 50 snapshots free on the Apify Free plan ($5 platform credit)

### Why scrape Amazon BSR instead of using PA-API?

The Amazon Product Advertising API (**PA-API**) sunsets on 2026-04-30. Even before that, PA-API requires:

- An approved Amazon Associates account (rejection-prone)
- A maintained affiliate site driving qualified sales (or your access is revoked)
- Heavy throttling that doesn't scale to multi-marketplace tracking

This **Amazon scraper** scrapes public product detail pages — same data PA-API exposed (`SalesRank`, `LowestPrice`, `OfferSummary`), without the gatekeeping. Roughly **5–10× cheaper at scale** than Helium 10 or Jungle Scout, with no UI lock-in.

### What data can this Amazon BSR Scraper extract?

| Field | Description |
|-------|-------------|
| `bsr_rank` | Primary Best Seller Rank within the parent category |
| `bsr_category` | Parent category name (localized to marketplace) |
| `bsr_categories_all` | Full list of sub-category ranks (`[{rank, category}, …]`) |
| `buy_box_winner` | `Amazon` / `FBA` / `FBM` — type of seller currently winning the Buy Box |
| `buy_box_seller_name` | Display name of the Buy Box seller |
| `price` | Localized price string (e.g. `899,00 €`, `£19.72`, `$24.99`) |
| `currency` | ISO-4217 code (USD, GBP, EUR, JPY, CAD, AUD) |
| `offer_count` | Total number of offers on the listing |
| `title` | Product title as shown on the listing |
| `main_image_url` | Hero image URL (CDN-hosted) |
| `snapshot_date` / `snapshot_ts` | YYYY-MM-DD + ISO-8601 timestamp keys for time-series queries |

Download the full dataset as **JSON, CSV, Excel, HTML, or XML** from the Storage tab, or pull it programmatically via the [Apify API](https://docs.apify.com/api/v2).

### How do I use this scraper to track Amazon BSR?

1. Open the **Amazon BSR Scraper** on [Apify Store](https://apify.com/) and click **Try for free**
2. Choose your marketplace(s) — US, UK, DE, FR, IT, ES, NL, JP, CA, or AU
3. Paste your ASIN list (10 alphanumeric chars each) — ASINs must be valid in the chosen marketplace
4. (Optional) Cap snapshots per run with `maxSnapshots` to control spend
5. Click **Start** — results stream into the dataset as each ASIN finishes
6. (Optional) Save the run as a [Scheduled Task](https://docs.apify.com/platform/schedules) for daily/hourly tracking

For multi-marketplace coverage at scale, create one scheduled task per marketplace, each with its own ASIN list.

### How much does it cost to scrape Amazon BSR?

| Tier | Price | Best for |
|------|-------|----------|
| **Free trial** | 50 snapshots free | Evaluate before paying |
| **Pay-per-result** | $1.50 per 1,000 snapshots | Burst use, ad-hoc tracking |
| **Subscription** | $29/mo + $0.80 / 1K (10K included) | Daily multi-marketplace cohorts |

On the **Apify Free plan** ($5 platform credit) you can extract roughly **3,300 Amazon snapshots** before hitting the credit limit. A typical 100-ASIN-per-day, 1-marketplace tracker costs about **$4.50/month** on pay-per-result, or fits comfortably in the Subscription's 10K included quota for ≤300 ASINs/day.

Break-even: subscription beats pay-per-result around **37,000 snapshots/month**.

### Input

The actor accepts a JSON payload — see the **Input** tab for full schema. Minimum example:

```json
{
  "marketplaces": ["UK"],
  "asins": ["0735211299", "1612680194", "0062316095", "1455586692"],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "GB"
  }
}
````

Each ASIN is fetched on every listed marketplace (Cartesian product). Residential proxy with per-marketplace country pinning is required to avoid the 'Currently unavailable' geo-redirect that strips price/BSR markup.

### Output

```json
{
  "asin": "B0CHX1W1XY",
  "marketplace": "DE",
  "url": "https://www.amazon.de/dp/B0CHX1W1XY",
  "title": "Apple iPhone 15 (128 GB) - Black",
  "price": "899,00 €",
  "currency": "EUR",
  "bsr_rank": 1234,
  "bsr_category": "Elektronik & Foto",
  "bsr_categories_all": [
    {"rank": 1234, "category": "Elektronik & Foto"},
    {"rank": 56, "category": "Smartphones"}
  ],
  "buy_box_winner": "Amazon",
  "buy_box_seller_name": "Amazon",
  "ships_from": "Amazon",
  "offer_count": 3,
  "main_image_url": "https://m.media-amazon.com/images/I/example.jpg",
  "snapshot_date": "2026-04-25",
  "snapshot_ts": "2026-04-25T18:30:00+00:00"
}
```

Download the full dataset as **JSON, CSV, Excel, HTML, or XML** from the Storage tab.

### Tips for higher data completeness

- **Pin a residential country** that matches the marketplace (`GB` for UK, `US` for amazon.com, `DE` for amazon.de). This is automatic, but verify in the proxy config.
- **Use globally-shippable ASINs** for testing (books, generic electronics). Region-locked ASINs (groceries, large appliances) may render the geo-restriction interstitial that strips BSR markup.
- **Schedule runs at off-peak hours** for the target marketplace — block-rate is markedly lower at 02:00–06:00 local time.
- **One marketplace per scheduled task** — keeps proxy country pinning clean and isolates regional failures.

### Use cases

**Amazon Sellers** — Track your own ASIN BSR and Buy Box status daily. Get alerted to Buy Box losses or sudden BSR drops before they impact sales.

**Brand Managers** — Monitor cross-marketplace price parity for Minimum Advertised Price (MAP) compliance — schedule one task per region with locale-correct ASINs.

**Market Researchers** — Build BSR and category trend datasets without paying $99/month for Helium 10 or Jungle Scout. Query your own accumulating snapshot history with any SQL or dataframe tool.

**Affiliate marketers / PA-API refugees** — Replace the soon-to-sunset Amazon Product Advertising API with public-page extraction. No Associates account, no affiliate gate.

### Other Apify scrapers you might like

- [Shopify GMV Scraper](https://apify.com/) — measures gross merchandise volume on any Shopify store
- [TikTok Shop Scraper](https://apify.com/) — product, price, and seller data from TikTok Shop
- [Airbnb Scraper](https://apify.com/) — listings, prices, and availability across Airbnb markets
- [Idealista Scraper](https://apify.com/) — real-estate listings from Idealista (Spain, Italy, Portugal)
- [LinkedIn Sales Navigator Scraper](https://apify.com/) — lead enrichment from LinkedIn Sales Navigator

### Is it legal to scrape Amazon?

Our scrapers are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our scrapers, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers. You can also read our blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**Does this work after the PA-API sunset on 2026-04-30?**
Yes — that is the entire point. The actor scrapes public Amazon product pages directly, bypassing PA-API entirely.

**Do I need a seller account or Amazon Associates membership?**
No. The actor only accesses public product detail pages — same as any browser visit.

**How does multi-marketplace tracking work?**
One run can cover multiple marketplaces (Cartesian product over `marketplaces` × `asins`). For large-scale daily tracking, create one Apify scheduled task per marketplace for cleaner regional proxy isolation and independent failure recovery.

**Why are some ASINs the same product in different regions?**
ASINs are marketplace-specific — the same physical product often has different ASINs across Amazon's regional catalogs. Always supply ASINs validated against your target marketplace.

**How is this different from Keepa or Jungle Scout?**
Those are full seller suites or chart-first products at $19–$99/month per seat. This actor is data-only: raw BSR, Buy Box, and price snapshots land in your own Apify dataset, queryable with any SQL or dataframe tool. Roughly 5–10× cheaper at scale with no UI lock-in.

**Why is `bsr_rank` sometimes null?**
A small fraction of listings legitimately have no BSR (new listings, parent ASINs that only show ranks on variants, or ASINs in regions where Amazon hides BSR for the category). For high-traffic ASINs in popular categories, rank presence is >98%. If you see persistent nulls, double-check the ASIN is valid in the chosen marketplace.

**Can I get a custom Amazon scraper built?**
Yes — open an issue on this GitHub repo or message us via the Apify Console. We build bespoke Amazon scrapers (review extraction, seller storefronts, category pagination) on a project basis.

**Which integrations are supported?**
Native [Apify integrations](https://apify.com/integrations) cover Make, Zapier, n8n, Google Drive, Airtable, Slack, GitHub, and webhooks. The dataset is also pullable directly via the [Apify API](https://docs.apify.com/api/v2).

***

*Amazon and the Amazon logo are trademarks of Amazon.com, Inc. or its affiliates. This actor is not affiliated with or endorsed by Amazon.*

# Actor input Schema

## `marketplaces` (type: `array`):

Amazon marketplace codes to scrape. Each ASIN is fetched on every listed marketplace (Cartesian product). Example: \["US", "UK"] × 5 ASINs = 10 requests per run.

## `asins` (type: `array`):

Amazon Standard Identification Numbers (10 alphanumeric chars each) valid in the chosen marketplace. Default prefill is 4 popular books (Atomic Habits, Rich Dad Poor Dad, Sapiens, Deep Work) — books are globally shippable and avoid the 'Currently unavailable' geo-restriction page that strips price/BSR markup. ASINs not in the catalog 404 and are skipped silently.

## `maxSnapshots` (type: `integer`):

Upper bound on records pushed per run.

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

Apify Proxy. Residential group is required (per-marketplace country\_code is applied automatically from the marketplace registry).

## Actor input object example

```json
{
  "marketplaces": [
    "UK"
  ],
  "asins": [
    "0735211299",
    "1612680194",
    "0062316095",
    "1455586692"
  ],
  "maxSnapshots": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}
```

# Actor output Schema

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

BSR snapshots stored in the named dataset (default: amazon-bsr-snapshots). Each item contains asin, marketplace, bsr\_rank, bsr\_category, price, buy\_box\_winner, buy\_box\_seller\_name, and snapshot\_date.

# 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 = {
    "marketplaces": [
        "UK"
    ],
    "asins": [
        "0735211299",
        "1612680194",
        "0062316095",
        "1455586692"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "GB"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("marketplace-scrapers/amazon-bsr-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 = {
    "marketplaces": ["UK"],
    "asins": [
        "0735211299",
        "1612680194",
        "0062316095",
        "1455586692",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "GB",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("marketplace-scrapers/amazon-bsr-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 '{
  "marketplaces": [
    "UK"
  ],
  "asins": [
    "0735211299",
    "1612680194",
    "0062316095",
    "1455586692"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}' |
apify call marketplace-scrapers/amazon-bsr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon BSR Scraper",
        "description": "Scrape Amazon BSR rank, Buy Box winner, price, and offer count for any list of ASINs across the US, UK, DE, and JP marketplaces. Time-series snapshots accumulate in a named Apify dataset keyed by date. PA-API sunset replacement; no seller account needed; bring your own cookies.",
        "version": "1.0",
        "x-build-id": "PTwdQBjXVLjDTCqni"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/marketplace-scrapers~amazon-bsr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-marketplace-scrapers-amazon-bsr-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/marketplace-scrapers~amazon-bsr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-marketplace-scrapers-amazon-bsr-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/marketplace-scrapers~amazon-bsr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-marketplace-scrapers-amazon-bsr-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": [
                    "marketplaces",
                    "asins"
                ],
                "properties": {
                    "marketplaces": {
                        "title": "Marketplaces",
                        "type": "array",
                        "description": "Amazon marketplace codes to scrape. Each ASIN is fetched on every listed marketplace (Cartesian product). Example: [\"US\", \"UK\"] × 5 ASINs = 10 requests per run.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "UK"
                        ]
                    },
                    "asins": {
                        "title": "ASINs",
                        "type": "array",
                        "description": "Amazon Standard Identification Numbers (10 alphanumeric chars each) valid in the chosen marketplace. Default prefill is 4 popular books (Atomic Habits, Rich Dad Poor Dad, Sapiens, Deep Work) — books are globally shippable and avoid the 'Currently unavailable' geo-restriction page that strips price/BSR markup. ASINs not in the catalog 404 and are skipped silently.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Z0-9]{10}$"
                        },
                        "default": [
                            "0735211299",
                            "1612680194",
                            "0062316095",
                            "1455586692"
                        ]
                    },
                    "maxSnapshots": {
                        "title": "Max Snapshots per Run",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper bound on records pushed per run.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify Proxy. Residential group is required (per-marketplace country_code is applied automatically from the marketplace registry).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "GB"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
