# Amazon Seller Scraper (`khadinakbar/amazon-seller-scraper`) Actor

Scrape Amazon sellers — business name, legal address, feedback ratings, rating distribution, and storefront products — from seller IDs, storefront/profile URLs, or product ASINs across 18 marketplaces. Flat JSON for AI agents and MCP.

- **URL**: https://apify.com/khadinakbar/amazon-seller-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 seller scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Amazon Seller Scraper

Scrape **Amazon seller profiles** — the legal business name and address, feedback ratings, rating distribution, "About" text, recent buyer comments, and (optionally) the seller's full storefront product list. Works from **seller IDs**, **seller / storefront / product URLs**, or **product ASINs** (the actor reads the "Sold by" seller from the buy box) across **18 Amazon marketplaces**. Output is flat JSON built for AI agents and MCP.

### What you get

| Field | Description |
|-------|-------------|
| `sellerId` | Amazon seller (merchant) ID, e.g. `A1ODG4ICFE5MU3` |
| `sellerName` | Public seller display name |
| `businessName` | **Legal business name** from "Detailed Seller Information" |
| `businessAddress` | **Full business address** (comma-joined) |
| `addressLines` | Address as individual lines |
| `businessCountryCode` | Two-letter business country |
| `hasBusinessDetails` | Whether business name/address were published |
| `starRating` | Seller star rating (0–5) |
| `positivePercent12mo` | % positive feedback over last 12 months |
| `ratingsCount12mo` | Number of ratings in last 12 months |
| `ratingDistribution` | % of ratings at each star level (5★→1★) |
| `aboutText` | Seller "About" description |
| `recentFeedback` | Recent buyer comments (rating, comment, author, date) |
| `storefrontUrl` | Link to the seller's storefront |
| `products` | Storefront products (when enabled) |
| `productCount` | Number of storefront products listed |
| `marketplace`, `sellerUrl`, `sourceType`, `scrapedAt` | Provenance + timestamp |

### When to use it

- **Brand protection / MAP enforcement** — identify the legal entity (name + address) behind an unauthorized reseller.
- **Competitor & supplier research** — vet third-party sellers, their feedback trend, and catalog breadth.
- **Lead generation** — turn a list of seller IDs or product ASINs into enriched business records.
- **Due diligence** — confirm a seller's reputation, business registration country, and rating history.

**Not** for product detail scraping (use **Amazon Product Scraper**) or review scraping (use **Amazon Reviews Scraper**).

### Pricing (pay-per-event)

| Event | Price |
|-------|-------|
| Actor start | $0.00005 |
| **Seller scraped** | **$0.02** per seller profile |
| Storefront product listed | $0.003 each (only when `includeStorefrontProducts` is on) |

A run of 100 seller profiles costs about **$2.00**. Adding 50 storefront products per seller adds ~$0.15/seller. The actor prints the upfront cost cap and the final billed estimate in its log and status.

### Input

Provide at least one of:

- **`sellerIds`** — Amazon seller IDs (13–14 uppercase chars).
- **`startUrls`** — seller profile (`/sp?seller=ID`), storefront (`/s?me=ID`), or product (`/dp/ASIN`) URLs.
- **`asins`** — product ASINs; the actor opens each product and resolves its third-party seller(s).

Options: `country` (marketplace, default US), `includeFeedback` (default true), `maxFeedback` (default 20), `includeStorefrontProducts` (default false), `maxStorefrontProducts` (default 100), `maxStorefrontPages` (default 3), `proxyConfiguration`.

#### Example input

```json
{
  "sellerIds": ["A1ODG4ICFE5MU3"],
  "country": "US",
  "includeFeedback": true,
  "includeStorefrontProducts": false
}
````

Resolve sellers from products instead:

```json
{
  "asins": ["B007ADJ4JI", "B00HHLNRVE"],
  "country": "US"
}
```

#### Example output (one record)

```json
{
  "sellerId": "A1ODG4ICFE5MU3",
  "sellerName": "Dreamfarm",
  "businessName": "Dreamfarm Inc",
  "businessAddress": "165 S River Road, BEDFORD, NH, 03110, US",
  "businessCountryCode": "US",
  "starRating": 4.5,
  "positivePercent12mo": 92,
  "ratingsCount12mo": 225,
  "ratingDistribution": { "fiveStar": 91, "fourStar": 5, "threeStar": 1, "twoStar": 1, "oneStar": 2 },
  "storefrontUrl": "https://www.amazon.com/s?me=A1ODG4ICFE5MU3",
  "recentFeedback": [
    { "rating": 5, "comment": "Great product, fast shipping.", "author": "Gma", "date": "June 11, 2026" }
  ],
  "sourceType": "sellerId",
  "marketplace": "US",
  "scrapedAt": "2026-06-19T12:00:00.000Z"
}
```

### Supported marketplaces

US, UK, DE, FR, CA, ES, IT, JP, AU, IN, MX, BR, NL, SE, PL, TR, AE, SG.

### Use from code

#### Apify JavaScript client

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/amazon-seller-scraper').call({
    sellerIds: ['A1ODG4ICFE5MU3'],
    country: 'US',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/amazon-seller-scraper").call(
    run_input={"asins": ["B007ADJ4JI"], "country": "US"}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["businessName"], item["businessAddress"])
```

### Use with AI agents (MCP)

This actor is MCP-ready. Add it to an MCP client via `https://mcp.apify.com` and call it with a seller ID, URL, or ASIN. It returns one flat record per seller — ideal for agents enriching a list of sellers or resolving "who sells this product."

### Proxies & reliability

The actor defaults to **automatic Apify proxy**. Amazon blocks datacenter IPs aggressively on heavy use — for large or repeated runs, switch the proxy to **RESIDENTIAL** in the input. Seller profile (`/sp`) pages tolerate datacenter IPs better than search/product pages, so small seller-only jobs usually run fine on the default. Storefront-product listing relies on Amazon search and benefits most from residential proxies.

### FAQ

**Where do I find a seller ID?** On any product page, click the "Sold by" seller name. The URL contains `seller=` (the ID), e.g. `/sp?seller=A1ODG4ICFE5MU3`.

**Why is `businessName` sometimes null?** Some sellers (especially 1P "Amazon.com" and certain individual sellers) do not publish a business name/address. `hasBusinessDetails` tells you whether any were found.

**Can I get every storefront product?** Set `includeStorefrontProducts: true` and raise `maxStorefrontProducts` / `maxStorefrontPages`. Amazon paginates storefronts at ~48 products per page.

**Does it scrape product details or reviews?** No — use **Amazon Product Scraper** and **Amazon Reviews Scraper** for those. This actor focuses on the seller entity.

### Legal

This actor scrapes only publicly available data from Amazon seller profile pages. It does not access private data or bypass authentication. You are responsible for using the output in compliance with Amazon's Terms of Service, applicable laws (including data-protection regulations such as GDPR/CCPA), and the rights of the data subjects. Do not use this actor for unlawful purposes. This tool is provided for legitimate research, compliance, and business-intelligence use cases.

# Actor input Schema

## `sellerIds` (type: `array`):

Amazon seller (merchant) IDs, 13–14 uppercase chars, e.g. \['A1ODG4ICFE5MU3','AN9M05X8SIK1X']. Each is resolved on the selected marketplace's /sp?seller= profile page. NOT an ASIN (10 chars) — for products use 'asins'. NOT a URL — for URLs use 'startUrls'.

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

Amazon URLs to scrape: seller profile ('/sp?seller=ID'), storefront ('/s?me=ID'), or product ('/dp/ASIN') pages. Product URLs are resolved to the seller(s) in their buy box. The domain in each URL overrides the 'country' setting. Use when you already have exact URLs.

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

Product ASINs (10 chars, e.g. \['B007ADJ4JI']) whose third-party seller(s) you want to find. The actor opens each product, reads the 'Sold by' seller(s), then scrapes their profile. NOT a seller ID (13–14 chars) — for sellers use 'sellerIds'.

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

Which Amazon marketplace to use for sellerIds and asins. Ignored when a startUrl already contains a specific Amazon domain. Defaults to US (amazon.com).

## `includeFeedback` (type: `boolean`):

When true, the seller record includes a 'recentFeedback' array of the most recent buyer comments rendered on the profile (rating, comment, author, date). Turn off for a leaner record focused on business details and rating summaries.

## `maxFeedback` (type: `integer`):

Maximum recent feedback comments to capture per seller (only the comments rendered on the profile page; Amazon shows ~5–10 without pagination). Ignored when 'includeFeedback' is off.

## `includeStorefrontProducts` (type: `boolean`):

When true, the actor also opens the seller's storefront ('/s?me=ID') and lists their products into a 'products' array on the seller record. Each product is billed at $0.003. Adds time and cost — leave off if you only need seller profile + feedback.

## `maxStorefrontProducts` (type: `integer`):

Maximum products to list from each seller's storefront. Only applies when 'includeStorefrontProducts' is on. Each product returned is billed as one 'storefront-product' event.

## `maxStorefrontPages` (type: `integer`):

Maximum storefront result pages to paginate per seller (~48 products per page). Only applies when 'includeStorefrontProducts' is on. Amazon caps most listings at ~7 pages.

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

Apify Proxy settings. Defaults to automatic proxy. Amazon blocks datacenter IPs aggressively on heavy use — for reliable, large runs switch this to RESIDENTIAL. Seller profile pages tolerate datacenter better than search/product pages.

## Actor input object example

```json
{
  "sellerIds": [
    "A1ODG4ICFE5MU3"
  ],
  "startUrls": [],
  "asins": [],
  "country": "US",
  "includeFeedback": true,
  "maxFeedback": 20,
  "includeStorefrontProducts": false,
  "maxStorefrontProducts": 50,
  "maxStorefrontPages": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sellerIds": [
        "A1ODG4ICFE5MU3"
    ],
    "country": "US",
    "maxStorefrontProducts": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/amazon-seller-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 = {
    "sellerIds": ["A1ODG4ICFE5MU3"],
    "country": "US",
    "maxStorefrontProducts": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/amazon-seller-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 '{
  "sellerIds": [
    "A1ODG4ICFE5MU3"
  ],
  "country": "US",
  "maxStorefrontProducts": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/amazon-seller-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Seller Scraper",
        "description": "Scrape Amazon sellers — business name, legal address, feedback ratings, rating distribution, and storefront products — from seller IDs, storefront/profile URLs, or product ASINs across 18 marketplaces. Flat JSON for AI agents and MCP.",
        "version": "0.1",
        "x-build-id": "1wxLwGwAYmifpq2cw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~amazon-seller-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-amazon-seller-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/khadinakbar~amazon-seller-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-amazon-seller-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/khadinakbar~amazon-seller-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-amazon-seller-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": {
                    "sellerIds": {
                        "title": "Seller IDs",
                        "type": "array",
                        "description": "Amazon seller (merchant) IDs, 13–14 uppercase chars, e.g. ['A1ODG4ICFE5MU3','AN9M05X8SIK1X']. Each is resolved on the selected marketplace's /sp?seller= profile page. NOT an ASIN (10 chars) — for products use 'asins'. NOT a URL — for URLs use 'startUrls'.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Z0-9]{13,14}$"
                        },
                        "default": []
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Amazon URLs to scrape: seller profile ('/sp?seller=ID'), storefront ('/s?me=ID'), or product ('/dp/ASIN') pages. Product URLs are resolved to the seller(s) in their buy box. The domain in each URL overrides the 'country' setting. Use when you already have exact URLs.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "asins": {
                        "title": "Product ASINs",
                        "type": "array",
                        "description": "Product ASINs (10 chars, e.g. ['B007ADJ4JI']) whose third-party seller(s) you want to find. The actor opens each product, reads the 'Sold by' seller(s), then scrapes their profile. NOT a seller ID (13–14 chars) — for sellers use 'sellerIds'.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Z0-9]{10}$"
                        },
                        "default": []
                    },
                    "country": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "CA",
                            "ES",
                            "IT",
                            "JP",
                            "AU",
                            "IN",
                            "MX",
                            "BR",
                            "NL",
                            "SE",
                            "PL",
                            "TR",
                            "AE",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to use for sellerIds and asins. Ignored when a startUrl already contains a specific Amazon domain. Defaults to US (amazon.com).",
                        "default": "US"
                    },
                    "includeFeedback": {
                        "title": "Include recent feedback comments",
                        "type": "boolean",
                        "description": "When true, the seller record includes a 'recentFeedback' array of the most recent buyer comments rendered on the profile (rating, comment, author, date). Turn off for a leaner record focused on business details and rating summaries.",
                        "default": true
                    },
                    "maxFeedback": {
                        "title": "Max feedback comments",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum recent feedback comments to capture per seller (only the comments rendered on the profile page; Amazon shows ~5–10 without pagination). Ignored when 'includeFeedback' is off.",
                        "default": 20
                    },
                    "includeStorefrontProducts": {
                        "title": "Also list storefront products",
                        "type": "boolean",
                        "description": "When true, the actor also opens the seller's storefront ('/s?me=ID') and lists their products into a 'products' array on the seller record. Each product is billed at $0.003. Adds time and cost — leave off if you only need seller profile + feedback.",
                        "default": false
                    },
                    "maxStorefrontProducts": {
                        "title": "Max storefront products per seller",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum products to list from each seller's storefront. Only applies when 'includeStorefrontProducts' is on. Each product returned is billed as one 'storefront-product' event.",
                        "default": 100
                    },
                    "maxStorefrontPages": {
                        "title": "Max storefront pages per seller",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum storefront result pages to paginate per seller (~48 products per page). Only applies when 'includeStorefrontProducts' is on. Amazon caps most listings at ~7 pages.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Defaults to automatic proxy. Amazon blocks datacenter IPs aggressively on heavy use — for reliable, large runs switch this to RESIDENTIAL. Seller profile pages tolerate datacenter better than search/product pages.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
