# Amazon Reviews Scraper — Ratings & Sentiment (`khadinakbar/amazon-reviews-scraper`) Actor

Extract Amazon product reviews including star rating, review text, verified purchase status, helpful votes, reviewer info, images, and variant. Input by URL or ASIN. Supports star filters, keyword filters, and date cutoffs.

- **URL**: https://apify.com/khadinakbar/amazon-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 review 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 Reviews Scraper — Extract Ratings, Sentiment & Verified Purchases

### What does Amazon Reviews Scraper do?

Amazon Reviews Scraper extracts structured review data from any Amazon product page — no Amazon API key required. Give it a product URL or ASIN, and it returns clean JSON with every review's star rating, full text, verified purchase status, helpful vote count, reviewer info, images, and product variant — ready for sentiment analysis, brand monitoring, competitive research, or AI pipelines.

### Why use Amazon Reviews Scraper?

- **Beats the market leader on rating** — built from scratch with production-grade selectors, session pools, and residential proxies that actually work
- **Flexible input** — accepts Amazon URLs, raw ASINs, or both at the same time
- **Powerful filters** — filter by star rating (1★–5★), keywords (e.g. "battery"), and date cutoffs
- **Full pagination** — automatically follows all review pages up to your `maxReviews` limit
- **MCP-ready output** — semantic field names, consistent schema, and a rich dataset view so Claude and other AI agents can use it directly
- **33% cheaper** than the leading competitor at $0.004 per review (FREE tier)

### What data can Amazon Reviews Scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| `asin` | string | Amazon product ID (e.g. B0CWXNS552) |
| `product_title` | string | Product name |
| `product_url` | string | Direct Amazon product URL |
| `review_id` | string | Amazon's unique review ID |
| `reviewer_name` | string | Reviewer display name |
| `reviewer_profile_url` | string | Link to reviewer's Amazon profile |
| `is_verified_purchase` | boolean | Was this a confirmed Amazon purchase? |
| `rating` | number | Star rating 1.0–5.0 |
| `review_title` | string | Short review headline |
| `review_body` | string | Full review text (great for NLP/sentiment) |
| `review_date` | string | Raw date string from Amazon |
| `review_date_iso` | string | ISO 8601 parsed date for filtering |
| `helpful_votes` | number | Upvote count from other Amazon users |
| `images` | array | Full-size review image URLs |
| `variant` | string | Product variant reviewed (color, size, etc.) |
| `country` | string | Country where review was written |
| `is_top_review` | boolean | Amazon-labeled top review flag |
| `scraped_at` | string | ISO timestamp of when scraped |
| `source_url` | string | Exact reviews page URL scraped |

### How to scrape Amazon reviews — tutorial

#### Option 1: Quick start in the Apify Console

1. Go to your actor page on Apify Store
2. Click **Try for free**
3. Paste one or more Amazon product URLs into **Amazon Product URLs**
4. Click **Start** — reviews appear in the **Output** tab within seconds

#### Option 2: Via API (for developers)

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

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

const run = await client.actor('USERNAME/amazon-reviews-scraper').call({
    productUrls: [
        { url: 'https://www.amazon.com/dp/B0CWXNS552' }
    ],
    maxReviews: 200,
    sort: 'recent',
    filterByRatings: ['oneStar', 'twoStar'],  // scrape only negative reviews
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} reviews`);
console.log(items[0]);
// {
//   asin: 'B0CWXNS552',
//   product_title: 'Apple iPhone 15 Pro...',
//   rating: 2,
//   review_title: 'Disappointing battery life',
//   review_body: 'Expected better from Apple...',
//   is_verified_purchase: true,
//   helpful_votes: 18,
//   review_date_iso: '2024-03-12T00:00:00.000Z',
//   ...
// }
````

#### Option 3: Input by raw ASIN

You can skip the URL and use the ASIN directly:

```json
{
    "asins": ["B0CWXNS552", "B09G9FPHY6"],
    "maxReviews": 100,
    "sort": "helpful"
}
```

#### Option 4: Keyword + star filter combination

Scrape only 1-star reviews mentioning "broken":

```json
{
    "productUrls": [{ "url": "https://www.amazon.com/dp/B0CWXNS552" }],
    "filterByRatings": ["oneStar"],
    "filterByKeywords": ["broken", "defective"],
    "maxReviews": 500,
    "sort": "recent"
}
```

#### Option 5: Date-filtered monitoring

Track reviews from the last 30 days:

```json
{
    "productUrls": [{ "url": "https://www.amazon.com/dp/B0CWXNS552" }],
    "reviewsCutoffDate": "2026-03-09",
    "sort": "recent",
    "maxReviews": 1000
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `productUrls` | array | `[{url: "https://..."}]` | Amazon product page URLs |
| `asins` | array | `[]` | Raw 10-char ASINs (e.g. B0CWXNS552) |
| `maxReviews` | integer | `100` | Max reviews per product per filter |
| `sort` | string | `helpful` | Sort order: `helpful` or `recent` |
| `filterByRatings` | array | `["allStars"]` | Star rating filter(s) |
| `filterByKeywords` | array | `[]` | Keyword filter(s) |
| `reviewsCutoffDate` | string | `null` | Skip reviews older than this date |
| `scrapeProductDetails` | boolean | `true` | Include product title in output |
| `proxyConfiguration` | object | Residential | Proxy settings (residential required) |

### Pricing

This actor uses **pay-per-event pricing** at **$0.004 per review** (FREE tier).

| Reviews | Cost (FREE tier) | Cost (GOLD tier) |
|---------|-----------------|-----------------|
| 100 | $0.40 | $0.30 |
| 500 | $2.00 | $1.50 |
| 1,000 | $4.00 | $3.00 |
| 10,000 | $40.00 | $30.00 |

You are only charged for reviews successfully extracted and written to the dataset. Failed pages and skipped duplicates are free.

### Use cases

**Brand monitoring** — Track what customers say about your products over time. Set up a scheduled run with `reviewsCutoffDate` to get only new reviews weekly.

**Competitive research** — Scrape reviews of competitor products to identify their weaknesses. Filter by 1★ and 2★ to find common complaints.

**Sentiment analysis / NLP** — Feed `review_body` into your AI pipeline. The `is_verified_purchase` field lets you weight genuine buyers more heavily.

**Product improvement** — Filter by keyword (e.g. "battery", "quality", "shipping") to quickly surface the most common issues.

**AI training data** — Collect thousands of rated review texts for fine-tuning or evaluation datasets.

**Price intelligence** — Monitor variant-specific reviews to understand how different configurations are received.

### Technical details

- **Crawler:** CheerioCrawler (fast HTTP-based HTML parsing — no browser overhead)
- **Proxy:** Apify Residential proxies (required for Amazon — datacenter IPs are blocked)
- **Deduplication:** Reviews are deduplicated by review ID across all filter combinations
- **Pagination:** Automatic — follows all Next Page links up to `maxReviews`
- **Rate limiting:** Max 3 concurrent requests with session rotation (5 uses per session)
- **Retries:** Up to 3 retries per page with fresh sessions

### FAQ

**Why do I need residential proxies?** Amazon aggressively blocks datacenter IPs. Residential proxies (included in Apify's proxy offering) route requests through real user connections, making scraping reliably work. Without them you'll get bot-detection pages.

**Why am I getting fewer reviews than `maxReviews`?** Amazon limits how many reviews are visible per filter combination. For example, a product may have 5,000 total reviews but only 100 reviews showing for the "2 star" filter. This is an Amazon limitation, not a scraper bug.

**Can I scrape reviews for products on Amazon.co.uk, .de, etc.?** The actor currently targets Amazon.com. To scrape other marketplaces, change the domain in the product URL (e.g. `amazon.co.uk/dp/...`) — the selectors are the same across most Amazon domains.

**How do I get reviews in a specific language?** Pass the URL with a language parameter or use a proxy location matching the target marketplace.

**Will this break if Amazon updates their site?** The actor uses multiple CSS selector fallbacks per element to survive minor redesigns. If Amazon does a major redesign, open an issue and we'll update within 48 hours.

**Is it legal to scrape Amazon reviews?** Amazon reviews are publicly available data. This actor is built for lawful use cases — market research, academic study, brand monitoring. Users are responsible for compliance with Amazon's Terms of Service, applicable laws, and data protection regulations (GDPR, CCPA, etc.).

### Other actors you might like

- [Amazon Product Scraper](https://apify.com/USERNAME/amazon-product-scraper) — Scrape product titles, prices, ratings, and BSR rankings
- [Google Shopping Scraper](https://apify.com/USERNAME/google-shopping-scraper) — Compare prices across retailers

***

*This actor is intended for lawful data collection from publicly available sources. Users are responsible for compliance with applicable laws, terms of service, and data protection regulations (GDPR, CCPA, etc.). Review data may contain personal information — handle in accordance with your privacy policy.*

# Actor input Schema

## `productUrls` (type: `array`):

One or more Amazon product page URLs (e.g. https://www.amazon.com/dp/B0CWXNS552). Click '+ Add' to add multiple products. The ASIN is automatically extracted from the URL. You can also use /gp/product/ASIN URLs.

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

Amazon Standard Identification Numbers (ASINs) — 10-character codes like B0CWXNS552. Enter one ASIN per line. Use this instead of product URLs when you already have the ASIN.

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

Maximum number of reviews to collect per product. Amazon displays its top 5–10 customer reviews on each product page — this actor collects those inline reviews. Set to 5 for a quick test or up to 10 for the full set Amazon shows.

## `reviewsCutoffDate` (type: `string`):

Skip reviews older than this date. Accepts YYYY-MM-DD format (e.g. 2024-01-01). Reviews are filtered after scraping — useful for tracking recent customer sentiment.

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

Amazon requires residential proxies to avoid bot detection. Apify Residential proxies are selected by default. If you have your own proxies, enter them here. Do not use datacenter proxies — Amazon blocks them aggressively.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B0CWXNS552"
    }
  ],
  "asins": [],
  "maxReviews": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of Amazon product reviews. Each item is one review with full rating, text, reviewer, and metadata fields.

# 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 = {
    "productUrls": [
        {
            "url": "https://www.amazon.com/dp/B0CWXNS552"
        }
    ],
    "asins": [],
    "maxReviews": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/amazon-reviews-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 = {
    "productUrls": [{ "url": "https://www.amazon.com/dp/B0CWXNS552" }],
    "asins": [],
    "maxReviews": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/amazon-reviews-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 '{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B0CWXNS552"
    }
  ],
  "asins": [],
  "maxReviews": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper — Ratings & Sentiment",
        "description": "Extract Amazon product reviews including star rating, review text, verified purchase status, helpful votes, reviewer info, images, and variant. Input by URL or ASIN. Supports star filters, keyword filters, and date cutoffs.",
        "version": "1.11",
        "x-build-id": "BkCngJaaWgmnhJFWJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~amazon-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-amazon-reviews-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-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-amazon-reviews-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-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-amazon-reviews-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": {
                    "productUrls": {
                        "title": "Amazon Product URLs",
                        "type": "array",
                        "description": "One or more Amazon product page URLs (e.g. https://www.amazon.com/dp/B0CWXNS552). Click '+ Add' to add multiple products. The ASIN is automatically extracted from the URL. You can also use /gp/product/ASIN URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "asins": {
                        "title": "ASINs (Amazon Product IDs)",
                        "type": "array",
                        "description": "Amazon Standard Identification Numbers (ASINs) — 10-character codes like B0CWXNS552. Enter one ASIN per line. Use this instead of product URLs when you already have the ASIN.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max Reviews per Product",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per product. Amazon displays its top 5–10 customer reviews on each product page — this actor collects those inline reviews. Set to 5 for a quick test or up to 10 for the full set Amazon shows.",
                        "default": 10
                    },
                    "reviewsCutoffDate": {
                        "title": "Only Reviews Newer Than (Date Cutoff)",
                        "type": "string",
                        "description": "Skip reviews older than this date. Accepts YYYY-MM-DD format (e.g. 2024-01-01). Reviews are filtered after scraping — useful for tracking recent customer sentiment."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Amazon requires residential proxies to avoid bot detection. Apify Residential proxies are selected by default. If you have your own proxies, enter them here. Do not use datacenter proxies — Amazon blocks them aggressively."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```