# Amazon Keyword Research Tool - Volume + Reverse ASIN (`doesaiknow/amazon-keyword-research-tool-volume-reverse-asin`) Actor

Amazon keyword research tool & API: bulk estimated search volume, related keywords & reverse-ASIN (every keyword a product ranks for + its position - like Helium 10 Cerebro). A pay-per-use Helium 10 / Jungle Scout / MerchantWords alternative - $0.99/1k, no subscription, free tier. US.

- **URL**: https://apify.com/doesaiknow/amazon-keyword-research-tool-volume-reverse-asin.md
- **Developed by:** [Dawid S](https://apify.com/doesaiknow) (community)
- **Categories:** E-commerce, SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / amazon search volume (up to 1000 keywords)

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Keyword Research API — Volume, Related & Reverse ASIN

Bulk **Amazon keyword metrics** via a native data API — estimated Amazon search volume, related
keywords, and **reverse-ASIN** (every keyword a product ranks for, with its position). A cheap,
pay-per-use, **no-subscription** alternative to Helium 10 / Jungle Scout / MerchantWords — **$0.99 per
1,000 keywords**, no monthly floor.

> v1 is US marketplace. Search volume is an **estimate** (Amazon hides official figures — every tool
> estimates). Reverse-ASIN keyword **positions are factual** (observed Amazon SERP rankings).

### What you get — 3 modes

| Mode | Input | Output |
|---|---|---|
| **search_volume** | `keywords[]` | Estimated monthly Amazon search volume per keyword |
| **related_keywords** | `keyword` seed | Related Amazon keywords + volume (long-tail discovery) |
| **reverse_asin** | `asin` | Every keyword the product ranks for + its Amazon position |

### Quick start
```json
{ "mode": "search_volume", "keywords": ["wireless earbuds", "yoga mat", "coffee maker"], "country": "us" }
````

```json
{ "mode": "reverse_asin", "asin": "B0BDHWDR12", "country": "us", "maxKeywords": 100 }
```

### Output example (search\_volume)

```json
[
  { "keyword": "coffee maker", "amazon_search_volume": 181315, "country": "us", "source": "estimated" },
  { "keyword": "yoga mat",     "amazon_search_volume": 82280,  "country": "us", "source": "estimated" }
]
```

### Output example (reverse\_asin)

One flat dataset row per ranked keyword. `rank` is the **factual** observed Amazon SERP position (the
value that matters here); the run log reports the ASIN's total ranked-keyword count.

```json
[
  { "asin": "B0BDHWDR12", "keyword": "magsafe airpods 2", "rank": 1, "amazon_search_volume": 0, "country": "us", "source": "factual" },
  { "asin": "B0BDHWDR12", "keyword": "ticpods 2 pro plus", "rank": 2, "amazon_search_volume": 0, "country": "us", "source": "factual" }
]
```

> Note: `amazon_search_volume` is often `0` in reverse\_asin output — the underlying ranked-keywords data
> reports little to no volume for long-tail ranked terms. Use **`rank`** for reverse-ASIN analysis; if you
> need volume for those keywords, feed them back through `search_volume` mode.

### Pricing

**Pay per event, no subscription.** You pay only for successful runs — failed or empty scans are never
billed. No monthly minimum, no seat fees. Each run charges a small `actor-start` fee plus **one** event
for the mode you ran.

| Event | Fires | Price (FREE / BRONZE tier) |
|---|---|---|
| `actor-start` | once per run (input validation + cache check) | $0.05 |
| `search-volume` | once, after a successful keyword volume call (up to 1,000 kw) | **$0.99 / 1k** |
| `related-keywords` | once, after a successful related-keywords call | $0.20 |
| `reverse-asin` | once, after a successful ranked-keywords call | $0.30 |

#### Volume discounts by Apify plan tier

Higher Apify subscription tiers get automatic per-event discounts — built for agencies and developers
running keywords and ASINs at scale. `actor-start` stays flat across all tiers.

| Event | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| `search-volume` (per 1k) | $0.99 | $0.95 | $0.85 | **$0.75** |
| `related-keywords` | $0.20 | $0.19 | $0.17 | **$0.15** |
| `reverse-asin` | $0.30 | $0.28 | $0.25 | **$0.20** |

> Tiers are determined by your Apify plan; the discounted unit price is applied automatically per run.
> PLATINUM / DIAMOND (enterprise) pricing available on request.

A single `search_volume` run of 1,000 keywords costs **$1.04** (start + batch) on FREE/BRONZE — versus
$29–$129/mo subscriptions elsewhere.

### How it compares

| | This actor | Helium 10 | Jungle Scout | MerchantWords |
|---|---|---|---|---|
| Entry price | **pay-per-use, $0.99/1k** | $129/mo | $49/mo | $29/mo (500 searches) |
| Public keyword API | **✅** | Enterprise only ($1,499/mo) | ❌ | ❌ |
| Reverse-ASIN | **✅ (= Cerebro)** | ✅ (paid) | ✅ (paid) | partial |
| No subscription | **✅** | ❌ | ❌ | ❌ |

Built for agencies running many ASINs, developers, and sub-$1M sellers who can't justify a $129/mo seat.

### What it does NOT do (honest scope)

- v1 = **US marketplace** only (more marketplaces in v0.2).
- Search volume is **estimated** (no tool has Amazon's official numbers); use it for relative
  prioritization, not absolute truth. Reverse-ASIN positions are observed/factual.
- No PPC bid data, no listing optimizer, no rank-tracking-over-time yet (v0.2).

### FAQ

**Is the search volume official?** No — Amazon hides it; every tool (Helium 10, MerchantWords, this one) estimates it. We label it `estimated`.

**Are the reverse-ASIN rankings real?** Yes — those are observed Amazon search positions, not estimates.

**Do I need a subscription?** No. Pay per use; failed runs aren't charged.

**What is Amazon keyword research?** Finding the search terms Amazon shoppers actually type, plus their estimated search volume, so you can put the right keywords in your listing title, bullets and backend. This actor returns estimated Amazon search volume, related keywords and reverse-ASIN data for exactly that.

**How does a reverse-ASIN lookup work?** Give it a product's ASIN and it returns every keyword that product ranks for on Amazon, with its position — so you can see what drives a competitor's sales and target the same terms. (This is the Helium 10 "Cerebro" use case, pay-per-use.)

**What's the difference between high-volume and high-conversion keywords?** High-volume keywords get the most searches but are broad and competitive; high-conversion keywords are more specific and closer to a purchase. Use volume to size demand and reverse-ASIN positions to find the specific terms competitors actually rank for.

**Is this safe for AI agents to run?** Yes. It runs under **limited permissions** — it only does its job (queries the Amazon keyword API and writes your dataset) and never touches the rest of your Apify account, so there's no full-permission approval step. Run it from any AI agent or IDE via the **Apify MCP server** (`mcp.apify.com`).

### Related Actors

- [**Keyword Metrics Pro**](https://apify.com/doesaiknow/doesaiknow-keyword-metrics-apify) — Google + Bing keyword volume, CPC & trend.
- [**AI Keyword Clustering Tool**](https://apify.com/doesaiknow/ai-keyword-clustering-tool-topical-clustering-bulk-serp) — cluster your Amazon keywords into topics.
- [**Competitor Keyword Research**](https://apify.com/doesaiknow/doesaiknow-competitor-keywords-apify) — any site's ranked keywords.
- [**Amazon Product Scraper**](https://apify.com/junglee/Amazon-crawler) — pull product data for your ASINs.

### Disclaimer

Provided as-is for research. Estimated search volumes are best-effort. Independent project — not
affiliated with, endorsed by, or partnered with Amazon.com, Helium 10, Jungle Scout, or MerchantWords.

### SEO keyword cluster

amazon keyword research tool, amazon keyword tool, amazon keyword research, amazon search volume,
amazon keyword finder, reverse asin, reverse asin tool, amazon keyword rank tracker, amazon seo tool,
amazon product research, helium 10 alternative, jungle scout alternative, merchantwords alternative,
amazon keyword api, amazon ppc keyword tool, fba keyword research, amazon backend keywords, asin keyword
lookup, amazon related keywords, cerebro alternative, magnet alternative, amazon keyword scraper.

# Actor input Schema

## `mode` (type: `string`):

Which metric to fetch. search\_volume: paste keywords\[] → estimated Amazon search volume per keyword. related\_keywords: a single seed keyword → related Amazon keywords + volume (long-tail discovery). reverse\_asin: an ASIN → every keyword the product ranks for + its Amazon SERP position (= Helium 10 Cerebro). Default search\_volume.

## `keywords` (type: `array`):

Used only in search\_volume mode. Up to 1000 keywords (paid Apify plans). Each is normalized (lowercase + trimmed) and deduplicated before the upstream call (identical tasks are not refundable per upstream ToS). FREE PLAN: limited to 10 keywords per scan; the actor exits early with an upgrade prompt above the limit. Search volume is an estimate (Amazon hides official figures — every tool estimates).

## `keyword` (type: `string`):

Used only in related\_keywords mode. A single seed keyword to expand into related Amazon keywords with estimated search volume.

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

Used only in reverse\_asin mode. A 10-character Amazon ASIN (e.g. B0BDHWDR12). Returns every keyword the product ranks for plus its Amazon SERP position. Positions are factual (observed), not estimated.

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

Amazon marketplace. v1 supports the US marketplace only; more marketplaces in v0.2. Unknown codes silently fall back to 'us'.

## `maxKeywords` (type: `integer`):

Caps the number of related keywords or ranked keywords returned (related\_keywords and reverse\_asin modes). 1-1000, default 100. Free plan is capped tighter to bound cost.

## `bypassRunCache` (type: `boolean`):

Skip the 24h KV Store run-cache and re-query the upstream API live. You will be charged the per-mode fee. Default false.

## Actor input object example

```json
{
  "mode": "search_volume",
  "keywords": [
    "wireless earbuds",
    "yoga mat",
    "coffee maker"
  ],
  "keyword": "headphones",
  "asin": "B0BDHWDR12",
  "country": "us",
  "maxKeywords": 100,
  "bypassRunCache": false
}
```

# Actor output Schema

## `keywordMetrics` (type: `string`):

Default dataset link. See dataset\_schema.json for per-field documentation.

# 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 = {
    "keywords": [
        "wireless earbuds",
        "yoga mat",
        "coffee maker"
    ],
    "keyword": "headphones",
    "asin": "B0BDHWDR12"
};

// Run the Actor and wait for it to finish
const run = await client.actor("doesaiknow/amazon-keyword-research-tool-volume-reverse-asin").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 = {
    "keywords": [
        "wireless earbuds",
        "yoga mat",
        "coffee maker",
    ],
    "keyword": "headphones",
    "asin": "B0BDHWDR12",
}

# Run the Actor and wait for it to finish
run = client.actor("doesaiknow/amazon-keyword-research-tool-volume-reverse-asin").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 '{
  "keywords": [
    "wireless earbuds",
    "yoga mat",
    "coffee maker"
  ],
  "keyword": "headphones",
  "asin": "B0BDHWDR12"
}' |
apify call doesaiknow/amazon-keyword-research-tool-volume-reverse-asin --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=doesaiknow/amazon-keyword-research-tool-volume-reverse-asin",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Keyword Research Tool - Volume + Reverse ASIN",
        "description": "Amazon keyword research tool & API: bulk estimated search volume, related keywords & reverse-ASIN (every keyword a product ranks for + its position - like Helium 10 Cerebro). A pay-per-use Helium 10 / Jungle Scout / MerchantWords alternative - $0.99/1k, no subscription, free tier. US.",
        "version": "0.0",
        "x-build-id": "M26RkkjNBVB43bad3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/doesaiknow~amazon-keyword-research-tool-volume-reverse-asin/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-doesaiknow-amazon-keyword-research-tool-volume-reverse-asin",
                "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/doesaiknow~amazon-keyword-research-tool-volume-reverse-asin/runs": {
            "post": {
                "operationId": "runs-sync-doesaiknow-amazon-keyword-research-tool-volume-reverse-asin",
                "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/doesaiknow~amazon-keyword-research-tool-volume-reverse-asin/run-sync": {
            "post": {
                "operationId": "run-sync-doesaiknow-amazon-keyword-research-tool-volume-reverse-asin",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search_volume",
                            "related_keywords",
                            "reverse_asin"
                        ],
                        "type": "string",
                        "description": "Which metric to fetch. search_volume: paste keywords[] → estimated Amazon search volume per keyword. related_keywords: a single seed keyword → related Amazon keywords + volume (long-tail discovery). reverse_asin: an ASIN → every keyword the product ranks for + its Amazon SERP position (= Helium 10 Cerebro). Default search_volume.",
                        "default": "search_volume"
                    },
                    "keywords": {
                        "title": "Keywords (search_volume mode)",
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Used only in search_volume mode. Up to 1000 keywords (paid Apify plans). Each is normalized (lowercase + trimmed) and deduplicated before the upstream call (identical tasks are not refundable per upstream ToS). FREE PLAN: limited to 10 keywords per scan; the actor exits early with an upgrade prompt above the limit. Search volume is an estimate (Amazon hides official figures — every tool estimates).",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 200
                        }
                    },
                    "keyword": {
                        "title": "Seed keyword (related_keywords mode)",
                        "type": "string",
                        "description": "Used only in related_keywords mode. A single seed keyword to expand into related Amazon keywords with estimated search volume."
                    },
                    "asin": {
                        "title": "ASIN (reverse_asin mode)",
                        "type": "string",
                        "description": "Used only in reverse_asin mode. A 10-character Amazon ASIN (e.g. B0BDHWDR12). Returns every keyword the product ranks for plus its Amazon SERP position. Positions are factual (observed), not estimated."
                    },
                    "country": {
                        "title": "Country (marketplace)",
                        "enum": [
                            "us"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace. v1 supports the US marketplace only; more marketplaces in v0.2. Unknown codes silently fall back to 'us'.",
                        "default": "us"
                    },
                    "maxKeywords": {
                        "title": "Max keywords returned (related / reverse_asin)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Caps the number of related keywords or ranked keywords returned (related_keywords and reverse_asin modes). 1-1000, default 100. Free plan is capped tighter to bound cost.",
                        "default": 100
                    },
                    "bypassRunCache": {
                        "title": "Bypass 24h run-cache",
                        "type": "boolean",
                        "description": "Skip the 24h KV Store run-cache and re-query the upstream API live. You will be charged the per-mode fee. Default false.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```