# Amazon Product Data Scraper (`delicious_zebu/amazon-product-data-scraper`) Actor

Scrape detailed Amazon product data, including ratings, prices, availability, and reviews, from any custom list or keyword search. Fast, precise, and tailored for your needs!

- **URL**: https://apify.com/delicious\_zebu/amazon-product-data-scraper.md
- **Developed by:** [ВAH](https://apify.com/delicious_zebu) (community)
- **Categories:** E-commerce, SEO tools, Lead generation
- **Stats:** 205 total users, 16 monthly users, 100.0% runs succeeded, 43 bookmarks
- **User rating**: 4.89 out of 5 stars

## Pricing

$1.50 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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 Data Scraper – Keyword & Category Product Crawler

Effortlessly scrape **structured Amazon product data** from **search keywords** or **filtered category/listing URLs**.
Perfect for **market research, price monitoring, competitor analysis, SEO content, and e‑commerce automation**.

---

### 🔍 What This Actor Does

This Actor automatically visits Amazon search or category listing pages and extracts **clean, structured product data** into a downloadable dataset (JSON, CSV, Excel via Apify).

You can:

- Search by **keywords** (e.g. `mechanical keyboard`, `ipad`, `gaming mouse`)
- Paste **any filtered Amazon list / search URL** (price, brand, rating, Prime only, etc.)
- Control how deep to crawl with **max pages per keyword/URL**

---

### 🌟 Key Features

- **Two powerful input modes**
  - **Search by keyword**: Let the Actor search Amazon for each term you provide.
  - **Scrape filtered URLs**: Paste full Amazon search or category URLs with your own filters already applied.
- **Rich product data**
  - ASIN, product URL, title, brand
  - Price & list price
  - Rating stars, rating count, rating distribution
  - Availability & recent purchases
  - Default variant (size/color), model number, manufacturer
  - Best Sellers Rank, breadcrumbs (category path)
  - Seller name & seller page URL
  - Images (array of URLs)
  - Customer review summary, about item, basic description (when available)
  - Scrape timestamp
- **Fast & scalable**
  - Designed for **high‑volume product collection**
- **Clean, analysis‑ready output**
  - Ideal for **BI tools, spreadsheets, data warehouses, and ML pipelines**
- **No Amazon API key needed**
  - Works directly on the Amazon website pages you already use in your browser

---

### 📥 Input Parameters

This Actor has a simple, flexible input schema:

#### `Urls` – Filtered List Page URLs (optional)

- **Type**: Array of strings (URLs)
- **Description**:
  Paste **full Amazon search or category URLs**.
  You can first:
  - Apply filters in your browser (price range, brand, ratings, Prime, delivery, etc.)
  - Copy the resulting URL from your address bar
  - Paste it here and the Actor will scrape all products listed on those pages
- **Example**:
  `https://www.amazon.com/s?k=gravastar+keyboard+crystal`

Use this when you already know the **exact filtered result set** you want.

---

#### `Keywords` – Search Keywords (optional)

- **Type**: Array of strings
- **Description**:
  Provide a list of search terms and let the Actor perform **fresh Amazon searches** for each.
- **Examples**:
  - `["mechanical keyboard", "gaming keyboard", "60% keyboard"]`
  - `["ipad 10th generation case", "usb-c hub"]`

Use this when you want to **discover products** in a category or niche without building URLs manually.

---

#### `maxCrawlPages` – Max Pages per URL / Keyword

- **Type**: Integer
- **Default**: `20`
- **Description**:
  - Controls how many result pages to crawl **for each keyword or URL**
  - One Amazon page typically yields **20–30 products**
  - Lower values = **faster runs & lower cost**
  - Maximum allowed is **200**

**Tip**:

- For quick tests, set `maxCrawlPages = 1–3`
- For production / full coverage, increase to match the number of pages in your target search/category

---

### 📤 Example Output

Here’s a **single product** example from the dataset:

```json
{
    "asin": "B0DFXWGJ6J",
    "product_url": "https://www.amazon.com/dp/B0DFXWGJ6J",
    "title": "GravaStar Mercury K1 75% Wireless Mechanical Gaming Keyboard, Aluminum Alloy Exoskeleton Design, Gasket Custom Keyboard Hot-Swap Socket, Linear Switches, RGB Backlit",
    "brand_name": "GravaStar Store",
    "rating_stars": "4.8",
    "rating_count": "679",
    "rating_distribution": {
        "5star": "89%",
        "4star": "6%",
        "3star": "1%",
        "2star": "1%",
        "1star": "3%"
    },
    "price": "$129.95",
    "list_price": "List Price: $139.95",
    "default_variant": [
        "style:Classic1",
        "color:Gradient White"
    ],
    "recent_purchases": "500+ bought",
    "availability": "Only 3 left in stock - order soon.",
    "about_item": "Futuristic Design: The Mercury K1 features a unique aluminum alloy exoskeleton with a gradient black finish, combining strength and lightness in its flowing curves. This design provides symmetrical stability, ideal for both intense gaming and comfortable typing.   Custom GravaStar x Kailh Linear Switches: Equipped with exclusive GravaStar x Kailh linear switches, the K1 offers a smooth and responsive typing experience. With a 40gf actuation force, 1.5mm pre-travel, and 3.5mm total travel distance, these switches ensure quick reactions while minimizing accidental key presses.   Gasket-Mounted Design with Sound Dampening: The keyboard's gasket-mounted structure, combined with a flexible polycarbonate plate, absorbs impact vibrations and softens each keystroke. Five layers of sound-dampening foam enhance acoustics and reduce noise, providing a comfortable typing experience during extended sessions.   Tri-Mode Connectivity: The Mercury K1 supports wired USB-C, Bluetooth 5.0, and 2.4GHz wireless connections, allowing seamless switching between devices. Its compatibility with both Windows and Mac systems ensures versatility for various setups.   Customizable RGB Lighting and Software Personalization: Featuring dual independent RGB lighting systems with 16.8 million colors, the K1 offers 13 customizable backlight modes. Users can personalize their keyboard's appearance and functions through dedicated software, tailoring the experience to match their style and gaming setup.",
    "delivery_date": "January 2 - 4",
    "fastest_delivery_date": "Friday, January 2",
    "product_description": "The Mercury K1 is about balance in all things, weaving strength and lightness into each curve of its aluminum alloy exoskeleton. The flowing metal frame stands strong under every keystroke, providing a symmetrical stability that is perfectly positioned for intense gaming and comfortable typing.",
    "customer_review_summary": "Customers find this keyboard well-crafted with smooth, creamy keys that sound and feel amazing. They appreciate its sleek design, bright RGB lighting, and solid build quality, with one customer noting the space bar isn't wobbly at all. Customers consider it worth the price, though opinions about functionality are mixed.",
    "best_sellers_rank": "#669 in Video Games (See Top 100 in Video Games)  #49 in PC Gaming Keyboards",
    "brand_page_url": "https://www.amazon.com/stores/GravaStar/page/E5DF00BB-1FE1-4198-BF2B-DF11DC783A64?lp_asin=B0DFXWGJ6J&ref_=ast_bln&store_ref=bl_ast_dp_brandLogo_sto",
    "model_number": "GS K1",
    "manufacturer": "",
    "breadcrumbs": "Video Games › PC › Accessories › Gaming Keyboards",
    "seller_name": "GravaStar Flagship",
    "seller_page_url": "https://www.amazon.com/gp/help/seller/at-a-glance.html/ref=dp_merchant_link?ie=UTF8&seller=ALHCARJOK5YNC&asin=B0DFXWGJ6J&ref_=dp_merchant_link&isAmazonFulfilled=1",
    "images": [
        "https://m.media-amazon.com/images/I/41ESwL3V3KL.jpg",
        "https://m.media-amazon.com/images/I/41rc2TT9NvL.jpg",
        "https://m.media-amazon.com/images/I/41aqnkfNtqL.jpg",
        "https://m.media-amazon.com/images/I/31ely5WtoHL.jpg",
        "https://m.media-amazon.com/images/I/41H5ZI22YZL.jpg",
        "https://m.media-amazon.com/images/I/418lVFvq1+L.jpg",
        "https://m.media-amazon.com/images/I/61HuHPJgrxL.SS40_BG85,85,85_BR-120_PKdp-play-icon-overlay__.jpg"
    ],
    "scrape_time": "2025-12-28 11:36"
}
````

You’ll get **one such JSON object per product**, which you can export to CSV, Excel, or connect to other systems using Apify integrations.

***

### 🚀 Quick Start

1. **Open the Actor** on Apify (`Amazon Product Data Scraper`).
2. In **Input**:
   - Option A: Fill `Keywords` with terms like `["gaming keyboard", "mechanical keyboard"]`, and/or
   - Option B: Fill `Urls` with filtered Amazon search or category URLs.
   - Optionally adjust `maxCrawlPages`.
3. **Click “Run”** and wait for the Actor to finish.
4. Go to the **Dataset** tab to:
   - Preview data
   - Download as JSON, CSV, or Excel
   - Use Apify integrations (Zapier, Make, webhooks, API) to send data wherever you need it

***

### 📊 Popular Use Cases

- **Market & Category Research**
  - Map out entire niches and subcategories
  - Analyze price ranges, review volumes, and star ratings
- **Competitor & Product Monitoring**
  - Track trending products and top‑ranked ASINs
  - Monitor changes in pricing, availability, and Best Sellers Rank
- **SEO & Content Creation**
  - Generate product comparison tables
  - Enrich blog posts and buying guides with real product data
- **E‑commerce & Dropshipping**
  - Discover winning products
  - Export structured data to build internal tools or dashboards
- **Data Science & Analytics**
  - Feed clean Amazon product data into BI tools and ML models

***

### 💡 Tips for Best Results

- Start with **a small test run**:
  - 1–2 keywords or URLs
  - `maxCrawlPages = 1–3`
- Then gradually scale up when you’re happy with:
  - Fields returned
  - Data volume per run
  - Usage cost per 1,000 products
- Combine with other Apify Actors to:
  - Scrape **reviews** for selected ASINs
  - Enrich your database with **deep product details**

***

### 🔗 Related Actors

If you need more specialized Amazon data:

1. [Amazon Product Details Scraper](https://apify.com/delicious_zebu/amazon-product-details-scraper)
   Extract **detailed product information** from Amazon using ASINs or product URLs. Perfect for building product catalogs and doing deep product analysis.
2. [Amazon Reviews Scraper with Advanced Filters](https://apify.com/delicious_zebu/amazon-reviews-scraper-with-advanced-filters)
   Collect up to **10,000+ reviews per ASIN** with filters by rating, verified purchase, reviews with media, and more—ideal for **sentiment analysis & customer feedback mining**.

***

### 💬 Support & Customization

- If you encounter any issues or need **custom fields / logic**, feel free to:
  - Reach out via **Apify support**
  - Leave feedback directly on the Actor page

I actively maintain and improve this Actor based on real‑world use cases and user feedback.

***

### 🔖 Tags

`Amazon Scraper` · `Amazon Product Scraper` · `Amazon Product Data` · `Amazon Price Tracker` · `E-commerce` · `Market Research` · `Competitor Analysis` · `Product Catalog` · `SEO Tools` · `Data Extraction` · `Web Scraping`

# Actor input Schema

## `Urls` (type: `array`):

Enter the full URLs of Amazon search result pages or category listing pages. You can apply filters (price, brand, rating) in your browser first, then paste the URL here to scrape specific segments. The scraper will extract details for all products listed on these pages.

## `Keywords` (type: `array`):

A list of terms you want to search for on Amazon (e.g., 'mechanical keyboard'). The Actor will perform a fresh search for each keyword. This is the easiest way to discover new products in a specific category.

## `maxCrawlPages` (type: `integer`):

Sets the depth of the scrape per URL or keyword. One page typically yields 20-30 products. Lowering this value will make the run faster and reduce usage costs. Maximum allowed is 200 pages.

## Actor input object example

```json
{
  "Urls": [
    "https://www.amazon.com/s?i=videogames&rh=n%3A468642%2Cp_123%3A358345&dc=&qid=1732861025&rnid=386453011&ref=sr_nr_p_36_0_0&low-price=&high-price=480"
  ],
  "Keywords": [
    "ipad",
    "gaming keyboard"
  ],
  "maxCrawlPages": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Table view of reviews using the 'overview' view from dataset\_schema.json.

## `rawResults` (type: `string`):

All review items from the default dataset without a specific view.

# 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 = {
    "Urls": [
        "https://www.amazon.com/s?k=gravastar+keyboard+crystal"
    ],
    "Keywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("delicious_zebu/amazon-product-data-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 = {
    "Urls": ["https://www.amazon.com/s?k=gravastar+keyboard+crystal"],
    "Keywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("delicious_zebu/amazon-product-data-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 '{
  "Urls": [
    "https://www.amazon.com/s?k=gravastar+keyboard+crystal"
  ],
  "Keywords": []
}' |
apify call delicious_zebu/amazon-product-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Data Scraper",
        "description": "Scrape detailed Amazon product data, including ratings, prices, availability, and reviews, from any custom list or keyword search. Fast, precise, and tailored for your needs!",
        "version": "0.0",
        "x-build-id": "156NOXsYCjowPu8Hq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/delicious_zebu~amazon-product-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-delicious_zebu-amazon-product-data-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/delicious_zebu~amazon-product-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-delicious_zebu-amazon-product-data-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/delicious_zebu~amazon-product-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-delicious_zebu-amazon-product-data-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": {
                    "Urls": {
                        "title": "Filtered List Page URLs",
                        "uniqueItems": false,
                        "type": "array",
                        "description": "Enter the full URLs of Amazon search result pages or category listing pages. You can apply filters (price, brand, rating) in your browser first, then paste the URL here to scrape specific segments. The scraper will extract details for all products listed on these pages.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "Keywords": {
                        "title": "Search Keywords",
                        "uniqueItems": false,
                        "type": "array",
                        "description": "A list of terms you want to search for on Amazon (e.g., 'mechanical keyboard'). The Actor will perform a fresh search for each keyword. This is the easiest way to discover new products in a specific category.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCrawlPages": {
                        "title": "Max Crawl Pages",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Sets the depth of the scrape per URL or keyword. One page typically yields 20-30 products. Lowering this value will make the run faster and reduce usage costs. Maximum allowed is 200 pages.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
