# Amazon Reviews Scraper — All Stars, Date Filter (`totaka/amazon-reviews-scraper`) Actor

Scrape unlimited Amazon product reviews by ASIN with filters for star rating, verified purchase, date range, and media. Includes product metadata. Supports 11 Amazon marketplaces.

- **URL**: https://apify.com/totaka/amazon-reviews-scraper.md
- **Developed by:** [Thomas Gharbi](https://apify.com/totaka) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 2 total users, 1 monthly users, 20.0% 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.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 — Unlimited Pages, All Stars, 11 Marketplaces

Scrape **all Amazon product reviews** by ASIN with no page cap. Filter by star rating, verified purchase, date range, or media-only. Includes full product metadata. Supports **11 Amazon marketplaces**. No Amazon API key required.

---

### Why unlimited reviews matters

Amazon's own interface caps at ~10 pages (100 reviews). Most scrapers stop there too. This scraper **follows pagination automatically** until your limit is reached — 100 reviews, 1,000 reviews, or every single review for a product.

Combined with the verified-only filter, it's the most practical way to separate genuine customer feedback from incentivized or fake reviews.

---

### Input parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `asins` | array | Amazon ASINs to scrape (e.g. `["B08N5WRWNW"]`) |
| `marketplace` | string | Amazon domain (default: `amazon.com`) |
| `maxReviewsPerAsin` | integer | Max reviews per product (default: 100) |
| `sortBy` | string | `recent` or `helpful` |
| `filterByRating` | integer | Only scrape this star rating (1–5), or omit for all |
| `verifiedOnly` | boolean | Only include Verified Purchase reviews |
| `since` | string | Only reviews on or after this date (YYYY-MM-DD) |
| `mediaOnly` | boolean | Only reviews with photos or videos |
| `amazonCookies` | string | Your Amazon session cookies (required for some markets) |
| `proxyConfiguration` | object | Proxy settings (residential recommended) |

#### Example — scraping 1-star verified reviews

```json
{
  "asins": ["B08N5WRWNW", "B0BX2K13KH"],
  "marketplace": "amazon.com",
  "maxReviewsPerAsin": 500,
  "sortBy": "recent",
  "filterByRating": 1,
  "verifiedOnly": true,
  "since": "2024-01-01"
}
````

#### Example — full product research

```json
{
  "asins": ["B08N5WRWNW"],
  "marketplace": "amazon.de",
  "maxReviewsPerAsin": 2000,
  "sortBy": "helpful"
}
```

***

### Output fields

Each review is one dataset item. The first review per ASIN also includes product-level metadata.

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | string | Amazon's unique review ID |
| `reviewUrl` | string | Direct link to the review |
| `asin` | string | Product ASIN |
| `marketplace` | string | Amazon marketplace |
| `rating` | number | Star rating (1–5) |
| `title` | string | Review headline |
| `body` | string | Full review text |
| `date` | string | Review date (YYYY-MM-DD) |
| `verifiedPurchase` | boolean | Verified Purchase badge |
| `helpfulVotes` | integer | "Helpful" votes from other customers |
| `reviewer.name` | string | Reviewer name |
| `reviewer.badges` | array | Badges (Top Reviewer, Vine Voice, etc.) |
| `variantPurchased` | object | Product variant (color, size, etc.) |
| `media` | array | Review photos/videos |
| `sellerResponse` | object|null | Seller's public response |
| `countryReviewed` | string | Country where review was written |
| `productTitle` | string | Product name |
| `productAvgRating` | number | Overall product rating |
| `productTotalReviews` | integer | Total review count |
| `productBrand` | string | Brand / manufacturer |
| `productPrice` | string | Price at scrape time |
| `productCategory` | string | Deepest category |
| `productBreadcrumbs` | array | Full category path |
| `ratingDistribution` | object | % per star rating (first review per ASIN) |
| `scrapedAt` | string | Scrape timestamp (ISO 8601) |

#### Output example

```json
{
  "reviewId": "R2EXAMPLE123ABC",
  "reviewUrl": "https://www.amazon.com/gp/customer-reviews/R2EXAMPLE123ABC",
  "asin": "B08N5WRWNW",
  "marketplace": "amazon.com",
  "rating": 1,
  "title": "Battery degraded after 3 months",
  "body": "The noise cancellation is great but the battery only lasts 4 hours after 90 days of use. Amazon refused to replace it. Very disappointing for this price.",
  "date": "2024-03-15",
  "verifiedPurchase": true,
  "helpfulVotes": 47,
  "reviewer": {
    "profileId": "AEXAMPLE123",
    "name": "John D.",
    "profileUrl": "https://www.amazon.com/gp/profile/AEXAMPLE123",
    "badges": ["Verified Purchase", "Top 500 Reviewer"]
  },
  "variantPurchased": { "Color": "Midnight Black" },
  "media": [
    {
      "type": "photo",
      "url": "https://m.media-amazon.com/images/I/example_full.jpg",
      "thumbnailUrl": "https://m.media-amazon.com/images/I/example_thumb.jpg"
    }
  ],
  "sellerResponse": {
    "text": "We're sorry to hear about your experience. Please contact our support team.",
    "date": "2024-03-18"
  },
  "countryReviewed": "the United States",
  "productTitle": "Sony WH-1000XM5 Wireless Noise Canceling Headphones",
  "productAvgRating": 4.4,
  "productTotalReviews": 28473,
  "productBrand": "Sony",
  "productPrice": "279.99",
  "productPriceCurrency": "$",
  "productCategory": "Headphones",
  "productBreadcrumbs": ["Electronics", "Headphones, Earbuds & Accessories", "Headphones", "Over-Ear Headphones"],
  "ratingDistribution": { "5star": 62, "4star": 14, "3star": 8, "2star": 5, "1star": 11 },
  "scrapedAt": "2024-06-01T12:00:00.000Z"
}
```

***

### Use cases

**Competitor product research** — Collect all 1-star and 2-star reviews for competitor ASINs. Identify recurring complaints to address in your own product positioning or development.

**Brand monitoring** — Track your product's reviews over time. Set up a regular scrape to detect spikes in negative reviews before they affect your rating.

**Launch validation** — Before releasing a product, scrape the top 3 competitors' verified reviews to understand what customers actually want vs. what the product delivers.

**Sentiment analysis pipelines** — Export thousands of reviews per ASIN to feed LLMs, NLP classifiers, or topic modeling tools.

**Review authenticity research** — Filter by `verifiedOnly: true` and compare volume vs. `verifiedOnly: false` to spot potential review manipulation patterns.

**Pricing intelligence** — Combine `productPrice` + `rating` + `reviewCount` across multiple ASINs to track pricing strategy and customer response over time.

**E-commerce due diligence** — Before partnering with a supplier, check their products' review patterns, seller response rate, and negative feedback themes.

***

### Supported marketplaces

| Marketplace | Domain |
|-------------|--------|
| United States | amazon.com |
| United Kingdom | amazon.co.uk |
| Germany | amazon.de |
| France | amazon.fr |
| Spain | amazon.es |
| Italy | amazon.it |
| Canada | amazon.ca |
| Japan | amazon.co.jp |
| Australia | amazon.com.au |
| India | amazon.in |
| Brazil | amazon.com.br |

***

### Authentication

Amazon may redirect to a login page for some product pages. To bypass this, provide your Amazon session cookies:

1. Open amazon.com in Chrome and log in
2. Open DevTools → Application → Cookies → amazon.com
3. Copy all cookies as a string and paste into `amazonCookies`

Use a secondary account if preferred.

***

### Limitations

- **Amazon blocks scrapers aggressively** — residential proxies (included) improve reliability
- **Review page access requires cookies** for some products — provide `amazonCookies` for reliable results
- **Product pages with no reviews** will produce 0 items
- **Historical reviews**: reviews may be removed by Amazon over time; results reflect the current state

***

### Support

Found a bug or have a question? Open a ticket in the **Issues tab** on the actor page. We monitor all issues and respond quickly.

# Actor input Schema

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

List of Amazon ASIN codes to scrape reviews for (e.g. \["B08N5WRWNW", "B0BX2K13KH"]).

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

Amazon marketplace to scrape reviews from.

## `maxReviewsPerAsin` (type: `integer`):

Maximum number of reviews to scrape per ASIN.

## `sortBy` (type: `string`):

Sort reviews by most recent or most helpful.

## `filterByRating` (type: `integer`):

Only scrape reviews of this star rating (1-5). Leave empty for all ratings.

## `verifiedOnly` (type: `boolean`):

Only scrape reviews marked as Verified Purchase.

## `mediaOnly` (type: `boolean`):

Only scrape reviews that include photos or videos.

## `since` (type: `string`):

Only collect reviews on or after this date (YYYY-MM-DD). Leave empty for no start date.

## `until` (type: `string`):

Only collect reviews on or before this date (YYYY-MM-DD). Leave empty for no end date.

## `includeSellerResponse` (type: `boolean`):

Extract seller/brand responses to reviews when available.

## `amazonCookies` (type: `string`):

Paste your Amazon session cookies to bypass login wall. In Chrome: DevTools → Network → any amazon.com request → Request Headers → Cookie. Key cookies: session-id, ubid-main, at-main, x-main.

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

Residential proxies strongly recommended to avoid Amazon blocking.

## Actor input object example

```json
{
  "asins": [
    "B08N5WRWNW"
  ],
  "marketplace": "amazon.com",
  "maxReviewsPerAsin": 500,
  "sortBy": "recent",
  "verifiedOnly": false,
  "mediaOnly": false,
  "includeSellerResponse": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Amazon reviews. Each item includes reviewId, asin, rating (1-5), title, body, date, verifiedPurchase, helpfulVotes, reviewer info, product metadata (title, brand, price, category, avgRating), and optional seller response.

# 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 = {
    "asins": [
        "B08N5WRWNW"
    ],
    "marketplace": "amazon.com",
    "maxReviewsPerAsin": 500,
    "sortBy": "recent",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("totaka/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 = {
    "asins": ["B08N5WRWNW"],
    "marketplace": "amazon.com",
    "maxReviewsPerAsin": 500,
    "sortBy": "recent",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("totaka/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 '{
  "asins": [
    "B08N5WRWNW"
  ],
  "marketplace": "amazon.com",
  "maxReviewsPerAsin": 500,
  "sortBy": "recent",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call totaka/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper — All Stars, Date Filter",
        "description": "Scrape unlimited Amazon product reviews by ASIN with filters for star rating, verified purchase, date range, and media. Includes product metadata. Supports 11 Amazon marketplaces.",
        "version": "1.0",
        "x-build-id": "ccxwMUG4RJ9tT2vao"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/totaka~amazon-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-totaka-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/totaka~amazon-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-totaka-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/totaka~amazon-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-totaka-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",
                "required": [
                    "asins"
                ],
                "properties": {
                    "asins": {
                        "title": "Amazon ASINs",
                        "type": "array",
                        "description": "List of Amazon ASIN codes to scrape reviews for (e.g. [\"B08N5WRWNW\", \"B0BX2K13KH\"]).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplace": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "amazon.com",
                            "amazon.co.uk",
                            "amazon.de",
                            "amazon.fr",
                            "amazon.es",
                            "amazon.it",
                            "amazon.ca",
                            "amazon.co.jp",
                            "amazon.com.au",
                            "amazon.in",
                            "amazon.com.br"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace to scrape reviews from."
                    },
                    "maxReviewsPerAsin": {
                        "title": "Max reviews per ASIN",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per ASIN."
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "recent",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Sort reviews by most recent or most helpful."
                    },
                    "filterByRating": {
                        "title": "Filter by star rating (1-5, empty = all)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only scrape reviews of this star rating (1-5). Leave empty for all ratings."
                    },
                    "verifiedOnly": {
                        "title": "Verified purchase only",
                        "type": "boolean",
                        "description": "Only scrape reviews marked as Verified Purchase.",
                        "default": false
                    },
                    "mediaOnly": {
                        "title": "Media reviews only",
                        "type": "boolean",
                        "description": "Only scrape reviews that include photos or videos.",
                        "default": false
                    },
                    "since": {
                        "title": "From date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only collect reviews on or after this date (YYYY-MM-DD). Leave empty for no start date."
                    },
                    "until": {
                        "title": "To date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only collect reviews on or before this date (YYYY-MM-DD). Leave empty for no end date."
                    },
                    "includeSellerResponse": {
                        "title": "Include seller responses",
                        "type": "boolean",
                        "description": "Extract seller/brand responses to reviews when available.",
                        "default": true
                    },
                    "amazonCookies": {
                        "title": "Amazon session cookies (optional but recommended)",
                        "type": "string",
                        "description": "Paste your Amazon session cookies to bypass login wall. In Chrome: DevTools → Network → any amazon.com request → Request Headers → Cookie. Key cookies: session-id, ubid-main, at-main, x-main."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies strongly recommended to avoid Amazon blocking."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
