# Amazon Reviews Scraper (`mighty_monk/amazon-reviews-scraper`) Actor

Scrape Amazon customer reviews by ASIN/URL: rating, title, body, author, date, verified purchase, helpful votes. VOC & complaint mining with rating filters, sort, pagination, residential proxy support.

- **URL**: https://apify.com/mighty\_monk/amazon-reviews-scraper.md
- **Developed by:** [Harsh](https://apify.com/mighty_monk) (community)
- **Categories:** E-commerce, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 review scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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/docs.md):

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

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

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

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

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

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

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

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

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


# README

### What does Amazon Reviews Scraper do?

**Amazon Reviews Scraper** extracts **customer reviews** from [Amazon](https://www.amazon.com) product pages by ASIN or product URL. It pulls star **rating**, review **title**, full **body** text, **author**, **date**, **verified purchase** flag, and **helpful votes** — ready for VOC research, complaint mining, and competitor analysis.

Run it on the **Apify platform** for API access, scheduling, integrations, residential proxy rotation, and monitoring — without managing servers.

Ideal for the classic DTC/FBA workflow: **top reviews → what people complain about**.

### Why use Amazon Reviews Scraper?

- **Voice of customer (VOC)** — Mine 1–2★ reviews to find product issues, packaging problems, and support gaps.
- **FBA / private label research** — Validate demand and risk before sourcing a product.
- **Ad creative mining** — Turn 5★ language into hooks; turn complaints into objection-handling copy.
- **Competitor intelligence** — Compare review themes across ASINs over time.
- **AI / LLM pipelines** — Structured JSON ready for clustering, sentiment, and topic models (ECOMMERCE + AI use cases).

### How to use Amazon Reviews Scraper

1. Open the Actor in [Apify Console](https://console.apify.com).
2. Paste one or more Amazon product URLs (or bare ASINs) into **Amazon product URLs**.
3. Set **Max reviews per product** (e.g. 50).
4. Optionally filter **Minimum / Maximum star rating** (e.g. max 2 for complaints only).
5. Choose **Sort reviews by**: `recent` (trends) or `helpful` (top complaints/praise).
6. Keep **Proxy configuration** on **RESIDENTIAL** (recommended — Amazon blocks most datacenter IPs).
7. Click **Start**. Download results as JSON, CSV, Excel, or HTML when the run finishes.

### Input

See the **Input** tab for the full form. Main fields:

| Field | Description | Default |
|-------|-------------|---------|
| `productUrls` | Product URLs, `/product-reviews/` URLs, or bare ASINs | required |
| `maxReviewsPerProduct` | Cap per ASIN (paginates ~10 reviews/page) | `50` |
| `minRating` / `maxRating` | Keep only reviews in this star range (1–5) | `1` / `5` |
| `sortBy` | `recent` or `helpful` | `recent` |
| `country` | Marketplace for bare ASINs (US, UK, DE, …) | `US` |
| `maxConcurrency` | Parallel requests (keep low: 1–2) | `2` |
| `requestDelayMs` | Polite delay + jitter before each request | `1500` |
| `proxyConfiguration` | Apify Proxy — **RESIDENTIAL recommended** | residential on |

Example input:

```json
{
    "productUrls": ["https://www.amazon.com/dp/B0BSHF7WHW"],
    "maxReviewsPerProduct": 20,
    "minRating": 1,
    "maxRating": 2,
    "sortBy": "helpful",
    "country": "US",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
````

### Output

Each dataset item is one review (or an error row if the page was blocked). You can download the dataset in **JSON, HTML, CSV, or Excel**.

```json
{
    "asin": "B0BSHF7WHW",
    "productTitle": "Example Product Title",
    "productUrl": "https://www.amazon.com/dp/B0BSHF7WHW",
    "reviewId": "R1EXAMPLE01",
    "rating": 1,
    "title": "Stopped working after two weeks",
    "body": "Unit died after 14 days. Customer service was no help.",
    "author": "AngryBuyer42",
    "date": "January 15, 2024",
    "verified": true,
    "helpfulVotes": 47,
    "country": "US",
    "page": 1,
    "scrapedAt": "2024-06-01T12:00:00.000Z",
    "error": null
}
```

Key-value store also includes:

- `REVIEWS.csv` — full CSV export
- `SUMMARY.md` — rating distribution + complaint sample
- `OUTPUT` — machine-readable run totals

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `asin` | string | Amazon ASIN |
| `productTitle` | string | Product title from reviews page |
| `productUrl` | string | Canonical `/dp/ASIN` URL |
| `reviewId` | string | Amazon review id (e.g. `R…`) |
| `rating` | number | Stars 1–5 |
| `title` | string | Review headline |
| `body` | string | Full review text |
| `author` | string | Reviewer name |
| `date` | string | Date as shown on Amazon |
| `verified` | boolean | Verified Purchase |
| `helpfulVotes` | integer | “People found this helpful” |
| `country` | string | Marketplace code |
| `page` | integer | Reviews page number |
| `scrapedAt` | string | ISO timestamp |
| `error` | string | null | Set when captcha/block/failure |

### How much does it cost to scrape Amazon reviews?

This Actor uses **pay-per-event** pricing:

- **$0.002 per review** (dataset item)
- Small **Actor start** fee per run

Example: 500 reviews ≈ **$1.00** in result charges (plus start fee and any proxy compute). Use `maxReviewsPerProduct` and rating filters to control cost.

**Residential proxy** usage is billed separately via Apify Proxy — required for reliable Amazon access.

### Tips for better results

- **Always use RESIDENTIAL proxies** on the platform. Datacenter IPs are frequently captcha’d.
- Keep **maxConcurrency** at 1–2 and **requestDelayMs** ≥ 1000–1500.
- For **complaint mining**, set `maxRating: 2` and `sortBy: "helpful"`.
- For **fresh VOC**, use `sortBy: "recent"`.
- Prefer product `/dp/ASIN` or bare ASINs; the Actor rewrites them to `/product-reviews/ASIN`.
- If you see captcha errors, lower concurrency, increase delay, and confirm residential proxy groups.

### FAQ, disclaimers, and support

**Is scraping Amazon legal?**\
Scraping publicly available data may be subject to Amazon’s Terms of Service and local law. Use this Actor responsibly, for legitimate research, and at your own risk. Do not overload Amazon’s servers.

**Why do I get captcha / robot check errors?**\
Amazon aggressively bot-checks. Use Apify **RESIDENTIAL** proxies, low concurrency, and retries. The Actor records a graceful error row instead of crashing.

**Does it work for non-US marketplaces?**\
Yes — set `country` or pass marketplace URLs (`amazon.co.uk`, `amazon.de`, etc.).

**Need a custom solution?**\
Open an issue on the Actor’s **Issues** tab or contact the developer for custom pipelines (e.g. multi-ASIN scheduling, NLP complaint clustering).

Built with Cheerio + Crawlee for fast HTTP scraping — no full browser required for reviews pages.

# Actor input Schema

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

Amazon product page URLs, product-reviews URLs, or bare ASINs (e.g. https://www.amazon.com/dp/B0XXXXXX or B0XXXXXX). ASINs are parsed from /dp/ASIN, /gp/product/ASIN, and /product-reviews/ASIN paths. Duplicates are removed by ASIN.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews to collect for each product (ASIN). Amazon typically shows ~10 reviews per page; the Actor paginates until this limit or no more reviews.

## `minRating` (type: `integer`):

Only include reviews with star rating greater than or equal to this value (1–5). Use maxRating=2 to focus on complaints.

## `maxRating` (type: `integer`):

Only include reviews with star rating less than or equal to this value (1–5). Set both min and max to 1 for 1-star-only complaint mining.

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

Amazon review sort order. "recent" = newest first (best for trend detection); "helpful" = most helpful first (best for top complaints and praise).

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

Default marketplace when a URL has no Amazon host (or when using bare ASINs). Country from the URL host always wins when present.

## `maxConcurrency` (type: `integer`):

Maximum parallel HTTP requests. Keep low (1–3) — Amazon aggressively blocks scrapers. Prefer 1–2 with residential proxies.

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed HTTP request before recording an error.

## `requestDelayMs` (type: `integer`):

Base delay before each request (with small random jitter). Helps avoid rate limits and captchas.

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

Apify Proxy settings. Strongly recommended — Amazon blocks most datacenter IPs. Prefer RESIDENTIAL groups for production (e.g. apifyProxyGroups: \["RESIDENTIAL"]).

## Actor input object example

```json
{
  "productUrls": [
    "https://www.amazon.com/dp/B0BSHF7WHW"
  ],
  "maxReviewsPerProduct": 50,
  "minRating": 1,
  "maxRating": 5,
  "sortBy": "recent",
  "country": "US",
  "maxConcurrency": 2,
  "maxRequestRetries": 3,
  "requestDelayMs": 1500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

## `csv` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "productUrls": [
        "https://www.amazon.com/dp/B0BSHF7WHW"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper",
        "description": "Scrape Amazon customer reviews by ASIN/URL: rating, title, body, author, date, verified purchase, helpful votes. VOC & complaint mining with rating filters, sort, pagination, residential proxy support.",
        "version": "1.0",
        "x-build-id": "6AC2wi2Bnm3FdfotN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mighty_monk~amazon-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mighty_monk-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/mighty_monk~amazon-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mighty_monk-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/mighty_monk~amazon-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mighty_monk-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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Amazon product URLs",
                        "type": "array",
                        "description": "Amazon product page URLs, product-reviews URLs, or bare ASINs (e.g. https://www.amazon.com/dp/B0XXXXXX or B0XXXXXX). ASINs are parsed from /dp/ASIN, /gp/product/ASIN, and /product-reviews/ASIN paths. Duplicates are removed by ASIN.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect for each product (ASIN). Amazon typically shows ~10 reviews per page; the Actor paginates until this limit or no more reviews.",
                        "default": 50
                    },
                    "minRating": {
                        "title": "Minimum star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include reviews with star rating greater than or equal to this value (1–5). Use maxRating=2 to focus on complaints.",
                        "default": 1
                    },
                    "maxRating": {
                        "title": "Maximum star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include reviews with star rating less than or equal to this value (1–5). Set both min and max to 1 for 1-star-only complaint mining.",
                        "default": 5
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "recent",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Amazon review sort order. \"recent\" = newest first (best for trend detection); \"helpful\" = most helpful first (best for top complaints and praise).",
                        "default": "recent"
                    },
                    "country": {
                        "title": "Amazon marketplace country",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "CA",
                            "JP",
                            "IN",
                            "AU",
                            "MX",
                            "BR",
                            "NL",
                            "SE",
                            "PL",
                            "SG",
                            "AE",
                            "SA",
                            "TR",
                            "EG"
                        ],
                        "type": "string",
                        "description": "Default marketplace when a URL has no Amazon host (or when using bare ASINs). Country from the URL host always wins when present.",
                        "default": "US"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum parallel HTTP requests. Keep low (1–3) — Amazon aggressively blocks scrapers. Prefer 1–2 with residential proxies.",
                        "default": 2
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failed HTTP request before recording an error.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Base delay before each request (with small random jitter). Helps avoid rate limits and captchas.",
                        "default": 1500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Strongly recommended — Amazon blocks most datacenter IPs. Prefer RESIDENTIAL groups for production (e.g. apifyProxyGroups: [\"RESIDENTIAL\"]).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
