# Amazon Product Scraper — Price, BSR, Reviews & Seller Data (`khadinakbar/amazon-product-intelligence`) Actor

Extract full Amazon product intelligence: price, Best Sellers Rank, ratings, reviews, seller info, Prime status, bullet points & images. Input an ASIN list, keyword, or URL. Supports 10 Amazon marketplaces.

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

## Pricing

from $5.00 / 1,000 product 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

## 📦 Scrape Amazon Products — Price, Reviews & BSR

### What does this actor do?

This actor extracts comprehensive product intelligence from Amazon — including price, Best Seller Rank (BSR), customer reviews, seller details, Prime eligibility, and FBA status — all in a single run. It accepts keyword searches, ASIN lists, or direct URLs across 10 Amazon marketplaces.

### Why use this actor?

Most Amazon scrapers make you run 2–3 actors to get a full picture: one for products, one for reviews, one for seller info. This actor does all of it in one call — making it the fastest, most complete solution on the Apify Store.

- **One actor, complete data** — products + reviews + BSR + seller in a single run
- **3 input modes** — keyword search, ASIN list, or direct URLs
- **10 marketplaces** — US, UK, DE, FR, CA, ES, IT, JP, AU, IN
- **MCP-optimized output** — semantic field names Claude and other AI agents can use directly
- **BSR extraction** — Best Seller Rank data missing from most competitors
- **FBA flag** — instantly see if fulfilled by Amazon or a third-party seller
- **Residential proxy ready** — handles Amazon's aggressive bot detection

### What data can this actor extract?

| Field | Type | Description |
|---|---|---|
| `asin` | string | Amazon Standard Identification Number |
| `title` | string | Full product title |
| `brand` | string | Brand or manufacturer |
| `price` | number | Current selling price |
| `original_price` | number | List price before discount |
| `discount_percent` | integer | Calculated discount percentage |
| `currency` | string | Currency code (USD, GBP, EUR…) |
| `in_stock` | boolean | Availability status |
| `prime_eligible` | boolean | Amazon Prime eligibility |
| `star_rating` | number | Average star rating (1–5) |
| `review_count` | integer | Total number of ratings |
| `best_seller_rank` | integer | BSR in primary category |
| `best_seller_category` | string | Category BSR applies to |
| `category` | string | Top-level product category |
| `seller_name` | string | Merchant name |
| `fulfilled_by_amazon` | boolean | FBA or Amazon-sold flag |
| `main_image_url` | string | Primary product image URL |
| `bullet_points` | array | Product feature bullet points |
| `description` | string | Full product description |
| `variations_count` | integer | Number of available variants |
| `reviews` | array | Customer reviews (when enabled) |
| `marketplace` | string | Marketplace country code |
| `product_url` | string | Clean Amazon product URL |
| `scraped_at` | string | ISO 8601 scrape timestamp |

### How to use this actor

#### By keyword search

Enter a search query to scrape products from Amazon search results:

```json
{
    "searchQuery": "wireless earbuds noise cancelling",
    "country": "US",
    "maxResults": 100
}
````

#### By ASIN list

Pass specific ASINs to scrape those exact products:

```json
{
    "asins": ["B08N5WRWNW", "B09G9HD6PD", "B07XJ8C8F5"],
    "country": "US",
    "maxResults": 50
}
```

#### By direct URL

Paste Amazon product or search result pages:

```json
{
    "startUrls": [
        { "url": "https://www.amazon.com/dp/B08N5WRWNW" },
        { "url": "https://www.amazon.com/s?k=bluetooth+speaker" }
    ],
    "maxResults": 50
}
```

#### With reviews included

```json
{
    "searchQuery": "ergonomic office chair",
    "country": "US",
    "maxResults": 20,
    "includeReviews": true,
    "maxReviews": 10
}
```

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchQuery` | string | No\* | — | Keyword to search on Amazon |
| `asins` | array | No\* | `[]` | List of ASIN codes to scrape |
| `startUrls` | array | No\* | `[]` | Direct Amazon product/search URLs |
| `country` | string | No | `US` | Marketplace: US, UK, DE, FR, CA, ES, IT, JP, AU, IN |
| `maxResults` | integer | No | `50` | Maximum products to extract |
| `includeReviews` | boolean | No | `false` | Fetch customer reviews per product |
| `maxReviews` | integer | No | `5` | Max reviews per product |
| `proxyConfiguration` | object | No | Residential | Proxy settings |

\*At least one of `searchQuery`, `asins`, or `startUrls` is required.

### Sample output

```json
{
    "asin": "B08N5WRWNW",
    "title": "Apple AirPods Pro (2nd Generation)",
    "brand": "Apple",
    "price": 189.99,
    "original_price": 249.99,
    "discount_percent": 24,
    "currency": "USD",
    "in_stock": true,
    "prime_eligible": true,
    "star_rating": 4.7,
    "review_count": 28543,
    "best_seller_rank": 3,
    "best_seller_category": "Earbud Headphones",
    "category": "Electronics",
    "seller_name": "Amazon.com",
    "fulfilled_by_amazon": true,
    "main_image_url": "https://m.media-amazon.com/images/I/...",
    "bullet_points": [
        "Active Noise Cancellation",
        "Adaptive Transparency",
        "Up to 30 hours total battery life"
    ],
    "description": "Rebuilt from the ground up...",
    "variations_count": 2,
    "marketplace": "US",
    "product_url": "https://www.amazon.com/dp/B08N5WRWNW",
    "reviews": null,
    "scraped_at": "2026-04-09T14:32:00.000Z",
    "source_url": "https://www.amazon.com/dp/B08N5WRWNW"
}
```

### Pricing

This actor uses **pay-per-event pricing**: $0.003 per product scraped.

| Products | Cost |
|---|---|
| 10 products | $0.03 |
| 100 products | $0.30 |
| 500 products | $1.50 |
| 1,000 products | $3.00 |

Reviews are included at no extra charge when `includeReviews: true` — you only pay per product, not per review.

### Use cases

**Price tracking & competitor monitoring** — Track competitor prices daily by running this actor on a schedule with their ASINs. Export to Google Sheets or your own database.

**Market research** — Search any keyword and extract BSR, ratings, and review counts to identify winning products and category leaders.

**Dropshipping research** — Filter by `prime_eligible`, `in_stock`, and `discount_percent` to find arbitrage opportunities across marketplaces.

**Sentiment analysis** — Enable reviews to extract customer feedback at scale for NLP and market intelligence pipelines.

**AI agent data collection** — This actor is MCP-optimized. Claude, ChatGPT, and other AI agents can call it directly via the Apify MCP server to retrieve Amazon product data on demand.

### Running via API

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

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

const run = await client.actor('USERNAME/amazon-product-intelligence').call({
    searchQuery: 'protein powder',
    country: 'US',
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("USERNAME/amazon-product-intelligence").call(run_input={
    "searchQuery": "protein powder",
    "country": "US",
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Scheduling

To run this actor daily for price tracking:

1. Open the actor → **Schedules** tab
2. Click **New Schedule**
3. Set your cron expression (e.g. `0 9 * * *` for 9am daily)
4. Save your input configuration
5. Enable the schedule

### Troubleshooting

**Getting 0 results?** Amazon blocks datacenter proxies aggressively. Make sure residential proxies are enabled in your proxy configuration. The default settings already include this.

**Captcha errors in logs?** This is normal on first runs with new sessions. The session pool rotates automatically and retries. If it persists, reduce `maxConcurrency` in the proxy settings.

**BSR is null?** Not all products show a BSR. Products with very few reviews or in niche categories may not be ranked.

**Reviews not loading?** Set `includeReviews: true` and `maxReviews` to your desired count. The reviews tab is loaded separately and adds time per product.

**Price is null?** Some products use dynamic pricing not available in the initial page load (e.g. Configure pricing, range pricing). This is an Amazon limitation.

### Other actors in this portfolio

This actor pairs well with other tools for a complete e-commerce intelligence pipeline:

- Run this actor to collect product data → export to Google Sheets for dashboards
- Chain with a keyword research actor to discover new search terms
- Use with a scheduler to track price changes over time

### Legal disclaimer

This actor is designed for lawful collection of publicly available data from Amazon. Users are responsible for complying with Amazon's Terms of Service, applicable data protection regulations (GDPR, CCPA, etc.), and the laws of their jurisdiction. The data extracted should be used only for legitimate research, competitive intelligence, and business analytics purposes. Do not use this actor to engage in unfair competition, mass spamming, or any activity prohibited by law.

# Actor input Schema

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

Use this when the user wants to search Amazon by keyword (e.g. 'wireless earbuds', 'vitamin C supplement'). Use startUrls instead when the user provides a direct Amazon product or search URL. Use asins instead when the user provides specific ASIN codes.

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

Use this when the user provides specific Amazon Standard Identification Numbers (ASINs), e.g. \['B08N5WRWNW', 'B09G9HD6PD']. Do NOT use this when the user describes a topic or category — use searchQuery for that.

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

Use this when the user provides direct Amazon product pages (e.g. amazon.com/dp/...) or Amazon search result pages. Both product and search URLs are accepted.

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

Which Amazon marketplace to scrape. Defaults to US (amazon.com). Options: US, UK, DE, FR, CA, ES, IT, JP, AU, IN.

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

Maximum number of products to extract. Each product counts as one billable event. Start with a small number to test. Maximum recommended: 1000 per run.

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

Set to true to extract customer reviews for each product. Each product's reviews page is loaded separately — this adds time but provides rich sentiment data. maxReviews controls how many reviews per product.

## `maxReviews` (type: `integer`):

How many customer reviews to extract per product. Only used when includeReviews is true. Higher values take longer.

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

Proxy settings. Amazon requires residential proxies — datacenter proxies are blocked. Defaults to Apify Residential proxies (recommended).

## Actor input object example

```json
{
  "searchQuery": "wireless earbuds",
  "asins": [],
  "startUrls": [],
  "country": "US",
  "maxResults": 5,
  "includeReviews": false,
  "maxReviews": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of extracted Amazon product records — price, BSR, rating, review count, seller, Prime status, bullet points, images and more.

# 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 = {
    "searchQuery": "wireless earbuds",
    "asins": [],
    "startUrls": [],
    "country": "US",
    "maxResults": 5,
    "includeReviews": false,
    "maxReviews": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/amazon-product-intelligence").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 = {
    "searchQuery": "wireless earbuds",
    "asins": [],
    "startUrls": [],
    "country": "US",
    "maxResults": 5,
    "includeReviews": False,
    "maxReviews": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/amazon-product-intelligence").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 '{
  "searchQuery": "wireless earbuds",
  "asins": [],
  "startUrls": [],
  "country": "US",
  "maxResults": 5,
  "includeReviews": false,
  "maxReviews": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/amazon-product-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper — Price, BSR, Reviews & Seller Data",
        "description": "Extract full Amazon product intelligence: price, Best Sellers Rank, ratings, reviews, seller info, Prime status, bullet points & images. Input an ASIN list, keyword, or URL. Supports 10 Amazon marketplaces.",
        "version": "1.0",
        "x-build-id": "gJJ3bUoxMSf7AwFQ7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~amazon-product-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-amazon-product-intelligence",
                "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-product-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-amazon-product-intelligence",
                "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-product-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-amazon-product-intelligence",
                "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": {
                    "searchQuery": {
                        "title": "Search Query (Keyword)",
                        "type": "string",
                        "description": "Use this when the user wants to search Amazon by keyword (e.g. 'wireless earbuds', 'vitamin C supplement'). Use startUrls instead when the user provides a direct Amazon product or search URL. Use asins instead when the user provides specific ASIN codes."
                    },
                    "asins": {
                        "title": "ASIN List",
                        "type": "array",
                        "description": "Use this when the user provides specific Amazon Standard Identification Numbers (ASINs), e.g. ['B08N5WRWNW', 'B09G9HD6PD']. Do NOT use this when the user describes a topic or category — use searchQuery for that.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct URLs",
                        "type": "array",
                        "description": "Use this when the user provides direct Amazon product pages (e.g. amazon.com/dp/...) or Amazon search result pages. Both product and search URLs are accepted.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "country": {
                        "title": "Amazon Marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "CA",
                            "ES",
                            "IT",
                            "JP",
                            "AU",
                            "IN"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to scrape. Defaults to US (amazon.com). Options: US, UK, DE, FR, CA, ES, IT, JP, AU, IN.",
                        "default": "US"
                    },
                    "maxResults": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of products to extract. Each product counts as one billable event. Start with a small number to test. Maximum recommended: 1000 per run.",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Set to true to extract customer reviews for each product. Each product's reviews page is loaded separately — this adds time but provides rich sentiment data. maxReviews controls how many reviews per product.",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Product",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many customer reviews to extract per product. Only used when includeReviews is true. Higher values take longer.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Amazon requires residential proxies — datacenter proxies are blocked. Defaults to Apify Residential proxies (recommended)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```