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

Scrape Amazon product data with ease 🛒📦 Extract titles, prices, ratings, reviews, ASINs, images, descriptions, seller details, and more from product pages. Perfect for ecommerce research, competitor tracking, price monitoring, and market analysis at scale 🚀

- **URL**: https://apify.com/scrapapi/amazon-product-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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

Amazon Product Scraper is a fast, reliable Amazon web scraping tool that extracts structured product data from category and product pages at scale. It solves the tedious task of collecting titles, prices, ratings, ASINs, images, and seller info by streaming clean JSON into your Apify dataset in real time — ideal for marketers, developers, data analysts, and researchers. With this amazon product data scraper and amazon competitor price scraper approach, you can monitor prices, track market shifts, and analyze catalogs with confidence.

### What data / output can you get?

Below are example fields the actor pushes to the Apify dataset (one record per product). Export your dataset in JSON, CSV, or Excel from the Apify platform.

| Data type | Description | Example value |
| --- | --- | --- |
| asin | Unique product identifier extracted from URL | B014EUQOGK |
| title | Product title from the product page | Logitech K400 Plus Wireless Touch TV Keyboard… |
| url | Canonical product URL | https://www.amazon.com/dp/B014EUQOGK |
| brand | Product brand extracted from byline/brand section | Logitech |
| price | Current price object with value and currency | {"value": 24.99, "currency": "$"} |
| listPrice | Strikethrough/reference price if present | {"value": 39.99, "currency": "$"} |
| inStock | Boolean flag indicating add-to-cart availability | true |
| inStockText | Availability message shown on page | In Stock |
| stars | Average star rating parsed from rating widgets | 4.4 |
| reviewsCount | Total customer review count (integer) | 38542 |
| breadCrumbs | Category path (joined by “ > ”) | Electronics > Keyboards > Wireless |
| thumbnailImage | Main product image URL | https://m.media-amazon.com/images/I/…._AC_UY218_.jpg |
| galleryThumbnails | Array of thumbnail image URLs | ["https://m.media-amazon.com/images/I/…SS40_.jpg"] |
| highResolutionImages | Derived high-res image URLs | ["https://m.media-amazon.com/images/I/…_SL1500_.jpg"] |
| reviewsLink | Link to all reviews (relative or absolute) | /product-reviews/B014EUQOGK?reviewerType=all_reviews |
| hasReviews | Whether the product has any reviews | true |
| answeredQuestions | Count of answered questions on the page | 57 |
| shippingPrice | Parsed shipping cost where present | {"value": 5.99, "currency": "$"} |
| delivery | Delivery estimate text (parsed date where present) | Friday, March 20 |
| fastestDelivery | Fastest delivery promise when shown | Thursday, March 19 |
| seller | Featured seller info (id, url, name, etc.) | {"id":"A1ABCDEF12","url":"https://www.amazon.com/sp?...","name":"Logitech Store","businessName":null,"phone":null,"address":null} |

Bonus fields include: starsBreakdown (per-star distribution), visitStoreLink, features (bullet points), productOverview (key–value specs), variantAsins, bestsellerRanks, isAmazonChoice, amazonChoiceText, monthlyPurchaseVolume, locationText, loadedCountryCode, categoryPageData (pageNumber, isSponsored, bestsellerBadge, productPosition), and more — all pushed as structured JSON that you can export with a click.

### Key features

- ⚡ Concurrent product scraping
  Uses maxConcurrentRequests to fetch multiple product pages in parallel for faster runs — ideal for amazon product listing scraper workflows.

- 🧠 Detailed product extraction
  Captures titles, brand, price/listPrice, ratings, reviewsCount, availability, images, breadcrumbs, seller details, and structured specs (productOverview). Perfect to scrape Amazon product details with a clean schema.

- 🌍 Smart proxy country selection
  Use proxyCountry to automatically align proxy geolocation with the Amazon domain (default: AUTO_SELECT_PROXY_COUNTRY) or opt out with NO_PROXY. Works great for region-specific amazon price monitoring scraper use cases.

- 🔐 Apify proxy configuration
  Configure proxyConfiguration with Apify Residential proxies for lower block rates. The actor negotiates a proxy URL and routes HTTP/HTTPS traffic accordingly.

- 🛡️ CAPTCHA handling (opt-in)
  useCaptchaSolver enables automatic CAPTCHA solving on amazon.com, with a documented caveat: some fields (attributes, manufacturer attributes, bestseller ranks) may be missing after a captcha is solved.

- 🏷️ Variant-aware options
  Control maxProductVariantsAsSeparateResults and scrapeProductVariantPrices to dig deeper into variations and pricing differences when needed for amazon product data extraction tool pipelines.

- 👤 Seller and offers controls
  Toggle scrapeSellers and limit maxOffers to balance data depth with speed and request volume — helpful when the amazon reviews scraper need is paired with basic seller analytics.

- 🧭 Location delivery settings
  Set countryCode and zipCode, and choose locationDeliverableRoutes to apply deliverability settings on specific routes (PRODUCT, SEARCH, OFFERS) for more relevant price/offer signals.

- 🧾 Real-time dataset streaming
  Results are pushed to the dataset as soon as each product is scraped (Actor.push_data), so you can monitor progress and start analyzing without waiting for the run to finish.

- 🛠️ Developer-friendly and production-ready
  Built on Apify infrastructure with robust request retries, headers, and threading. Ideal for integrating with APIs or python pipelines powering an amazon competitor price scraper.

### How to use Amazon Product Scraper - step by step

1. Create or log in to your Apify account.
2. Open the Amazon Product Scraper actor in the Apify Console.
3. Paste your category or product URLs into categoryOrProductUrls.
   - Example: https://www.amazon.com/s?k=keyboard or https://www.amazon.com/dp/B014EUQOGK
4. Set limits and scope.
   - maxItemsPerStartUrl to cap results per start URL.
   - maxSearchPagesPerStartUrl to restrict pagination depth for search/category pages.
5. Configure location and language (optional).
   - countryCode and zipCode for delivery context.
   - language to request a specific UI language supported by the given Amazon domain.
6. Configure proxy and concurrency.
   - proxyCountry or full proxyConfiguration. Use residential proxies for best reliability.
   - maxConcurrentRequests to control throughput.
7. Start the run.
   - The actor will fetch search/product pages and stream each scraped product to the dataset in real time. Watch logs for progress and completion (including totals and duration).
8. Export your results.
   - Download from the dataset in JSON, CSV, or Excel, or pull via the Apify API into your analytics stack.

Pro tip: For large-scale price tracking with this amazon price scraper tool, schedule runs on Apify and connect the dataset to your BI tool or data warehouse for continuous monitoring.

### Use cases

| Use case name | Description |
| --- | --- |
| E-commerce price monitoring | Track price, listPrice, and availability signals across categories to power a robust amazon price monitoring scraper. |
| Competitor assortment analysis | Scrape Amazon search results and product pages to benchmark brands, categories, and seller coverage using this amazon product listing scraper. |
| ASIN catalog building | Build an ASIN library with images, breadcrumbs, and structured specs for catalog enrichment in PIM/ERP systems using an amazon ASIN scraper workflow. |
| Market research & trend tracking | Aggregate ratings, reviewsCount, and bestseller badges to identify top performers with this amazon web scraping tool. |
| Seller intelligence (featured seller) | Extract the featured offer seller name/id/url per product to see who holds the Buy Box. |
| Variant & pricing analysis | Use variantAsins and optional variant price scraping to map variation-level pricing for an amazon competitor price scraper pipeline. |

### Why choose Amazon Product Scraper?

Purpose-built for precision, speed, and automation, this actor delivers reliable amazon product scraper software performance without the fragility of manual tools.

- ✅ Accurate, structured JSON
- 🌍 Geo-targeted results via proxyCountry and delivery location settings
- ⚡ Scalable concurrency with maxConcurrentRequests
- 🧩 Developer-friendly — integrates with Apify datasets and APIs
- 🔒 Ethical-by-design — scrapes publicly available product pages
- 💸 Cost-effective for recurring amazon price scraper tool workflows
- 🛠️ Production-grade reliability vs. brittle browser extensions

Bottom line: If you need a dependable amazon product data scraper for ongoing analysis, this actor gives you clean fields, controlled scope, and repeatable performance.

### Is it legal / ethical to use Amazon Product Scraper?

Yes — when done responsibly. This actor extracts publicly available product information from Amazon pages. Avoid collecting private or sensitive data and ensure you comply with Amazon’s terms and applicable regulations (e.g., GDPR, CCPA). Limit your use to legitimate purposes such as research, analytics, or price comparison, and consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

Example JSON input
```json
{
  "categoryOrProductUrls": [
    "https://www.amazon.com/s?k=keyboard",
    "https://www.amazon.com/dp/B014EUQOGK"
  ],
  "maxItemsPerStartUrl": 50,
  "maxSearchPagesPerStartUrl": 10,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "maxConcurrentRequests": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

Parameter reference

- categoryOrProductUrls (array) — Use a link to the Amazon category/product you want to scrape. Required: Yes. Default: none.
- maxItemsPerStartUrl (integer) — Maximum number of results to scrape per start URL. Required: No. Default: 100.
- language (string, nullable) — Language to use on Amazon (domain-dependent). Required: No. Default: null.
- proxyCountry (string) — Proxy country selection. Required: No. Default: AUTO\_SELECT\_PROXY\_COUNTRY.
- maxSearchPagesPerStartUrl (integer) — Maximum search pages per start URL. Required: No. Default: 9999.
- maxProductVariantsAsSeparateResults (integer) — Maximum product variants to output as separate results. Required: No. Default: none.
- maxOffers (integer) — Maximum number of offers to scrape per product. Required: No. Default: 0.
- scrapeSellers (boolean) — Extract further information about sellers of the product. Required: No. Default: false.
- ensureLoadedProductDescriptionFields (boolean) — Ensure seller-editable product description fields are loaded. Required: No. Default: false.
- useCaptchaSolver (boolean) — Automatically solve CAPTCHAs (see description caveats). Required: No. Default: false.
- scrapeProductVariantPrices (boolean) — Extract prices of different product variations. Required: No. Default: false.
- scrapeProductDetails (boolean) — If disabled, only quick info is extracted from category pages. Required: No. Default: true.
- maxConcurrentRequests (integer) — Number of concurrent product page requests. Required: No. Default: 10.
- countryCode (string, nullable) — Country code for delivery location. Required: No. Default: null.
- zipCode (string, nullable) — Zip code for delivery location. Required: No. Default: null.
- locationDeliverableRoutes (array) — Routes where delivery location settings are applied (PRODUCT, SEARCH, OFFERS). Required: No. Default: \["PRODUCT", "SEARCH", "OFFERS"].
- proxyConfiguration (object) — Apify proxy settings (use residential for best results). Required: No. Default: none (prefill: useApifyProxy true, group RESIDENTIAL).

Example dataset item (one product)

```json
{
  "title": "Logitech K400 Plus Wireless Touch TV Keyboard",
  "url": "https://www.amazon.com/dp/B014EUQOGK",
  "asin": "B014EUQOGK",
  "originalAsin": "B014EUQOGK",
  "price": { "value": 24.99, "currency": "$" },
  "inStock": true,
  "inStockText": "In Stock",
  "listPrice": { "value": 39.99, "currency": "$" },
  "brand": "Logitech",
  "author": null,
  "shippingPrice": { "value": 5.99, "currency": "$" },
  "stars": 4.4,
  "starsBreakdown": { "5star": 0.68, "4star": 0.20, "3star": 0.07, "2star": 0.03, "1star": 0.02 },
  "reviewsCount": 38542,
  "answeredQuestions": 57,
  "breadCrumbs": "Electronics > Keyboards > Wireless",
  "videosCount": 0,
  "visitStoreLink": { "text": "Visit the Logitech Store", "url": "https://www.amazon.com/stores/Logitech" },
  "thumbnailImage": "https://m.media-amazon.com/images/I/…._AC_UY218_.jpg",
  "galleryThumbnails": ["https://m.media-amazon.com/images/I/…SS40_.jpg"],
  "highResolutionImages": ["https://m.media-amazon.com/images/I/…_SL1500_.jpg"],
  "importantInformation": null,
  "sustainabilityFeatures": null,
  "description": "Compact keyboard with integrated touchpad designed for living room media control.",
  "features": ["Easy-access media keys", "10-meter wireless range"],
  "attributes": [],
  "productOverview": [
    { "key": "Brand", "value": "Logitech" },
    { "key": "Connectivity", "value": "Wireless" }
  ],
  "variantAsins": ["B014EUQOGK"],
  "variantDetails": [],
  "reviewsLink": "/product-reviews/B014EUQOGK?reviewerType=all_reviews",
  "hasReviews": true,
  "delivery": "Friday, March 20",
  "fastestDelivery": "Thursday, March 19",
  "returnPolicy": "Eligible for return, refund or replacement within 30 days of receipt.",
  "support": null,
  "variantAttributes": [],
  "manufacturerAttributes": [],
  "seller": {
    "id": "A1ABCDEF12",
    "url": "https://www.amazon.com/sp?seller=A1ABCDEF12",
    "name": "Logitech Store",
    "businessName": null,
    "phone": null,
    "address": null
  },
  "bestsellerRanks": [
    { "rank": 3, "category": "Computer Keyboards" }
  ],
  "isAmazonChoice": false,
  "amazonChoiceText": null,
  "bookDescription": null,
  "priceRange": null,
  "aPlusContent": null,
  "brandStory": null,
  "productComparison": null,
  "aiReviewsSummary": null,
  "monthlyPurchaseVolume": "3K bought in past month",
  "productPageReviews": [],
  "productPageReviewsFromOtherCountries": [],
  "locationText": "Deliver to New York 10001",
  "loadedCountryCode": "US",
  "offers": [],
  "unNormalizedProductUrl": "https://www.amazon.com/s?k=keyboard",
  "categoryPageData": {
    "pageNumber": 1,
    "saleSummary": null,
    "isSponsored": false,
    "bestsellerBadge": null,
    "productPosition": 1
  },
  "input": "https://www.amazon.com/s?k=keyboard"
}
```

Note: In addition to dataset items, the actor stores a run summary in the key-value store under the "OUTPUT" key with fields: status, scrapedAt, duration, stats, products, errors.

### FAQ

#### Does this actor scrape Amazon product pages and search results?

Yes. If you provide product URLs, it scrapes detailed product pages. If you provide category/search URLs, it finds product links and scrapes those, honoring maxItemsPerStartUrl and maxSearchPagesPerStartUrl.

#### Can it capture prices, ratings, and reviews?

Yes. It extracts price and listPrice when available, parses stars and reviewsCount, and includes a reviewsLink and hasReviews flag. It does not download full review texts by default (productPageReviews is included as an empty array in the output).

#### How does proxy configuration work?

By default you can use Apify Residential proxies via proxyConfiguration. The proxyCountry setting is AUTO\_SELECT\_PROXY\_COUNTRY unless you override it; set NO\_PROXY to disable proxies. The actor negotiates a proxy URL and uses it for HTTP/HTTPS requests.

#### Can I monitor competitor prices with this?

Yes. With structured price, listPrice, inStock, and delivery fields, it’s a solid base for an amazon competitor price scraper pipeline, especially when scheduled on Apify.

#### Does it support product variants and sellers?

Yes. The output includes variantAsins and a featured seller object (id, url, name, etc.). Optional inputs let you scrape sellers and variant prices more deeply when enabled.

#### How fast can it run?

You control throughput via maxConcurrentRequests (default 10, up to 20). Results are pushed to the dataset as each product finishes, enabling real-time monitoring.

#### Is CAPTCHA solving supported?

Yes, via useCaptchaSolver. This is optimized for the .com domain and may cause some fields (attributes, manufacturer attributes, bestseller ranks) to be unavailable after a solved CAPTCHA, as noted in the input description.

#### Can I localize pricing and availability?

Yes. Use countryCode and zipCode to set delivery location, and locationDeliverableRoutes to apply those settings to PRODUCT, SEARCH, and/or OFFERS pages for localized data.

### Final thoughts

Amazon Product Scraper is built to extract structured Amazon product data reliably at scale. With concurrent crawling, proxy country control, and clean JSON output, it equips marketers, developers, analysts, and researchers to automate catalog research, price tracking, and market analysis. Developers can integrate dataset exports or the key-value summary into pipelines and dashboards. Start extracting smarter product insights and power your next Amazon dataset today.

# Actor input Schema

## `categoryOrProductUrls` (type: `array`):

Use a link to the Amazon category you want to scrape, e.g. video games - https://www.amazon.com/s?bbn=16225016011\&rh=n%3A20972781011, https://www.amazon.com/dp/B0B3BVWJ6Y. You can also filter within the category with almost any filter available, i.e. price, manufacturer, rating, etc. By using a different URL you can also choose a different Amazon country, e.g. Germany: https://www.amazon.de/. You don't need to set a proxy country to do that.

## `maxItemsPerStartUrl` (type: `integer`):

Enter the maximum number of results you want to scrape per each start URL. This will let the scraper know when to stop.

## `language` (type: `string`):

Language to use on Amazon. Disclaimer: each Amazon domain has a different set of supported languages. If you choose a language that is not supported by the domain, the scraper will use the default language of the domain.

## `proxyCountry` (type: `string`):

You can set proxy country to avoid geo-blocking and access region-specific content. Amazon shows you the products that can be shipped to your address based on the proxy you use. By default, the scraper automatically selects the proxy country based on the used Amazon website domain, ensuring low blocking rates and results relevant to the base domain.

## `maxSearchPagesPerStartUrl` (type: `integer`):

Enter the maximum number of search pages to scrape for each start URL. E.g. only scrape the first 5 pages. This field can also be used with the maxItemsPerStartUrl option, the scraper will stop after either one of these limits is reached.

## `maxProductVariantsAsSeparateResults` (type: `integer`):

Enter the maximum number of product variants you want to scrape per each product, outputted as separate results. Please beware that you can already get most of the variant details changes, in the variantDetails field, which is outputted by default. Note that this will increase the number of requests and extend the scraping time.

## `maxOffers` (type: `integer`):

Enter the maximum number of offers you want to scrape per each product. This will let the scraper know when to stop. Note that this will increase the number of requests and extend the scraping time.

## `scrapeSellers` (type: `boolean`):

Enable this option to extract further information about sellers of the product. Scrapes the featured offer seller (main seller). This option goes hand in hand with the maxOffers option by scraping the seller of each offer. If you set maxOffers to 0, only the featured offer seller will be scraped. Note that this will increase the number of requests and extend the scraping time.

## `ensureLoadedProductDescriptionFields` (type: `boolean`):

Enable this feature to always load all seller-editable product description fields, such as description, aPlusContent, attributes, etc. Amazon sometimes hides these fields as a form of blocking. Enabling this option helps ensure data consistency but will increase the number of requests and may extend scraping time based on the blocking rate. Turn it on only if you need the data.

## `useCaptchaSolver` (type: `boolean`):

If enabled the scraper will automatically solve captchas thrown by Amazon. This will decrease the amount of request retries and increase the speed of the scraper. IMPORTANT - This option works well only for the '.com' Amazon domain, but even for that one Amazon doesn't show a few product fields after solving a captcha (specifically: 'attributes', 'manufacturer attributes', and 'bestseller ranks').

## `scrapeProductVariantPrices` (type: `boolean`):

Enable this option to extract prices of different variations of a product. Useful when you need prices for each variant. Note that this will increase the number of requests and extend the scraping time.

## `scrapeProductDetails` (type: `boolean`):

If enabled, the scraper will extract each found product from the category page in detail (this is the default behavior). If disabled, the scraper will only extract the quick product information from the category page. Useful for faster and more lightweight searches for products.

## `maxConcurrentRequests` (type: `integer`):

Number of concurrent product page requests.

## `countryCode` (type: `string`):

The country code to use as the delivery location.

## `zipCode` (type: `string`):

The zip code to use as the delivery location. This is useful for more precise location settings, especially in larger countries.

## `locationDeliverableRoutes` (type: `array`):

The list of routes/page types, for which the deliverable location settings should be applied. This is useful for speeding up the scraping process by not applying the location settings to all pages, for which you don't need the localized data for. For example, you can set it to \['SEARCH', 'PRODUCT'] to apply the location settings only to search and product pages. By default, all pages are included.

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

🔒 Apify proxy settings. Use residential proxy for best results and fewer blocks.

## Actor input object example

```json
{
  "categoryOrProductUrls": [
    "https://www.amazon.com/s?k=keyboard"
  ],
  "maxItemsPerStartUrl": 100,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "maxSearchPagesPerStartUrl": 9999,
  "maxOffers": 0,
  "scrapeSellers": false,
  "ensureLoadedProductDescriptionFields": false,
  "useCaptchaSolver": false,
  "scrapeProductVariantPrices": false,
  "scrapeProductDetails": true,
  "maxConcurrentRequests": 10,
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "categoryOrProductUrls": [
        "https://www.amazon.com/s?k=keyboard"
    ],
    "locationDeliverableRoutes": [
        "PRODUCT",
        "SEARCH",
        "OFFERS"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/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 = {
    "categoryOrProductUrls": ["https://www.amazon.com/s?k=keyboard"],
    "locationDeliverableRoutes": [
        "PRODUCT",
        "SEARCH",
        "OFFERS",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/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 '{
  "categoryOrProductUrls": [
    "https://www.amazon.com/s?k=keyboard"
  ],
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapapi/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper",
        "description": "Scrape Amazon product data with ease 🛒📦 Extract titles, prices, ratings, reviews, ASINs, images, descriptions, seller details, and more from product pages. Perfect for ecommerce research, competitor tracking, price monitoring, and market analysis at scale 🚀",
        "version": "0.1",
        "x-build-id": "58wfWF5dMKddA5Hqa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~amazon-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~amazon-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~amazon-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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",
                "required": [
                    "categoryOrProductUrls"
                ],
                "properties": {
                    "categoryOrProductUrls": {
                        "title": "🔗 Enter one or more Amazon category or product URLs",
                        "type": "array",
                        "description": "Use a link to the Amazon category you want to scrape, e.g. video games - https://www.amazon.com/s?bbn=16225016011&rh=n%3A20972781011, https://www.amazon.com/dp/B0B3BVWJ6Y. You can also filter within the category with almost any filter available, i.e. price, manufacturer, rating, etc. By using a different URL you can also choose a different Amazon country, e.g. Germany: https://www.amazon.de/. You don't need to set a proxy country to do that.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerStartUrl": {
                        "title": "📊 Max results (per start URL)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Enter the maximum number of results you want to scrape per each start URL. This will let the scraper know when to stop.",
                        "default": 100
                    },
                    "language": {
                        "title": "🌐 Language",
                        "enum": [
                            "cs",
                            "da",
                            "de",
                            "en",
                            "es",
                            "fr",
                            "nl",
                            "pl",
                            "pt",
                            "sv",
                            "tr",
                            "he",
                            "ar",
                            "mrta",
                            "hi",
                            "bn",
                            "ta",
                            "te",
                            "kn",
                            "ml",
                            "ko",
                            "zh_CN",
                            "zh_TW",
                            "ja"
                        ],
                        "type": "string",
                        "description": "Language to use on Amazon. Disclaimer: each Amazon domain has a different set of supported languages. If you choose a language that is not supported by the domain, the scraper will use the default language of the domain."
                    },
                    "proxyCountry": {
                        "title": "🌍 Proxy country",
                        "enum": [
                            "AUTO_SELECT_PROXY_COUNTRY",
                            "NO_PROXY",
                            "AF",
                            "AL",
                            "DZ",
                            "AS",
                            "AD",
                            "AO",
                            "AI",
                            "AQ",
                            "AG",
                            "AR",
                            "AM",
                            "AW",
                            "AU",
                            "AT",
                            "AZ",
                            "BS",
                            "BH",
                            "BD",
                            "BB",
                            "BY",
                            "BE",
                            "BZ",
                            "BJ",
                            "BM",
                            "BT",
                            "BO",
                            "BQ",
                            "BA",
                            "BW",
                            "BV",
                            "BR",
                            "IO",
                            "VG",
                            "BN",
                            "BG",
                            "BF",
                            "BI",
                            "KH",
                            "CM",
                            "CA",
                            "CV",
                            "KY",
                            "CF",
                            "TD",
                            "CL",
                            "CN",
                            "CX",
                            "CC",
                            "CO",
                            "KM",
                            "CK",
                            "CR",
                            "HR",
                            "CU",
                            "CW",
                            "CY",
                            "CZ",
                            "CD",
                            "DK",
                            "DJ",
                            "DM",
                            "DO",
                            "TL",
                            "EC",
                            "EG",
                            "SV",
                            "GQ",
                            "ER",
                            "EE",
                            "ET",
                            "FK",
                            "FO",
                            "FJ",
                            "FI",
                            "FR",
                            "GF",
                            "PF",
                            "TF",
                            "GA",
                            "GM",
                            "GE",
                            "DE",
                            "GH",
                            "GI",
                            "GR",
                            "GL",
                            "GD",
                            "GP",
                            "GU",
                            "GT",
                            "GG",
                            "GW",
                            "GN",
                            "GY",
                            "HT",
                            "HM",
                            "HN",
                            "HK",
                            "HU",
                            "IS",
                            "IN",
                            "ID",
                            "IR",
                            "IQ",
                            "IE",
                            "IM",
                            "IL",
                            "IT",
                            "CI",
                            "JM",
                            "JP",
                            "JE",
                            "JO",
                            "KZ",
                            "KE",
                            "KI",
                            "XK",
                            "KW",
                            "KG",
                            "LA",
                            "LV",
                            "LB",
                            "LS",
                            "LR",
                            "LY",
                            "LI",
                            "LT",
                            "LU",
                            "MO",
                            "MG",
                            "MW",
                            "MY",
                            "MV",
                            "ML",
                            "MT",
                            "MH",
                            "MQ",
                            "MR",
                            "MU",
                            "YT",
                            "MX",
                            "FM",
                            "MD",
                            "MC",
                            "MN",
                            "ME",
                            "MS",
                            "MA",
                            "MZ",
                            "MM",
                            "NA",
                            "NR",
                            "NP",
                            "NL",
                            "NC",
                            "NZ",
                            "NI",
                            "NE",
                            "NG",
                            "NU",
                            "NF",
                            "KP",
                            "MK",
                            "MP",
                            "NO",
                            "OM",
                            "PK",
                            "PW",
                            "PS",
                            "PA",
                            "PG",
                            "PY",
                            "PE",
                            "PH",
                            "PN",
                            "PL",
                            "PT",
                            "PR",
                            "QA",
                            "CG",
                            "RE",
                            "RO",
                            "RU",
                            "RW",
                            "BL",
                            "SH",
                            "KN",
                            "LC",
                            "MF",
                            "PM",
                            "VC",
                            "WS",
                            "SM",
                            "ST",
                            "SA",
                            "SN",
                            "RS",
                            "SC",
                            "SL",
                            "SG",
                            "SX",
                            "SK",
                            "SI",
                            "SB",
                            "SO",
                            "ZA",
                            "GS",
                            "KR",
                            "SS",
                            "ES",
                            "LK",
                            "SD",
                            "SR",
                            "SJ",
                            "SZ",
                            "SE",
                            "CH",
                            "SY",
                            "TW",
                            "TJ",
                            "TZ",
                            "TH",
                            "TG",
                            "TK",
                            "TO",
                            "TT",
                            "TN",
                            "TR",
                            "TM",
                            "TC",
                            "TV",
                            "UM",
                            "VI",
                            "UG",
                            "UA",
                            "AE",
                            "GB",
                            "US",
                            "UY",
                            "UZ",
                            "VU",
                            "VA",
                            "VE",
                            "VN",
                            "WF",
                            "EH",
                            "YE",
                            "ZM",
                            "ZW",
                            "AX"
                        ],
                        "type": "string",
                        "description": "You can set proxy country to avoid geo-blocking and access region-specific content. Amazon shows you the products that can be shipped to your address based on the proxy you use. By default, the scraper automatically selects the proxy country based on the used Amazon website domain, ensuring low blocking rates and results relevant to the base domain.",
                        "default": "AUTO_SELECT_PROXY_COUNTRY"
                    },
                    "maxSearchPagesPerStartUrl": {
                        "title": "📄 Maximum search pages (per start URL)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Enter the maximum number of search pages to scrape for each start URL. E.g. only scrape the first 5 pages. This field can also be used with the maxItemsPerStartUrl option, the scraper will stop after either one of these limits is reached.",
                        "default": 9999
                    },
                    "maxProductVariantsAsSeparateResults": {
                        "title": "🔄 Maximum product variants (as separate results)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Enter the maximum number of product variants you want to scrape per each product, outputted as separate results. Please beware that you can already get most of the variant details changes, in the variantDetails field, which is outputted by default. Note that this will increase the number of requests and extend the scraping time."
                    },
                    "maxOffers": {
                        "title": "💰 Maximum scraped offers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Enter the maximum number of offers you want to scrape per each product. This will let the scraper know when to stop. Note that this will increase the number of requests and extend the scraping time.",
                        "default": 0
                    },
                    "scrapeSellers": {
                        "title": "👤 Scrape sellers",
                        "type": "boolean",
                        "description": "Enable this option to extract further information about sellers of the product. Scrapes the featured offer seller (main seller). This option goes hand in hand with the maxOffers option by scraping the seller of each offer. If you set maxOffers to 0, only the featured offer seller will be scraped. Note that this will increase the number of requests and extend the scraping time.",
                        "default": false
                    },
                    "ensureLoadedProductDescriptionFields": {
                        "title": "📝 Ensure loaded product description fields",
                        "type": "boolean",
                        "description": "Enable this feature to always load all seller-editable product description fields, such as description, aPlusContent, attributes, etc. Amazon sometimes hides these fields as a form of blocking. Enabling this option helps ensure data consistency but will increase the number of requests and may extend scraping time based on the blocking rate. Turn it on only if you need the data.",
                        "default": false
                    },
                    "useCaptchaSolver": {
                        "title": "🤖 Use Captcha solver (warning: see description)",
                        "type": "boolean",
                        "description": "If enabled the scraper will automatically solve captchas thrown by Amazon. This will decrease the amount of request retries and increase the speed of the scraper. IMPORTANT - This option works well only for the '.com' Amazon domain, but even for that one Amazon doesn't show a few product fields after solving a captcha (specifically: 'attributes', 'manufacturer attributes', and 'bestseller ranks').",
                        "default": false
                    },
                    "scrapeProductVariantPrices": {
                        "title": "💵 Scrape product variant prices",
                        "type": "boolean",
                        "description": "Enable this option to extract prices of different variations of a product. Useful when you need prices for each variant. Note that this will increase the number of requests and extend the scraping time.",
                        "default": false
                    },
                    "scrapeProductDetails": {
                        "title": "📦 Scrape product details",
                        "type": "boolean",
                        "description": "If enabled, the scraper will extract each found product from the category page in detail (this is the default behavior). If disabled, the scraper will only extract the quick product information from the category page. Useful for faster and more lightweight searches for products.",
                        "default": true
                    },
                    "maxConcurrentRequests": {
                        "title": "⚡ Maximum concurrent requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of concurrent product page requests.",
                        "default": 10
                    },
                    "countryCode": {
                        "title": "🏳️ Country code",
                        "enum": [
                            "AF",
                            "AX",
                            "AL",
                            "DZ",
                            "AS",
                            "AD",
                            "AO",
                            "AI",
                            "AG",
                            "AR",
                            "AM",
                            "AW",
                            "AU",
                            "AT",
                            "AZ",
                            "BS",
                            "BH",
                            "BD",
                            "BB",
                            "BY",
                            "BE",
                            "BZ",
                            "BJ",
                            "BM",
                            "BT",
                            "BO",
                            "BQ",
                            "BA",
                            "BW",
                            "BV",
                            "BR",
                            "IO",
                            "BN",
                            "BG",
                            "BF",
                            "BI",
                            "KH",
                            "CM",
                            "CA",
                            "CV",
                            "KY",
                            "CF",
                            "TD",
                            "CL",
                            "CN",
                            "CX",
                            "CC",
                            "CO",
                            "KM",
                            "CD",
                            "CG",
                            "CK",
                            "CR",
                            "CI",
                            "HR",
                            "CW",
                            "CY",
                            "CZ",
                            "DK",
                            "DJ",
                            "DM",
                            "DO",
                            "EC",
                            "EG",
                            "SV",
                            "GQ",
                            "ER",
                            "EE",
                            "ET",
                            "FK",
                            "FO",
                            "FJ",
                            "FI",
                            "FR",
                            "GF",
                            "PF",
                            "TF",
                            "GA",
                            "GM",
                            "GE",
                            "DE",
                            "GH",
                            "GI",
                            "GR",
                            "GL",
                            "GD",
                            "GP",
                            "GT",
                            "GG",
                            "GW",
                            "GN",
                            "GY",
                            "HT",
                            "HM",
                            "VA",
                            "HN",
                            "HK",
                            "HU",
                            "IS",
                            "IN",
                            "ID",
                            "IQ",
                            "IE",
                            "IM",
                            "IL",
                            "IT",
                            "JM",
                            "JP",
                            "JE",
                            "JO",
                            "KZ",
                            "KE",
                            "KI",
                            "XK",
                            "KW",
                            "KG",
                            "LA",
                            "LV",
                            "LB",
                            "LS",
                            "LR",
                            "LY",
                            "LI",
                            "LT",
                            "LU",
                            "MO",
                            "MK",
                            "MG",
                            "MW",
                            "MY",
                            "MV",
                            "ML",
                            "MT",
                            "MH",
                            "MQ",
                            "MR",
                            "MU",
                            "YT",
                            "MX",
                            "FM",
                            "MD",
                            "MC",
                            "MN",
                            "ME",
                            "MS",
                            "MA",
                            "MZ",
                            "MM",
                            "NA",
                            "NR",
                            "NP",
                            "AN",
                            "NL",
                            "NC",
                            "NZ",
                            "NI",
                            "NE",
                            "NG",
                            "NU",
                            "NF",
                            "NO",
                            "OM",
                            "PK",
                            "PW",
                            "PS",
                            "PA",
                            "PG",
                            "PY",
                            "PE",
                            "PH",
                            "PN",
                            "PL",
                            "PT",
                            "QA",
                            "KR",
                            "RE",
                            "RO",
                            "RU",
                            "RW",
                            "BL",
                            "SH",
                            "KN",
                            "LC",
                            "MF",
                            "PM",
                            "VC",
                            "WS",
                            "SM",
                            "ST",
                            "SA",
                            "SN",
                            "RS",
                            "SC",
                            "SL",
                            "SG",
                            "SX",
                            "SK",
                            "SI",
                            "SB",
                            "SO",
                            "ZA",
                            "GS",
                            "ES",
                            "LK",
                            "SR",
                            "SJ",
                            "SZ",
                            "SE",
                            "CH",
                            "TW",
                            "TJ",
                            "TZ",
                            "TH",
                            "TL",
                            "TG",
                            "TK",
                            "TO",
                            "TT",
                            "TN",
                            "TR",
                            "TM",
                            "TC",
                            "TV",
                            "UG",
                            "UA",
                            "AE",
                            "GB",
                            "UM",
                            "US",
                            "UY",
                            "UZ",
                            "VU",
                            "VE",
                            "VN",
                            "VG",
                            "WF",
                            "EH",
                            "YE",
                            "ZM",
                            "ZW"
                        ],
                        "type": "string",
                        "description": "The country code to use as the delivery location."
                    },
                    "zipCode": {
                        "title": "📮 Zip code",
                        "type": "string",
                        "description": "The zip code to use as the delivery location. This is useful for more precise location settings, especially in larger countries."
                    },
                    "locationDeliverableRoutes": {
                        "title": "🛣️ Location deliverable routes",
                        "type": "array",
                        "description": "The list of routes/page types, for which the deliverable location settings should be applied. This is useful for speeding up the scraping process by not applying the location settings to all pages, for which you don't need the localized data for. For example, you can set it to ['SEARCH', 'PRODUCT'] to apply the location settings only to search and product pages. By default, all pages are included.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PRODUCT",
                                "SEARCH",
                                "OFFERS"
                            ]
                        },
                        "default": [
                            "PRODUCT",
                            "SEARCH",
                            "OFFERS"
                        ]
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy configuration",
                        "type": "object",
                        "description": "🔒 Apify proxy settings. Use residential proxy for best results and fewer blocks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
