# Amazon Multi Marketplace Scraper \[Most Advance] (`scrapeio/amazon-multi-marketplace-scraper-most-advanced`) Actor

Scrape Amazon search results across 23 marketplaces (US, UK, India, Germany, Japan, UAE, and more) in one run. Extract ASINs, titles, prices, URLs, images, sponsored flags, and exact search ranking position. Up to 10,000 products per run. Export to CSV or JSON. No Amazon Associates or PA‑API account

- **URL**: https://apify.com/scrapeio/amazon-multi-marketplace-scraper-most-advanced.md
- **Developed by:** [Shop Intel](https://apify.com/scrapeio) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $10.00 / 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.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Amazon Scraper – Extract ASINs, Prices & Search Rankings Across 23 Marketplaces | Apify Actor

**Amazon Scraper** extracts ASINs, titles, prices, product URLs, sponsored flags, and search rankings from [Amazon](https://www.amazon.com) across 23 global marketplaces — up to 10,000 products per run, delivered as CSV or JSON without the official Amazon API.

### 🧠 Overview

This **Amazon Scraper** is an enterprise‑grade Apify Actor for e‑commerce intelligence teams, affiliates, pricing analysts, and agencies that need **structured Amazon search data** across multiple countries in a single run. Search any keyword and the Actor paginates across **Amazon.com, Amazon.in, Amazon.co.uk, Amazon.de, Amazon.co.jp**, and 18 more retail storefronts, returning **ASINs, titles, prices, image URLs, sponsored vs organic flags, and exact search‑ranking positions**. Every run writes to the Apify Dataset plus `RESULTS_CSV` and `RESULTS_JSON`, ready for **Google Sheets, BigQuery, Snowflake, n8n, Make, or Zapier**. Use it as a drop‑in **Amazon Product Advertising API alternative** — no seller account, no throttling, no per‑request fees.

### 🆚 Amazon Scraper vs. Amazon Product Advertising API

| Feature | Official Amazon PA‑API | **This Amazon Scraper** |
|---|---|---|
| **Account required** | Associates account + approval | **None** — just Apify |
| **Rate limits** | Strict per‑day quota | **Unlimited scaling** |
| **Marketplaces** | Single per call | **23 marketplaces** in one Actor |
| **Search ranking position** | Not exposed | **Exact page + position** per ASIN |
| **Sponsored vs organic** | Not distinguished | **`isSponsored` boolean** per row |
| **Setup time** | Days to weeks | **Seconds** |
| **Output** | JSON only | **CSV, JSON, Excel** out of the box |
| **Custom domains** | No | **`baseUrl` override** for any Amazon site |

### ✨ Features

- **Scrape** ASINs, titles, prices, product URLs, image URLs, and sponsored flags from Amazon search results.
- **Support** 23 Amazon marketplaces: US, CA, MX, BR, UK, DE, FR, IT, ES, NL, BE, SE, PL, TR, IE, AE, SA, EG, ZA, IN, JP, AU, SG.
- **Extract** exact **search ranking position** and page number for SEO, category, and share‑of‑shelf reporting.
- **Paginate** automatically up to **10,000 unique ASINs per run** with built‑in retry logic on HTTP errors.
- **Override** the marketplace dropdown with a **custom `baseUrl`** for any Amazon domain your workflow needs.
- **Inject** session **cookie headers** for challenging networks or localized pricing.
- **Export** Dataset + `RESULTS_CSV` + `RESULTS_JSON` + `OUTPUT` run summary in one click.
- **Flag** sponsored ads vs organic listings with a boolean `isSponsored` for PPC vs SEO analysis.
- **Distinguish** marketplaces in output with `marketplace` URL and `marketplaceCode` columns (`US`, `IN`, `UK`, …).
- **Automate** with the Apify scheduler, webhooks, and REST API for daily pricing feeds or ASIN harvesting.
- **Skip** the Amazon Product Advertising API — no Associates account, no API keys, no tight rate limits.

### 🎯 Use Cases

- **Dynamic Pricing & Repricers:** Feed live Amazon prices into your repricing engine to win the Buy Box or set competitive SKUs across multiple countries.
- **Competitor Share of Voice:** Track how often your brand appears on page 1 for high‑value keywords vs competing sellers and sponsored ads.
- **Amazon SEO (AMZ) Research:** Identify high‑ranking ASIN titles, categories, and keywords to optimize your own listings.
- **Affiliate Product Roundups:** Build content sites, Chrome extensions, or comparison tools by harvesting thousands of ASINs from live Amazon searches.
- **Category & Market Expansion:** Scout products across regional Amazon sites (e.g., `Amazon.de` vs `Amazon.co.uk`) to plan international rollout.
- **Lead Generation for Brands:** Find sellers running Sponsored Products ads to target for agency services, tools, or marketing outreach.

### ⚙️ Input Parameters

| Name | Type | Required | Description | Example |
|------|------|----------|-------------|---------|
| `keyword` | string | Yes | Amazon search query (same as typing into `k=` search bar). | `"wireless earbuds"` |
| `maxResults` | integer | Yes | Unique ASINs to collect, 1–10,000 (aliases: `numberOfResults`, `resultsRequired`). | `1000` |
| `marketplace` | string | No | Amazon country code. Ignored if `baseUrl` is set. | `"US"` |
| `baseUrl` | string | No | Custom Amazon domain override. | `"https://www.amazon.co.uk"` |
| `city` | string | No | Label stored in output for reporting; does not affect the scrape. | `"New York"` |
| `callQueryApi` | boolean | No | Use Amazon's `/s/query` XHR (enabled by default for `amazon.in`). | `false` |
| `cookieHeader` | string | No | Raw `Cookie` header for sessions that face challenges. | `"session-id=123-456-789; ..."` |

### 📤 Output Example (JSON)

```json
{
  "position": 1,
  "page": 1,
  "asin": "B0FC64RYH1",
  "title": "BrowseBook 14.1\" FHD IPS Laptop | Student & Office Work",
  "price": "$539.99",
  "productUrl": "https://www.amazon.com/dp/B0FC64RYH1",
  "imageUrl": "https://m.media-amazon.com/images/I/71h7L8gcrL.jpg",
  "isSponsored": false,
  "searchKeyword": "laptops",
  "marketplace": "https://www.amazon.com",
  "marketplaceCode": "US"
}
````

### 📋 Output Data Schema

Every product row includes these fields:

| Field | Type | Description |
|---|---|---|
| `position` | integer | Exact rank in Amazon search results (1‑based). |
| `page` | integer | Search page number the product appeared on. |
| `asin` | string | Amazon Standard Identification Number (unique product ID). |
| `title` | string | Full product title as shown in search. |
| `price` | string | Listed price with local currency symbol (e.g. `$`, `₹`, `£`). |
| `productUrl` | string | Direct, clean URL to the product detail page. |
| `imageUrl` | string | High‑resolution product image URL. |
| `isSponsored` | boolean | `true` for Sponsored Products ads; `false` for organic. |
| `searchKeyword` | string | The keyword that produced this row. |
| `marketplace` | string | Retail storefront URL (e.g. `https://www.amazon.com`). |
| `marketplaceCode` | string | Country code (`US`, `UK`, `IN`, `DE`, …). |

### ▶️ How to Use

1. **Run on Apify Console:** Open the [Amazon Multi‑Marketplace Scraper](https://apify.com/scrapeio/amazon-multi-marketplace-scraper-most-advanced), click **Try for free**, enter a keyword, pick a marketplace, set `maxResults`, and press **Start**. Export the Dataset as CSV or JSON.
2. **Via API:** Trigger the Actor with the [Apify REST API](https://docs.apify.com/api/v2) or `ApifyClient` and fetch the Dataset programmatically.
3. **Via CLI:** Run locally with the [Apify CLI](https://docs.apify.com/cli):
   ```bash
   apify call scrapeio/amazon-multi-marketplace-scraper-most-advanced \
     --input='{"keyword":"running shoes","marketplace":"UK","maxResults":500}'
   ```

### 🔗 API Example (JavaScript)

```js
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('scrapeio/amazon-multi-marketplace-scraper-most-advanced').call({
  keyword: 'mechanical keyboard',
  marketplace: 'US',
  maxResults: 250,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Collected ${items.length} ASINs from Amazon US`);
console.log(items[0]);
```

### 📈 Why Use This Amazon Product Scraper?

- **Speed & Automation:** Pull thousands of ASINs in a single run with automatic pagination and retries — no manual clicking, no brittle DIY scrapers.
- **23 Marketplaces, One Actor:** Switch from `Amazon.com` to `Amazon.de` to `Amazon.co.jp` with one dropdown — or override with any custom `baseUrl`.
- **Search‑Ranking Fidelity:** `position` and `page` fields preserve exact Amazon organic + sponsored order, which the official PA‑API does not expose.
- **Official API Alternative:** No Associates account, no throttled PA‑API quotas, no OAuth — just keyword + marketplace + results.
- **Bulk Export Bundle:** Dataset + `RESULTS_CSV` + `RESULTS_JSON` + `OUTPUT` summary are all produced per run — feed Google Sheets, BigQuery, Snowflake, or n8n in minutes.
- **Enterprise Reliability:** Retries on transient `503`/`429`, cookie‑header support, and `meta.stoppedReason` diagnostics for robust pipelines.

### ❓ FAQ

**Q: Is it legal to scrape Amazon?**
Amazon search results are publicly visible, and web scraping for lawful research and analytics is widely practiced. You are responsible for complying with [Amazon's Conditions of Use](https://www.amazon.com/gp/help/customer/display.html?nodeId=508088) and local data laws.

**Q: Is this the official Amazon Product Advertising API?**
No. This Actor is an **Amazon API alternative** that automates the public Amazon search pages. No Associates account or PA‑API keys are required.

**Q: Can I get more than 1,000 products?**
Yes. Set `maxResults` up to **10,000**. The Actor paginates automatically until the target is reached or listings end.

**Q: How do I target Amazon UK, Germany, or Japan?**
Pick the marketplace code (`UK`, `DE`, `JP`, …) in the dropdown — or set `baseUrl` to any Amazon domain for custom routing.

**Q: Does it support proxies?**
Yes. Use Apify Proxy (residential or datacenter) in the run configuration for large or high‑frequency jobs.

**Q: How do I handle CAPTCHAs or 503 errors?**
The Actor retries transient HTTP errors automatically and returns partial results with reasons in `meta.stoppedReason`. For stubborn regions, provide a `cookieHeader` or switch to residential proxies.

**Q: What output formats are supported?**
Dataset exports to CSV, JSON, Excel, XML, and HTML. A complete `RESULTS_CSV` and `RESULTS_JSON` are also written to the key‑value store.

**Q: Can I distinguish sponsored vs organic listings?**
Yes — every row includes `isSponsored` (boolean). Combined with `position`, this gives a precise PPC‑vs‑SEO view per page.

### 📣 Start Scraping Amazon in Seconds

**[Run the Amazon Scraper on Apify now →](https://apify.com/scrapeio/amazon-multi-marketplace-scraper-most-advanced)** and turn any keyword into structured ASIN, price, and ranking data across 23 marketplaces.

***

***

### 🔗 Related Scrapers by ScrapeIO

Combine with these Apify Actors to build full e‑commerce and market‑intelligence pipelines:

- **[Google Maps Scraper](https://apify.com/scrapeio/google-maps-scraper-advance)** — local businesses, reviews, and contacts.
- **[Google News Scraper](https://apify.com/scrapeio/google-news-scraper)** — headlines, sources, and publisher links by keyword.
- **[Facebook Ad Library Scraper](https://apify.com/scrapeio/meta-facebook-ad-scrapper-using-ad-library-url-premium)** — Meta ads by keyword, Page ID, or URL.
- **[Instagram Ads Scraper](https://apify.com/scrapeio/instagram-scraper-premium)** — Instagram‑only ads with creative and copy.
- **[WhatsApp Ads Scraper](https://apify.com/scrapeio/whatsapp-scraper-premium)** — Click‑to‑WhatsApp ad intelligence.
- **[Facebook Ad Library Brand Finder](https://apify.com/scrapeio/facebook-ad-library-suggestions)** — resolve brand names to verified Page IDs.
- **[YouTube Video Downloader](https://apify.com/scrapeio/youtube-downloader)** — download videos or audio to cloud storage.

***

*This README describes the **Amazon Multi‑Marketplace Search Scraper** for **Apify**. Use in compliance with Amazon's terms of service and applicable laws. This tool is not affiliated with or endorsed by Amazon.*

# Actor input Schema

## `keyword` (type: `string`):

Search query (Amazon k= parameter).

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

How many unique products to collect (1–10000). Pagination is automatic.

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

Retail storefront to search. Ignored if you set baseUrl below.

## `baseUrl` (type: `string`):

Optional. Overrides marketplace dropdown, e.g. https://www.amazon.com or a regional Amazon domain.

## `city` (type: `string`):

Stored in output for your records only; does not change search geography (marketplace does).

## `callQueryApi` (type: `boolean`):

Browser-style XHR. If omitted: enabled only for amazon.in; set false to skip, true to attempt on any marketplace.

## `wIndexMainSlot` (type: `integer`):

Body field for /s/query when enabled.

## `queryExtraParams` (type: `string`):

Optional DevTools string (after k, page, dc, qid, ds).

## `cookieHeader` (type: `string`):

Optional Cookie header for difficult sessions.

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

Use Apify Proxy (ideally RESIDENTIAL) when Amazon returns HTTP 503 or empty pages from datacenter IPs. Set useApifyProxy to true and pick groups/country in the editor.

## Actor input object example

```json
{
  "maxResults": 25,
  "marketplace": "IN",
  "wIndexMainSlot": 75,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeio/amazon-multi-marketplace-scraper-most-advanced").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapeio/amazon-multi-marketplace-scraper-most-advanced").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 '{}' |
apify call scrapeio/amazon-multi-marketplace-scraper-most-advanced --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Multi Marketplace Scraper [Most Advance]",
        "description": "Scrape Amazon search results across 23 marketplaces (US, UK, India, Germany, Japan, UAE, and more) in one run. Extract ASINs, titles, prices, URLs, images, sponsored flags, and exact search ranking position. Up to 10,000 products per run. Export to CSV or JSON. No Amazon Associates or PA‑API account",
        "version": "1.7",
        "x-build-id": "HyrhZFMWM0w0uj2WQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeio~amazon-multi-marketplace-scraper-most-advanced/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeio-amazon-multi-marketplace-scraper-most-advanced",
                "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/scrapeio~amazon-multi-marketplace-scraper-most-advanced/runs": {
            "post": {
                "operationId": "runs-sync-scrapeio-amazon-multi-marketplace-scraper-most-advanced",
                "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/scrapeio~amazon-multi-marketplace-scraper-most-advanced/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeio-amazon-multi-marketplace-scraper-most-advanced",
                "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": [
                    "keyword",
                    "maxResults"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Search query (Amazon k= parameter)."
                    },
                    "maxResults": {
                        "title": "Number of results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many unique products to collect (1–10000). Pagination is automatic.",
                        "default": 25
                    },
                    "marketplace": {
                        "title": "Amazon marketplace (country / region)",
                        "enum": [
                            "US",
                            "CA",
                            "MX",
                            "BR",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "BE",
                            "SE",
                            "PL",
                            "TR",
                            "AE",
                            "SA",
                            "EG",
                            "IN",
                            "JP",
                            "AU",
                            "SG",
                            "IE",
                            "ZA"
                        ],
                        "type": "string",
                        "description": "Retail storefront to search. Ignored if you set baseUrl below.",
                        "default": "IN"
                    },
                    "baseUrl": {
                        "title": "Custom Amazon base URL (advanced)",
                        "type": "string",
                        "description": "Optional. Overrides marketplace dropdown, e.g. https://www.amazon.com or a regional Amazon domain."
                    },
                    "city": {
                        "title": "Location note (optional)",
                        "type": "string",
                        "description": "Stored in output for your records only; does not change search geography (marketplace does)."
                    },
                    "callQueryApi": {
                        "title": "POST /s/query (page 1)",
                        "type": "boolean",
                        "description": "Browser-style XHR. If omitted: enabled only for amazon.in; set false to skip, true to attempt on any marketplace."
                    },
                    "wIndexMainSlot": {
                        "title": "wIndexMainSlot",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Body field for /s/query when enabled.",
                        "default": 75
                    },
                    "queryExtraParams": {
                        "title": "Extra /s/query URL params",
                        "type": "string",
                        "description": "Optional DevTools string (after k, page, dc, qid, ds)."
                    },
                    "cookieHeader": {
                        "title": "Cookie header (optional)",
                        "type": "string",
                        "description": "Optional Cookie header for difficult sessions."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy (ideally RESIDENTIAL) when Amazon returns HTTP 503 or empty pages from datacenter IPs. Set useApifyProxy to true and pick groups/country in the editor.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
