# Amazon Search Scraper (`khadinakbar/amazon-search-scraper`) Actor

Scrape Amazon search result pages by keyword or URL across 18 marketplaces. Extract rank, ASIN, title, price, rating, reviews, Prime, sponsored flags, badges, thumbnails, and product URLs in flat JSON optimized for SEO and AI agents.

- **URL**: https://apify.com/khadinakbar/amazon-search-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 search result scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Search Scraper

Scrape Amazon search results by keyword or URL across 18 marketplaces. This actor returns ranked product rows with ASIN, title, product URL, price, rating, review count, Prime status, sponsored flag, badges, thumbnails, and search-page position.

It is perfect for SEO and AI agents, MCP optimized, and built for ecommerce teams that need clean Amazon SERP data without opening every product detail page.

### What does this actor do?

Amazon Search Scraper turns Amazon keywords and search/category URLs into structured datasets.

You can use it to:

- Track organic and sponsored Amazon rankings for product keywords
- Monitor competitor visibility across marketplaces
- Build ecommerce SEO reports from Amazon SERPs
- Collect lightweight product discovery data for pricing and catalog research
- Give AI agents a reliable Amazon search tool with simple inputs and flat output

Supported marketplaces: US, UK, DE, FR, CA, ES, IT, JP, AU, IN, MX, BR, NL, SE, PL, TR, AE, SG.

### Why use it?

- MCP optimized output: flat JSON rows that agents can read without complex nesting
- Rank-aware fields: page, positionOnPage, organicRank, and globalPosition
- Sponsored result detection: sponsored rows are included and clearly marked
- Fast search-page scraping: no product detail page crawl unless you use another actor for enrichment
- Residential proxy defaults: Amazon blocks many datacenter IPs, so this actor ships with safer defaults
- Pay-per-event pricing: you pay only for search result rows returned to the dataset

### Input

Example input:

```json
{
    "searchQueries": ["wireless earbuds", "standing desk"],
    "country": "US",
    "maxResultsPerQuery": 25,
    "maxSearchPages": 2,
    "sortBy": "relevance",
    "includeSponsored": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US"
    }
}
````

You can also provide direct Amazon search or category URLs:

```json
{
    "startUrls": [
        { "url": "https://www.amazon.com/s?k=mechanical+keyboard" },
        { "url": "https://www.amazon.co.uk/s?k=running+shoes" }
    ],
    "maxResultsPerQuery": 50
}
```

### Input fields

| Field                | Type    | Description                                                    |
| -------------------- | ------- | -------------------------------------------------------------- |
| `searchQueries`      | array   | Amazon keywords to search, one per line.                       |
| `searchQuery`        | string  | Optional single keyword for API and MCP callers.               |
| `startUrls`          | array   | Direct Amazon search or category URLs.                         |
| `country`            | string  | Marketplace for keyword searches. Defaults to `US`.            |
| `maxResultsPerQuery` | integer | Maximum rows returned per keyword or start URL.                |
| `maxSearchPages`     | integer | Maximum result pages to paginate for each seed.                |
| `sortBy`             | string  | Sort keyword searches by relevance, price, reviews, or newest. |
| `includeSponsored`   | boolean | Include sponsored rows and mark them with `isSponsored`.       |
| `proxyConfiguration` | object  | Defaults to Apify Residential proxy with marketplace country.  |

### Output

Each Amazon search result is pushed as a flat JSON object:

```json
{
    "asin": "B08N5WRWNW",
    "title": "Wireless Earbuds Bluetooth Headphones",
    "url": "https://www.amazon.com/dp/B08N5WRWNW",
    "marketplace": "US",
    "searchQuery": "wireless earbuds",
    "searchUrl": "https://www.amazon.com/s?k=wireless+earbuds",
    "sourceType": "keyword",
    "page": 1,
    "positionOnPage": 3,
    "organicRank": 2,
    "globalPosition": 3,
    "isSponsored": false,
    "price": 49.99,
    "listPrice": 69.99,
    "currency": "USD",
    "discountPercent": 29,
    "rating": 4.5,
    "reviewCount": 12345,
    "boughtInPastMonth": "10K+ bought in past month",
    "isPrime": true,
    "thumbnail": "https://m.media-amazon.com/images/I/example.jpg",
    "badgeText": "Amazon's Choice",
    "deliveryText": "FREE delivery Fri, Jun 12",
    "couponText": "Save 10% with coupon",
    "availabilityText": null,
    "scrapedAt": "2026-06-11T10:00:00.000Z"
}
```

### Data fields

| Field                                                         | Description                                            |
| ------------------------------------------------------------- | ------------------------------------------------------ |
| `asin`                                                        | Amazon Standard Identification Number.                 |
| `title`                                                       | Product title shown in search results.                 |
| `url`                                                         | Product URL resolved from the search result card.      |
| `marketplace`                                                 | Marketplace code such as US, UK, or DE.                |
| `searchQuery`                                                 | Keyword used for the result when available.            |
| `searchUrl`                                                   | Result page URL where the row was found.               |
| `sourceType`                                                  | `keyword`, `searchUrl`, or `categoryUrl`.              |
| `page`                                                        | Amazon result page number.                             |
| `positionOnPage`                                              | Position on the page including sponsored rows.         |
| `organicRank`                                                 | Organic position on the page. Sponsored rows are null. |
| `globalPosition`                                              | Position across paginated results for the same seed.   |
| `isSponsored`                                                 | Whether Amazon marks the result as sponsored.          |
| `price`, `listPrice`, `currency`, `discountPercent`           | Search-page price data.                                |
| `rating`, `reviewCount`                                       | Visible customer rating signals.                       |
| `boughtInPastMonth`                                           | Amazon purchase-frequency badge text.                  |
| `isPrime`                                                     | Prime eligibility shown in the result card.            |
| `thumbnail`                                                   | Product image URL.                                     |
| `badgeText`, `deliveryText`, `couponText`, `availabilityText` | Extra visible search-card signals.                     |
| `scrapedAt`                                                   | ISO timestamp for the row.                             |

### Pricing

This actor uses pay-per-event pricing.

| Event                 |    Price | Charged when                       |
| --------------------- | -------: | ---------------------------------- |
| Actor start           | $0.00005 | The run starts.                    |
| Search result scraped |   $0.002 | One Amazon result row is returned. |

Example costs:

- 25 results: about $0.05
- 100 results: about $0.20
- 1,000 results: about $2.00

### Tips

- Start with `maxResultsPerQuery: 10` to verify the output shape.
- Use `includeSponsored: false` for organic-only rank reports.
- Use start URLs when you already have a category or filtered Amazon SERP.
- Keep proxy country aligned with the Amazon marketplace to avoid converted local prices.
- Keep `maxSearchPages` modest. Amazon often limits search pagination.
- Use the Amazon Product Scraper actor when you need full product detail pages, bullets, variants, or seller data.

### Use with AI agents and MCP

This actor is designed for the Apify MCP server. Agents can call it with a natural language product keyword and receive compact, predictable rows. The input is narrow, the output is flat, and the fields are named for direct use in SEO workflows, ecommerce dashboards, and automated product research.

Suggested MCP call:

```json
{
    "searchQueries": ["best travel backpack"],
    "country": "US",
    "maxResultsPerQuery": 10,
    "includeSponsored": false
}
```

### FAQ

#### Is this affiliated with Amazon?

No. This actor is not affiliated with, endorsed by, or sponsored by Amazon.com, Inc.

#### Does it scrape reviews?

No. It extracts search result data. Use a reviews-specific actor for review text.

#### Does it open product detail pages?

No. This actor is optimized for Amazon search pages. Use Amazon Product Scraper for full product enrichment.

#### Why use residential proxies?

Amazon blocks many datacenter IPs. Residential proxies improve reliability for public search pages.

#### Why did I get fewer results than requested?

Amazon may cap pagination, omit products for a marketplace, return sponsored modules, or serve a block page. The actor returns every successfully extracted row and records blocked or empty pages in the run summary.

### Support

Open an issue on the Apify Store listing if you need a field added, a marketplace tuned, or a parsing fix for a changed Amazon layout.

### Disclaimer

Use this actor responsibly and comply with Amazon's Terms of Service and all laws that apply to your use case. This actor extracts publicly visible search result pages and does not bypass login-only content.

# Actor input Schema

## `searchQueries` (type: `array`):

Amazon keywords to search, one per line. Use natural language product keywords such as 'wireless earbuds', 'standing desk', or 'vitamin c serum'.

## `searchQuery` (type: `string`):

Optional single keyword for MCP and API callers. If both this and Search queries are set, the actor deduplicates them.

## `startUrls` (type: `array`):

Direct Amazon search result or category URLs. The URL domain overrides the selected marketplace. Product detail URLs are not supported by this search-focused actor.

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

Marketplace used for keyword searches. Ignored when a start URL contains an Amazon marketplace domain.

## `maxResultsPerQuery` (type: `integer`):

Maximum product rows returned for each keyword or start URL. Each returned row is billed as one search-result-scraped event.

## `maxSearchPages` (type: `integer`):

Maximum result pages to paginate per keyword or start URL. Amazon commonly caps searches at a small number of pages, so start with 1-3.

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

Amazon sorting applied to keyword searches. Start URLs keep their own URL parameters.

## `includeSponsored` (type: `boolean`):

When enabled, sponsored products are included and marked with isSponsored=true. Disable this for organic-only rank tracking.

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

Amazon blocks datacenter IPs. Residential proxies are the default and strongly recommended.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "searchQuery": "wireless earbuds",
  "startUrls": [],
  "country": "US",
  "maxResultsPerQuery": 25,
  "maxSearchPages": 2,
  "sortBy": "relevance",
  "includeSponsored": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "wireless earbuds"
    ],
    "country": "US",
    "maxResultsPerQuery": 25,
    "maxSearchPages": 2,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/amazon-search-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 = {
    "searchQueries": ["wireless earbuds"],
    "country": "US",
    "maxResultsPerQuery": 25,
    "maxSearchPages": 2,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/amazon-search-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 '{
  "searchQueries": [
    "wireless earbuds"
  ],
  "country": "US",
  "maxResultsPerQuery": 25,
  "maxSearchPages": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call khadinakbar/amazon-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Search Scraper",
        "description": "Scrape Amazon search result pages by keyword or URL across 18 marketplaces. Extract rank, ASIN, title, price, rating, reviews, Prime, sponsored flags, badges, thumbnails, and product URLs in flat JSON optimized for SEO and AI agents.",
        "version": "0.1",
        "x-build-id": "ye30Rfc53waDiVE9n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~amazon-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-amazon-search-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/khadinakbar~amazon-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-amazon-search-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/khadinakbar~amazon-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-amazon-search-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Amazon keywords to search, one per line. Use natural language product keywords such as 'wireless earbuds', 'standing desk', or 'vitamin c serum'.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "wireless earbuds"
                        ]
                    },
                    "searchQuery": {
                        "title": "Single search query",
                        "type": "string",
                        "description": "Optional single keyword for MCP and API callers. If both this and Search queries are set, the actor deduplicates them."
                    },
                    "startUrls": {
                        "title": "Amazon search or category URLs",
                        "type": "array",
                        "description": "Direct Amazon search result or category URLs. The URL domain overrides the selected marketplace. Product detail URLs are not supported by this search-focused actor.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "country": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "CA",
                            "ES",
                            "IT",
                            "JP",
                            "AU",
                            "IN",
                            "MX",
                            "BR",
                            "NL",
                            "SE",
                            "PL",
                            "TR",
                            "AE",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Marketplace used for keyword searches. Ignored when a start URL contains an Amazon marketplace domain.",
                        "default": "US"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum product rows returned for each keyword or start URL. Each returned row is billed as one search-result-scraped event.",
                        "default": 50
                    },
                    "maxSearchPages": {
                        "title": "Max search pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum result pages to paginate per keyword or start URL. Amazon commonly caps searches at a small number of pages, so start with 1-3.",
                        "default": 3
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "avgCustomerReview",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Amazon sorting applied to keyword searches. Start URLs keep their own URL parameters.",
                        "default": "relevance"
                    },
                    "includeSponsored": {
                        "title": "Include sponsored results",
                        "type": "boolean",
                        "description": "When enabled, sponsored products are included and marked with isSponsored=true. Disable this for organic-only rank tracking.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Amazon blocks datacenter IPs. Residential proxies are the default and strongly recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
