# Free Amazon Product Scraper: Prices & Sellers (`kingly_winter/amazon-product-scraper`) Actor

Free Actor for Amazon products, prices, search, offers, and sellers. Accepts URLs, ASINs, or queries across marketplaces; returns ratings, stock, delivery, images, variants, and seller profiles through Apify API. No developer fee; normal Apify usage applies. Unofficial; not affiliated with Amazon.

- **URL**: https://apify.com/kingly\_winter/amazon-product-scraper.md
- **Developed by:** [Sean G](https://apify.com/kingly_winter) (community)
- **Categories:** E-commerce, AI, Integrations
- **Stats:** 3 total users, 2 monthly users, 76.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Product Data for AI

> **Unofficial integration:** This Actor is not affiliated with, endorsed by,
> or sponsored by Amazon. It accesses publicly available Amazon storefront
> pages and does not use the Amazon Product Advertising API.

Collect normalized Amazon product data from product URLs, search/category URLs,
ASINs, or search queries. The interface is designed for LLM tool calls and
automation: storefront, delivery destination, enrichment depth, and result
limits are explicit, and every dataset row has a version and status.

There is no Actor developer fee. Users pay only their own Apify platform usage
for compute, storage, and any proxy they explicitly enable.

### Use cases

- Look up products by URL or ASIN.
- Search an Amazon marketplace by natural-language query.
- Monitor prices, availability, ratings, and review counts.
- Enrich catalogs with product content, media, and variant relationships.
- Compare visible offers and public seller profiles.
- Check delivery availability for a country and postal code.
- Give an AI agent bounded access to normalized Amazon product data.

### Quick start

Scrape one product URL:

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/dp/B01MG4OX6Q" }
  ],
  "maxTotalResults": 1
}
````

Look up ASINs without constructing URLs:

```json
{
  "asins": ["B01MG4OX6Q"],
  "marketplace": "US",
  "maxTotalResults": 1
}
```

Collect five lightweight search results:

```json
{
  "searchQueries": ["mechanical keyboard"],
  "marketplace": "US",
  "resultDepth": "listing",
  "maxResultsPerTarget": 5,
  "maxTotalResults": 5,
  "maxSearchPages": 1
}
```

Request product details, one offer, seller enrichment, and a delivery
destination:

```json
{
  "asins": ["B01MG4OX6Q"],
  "marketplace": "US",
  "resultDepth": "product",
  "maxOffersPerProduct": 1,
  "includeSellerProfiles": true,
  "deliveryLocation": {
    "countryCode": "US",
    "postalCode": "10001"
  },
  "maxTotalResults": 1
}
```

### Input model

Provide at least one target type:

| Field | Purpose |
| --- | --- |
| `startUrls` | Amazon product, search, or category URLs. The domain selects the marketplace. |
| `asins` | Ten-character product identifiers. Requires `marketplace`. |
| `searchQueries` | Search phrases. Requires `marketplace`. |
| `marketplace` | Storefront country used for ASIN and query targets, such as `US`, `GB`, `DE`, or `JP`. |

Control work and output explicitly:

| Field | Purpose |
| --- | --- |
| `maxResultsPerTarget` | Maximum product records from each target. |
| `maxTotalResults` | Hard product-record cap across the complete run. |
| `maxSearchPages` | Maximum pages followed for each listing target. |
| `resultDepth` | `listing` returns cards; `product` opens product pages. |
| `maxVariantResultsPerProduct` | Maximum child variants emitted as separate records. |
| `fetchVariantPrices` | Enrich nested variants from bounded child pages. |
| `maxOffersPerProduct` | Maximum visible or all-offers rows requested per product. |
| `includeSellerProfiles` | Enrich visible merchants from bounded public seller pages. |
| `language` | Optional Amazon page language. |
| `deliveryLocation` | Customer delivery country and optional postal code. |
| `proxyConfiguration` | Standard optional Apify proxy configuration. |

`marketplace`, `deliveryLocation`, and proxy location are separate concepts:

- Marketplace chooses the Amazon storefront.
- Delivery location chooses the customer destination displayed by Amazon.
- Proxy configuration chooses the network route.

### Normalized output

Every dataset row contains:

- `schemaVersion`: currently `1.0`.
- `recordType`: `product` or `error`.
- `status`: `ok`, `partial`, or `error`.
- `source`: target kind, original value, page, position, and optional user data.
- `marketplace`: storefront country, domain, and currency.
- Compact product identity plus grouped `pricing`, `rating`, `demand`,
  `availability`, `delivery`, `variants`, `media`, and `content` objects.
- Optional `seller`, `offers`, `diagnostics`, and structured `error` objects.
- `scrapedAt`: collection timestamp.

Example:

```json
{
  "schemaVersion": "1.0",
  "recordType": "product",
  "status": "ok",
  "source": {
    "kind": "asin",
    "value": "B01MG4OX6Q",
    "targetIndex": 0
  },
  "marketplace": {
    "countryCode": "US",
    "domain": "amazon.com",
    "currency": "USD"
  },
  "asin": "B01MG4OX6Q",
  "title": "Product title",
  "pricing": {
    "current": {
      "value": 7.29,
      "currency": "USD"
    }
  },
  "rating": {
    "value": 4.4,
    "count": 10940
  },
  "availability": {
    "inStock": true
  }
}
```

Failed requests are emitted as `recordType: "error"` rows, so agents that read
only the dataset do not silently miss failures. The `OUTPUT` record in the
default key-value store also contains canonical input, target planning, run
warnings, request statistics, proxy context, and delivery diagnostics. If every
target fails, the Actor run is marked failed after those diagnostics are saved.

### Optional Apify MCP integration

Apify automatically exposes standard Actors as MCP tools. This Actor keeps one
Actor input/output contract; it does not maintain a separate MCP-specific API.

Connect an MCP client to:

```text
https://mcp.apify.com/?tools=kingly_winter/amazon-product-scraper
```

Authenticate with an Apify API token. The Actor appears as the
`kingly_winter--amazon-product-scraper` tool together with helpers for run
status, dataset records, key-value records, and aborting a run.

Useful agent requests include:

- "Find a free Amazon product data Actor that accepts ASINs."
- "Search Amazon US for mechanical keyboards and return five listing records."
- "Get this ASIN's price, rating, availability, and delivery to ZIP 10001."
- "Collect one visible offer and the public seller profile for this product."

### Cost and reliability

The Actor is free; normal Apify compute, storage, data transfer, and optional
proxy charges still apply. Keep `maxTotalResults`, `maxResultsPerTarget`, pages,
variants, and offers low until output is verified.

Amazon can return challenges, interstitials, redirects, HTTP errors, or changed
markup without notice. No external CAPTCHA solver is integrated. The Actor uses
one isolated browser context as a bounded fallback when the direct HTTP path is
challenged. Remaining failures are returned through diagnostics and error
records rather than being reported as successful results. Offers, seller pages,
variants, and delivery setup are bounded and best effort.

### Responsible use

Use this Actor only for a lawful purpose and comply with applicable laws,
Amazon's terms, robots directives where applicable, and Apify's Acceptable Use
Policy. Do not collect private, authenticated, paywalled, or sensitive data.
Avoid excessive request rates and retain only the data your workflow needs.

# Actor input Schema

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

Product, search, or category URLs. The URL domain selects the marketplace.

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

Ten-character ASINs. Requires marketplace.

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

Search phrases to run on the selected marketplace.

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

Required for ASIN and search-query targets. URL targets infer it from their domain.

## `maxResultsPerTarget` (type: `integer`):

Maximum product records produced by each URL, ASIN, or search query.

## `maxTotalResults` (type: `integer`):

Hard cap on product records across the entire run.

## `maxSearchPages` (type: `integer`):

Maximum pages followed for each search or category target.

## `resultDepth` (type: `string`):

listing returns listing-card data without opening product pages; product opens product pages for complete records.

## `maxVariantResultsPerProduct` (type: `integer`):

Maximum child variants emitted as separate product records.

## `fetchVariantPrices` (type: `boolean`):

Visit bounded child-variant pages and enrich the nested variants object.

## `maxOffersPerProduct` (type: `integer`):

Maximum visible or all-offers records requested per product.

## `includeSellerProfiles` (type: `boolean`):

Enrich visible merchants with bounded public seller-profile data.

## `language` (type: `string`):

Optional Amazon request language.

## `deliveryLocation` (type: `object`):

Optional customer destination. This is independent of marketplace and proxy location.

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

Optional standard Apify proxy configuration. Direct connections are used by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/dp/B01MG4OX6Q"
    }
  ],
  "maxResultsPerTarget": 20,
  "maxTotalResults": 20,
  "maxSearchPages": 1,
  "resultDepth": "product",
  "maxVariantResultsPerProduct": 0,
  "fetchVariantPrices": false,
  "maxOffersPerProduct": 0,
  "includeSellerProfiles": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Normalized, versioned product and error records in the default dataset.

## `runSummary` (type: `string`):

Canonical input, target plan, warnings, errors, request statistics, proxy context, and location diagnostics.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.amazon.com/dp/B01MG4OX6Q"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kingly_winter/amazon-product-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 = { "startUrls": [{ "url": "https://www.amazon.com/dp/B01MG4OX6Q" }] }

# Run the Actor and wait for it to finish
run = client.actor("kingly_winter/amazon-product-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 '{
  "startUrls": [
    {
      "url": "https://www.amazon.com/dp/B01MG4OX6Q"
    }
  ]
}' |
apify call kingly_winter/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Free Amazon Product Scraper: Prices & Sellers",
        "description": "Free Actor for Amazon products, prices, search, offers, and sellers. Accepts URLs, ASINs, or queries across marketplaces; returns ratings, stock, delivery, images, variants, and seller profiles through Apify API. No developer fee; normal Apify usage applies. Unofficial; not affiliated with Amazon.",
        "version": "0.6",
        "x-build-id": "4qIV3dWwr3zjYJl44"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kingly_winter~amazon-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kingly_winter-amazon-product-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/kingly_winter~amazon-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kingly_winter-amazon-product-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/kingly_winter~amazon-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kingly_winter-amazon-product-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": {
                    "startUrls": {
                        "title": "Amazon URLs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Product, search, or category URLs. The URL domain selects the marketplace.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Absolute URL on a supported Amazon storefront."
                                },
                                "userData": {
                                    "type": "object",
                                    "title": "User data",
                                    "description": "Optional caller metadata copied into source.userData."
                                }
                            },
                            "required": [
                                "url"
                            ]
                        }
                    },
                    "asins": {
                        "title": "ASINs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Ten-character ASINs. Requires marketplace.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z0-9]{10}$"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Search phrases to run on the selected marketplace.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 500
                        }
                    },
                    "marketplace": {
                        "title": "Marketplace",
                        "enum": [
                            "AE",
                            "AU",
                            "BE",
                            "BR",
                            "CA",
                            "CN",
                            "DE",
                            "EG",
                            "ES",
                            "FR",
                            "GB",
                            "IE",
                            "IN",
                            "IT",
                            "JP",
                            "MX",
                            "NL",
                            "PL",
                            "SA",
                            "SE",
                            "SG",
                            "TR",
                            "US",
                            "ZA"
                        ],
                        "type": "string",
                        "description": "Required for ASIN and search-query targets. URL targets infer it from their domain."
                    },
                    "maxResultsPerTarget": {
                        "title": "Results per target",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum product records produced by each URL, ASIN, or search query.",
                        "default": 20
                    },
                    "maxTotalResults": {
                        "title": "Total result cap",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on product records across the entire run.",
                        "default": 20
                    },
                    "maxSearchPages": {
                        "title": "Search pages per target",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum pages followed for each search or category target.",
                        "default": 1
                    },
                    "resultDepth": {
                        "title": "Result depth",
                        "enum": [
                            "listing",
                            "product"
                        ],
                        "type": "string",
                        "description": "listing returns listing-card data without opening product pages; product opens product pages for complete records.",
                        "default": "product"
                    },
                    "maxVariantResultsPerProduct": {
                        "title": "Separate variant records",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum child variants emitted as separate product records.",
                        "default": 0
                    },
                    "fetchVariantPrices": {
                        "title": "Fetch variant prices",
                        "type": "boolean",
                        "description": "Visit bounded child-variant pages and enrich the nested variants object.",
                        "default": false
                    },
                    "maxOffersPerProduct": {
                        "title": "Offers per product",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum visible or all-offers records requested per product.",
                        "default": 0
                    },
                    "includeSellerProfiles": {
                        "title": "Include seller profiles",
                        "type": "boolean",
                        "description": "Enrich visible merchants with bounded public seller-profile data.",
                        "default": false
                    },
                    "language": {
                        "title": "Page language",
                        "enum": [
                            "cs",
                            "da",
                            "de",
                            "en",
                            "es",
                            "fr",
                            "nl",
                            "pl",
                            "pt",
                            "sv",
                            "tr",
                            "he",
                            "ar",
                            "mr",
                            "hi",
                            "bn",
                            "ta",
                            "te",
                            "kn",
                            "ml",
                            "ko",
                            "zh_CN",
                            "zh_TW",
                            "ja"
                        ],
                        "type": "string",
                        "description": "Optional Amazon request language."
                    },
                    "deliveryLocation": {
                        "title": "Delivery destination",
                        "required": [
                            "countryCode"
                        ],
                        "type": "object",
                        "description": "Optional customer destination. This is independent of marketplace and proxy location.",
                        "properties": {
                            "countryCode": {
                                "title": "Country code",
                                "description": "Two-letter delivery country code.",
                                "type": "string",
                                "pattern": "^[A-Za-z]{2}$"
                            },
                            "postalCode": {
                                "title": "Postal code",
                                "description": "Optional postal code within the delivery country.",
                                "type": "string",
                                "minLength": 1,
                                "maxLength": 20
                            }
                        },
                        "additionalProperties": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional standard Apify proxy configuration. Direct connections are used by default.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
