# Amazon Seller Contact Scraper — Emails, Phone, VAT & Ratings (`memo23/amazon-sellers-scraper`) Actor

Turn any Amazon search, best-seller list or product URL into a lead list of the third-party sellers behind the products — with legal business name, address, VAT number, phone and email (EU impressum), ratings and storefront. 18 marketplaces, pure HTTP. Opt-in email enrichment. JSON/CSV

- **URL**: https://apify.com/memo23/amazon-sellers-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, E-commerce, AI
- **Stats:** 4 total users, 2 monthly users, 82.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 seller scrapeds

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 Seller Contact Scraper — Emails, Phone, VAT & Ratings

Turn any Amazon keyword, best-seller list, category or product URL into a clean list of the **third-party sellers** behind those products — with the contact and business data Amazon publishes on each seller's profile page. Built for B2B lead generation, supplier discovery and competitor research across **18 Amazon marketplaces**. Pure HTTP, no browser.

![How the Amazon Seller Contact Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-amazon-sellers.png)

### Why use this scraper?

Most Amazon scrapers give you *products*. This one gives you the **companies** selling them — the people you actually want to reach.

- **Real contact data, not just a name.** On EU marketplaces Amazon is legally required to publish each business seller's impressum: **email, phone, VAT number, trade-register number and full address**. This actor extracts all of it. US (.com) profiles carry business name + address under the INFORM Consumers Act.
- **Discovery, not one-URL-at-a-time.** Feed it a keyword, a best-seller list or a category and it walks the products, identifies every seller behind them (buy-box **and** other offers), deduplicates, and returns one clean row per seller. Competing seller scrapers make you paste one seller URL at a time or hand you a stale pre-scraped database.
- **18 marketplaces.** com, co.uk, de, fr, it, es, ca, com.au, co.jp, in, nl, se, pl, com.be, ae, com.mx, com.tr, sg.
- **Optional email enrichment.** For sellers whose Amazon page shows no email (common on .com), the actor can resolve the seller's business name to a company website and scan it for a contact address.
- **Fast & cheap.** Pure HTTP over residential proxies — no headless browser, so runs are quick and light.

### What it does

Given search queries, marketplaces and/or direct URLs, the actor:

1. **Finds products** — runs each keyword search (or reads your best-seller / category / product URL) and collects ASINs.
2. **Identifies the sellers** — opens each product and extracts the buy-box seller plus every other offer merchant. Amazon's own retail accounts are filtered out.
3. **Scrapes each seller profile** — pulls the full "Detailed Seller Information" / Impressum box, the 12-month feedback summary, storefront link and about text.
4. **Deduplicates & (optionally) enriches** — one row per unique seller per marketplace; opt-in website/email discovery for sellers with no published email.

### Supported inputs

| Input | Example | What it does |
|---|---|---|
| **Search query** | `phone case` | Searches each selected marketplace, scrapes the sellers behind the results |
| **Marketplaces** | `["com", "de", "co.uk"]` | Which marketplaces the search queries run on |
| **Seller URL** | `https://www.amazon.de/sp?seller=A3LPZDJX7TOX01` | Scrapes that one seller profile |
| **Product URL** | `https://www.amazon.com/dp/B0FDQK69GQ` | Scrapes the seller(s) offering that product |
| **Search URL** | `https://www.amazon.com/s?k=yoga+mat` | Paginates the results, scrapes their sellers |
| **Best-sellers URL** | `https://www.amazon.com/gp/bestsellers/kitchen/` | Scrapes the sellers behind the top-100 |
| **Category URL** | `https://www.amazon.de/b?node=340852031` | Scrapes the sellers in that category |

Start URLs use whichever marketplace domain they carry, so you can mix countries in one run.

### Use cases

- **B2B lead generation** — build targeted lists of Amazon sellers (with email/phone) by product niche or category.
- **Supplier & sourcing research** — find manufacturers and distributors selling in a category, with their legal business identity.
- **Competitor & market intelligence** — map who sells what, their ratings, feedback volume and country of operation.
- **Brand protection** — enumerate every third-party seller offering a given ASIN (buy-box and beyond).
- **CRM / sales enrichment** — resolve seller storefronts to real company names, VAT numbers and websites.

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array | — | Keywords to search; each runs on every selected marketplace |
| `marketplaces` | array | `["com"]` | Marketplace TLDs for the search queries |
| `startUrls` | array | — | Direct seller / product / search / best-seller / category URLs |
| `maxItems` | integer | — | Hard ceiling of sellers across the whole run |
| `maxItemsPerQuery` | integer | `100` | Max sellers per query / start URL |
| `maxProductsPerQuery` | integer | `100` | Products inspected per query while discovering sellers |
| `enrichEmails` | boolean | `false` | Opt-in website/email discovery for sellers with no on-page email |
| `concurrency` | integer | `10` | Parallel page fetches (1–30) |

#### Example input

```json
{
  "searchQueries": ["phone case", "wireless charger"],
  "marketplaces": ["de", "co.uk"],
  "maxItems": 200,
  "maxProductsPerQuery": 60,
  "enrichEmails": true
}
````

### Output

One row per unique seller. Example (amazon.de business seller):

```json
{
  "sellerId": "A18EE9GVRFMIY1",
  "marketplace": "amazon.de",
  "sellerUrl": "https://www.amazon.de/sp?seller=A18EE9GVRFMIY1",
  "sellerName": "DWD-Company GmbH & Co. KG",
  "storefrontUrl": "https://www.amazon.de/s?me=A18EE9GVRFMIY1&marketplaceID=A1PA6795UKMFR9",
  "isBusinessSeller": true,
  "businessName": "DWD-Company GmbH & Co. KG",
  "businessType": "Unternehmen in Privatbesitz",
  "registrationNumber": "HRA33845",
  "vatNumber": "DE321852937",
  "phoneNumber": "+4922134809900",
  "email": "danieldresbach@dwd-company.de",
  "businessAddress": "Am Eifeltor, 20, Köln, 50997, DE",
  "addressCountryCode": "DE",
  "ratingStars": 3.5,
  "ratingPositivePercent12m": 68,
  "ratingCount12m": 1981,
  "aboutSeller": "DWD-Company GmbH & Co. KG …",
  "sourceAsins": ["B0FDQK69GQ"],
  "scrapedAt": "2026-07-07T20:31:00.000Z"
}
```

#### Key output fields

| Field | Description |
|---|---|
| `sellerId` / `marketplace` | Amazon seller id and which marketplace it was scraped from |
| `sellerName` | Display/storefront name |
| `businessName` | Legal business name (impressum / INFORM) |
| `businessType` | e.g. "privately owned business" (localised) |
| `registrationNumber` | Trade-register / company registration number (EU) |
| `vatNumber` | VAT / USt-ID (EU) |
| `phoneNumber` | Published business phone |
| `email` | Published business email (EU impressum) |
| `businessAddress` / `addressCountryCode` | Full address + ISO country |
| `customerServiceAddress` | Separate customer-service address, when published |
| `ratingStars` / `ratingPositivePercent12m` / `ratingCount12m` | 12-month feedback summary |
| `aboutSeller` | Seller's "about" / impressum blurb |
| `storefrontUrl` | Link to the seller's storefront |
| `isBusinessSeller` | Whether Amazon flags it as a business seller |
| `sourceAsins` | The product(s) this seller was discovered through |
| `contactEmail` / `contactWebsite` / `emailEnrichment` | Filled when `enrichEmails` is on |

### How it works

The actor fetches Amazon pages over rotating residential proxies with a real browser TLS fingerprint (pure HTTP — no headless browser). Listing pages yield ASINs; product pages reveal the seller ids of every offer; seller-profile pages (`/sp?seller=…`) carry the "Detailed Seller Information" box that this actor parses field-by-field. Amazon's own retail seller ids are filtered out so you only get third-party leads.

### FAQ

**Which marketplaces give email and phone?**
The EU marketplaces (de, fr, it, es, nl, se, pl, com.be) require sellers to publish a full impressum, so email, phone, VAT and registration number are usually present. .com, .co.uk, .ca etc. reliably give business name and address; email/phone appear less often — turn on `enrichEmails` to fill the gap from the seller's own website.

**Are emails already on Amazon charged as enrichment?**
No. Emails Amazon publishes on the seller page are included for free. The optional enrichment event is charged only when the actor discovers an email off-Amazon for a seller who had none.

**Can I get every seller for one product?**
Yes — pass the product URL (`/dp/ASIN`) and the actor returns the buy-box seller plus the other offer merchants it can see on the page.

**Why are some sellers based in CN/HK with a DE VAT?**
Many Amazon EU sellers are overseas companies that hold an EU VAT registration to sell into the marketplace — the actor reports exactly what Amazon publishes.

### Support

Found a bug or need a field added? Open an issue on the actor's Issues tab and we'll take a look.

### Additional services

Turn on **email enrichment** to resolve sellers with no published email to a company website and contact address — ideal for outbound sales lists.

### Explore more scrapers

Check the [memo23 store profile](https://apify.com/memo23) for more e-commerce, directory and lead-generation scrapers.

### ⚠️ Disclaimer

This actor scrapes only **publicly available** information that Amazon displays on seller profile and product pages — the same data any visitor can see, including the business identity details sellers are legally required to publish. It does not log in, bypass access controls, or collect private personal data. Use the output in compliance with Amazon's Terms of Service, the GDPR/applicable data-protection law, and any marketing/anti-spam regulations that apply to how you contact the businesses you find. You are responsible for how you use the scraped data.

### SEO Keywords

Amazon seller scraper, Amazon seller email scraper, Amazon seller contact scraper, Amazon seller leads, Amazon seller data extractor, Amazon third-party seller finder, Amazon seller VAT number, Amazon impressum scraper, Amazon seller phone number, Amazon FBA seller list, Amazon marketplace seller database, Amazon lead generation, Amazon supplier scraper, Amazon seller ratings scraper, Amazon storefront scraper.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on Amazon. Each keyword runs its own paginated crawl on every selected marketplace; the sellers behind the returned products are then scraped. Example: "phone case", "yoga mat", "dog toys".

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

Which Amazon marketplaces the search queries run on. EU marketplaces (DE, FR, IT, ES…) return the richest contact data — the legally required impressum includes email, phone, VAT and trade-register number. US (.com) returns business name + address (INFORM Act). Start URLs ignore this and use the domain in the URL.

## `startUrls` (type: `array`):

Direct Amazon URLs, mixed freely: seller profiles (amazon.com/sp?seller=…), product pages (/dp/ASIN), search results (/s?k=…), best-seller lists (/gp/bestsellers/…) or category pages (/b?node=…). Any supported marketplace — the domain in the URL wins. Runs in addition to search queries.

## `maxItems` (type: `integer`):

Hard ceiling of seller profiles to scrape across the whole run. Also capped by your plan and charge limit.

## `maxItemsPerQuery` (type: `integer`):

Upper bound of sellers to emit per search query or per start URL.

## `maxProductsPerQuery` (type: `integer`):

How many products each search query / listing URL inspects while discovering sellers (one fetch per product; each product yields its buy-box seller plus other offer merchants). More products = more and deeper-tail sellers. ~48 products per search page.

## `enrichEmails` (type: `boolean`):

For sellers whose Amazon page shows no email (typical on amazon.com), resolve the seller's legal business name to a company website and scan it for contact emails. Best-effort; adds latency. Emails already published on Amazon are always included for free.

## `concurrency` (type: `integer`):

How many pages to fetch in parallel. Automatically clamped to what the run's memory can safely hold (Amazon product pages are large ~2.8MB each), so higher values are capped rather than risking an out-of-memory failure — raise the run's memory to go faster. Default 8.

## Actor input object example

```json
{
  "searchQueries": [
    "phone case"
  ],
  "marketplaces": [
    "com"
  ],
  "startUrls": [],
  "maxItems": 50,
  "maxItemsPerQuery": 25,
  "maxProductsPerQuery": 40,
  "enrichEmails": false,
  "concurrency": 8
}
```

# 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 = {
    "searchQueries": [
        "phone case"
    ],
    "marketplaces": [
        "com"
    ],
    "startUrls": [],
    "maxItems": 50,
    "maxItemsPerQuery": 25,
    "maxProductsPerQuery": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/amazon-sellers-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 = {
    "searchQueries": ["phone case"],
    "marketplaces": ["com"],
    "startUrls": [],
    "maxItems": 50,
    "maxItemsPerQuery": 25,
    "maxProductsPerQuery": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/amazon-sellers-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 '{
  "searchQueries": [
    "phone case"
  ],
  "marketplaces": [
    "com"
  ],
  "startUrls": [],
  "maxItems": 50,
  "maxItemsPerQuery": 25,
  "maxProductsPerQuery": 40
}' |
apify call memo23/amazon-sellers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Seller Contact Scraper — Emails, Phone, VAT & Ratings",
        "description": "Turn any Amazon search, best-seller list or product URL into a lead list of the third-party sellers behind the products — with legal business name, address, VAT number, phone and email (EU impressum), ratings and storefront. 18 marketplaces, pure HTTP. Opt-in email enrichment. JSON/CSV",
        "version": "0.0",
        "x-build-id": "I6wAWWdAxmcwriXHS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~amazon-sellers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-amazon-sellers-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/memo23~amazon-sellers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-amazon-sellers-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/memo23~amazon-sellers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-amazon-sellers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "🔍 Search queries",
                        "type": "array",
                        "description": "Keywords to search on Amazon. Each keyword runs its own paginated crawl on every selected marketplace; the sellers behind the returned products are then scraped. Example: \"phone case\", \"yoga mat\", \"dog toys\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplaces": {
                        "title": "🌍 Marketplaces",
                        "type": "array",
                        "description": "Which Amazon marketplaces the search queries run on. EU marketplaces (DE, FR, IT, ES…) return the richest contact data — the legally required impressum includes email, phone, VAT and trade-register number. US (.com) returns business name + address (INFORM Act). Start URLs ignore this and use the domain in the URL.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "com",
                                "co.uk",
                                "de",
                                "fr",
                                "it",
                                "es",
                                "ca",
                                "com.au",
                                "co.jp",
                                "in",
                                "nl",
                                "se",
                                "pl",
                                "com.be",
                                "ae",
                                "com.mx",
                                "com.tr",
                                "sg"
                            ],
                            "enumTitles": [
                                "amazon.com (US)",
                                "amazon.co.uk (UK)",
                                "amazon.de (Germany)",
                                "amazon.fr (France)",
                                "amazon.it (Italy)",
                                "amazon.es (Spain)",
                                "amazon.ca (Canada)",
                                "amazon.com.au (Australia)",
                                "amazon.co.jp (Japan)",
                                "amazon.in (India)",
                                "amazon.nl (Netherlands)",
                                "amazon.se (Sweden)",
                                "amazon.pl (Poland)",
                                "amazon.com.be (Belgium)",
                                "amazon.ae (UAE)",
                                "amazon.com.mx (Mexico)",
                                "amazon.com.tr (Turkey)",
                                "amazon.sg (Singapore)"
                            ]
                        },
                        "default": [
                            "com"
                        ]
                    },
                    "startUrls": {
                        "title": "📎 Start URLs (optional)",
                        "type": "array",
                        "description": "Direct Amazon URLs, mixed freely: seller profiles (amazon.com/sp?seller=…), product pages (/dp/ASIN), search results (/s?k=…), best-seller lists (/gp/bestsellers/…) or category pages (/b?node=…). Any supported marketplace — the domain in the URL wins. Runs in addition to search queries.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max sellers (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard ceiling of seller profiles to scrape across the whole run. Also capped by your plan and charge limit."
                    },
                    "maxItemsPerQuery": {
                        "title": "Max sellers per query / URL",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper bound of sellers to emit per search query or per start URL.",
                        "default": 100
                    },
                    "maxProductsPerQuery": {
                        "title": "Products to inspect per query / URL",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many products each search query / listing URL inspects while discovering sellers (one fetch per product; each product yields its buy-box seller plus other offer merchants). More products = more and deeper-tail sellers. ~48 products per search page.",
                        "default": 100
                    },
                    "enrichEmails": {
                        "title": "💌 Enrich missing emails (opt-in)",
                        "type": "boolean",
                        "description": "For sellers whose Amazon page shows no email (typical on amazon.com), resolve the seller's legal business name to a company website and scan it for contact emails. Best-effort; adds latency. Emails already published on Amazon are always included for free.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many pages to fetch in parallel. Automatically clamped to what the run's memory can safely hold (Amazon product pages are large ~2.8MB each), so higher values are capped rather than risking an out-of-memory failure — raise the run's memory to go faster. Default 8.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
