# Amazon Product Scraper (`reefapi/amazon-product-scraper`) Actor

Scrape Amazon products as clean JSON — keyword search, full product detail, offers, related items, best sellers, new releases, today's deals, autocomplete and GTIN/UPC→ASIN, across 19 Amazon marketplaces. Get ASIN, title, brand, price, rating, reviews and images. No proxies, no CAPTCHAs, no login.

- **URL**: https://apify.com/reefapi/amazon-product-scraper.md
- **Developed by:** [ReefAPI](https://apify.com/reefapi) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.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 Product Scraper — Search, Product Data, Offers & Deals as JSON

> 📮 **Need help, hit a problem, want a new feature, or a field that's missing from the output?** Email **support@reefapi.com** or open an issue on the **Issues** tab of this Actor — we reply fast and take feature requests seriously.

Scrape **Amazon products** as clean, structured JSON across **19 marketplaces** (US, UK, DE, FR, IT, ES, JP, IN, CA, AU, MX, BR, TR, AE, NL, SE, PL, SG, SA). Keyword **search** with filters, full **product detail**, **offers / buy box**, **related products**, **best sellers**, **new releases**, **today's deals**, **search autocomplete** and **GTIN/UPC/EAN → ASIN**. Every product comes back with ASIN, title, price, rating, review count, images, features, variations and tech specs. **No proxies, no CAPTCHAs, no login** — just send a query or an ASIN and get the data.

### What is the Amazon Product Scraper?

The Amazon Product Scraper is a no-code **Amazon data API** that turns Amazon into a structured dataset across 19 country marketplaces. Instead of maintaining brittle scrapers or rotating proxies yourself, you send a keyword or an ASIN and get clean JSON: title, price and list price, rating and review count, images, bullet features, variations, tech specs and category. It covers the whole catalog surface — **search** with price/rating/deal filters, deep **product detail**, the **buy box and every offer**, **related products**, **best sellers**, **new releases**, **today's deals**, **autocomplete** suggestions and **barcode-to-ASIN** lookup. It's the tool you use to **scrape Amazon products** for price monitoring, product research, catalog enrichment and competitor tracking.

### What can this Amazon Product Scraper do?

- 🔎 **Search products** — keyword search with price range, min rating, deals-only, sort and paging.
- 📦 **Product detail** — full product: price, list price, rating, features, images, variations, tech specs, category.
- 🏷️ **Product offers** — the buy box and all seller offers (price, condition, ships-from) for an ASIN.
- 🔁 **Related products** — "compare with similar", "bought together" and related carousels.
- 🏆 **Best sellers / New releases** — top products in a category.
- 💥 **Today's deals** — the active deals feed.
- ⌨️ **Autocomplete** — Amazon search suggestions for a term.
- 🔗 **GTIN/UPC/EAN → ASIN** — resolve a barcode to its Amazon product.
- 🌍 **19 marketplaces** — one input field switches country, language and currency.

### What data can I extract?

`search` returns one record per product; `product/detail` returns a deep record. Key fields (from real output):

| Field | What it is |
|---|---|
| `asin` | Amazon product id (stable key) |
| `title` | Product title |
| `price` / `price_str` / `currency` | Numeric price + formatted string + currency |
| `list_price` | Strike-through / RRP price (detail) |
| `rating` | Average star rating |
| `rating_count` | Number of ratings |
| `image` / `images` | Main image (search) / full image set (detail) |
| `sponsored` | Whether the search result is an ad |
| `availability` | Stock status (detail) |
| `features` | Bullet-point feature list (detail) |
| `variations` | Size/color/style variants (detail) |
| `tech_specs` | Structured technical specification table (detail) |
| `categories` | Category / breadcrumb path (detail) |
| `compare_similar` | "Compare with similar items" data (detail) |
| `aplus` | A+ / enhanced brand content presence (detail) |

Search results also carry `pagination{page, has_more}` so you can walk multiple pages.

> Field availability can vary — Amazon hides price for some listings, and not every product has variations, A+ content or a list price. It also changes its layout frequently. Core fields (ASIN, title, rating, image) are present for real products.

### How do I scrape Amazon?

1. Open the Actor and go to the **Input** tab.
2. Pick an **Action** (Search products is the default) and a **Marketplace** (e.g. `com`, `co.uk`, `de`).
3. Enter a **Search query** (or an **ASIN** for detail/offers/related, a **Category** for best sellers, a **GTIN** for barcode lookup) and any filters (price, min rating, deals, sort, page).
4. Click **Start**, then download the results as **JSON, CSV or Excel** from the **Dataset** tab.

### Input

```json
{ "action": "search", "query": "wireless mouse", "marketplace": "com", "min_rating": 4, "price_max": 50 }
````

- `query` — for **search** / **autocomplete**.  `asin` — for **detail** / **offers** / **related**.
- `marketplace` — `com`, `co.uk`, `de`, `fr`, `it`, `es`, `co.jp`, `in`, `ca`, `com.au`, `com.mx`, `com.br`, `com.tr`, `ae`, `nl`, `se`, `pl`, `sg`, `sa`.
- `category` — for **best sellers** / **new releases** (e.g. `electronics`).  `gtin` — for **GTIN→ASIN**.
- `sort`, `price_min` / `price_max`, `min_rating`, `deals`, `page`, and more via `params`.

### Output

Real `search` response (trimmed to one representative product):

```json
{
  "asin": "B004YAVF8I",
  "title": "Logitech M185 Wireless Mouse, 2.4GHz with USB Mini Receiver, 12-Month Battery Life, 1000 DPI Optical Tracking, Ambidextrous — Swift Grey",
  "price": null,
  "currency": null,
  "rating": 4.5,
  "rating_count": 427,
  "image": "https://m.media-amazon.com/images/I/51WN5aXZWIL._AC_UY218_.jpg",
  "sponsored": false
}
```

Real `product/detail` response (trimmed):

```json
{
  "asin": "B004YAVF8I",
  "title": "Logitech M185 Wireless Mouse …",
  "price": 13.99,
  "price_str": "$13.99",
  "currency": "$",
  "list_price": 17.99,
  "rating": 4.5,
  "rating_count": 42718,
  "availability": "In Stock",
  "features": ["Compact Mouse: comfortable, contoured, ambidextrous…", "1-year battery life…"],
  "images": ["https://m.media-amazon.com/images/I/51WN5aXZWIL._AC_SL1500_.jpg", "…"],
  "categories": [ … ],
  "variations": [ … ],
  "tech_specs": { … },
  "compare_similar": [ … ]
}
```

### Use cases

- **Price monitoring & repricing** — track prices, list prices, offers and the buy box across marketplaces.
- **Product & market research** — search, best sellers, new releases and deals by category and country.
- **Catalog enrichment** — hydrate ASINs (or GTINs/UPCs) into full product records with specs and images.
- **Competitor & brand tracking** — ratings, review counts and pricing by brand over time.
- **Deal & arbitrage sourcing** — scan today's deals and offers for margin opportunities.
- **MAP / availability compliance** — watch stock status and seller offers on your own listings.

### FAQ

**Is there an official Amazon API?**
Amazon's official APIs (Product Advertising API, Selling Partner API) require an approved account, are tightly rate-limited and restrict what data you can pull. This Actor gives you public product data as clean JSON without an approval process — across 19 marketplaces.

**Why scrape Amazon?**
Amazon is the largest e-commerce catalog in the world. Its price, rating, offer and best-seller data drives repricing, product research, brand monitoring and sourcing decisions you can't make from the front end.

**How much does it cost?**
Billed on Apify's pay-per-result model, benchmarked to be competitive with other Amazon scrapers. See the **Pricing** section on this Actor's page for the current rate.

**Can I integrate it?**
Yes — run it from the Apify **API** or the **Python / Node.js clients**, and connect the output to **Make, Zapier, n8n, Google Sheets, webhooks** or your database via Apify integrations. Ideal for scheduled price/stock pulls.

**Is it legal to scrape Amazon?**
This Actor reads publicly available product pages (no login, no accounts). Collecting public product facts is generally lawful; you're responsible for how you use the data. This is not legal advice — consult a lawyer for your specific case.

***

Unofficial — not affiliated with Amazon. Public data only.

# Actor input Schema

## `action` (type: `string`):

What to run: search, product detail, offers, related items, best sellers, new releases, deals, autocomplete or GTIN→ASIN.

## `query` (type: `string`):

Product keywords — for Search / Autocomplete. e.g. 'wireless mouse'.

## `asin` (type: `string`):

Amazon product id — for Product detail / Offers / Related. e.g. B09B8V1LZ3.

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

Which Amazon site (sets language + currency). One of: com, co.uk, de, fr, it, es, co.jp, in, ca, com.au, com.mx, com.br, com.tr, ae, nl, se, pl, sg, sa.

## `category` (type: `string`):

Category slug for Best sellers / New releases (required for those). e.g. electronics, books, toys-and-games.

## `gtin` (type: `string`):

Barcode to resolve to an ASIN — for the 'GTIN→ASIN' action.

## `sort` (type: `string`):

Search result ordering.

## `price_min` (type: `integer`):

Minimum price (whole units of the marketplace currency).

## `price_max` (type: `integer`):

Maximum price (whole units of the marketplace currency).

## `min_rating` (type: `integer`):

Keep products rated this many stars and up (1-4, e.g. 4 = '4 stars & up').

## `deals` (type: `boolean`):

Restrict search to products with an active Amazon deal.

## `page` (type: `integer`):

Page number for search (1, 2, 3…).

## `params` (type: `object`):

Any extra parameters as key/value JSON (brand, prime, review filters, …). Merged into the request.

## Actor input object example

```json
{
  "action": "search",
  "query": "wireless mouse",
  "marketplace": "com",
  "sort": "relevanceblender",
  "deals": false
}
```

# Actor output Schema

## `products` (type: `string`):

The Amazon products scraped (one item per product / result).

# 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 = {
    "query": "wireless mouse"
};

// Run the Actor and wait for it to finish
const run = await client.actor("reefapi/amazon-product-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "query": "wireless mouse" }

# Run the Actor and wait for it to finish
run = client.actor("reefapi/amazon-product-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "wireless mouse"
}' |
apify call reefapi/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper",
        "description": "Scrape Amazon products as clean JSON — keyword search, full product detail, offers, related items, best sellers, new releases, today's deals, autocomplete and GTIN/UPC→ASIN, across 19 Amazon marketplaces. Get ASIN, title, brand, price, rating, reviews and images. No proxies, no CAPTCHAs, no login.",
        "version": "0.1",
        "x-build-id": "zwsHr5Y2QkUz0dakY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reefapi~amazon-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reefapi-amazon-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/reefapi~amazon-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reefapi-amazon-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/reefapi~amazon-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reefapi-amazon-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "search",
                            "product/detail",
                            "product/offers",
                            "product/related",
                            "bestsellers",
                            "new-releases",
                            "deals",
                            "autocomplete",
                            "gtin-to-asin"
                        ],
                        "type": "string",
                        "description": "What to run: search, product detail, offers, related items, best sellers, new releases, deals, autocomplete or GTIN→ASIN.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Product keywords — for Search / Autocomplete. e.g. 'wireless mouse'."
                    },
                    "asin": {
                        "title": "ASIN",
                        "type": "string",
                        "description": "Amazon product id — for Product detail / Offers / Related. e.g. B09B8V1LZ3."
                    },
                    "marketplace": {
                        "title": "Marketplace",
                        "enum": [
                            "com",
                            "co.uk",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "co.jp",
                            "in",
                            "ca",
                            "com.au",
                            "com.mx",
                            "com.br",
                            "com.tr",
                            "ae",
                            "nl",
                            "se",
                            "pl",
                            "sg",
                            "sa"
                        ],
                        "type": "string",
                        "description": "Which Amazon site (sets language + currency). One of: com, co.uk, de, fr, it, es, co.jp, in, ca, com.au, com.mx, com.br, com.tr, ae, nl, se, pl, sg, sa.",
                        "default": "com"
                    },
                    "category": {
                        "title": "Category (best sellers / new releases)",
                        "type": "string",
                        "description": "Category slug for Best sellers / New releases (required for those). e.g. electronics, books, toys-and-games."
                    },
                    "gtin": {
                        "title": "GTIN / UPC / EAN / ISBN",
                        "type": "string",
                        "description": "Barcode to resolve to an ASIN — for the 'GTIN→ASIN' action."
                    },
                    "sort": {
                        "title": "Sort (search)",
                        "enum": [
                            "relevanceblender",
                            "price-asc-rank",
                            "price-desc-rank",
                            "review-rank",
                            "date-desc-rank",
                            "exact-aware-popularity-rank"
                        ],
                        "type": "string",
                        "description": "Search result ordering.",
                        "default": "relevanceblender"
                    },
                    "price_min": {
                        "title": "Min price",
                        "type": "integer",
                        "description": "Minimum price (whole units of the marketplace currency)."
                    },
                    "price_max": {
                        "title": "Max price",
                        "type": "integer",
                        "description": "Maximum price (whole units of the marketplace currency)."
                    },
                    "min_rating": {
                        "title": "Min rating (search)",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Keep products rated this many stars and up (1-4, e.g. 4 = '4 stars & up')."
                    },
                    "deals": {
                        "title": "Deals only (search)",
                        "type": "boolean",
                        "description": "Restrict search to products with an active Amazon deal.",
                        "default": false
                    },
                    "page": {
                        "title": "Page",
                        "type": "integer",
                        "description": "Page number for search (1, 2, 3…)."
                    },
                    "params": {
                        "title": "Advanced parameters",
                        "type": "object",
                        "description": "Any extra parameters as key/value JSON (brand, prime, review filters, …). Merged into the request."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```