# Amazon Multi-Country Scraper - 7 Marketplaces EN+EU+CA (`viralanalyzer/amazon-multi-country`) Actor

Scrape Amazon products across 7 marketplaces: US, UK, Germany, France, Italy, Spain, Canada. Country-aware locale, currency (USD/GBP/EUR/CAD), Accept-Language, and Prime filter. Smart proxy routing per region.

- **URL**: https://apify.com/viralanalyzer/amazon-multi-country.md
- **Developed by:** [viralanalyzer](https://apify.com/viralanalyzer) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Multi-Country Scraper — US / UK / DE / FR / IT / ES / CA

> 🔗 [View on Apify Store](https://apify.com/viralanalyzer/amazon-multi-country) | 🇺🇸 English | [🇧🇷 Português](#português)

Scrape **Amazon products across 7 marketplaces** (US, UK, DE, FR, IT, ES, CA) from a single actor. Country-aware TLD, locale, currency, Accept-Language, and Prime filter ID. Handles US/UK/CA period-decimal prices AND DE/FR/IT/ES comma-decimal prices automatically.

### ✨ Features

- **7 marketplaces in one actor** — `amazon.com`, `co.uk`, `.de`, `.fr`, `.it`, `.es`, `.ca`
- **Country-aware Prime filter** — each marketplace has its own `primeFilterRh` browse node verified against Amazon's category URLs
- **Locale-correct price parsing** — auto-detects whether `.` or `,` is the decimal separator (US `$1,299.90` vs DE `1.299,90 €`)
- **Search OR direct URLs** — pass a keyword OR pass an array of full product URLs matching the chosen country
- **Sort modes** — relevance / price-asc / price-desc / rating / newest
- **Price range filter** — `minPrice` / `maxPrice` in local currency
- **Prime-only toggle** — adds the country-specific `rh=p_n_prime_eligible` filter automatically
- **Optional review extraction** — up to 100 reviews per product, with rating + verified-purchase + helpful-votes
- **CheerioCrawler** — fast HTTP-only, no Playwright overhead — works with default datacenter proxy
- **NEVER 0 ITEMS guard** — actor fails loudly with HTML byte-count and selector trace instead of silently succeeding

### 📥 Input

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `country` | enum | No | `US` | Marketplace: `US` / `UK` / `DE` / `FR` / `IT` / `ES` / `CA` |
| `searchQuery` | string | Yes* | `iphone 15` | Keyword search (required if no `productUrls`) |
| `productUrls` | string[] | Yes* | `[]` | Direct Amazon URLs (alternative to search; must match chosen country TLD) |
| `maxProducts` | integer | No | `10` | Total products to extract (1-500) |
| `sortBy` | enum | No | `relevance` | `relevance` / `price-asc` / `price-desc` / `rating` / `newest` |
| `minPrice` | number | No | `0` | Minimum price filter in local currency |
| `maxPrice` | number | No | `0` | Maximum price filter (0 = no limit) |
| `primeOnly` | boolean | No | `false` | Only return products eligible for Prime delivery |
| `includeReviews` | boolean | No | `false` | Extract customer reviews (slower) |
| `maxReviewsPerProduct` | integer | No | `10` | Reviews per product if `includeReviews=true` (1-100) |
| `proxyConfiguration` | object | No | datacenter | Default is cheap Apify datacenter; switch to `RESIDENTIAL` + `countryCode` if blocked |

*Either `searchQuery` OR `productUrls` is required.

#### Input example (JSON)

```json
{
  "country": "DE",
  "searchQuery": "kaffeevollautomat",
  "maxProducts": 20,
  "sortBy": "rating",
  "minPrice": 200,
  "maxPrice": 800,
  "primeOnly": true
}
````

### 📤 Output

Each record carries country-specific currency and locale. Example DE output:

```json
{
  "asin": "B08FBN5BTC",
  "title": "De'Longhi Magnifica S ECAM 22.110.B Kaffeevollautomat",
  "url": "https://www.amazon.de/dp/B08FBN5BTC",
  "price": 349.0,
  "originalPrice": 449.99,
  "discount": 22,
  "currency": "EUR",
  "rating": 4.5,
  "reviewCount": 31412,
  "mainImage": "https://m.media-amazon.com/images/I/61gn8E2y8FL.jpg",
  "isPrime": true,
  "brand": "De'Longhi",
  "seller": "Amazon",
  "categories": ["Küche, Haushalt & Wohnen", "Kaffee & Espresso"],
  "features": ["13 Mahlgrade", "Cappuccino-System", "..."],
  "bestSellerRank": 7,
  "isSponsored": false,
  "isAvailable": true,
  "scrapedAt": "2026-05-15T14:23:00Z"
}
```

### 💰 Pricing

Pay-per-event (`product-scraped`): you are only charged once per product successfully extracted. CAPTCHA / 0-item runs do **not** charge (NEVER 0 ITEMS guard).

### 🚀 Use cases

- **Multi-market price comparison** — same ASIN/equivalent product in US vs UK vs DE for arbitrage research
- **Currency-aware competitor monitoring** — track regional pricing in EUR/GBP/USD/CAD with correct decimal parsing
- **Affiliate catalog seeding** — bulk-import 500 products per country into a comparison shopping site
- **Prime-eligible inventory scout** — filter to fast-delivery SKUs per region
- **Localized SEO research** — extract `features` + `categories` in DE/FR/IT/ES for non-English keyword mining

### ⚠️ Common errors

| Error | Cause | Fix |
|---|---|---|
| `[FAIL] Zero products extracted` | Aggressive anti-bot in target country (typically DE/UK on hot keywords) | Switch `proxyConfiguration.apifyProxyGroups: ["RESIDENTIAL"]` + matching `countryCode` |
| `Price parsed as 1.299` for `1.299,90 €` | Old version (<1.0) used BR-only parser | Locale parser is automatic from v1.0; upgrade |
| `productUrls did not match country` | URL points to `.com` while `country: "UK"` | URLs must match the chosen marketplace TLD |
| `CAPTCHA page detected` | Datacenter IP fingerprinted | Retry with RESIDENTIAL proxy in the same country |

### 🔒 Privacy

No credentials stored. Apify proxy traffic only — no third-party proxy vendors. Datasets stay inside your Apify account.

### 📚 Related actors

- [Amazon US Intelligence](https://apify.com/viralanalyzer/amazon-us-intelligence) — dedicated US-only with deeper review extraction
- [Amazon Brazil Intelligence](https://apify.com/viralanalyzer/amazon-brazil-intelligence) — Amazon.com.br canonical (BR-only)
- [Mercado Livre Scraper](https://apify.com/viralanalyzer/mercadolivre-scraper) — LATAM equivalent
- [Etsy Product Intelligence](https://apify.com/viralanalyzer/etsy-product-intelligence) — handmade/vintage marketplace (BYOC)

### 🆕 Changelog

- **v1.0** (2026-05-14): Initial release. 7 marketplaces, country-aware Prime filter, locale-correct price parser, CheerioCrawler, NEVER 0 ITEMS guard.

***

### Português

## 🌍 Amazon Multi-País Scraper — US / UK / DE / FR / IT / ES / CA

> 🔗 [Ver na Apify Store](https://apify.com/viralanalyzer/amazon-multi-country)

Scrape **produtos Amazon em 7 marketplaces** (US, UK, DE, FR, IT, ES, CA) com um único actor. TLD, locale, moeda, Accept-Language e ID do filtro Prime corretos por país. Lida tanto com preço decimal por ponto (US/UK/CA) quanto por vírgula (DE/FR/IT/ES) automaticamente.

#### ✨ Recursos

- **7 marketplaces num actor só** — `amazon.com`, `.co.uk`, `.de`, `.fr`, `.it`, `.es`, `.ca`
- **Filtro Prime por país** — cada marketplace tem seu próprio `primeFilterRh` (browse node) validado
- **Parser de preço por locale** — detecta automaticamente se decimal é `.` ou `,`
- **Busca OU URLs diretas** — palavra-chave OU lista de URLs que casem com o país escolhido
- **Ordenação** — relevância / preço asc/desc / rating / mais novos
- **Faixa de preço** — `minPrice` / `maxPrice` em moeda local
- **Apenas Prime** — adiciona o `rh=p_n_prime_eligible` específico da região
- **Reviews opcionais** — até 100 reviews por produto
- **CheerioCrawler** — leve, sem overhead Playwright, funciona com proxy datacenter
- **NUNCA 0 ITENS** — actor falha alto com diagnóstico (tamanho HTML, selectors testados, proxy ativo)

#### 📥 Input

| Parâmetro | Tipo | Obrigatório | Default | Descrição |
|---|---|---|---|---|
| `country` | enum | Não | `US` | Marketplace alvo |
| `searchQuery` | string | Sim\* | `iphone 15` | Termo de busca |
| `productUrls` | string\[] | Sim\* | `[]` | URLs diretas (alternativa à busca) |
| `maxProducts` | integer | Não | `10` | Produtos a extrair (1-500) |
| `sortBy` | enum | Não | `relevance` | Ordenação |
| `minPrice` / `maxPrice` | number | Não | `0` | Faixa de preço em moeda local |
| `primeOnly` | boolean | Não | `false` | Só produtos elegíveis ao Prime |
| `includeReviews` | boolean | Não | `false` | Extrair reviews |
| `maxReviewsPerProduct` | integer | Não | `10` | Reviews por produto |
| `proxyConfiguration` | object | Não | datacenter | Trocar para RESIDENTIAL se bloqueado |

#### 💰 Cobrança

Pay-per-event `product-scraped`: você só paga por produto extraído com sucesso. Runs com CAPTCHA ou 0 itens **não cobram**.

#### 🚀 Casos de uso

- Comparação de preço entre mercados (US vs UK vs DE) para arbitragem
- Monitoramento de concorrência regional em EUR/GBP/USD/CAD
- População de catálogo afiliado multi-país
- Inventário Prime-elegível por região
- SEO multi-idioma a partir de `features` e `categories`

#### ⚠️ Erros comuns

- `[FAIL] Zero products extracted`: anti-bot agressivo — trocar para `RESIDENTIAL` no mesmo `countryCode`
- `CAPTCHA page detected`: IP datacenter sinalizado — retry com residential
- `productUrls did not match country`: as URLs precisam casar o TLD do `country` escolhido

#### 🔒 Privacidade

Sem credenciais armazenadas. Tráfego só via Apify Proxy. Datasets ficam na sua conta Apify.

#### 📚 Actors relacionados

- [Amazon US Intelligence](https://apify.com/viralanalyzer/amazon-us-intelligence)
- [Amazon Brazil Intelligence](https://apify.com/viralanalyzer/amazon-brazil-intelligence)
- [Mercado Livre Scraper](https://apify.com/viralanalyzer/mercadolivre-scraper)
- [Etsy Product Intelligence](https://apify.com/viralanalyzer/etsy-product-intelligence)

#### 🆕 Changelog

- **v1.0** (2026-05-14): release inicial com 7 marketplaces, Prime filter por país, parser locale-aware.

# Actor input Schema

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

Amazon marketplace target. Each country uses its own TLD + locale + currency.

## `searchQuery` (type: `string`):

Product search term (e.g., 'iPhone 15', 'bluetooth headphones', 'laptop')

## `productUrls` (type: `array`):

Direct Amazon product URLs (alternative to search). Use full URLs matching the chosen country.

## `maxProducts` (type: `integer`):

Maximum products to scrape

## `includeReviews` (type: `boolean`):

Scrape customer reviews per product (slower, more data)

## `maxReviewsPerProduct` (type: `integer`):

Maximum reviews per product (if includeReviews=true)

## `sortBy` (type: `string`):

How to sort search results

## `minPrice` (type: `number`):

Filter products above this price (in local currency)

## `maxPrice` (type: `number`):

Filter products below this price (0 = no limit, in local currency)

## `primeOnly` (type: `boolean`):

Only return products with Amazon Prime delivery

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

Proxy settings. Default uses datacenter (cheap). For aggressive anti-bot regions, switch to RESIDENTIAL with matching countryCode.

## Actor input object example

```json
{
  "country": "US",
  "searchQuery": "iphone 15",
  "productUrls": [],
  "maxProducts": 5,
  "includeReviews": false,
  "maxReviewsPerProduct": 10,
  "sortBy": "relevance",
  "minPrice": 0,
  "maxPrice": 0,
  "primeOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped results. Each item follows the dataset schema.

# 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 = {
    "country": "US",
    "searchQuery": "iphone 15",
    "maxProducts": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("viralanalyzer/amazon-multi-country").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 = {
    "country": "US",
    "searchQuery": "iphone 15",
    "maxProducts": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("viralanalyzer/amazon-multi-country").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 '{
  "country": "US",
  "searchQuery": "iphone 15",
  "maxProducts": 5
}' |
apify call viralanalyzer/amazon-multi-country --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Multi-Country Scraper - 7 Marketplaces EN+EU+CA",
        "description": "Scrape Amazon products across 7 marketplaces: US, UK, Germany, France, Italy, Spain, Canada. Country-aware locale, currency (USD/GBP/EUR/CAD), Accept-Language, and Prime filter. Smart proxy routing per region.",
        "version": "1.0",
        "x-build-id": "jL8sUaMX2AwcdOLeh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/viralanalyzer~amazon-multi-country/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-viralanalyzer-amazon-multi-country",
                "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/viralanalyzer~amazon-multi-country/runs": {
            "post": {
                "operationId": "runs-sync-viralanalyzer-amazon-multi-country",
                "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/viralanalyzer~amazon-multi-country/run-sync": {
            "post": {
                "operationId": "run-sync-viralanalyzer-amazon-multi-country",
                "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": {
                    "country": {
                        "title": "Country (Amazon marketplace)",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "CA"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace target. Each country uses its own TLD + locale + currency.",
                        "default": "US"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Product search term (e.g., 'iPhone 15', 'bluetooth headphones', 'laptop')"
                    },
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Direct Amazon product URLs (alternative to search). Use full URLs matching the chosen country.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "Maximum Products",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum products to scrape",
                        "default": 10
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Scrape customer reviews per product (slower, more data)",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews per Product",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum reviews per product (if includeReviews=true)",
                        "default": 10
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "rating",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to sort search results",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "type": "number",
                        "description": "Filter products above this price (in local currency)",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "type": "number",
                        "description": "Filter products below this price (0 = no limit, in local currency)",
                        "default": 0
                    },
                    "primeOnly": {
                        "title": "Prime Only",
                        "type": "boolean",
                        "description": "Only return products with Amazon Prime delivery",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Default uses datacenter (cheap). For aggressive anti-bot regions, switch to RESIDENTIAL with matching countryCode.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
