# Amazon Review Unmet Needs Extractor (`trovevault/amazon-review-unmet-needs-extractor`) Actor

Scrape 2-4 star Amazon reviews and identify recurring product gaps, unmet needs, and improvement opportunities. Two analysis modes: AI-powered gap clustering (Groq or OpenAI) or keyword frequency analysis with AFINN sentiment scoring - no AI required.

- **URL**: https://apify.com/trovevault/amazon-review-unmet-needs-extractor.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** E-commerce, Integrations, Other
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 gaps

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 Review Unmet Needs Extractor

Scrape 2-4 star Amazon reviews and identify recurring product gaps, unmet needs, and improvement opportunities. Two analysis modes: AI-powered gap clustering (Groq or OpenAI) or keyword frequency analysis with AFINN sentiment scoring - no AI required.

---

### What does Amazon Review Unmet Needs Extractor do?

Amazon Review Unmet Needs Extractor scrapes mixed-rating reviews (2-4 stars) from Amazon product pages and surfaces the patterns that matter for product development. These are the reviews where customers describe exactly what a product is missing.

- **Scrape Amazon reviews by star rating** - Filter to 2-4 star reviews where buyers describe specific gaps, not just complaints or praise
- **AI gap clustering** - Groq or OpenAI groups recurring issues into themes with severity, mention count, and representative quotes
- **Keyword frequency mode** - No AI required. AFINN sentiment scoring labels each frequent phrase as negative (gap), positive (strength), or neutral
- **Multiple products per run** - Analyze competitor products side by side in a single run
- **Works with any Amazon domain** - .com, .co.uk, .de, .co.jp, and all other Amazon marketplaces

---

### What data can you extract?

#### AI mode output (one row per identified gap)

| Field | Description |
|---|---|
| `gap` | One-sentence description of the unmet need |
| `theme` | Category label (e.g., "Battery life", "Build quality") |
| `mentionCount` | How many reviews mention this gap |
| `mentionPercentage` | Percentage of analyzed reviews |
| `severity` | high, medium, or low |
| `representativeQuotes` | 2-3 exact quotes from reviews |
| `starDistribution` | Breakdown by star rating |

#### Keyword mode output (one row per frequent phrase)

| Field | Description |
|---|---|
| `keyword` | Frequent bigram or trigram phrase |
| `frequency` | Number of reviews containing this phrase |
| `sentiment` | negative, positive, or neutral (AFINN-165) |
| `sentimentScore` | Numeric score from -5 to +5 |
| `averageStarRating` | Average star rating of reviews mentioning this phrase |
| `sentimentContext` | Surrounding text snippets for context |

---

### Why analyze 2-4 star reviews specifically?

5-star reviews are praise. 1-star reviews are frustration. But 2-4 star reviews are where customers describe exactly what would make the product better - specific features they wish existed, quality issues that almost stopped them from recommending, and comparisons to competitors.

| Star rating | What reviewers typically say |
|---|---|
| 2 stars | "Almost returned it because..." - Near deal-breakers |
| 3 stars | "Good but..." - Specific feature gaps and tradeoffs |
| 4 stars | "Would be perfect if..." - Minor improvements for next version |

---

### How does Amazon Review Unmet Needs Extractor work?

1. Parses Amazon product URLs to extract ASINs
2. Scrapes review pages filtered by selected star ratings (default 2-4)
3. Paginates automatically until the review limit is reached (default 50 per product)
4. Analyzes all collected reviews using AI gap clustering or keyword frequency
5. Outputs one row per gap (AI mode) or one row per keyword (frequency mode)

Amazon review pages are server-rendered HTML - no browser needed. Scraping uses Apify residential proxy to avoid blocks.

---

### How to use Amazon Review Unmet Needs Extractor?

1. [Create an Apify account](https://console.apify.com/sign-up) using your email
2. Open Amazon Review Unmet Needs Extractor in Apify Store
3. Add one or more Amazon product URLs
4. Choose your AI provider (or select **None** for keyword frequency mode)
5. Click **Start** and wait for the analysis to complete

---

### Input example

#### Keyword frequency mode (no AI needed)

```json
{
    "productUrls": [
        "https://www.amazon.com/dp/B09XS7JWHH",
        "https://www.amazon.com/dp/B0BX2L8PBT"
    ],
    "starRange": ["2", "3", "4"],
    "maxReviewsPerProduct": 50,
    "aiProvider": "none"
}
````

#### AI gap clustering with Groq

```json
{
    "productUrls": [
        "https://www.amazon.com/dp/B09XS7JWHH"
    ],
    "starRange": ["2", "3", "4"],
    "maxReviewsPerProduct": 50,
    "aiProvider": "groq",
    "aiApiKey": "gsk_your_groq_key_here"
}
```

***

### Output example

#### AI mode

```json
{
    "gap": "Battery drains within 3 hours of moderate use, forcing mid-day recharging",
    "theme": "Battery life",
    "mentionCount": 17,
    "mentionPercentage": 34,
    "severity": "high",
    "representativeQuotes": [
        "Love everything except battery dies by lunch",
        "Would be 5 stars if battery lasted longer"
    ],
    "starDistribution": { "2": 3, "3": 9, "4": 5 },
    "sourceProduct": "Sony WH-1000XM5",
    "sourceAsin": "B09XS7JWHH",
    "totalReviewsAnalyzed": 50,
    "analyzedAt": "2026-04-10T14:30:00.000Z"
}
```

#### Keyword mode

```json
{
    "keyword": "battery life",
    "frequency": 17,
    "percentageOfReviews": 34,
    "averageStarRating": 2.8,
    "sentiment": "negative",
    "sentimentScore": -2.3,
    "sentimentContext": [
        "...except battery dies by lunch...",
        "...if battery lasted longer..."
    ],
    "sourceProduct": "Sony WH-1000XM5",
    "sourceAsin": "B09XS7JWHH",
    "totalReviewsAnalyzed": 50,
    "analyzedAt": "2026-04-10T14:30:00.000Z"
}
```

***

### How much does it cost?

Amazon Review Unmet Needs Extractor calls [Amazon Reviews Scraper](https://apify.com/junglee/amazon-reviews-scraper) to fetch reviews. The cost of that sub-run is charged to your Apify account in addition to this Actor's compute cost.

- **Review scraping**: charged per the Amazon Reviews Scraper's pricing model (check its [pricing tab](https://apify.com/junglee/amazon-reviews-scraper/pricing) for current rates)
- **Analysis compute**: minimal - keyword mode runs in seconds, LLM mode depends on provider
- **AI analysis (optional)**: Groq free tier handles most runs. OpenAI GPT-4o mini costs ~$0.01 per 50 reviews.

***

### Are there other e-commerce tools in Apify Store?

- [E-commerce Scraping Tool](https://apify.com/apify/e-commerce-scraping-tool) - Scrape product data, prices, and reviews from any e-commerce site
- [Product Matching Vectorizer](https://apify.com/tri_angle/product-matching-vectorizer) - Build vector indexes from product catalogs for similarity matching
- [E-commerce Product Matching Tool](https://apify.com/tri_angle/e-commerce-product-matching-tool) - Match products across competitor catalogs

***

### Frequently asked questions

#### Do I need an AI API key to use Amazon Review Unmet Needs Extractor?

No. Select "None" as the AI provider and Amazon Review Unmet Needs Extractor runs in keyword frequency mode - extracting the most common phrases from reviews and scoring each one with AFINN sentiment analysis. Negative phrases indicate product gaps, positive phrases indicate strengths.

#### Which AI provider should I use?

Groq offers a free tier that handles most runs. OpenAI GPT-4o mini produces slightly more nuanced gap descriptions but costs ~$0.01 per 50 reviews. Both work well - Groq is recommended for cost-sensitive users.

#### Can I analyze products from different Amazon domains?

Yes. Amazon Review Unmet Needs Extractor works with any Amazon domain: .com, .co.uk, .de, .co.jp, .fr, .it, .es, and more. Mix domains in the same run to compare regional review patterns.

#### How are "gaps" different from "negative reviews"?

Gaps are recurring patterns, not individual complaints. A single reviewer saying "the battery is bad" is a review. Seventeen reviewers describing battery drain within 3 hours is a product gap. Amazon Review Unmet Needs Extractor surfaces the patterns, not the noise.

#### Can I use Amazon Review Unmet Needs Extractor with the Apify API?

Yes. [Apify API](https://docs.apify.com/api/v2) gives you programmatic access to run Amazon Review Unmet Needs Extractor, manage schedules, fetch results, and integrate with your data pipeline.

#### Can I use Amazon Review Unmet Needs Extractor through an MCP Server?

Yes. Connect via [Apify MCP server](https://blog.apify.com/how-to-use-mcp/) for use with Claude Desktop, Claude Code, or any MCP-compatible AI assistant.

#### Is scraping Amazon reviews legal?

Amazon Review Unmet Needs Extractor only extracts publicly available review data visible to any visitor without login. Read more about the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### Your feedback

Found a bug or have a feature request? [Create an issue](https://console.apify.com) on the Actor page.

# Actor input Schema

## `productUrls` (type: `array`):

One or more Amazon product URLs to analyze. Accepts product pages (amazon.com/dp/ASIN), review pages (amazon.com/product-reviews/ASIN), or any URL containing a 10-character ASIN. Works with any Amazon domain (.com, .co.uk, .de, .co.jp, etc.).

## `starRange` (type: `array`):

Which star ratings to scrape. Default is 2-4 stars - the range where reviewers describe specific product issues and improvements. 3-star reviews are the sweet spot for unmet needs. Add 1 or 5 if you want the full spectrum.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews to scrape per product across all selected star ratings. Amazon shows ~10 reviews per page, so 50 reviews requires ~5 pages per star filter. Higher values increase run time and cost.

## `aiProvider` (type: `string`):

Choose an AI provider for intelligent gap clustering, or select None for keyword frequency analysis with AFINN sentiment scoring. Without AI, you still get actionable data - top phrases ranked by frequency with positive/negative sentiment labels.

## `aiApiKey` (type: `string`):

API key for your chosen AI provider. Required when AI provider is Groq or OpenAI. Leave blank for keyword frequency mode. Get a Groq key at console.groq.com (free tier available) or an OpenAI key at platform.openai.com.

## `aiModel` (type: `string`):

Override the default model. Groq default: llama-3.3-70b-versatile. OpenAI default: gpt-4o-mini. Leave blank to use the default model for your chosen provider.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to push results into in addition to the default dataset. Useful for combining results from multiple runs or integrating with downstream actors.

## `runId` (type: `string`):

ID of a previous actor run to associate this run with. Used for chaining actors in multi-step pipelines.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.amazon.com/dp/B09XS7JWHH"
  ],
  "starRange": [
    "2",
    "3",
    "4"
  ],
  "maxReviewsPerProduct": 50,
  "aiProvider": "none"
}
```

# Actor output Schema

## `dataset` (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 = {
    "productUrls": [
        "https://www.amazon.com/dp/B09XS7JWHH"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/amazon-review-unmet-needs-extractor").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 = { "productUrls": ["https://www.amazon.com/dp/B09XS7JWHH"] }

# Run the Actor and wait for it to finish
run = client.actor("trovevault/amazon-review-unmet-needs-extractor").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 '{
  "productUrls": [
    "https://www.amazon.com/dp/B09XS7JWHH"
  ]
}' |
apify call trovevault/amazon-review-unmet-needs-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/amazon-review-unmet-needs-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Review Unmet Needs Extractor",
        "description": "Scrape 2-4 star Amazon reviews and identify recurring product gaps, unmet needs, and improvement opportunities. Two analysis modes: AI-powered gap clustering (Groq or OpenAI) or keyword frequency analysis with AFINN sentiment scoring - no AI required.",
        "version": "0.1",
        "x-build-id": "gYWK8tbxKsyepyHX8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~amazon-review-unmet-needs-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-amazon-review-unmet-needs-extractor",
                "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/trovevault~amazon-review-unmet-needs-extractor/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-amazon-review-unmet-needs-extractor",
                "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/trovevault~amazon-review-unmet-needs-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-amazon-review-unmet-needs-extractor",
                "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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Amazon product URLs",
                        "type": "array",
                        "description": "One or more Amazon product URLs to analyze. Accepts product pages (amazon.com/dp/ASIN), review pages (amazon.com/product-reviews/ASIN), or any URL containing a 10-character ASIN. Works with any Amazon domain (.com, .co.uk, .de, .co.jp, etc.).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "starRange": {
                        "title": "Star rating filter",
                        "type": "array",
                        "description": "Which star ratings to scrape. Default is 2-4 stars - the range where reviewers describe specific product issues and improvements. 3-star reviews are the sweet spot for unmet needs. Add 1 or 5 if you want the full spectrum.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ]
                        },
                        "default": [
                            "2",
                            "3",
                            "4"
                        ]
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per product across all selected star ratings. Amazon shows ~10 reviews per page, so 50 reviews requires ~5 pages per star filter. Higher values increase run time and cost.",
                        "default": 50
                    },
                    "aiProvider": {
                        "title": "AI provider",
                        "enum": [
                            "none",
                            "groq",
                            "openai"
                        ],
                        "type": "string",
                        "description": "Choose an AI provider for intelligent gap clustering, or select None for keyword frequency analysis with AFINN sentiment scoring. Without AI, you still get actionable data - top phrases ranked by frequency with positive/negative sentiment labels.",
                        "default": "none"
                    },
                    "aiApiKey": {
                        "title": "AI API key",
                        "type": "string",
                        "description": "API key for your chosen AI provider. Required when AI provider is Groq or OpenAI. Leave blank for keyword frequency mode. Get a Groq key at console.groq.com (free tier available) or an OpenAI key at platform.openai.com."
                    },
                    "aiModel": {
                        "title": "AI model (optional)",
                        "type": "string",
                        "description": "Override the default model. Groq default: llama-3.3-70b-versatile. OpenAI default: gpt-4o-mini. Leave blank to use the default model for your chosen provider."
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to push results into in addition to the default dataset. Useful for combining results from multiple runs or integrating with downstream actors."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "ID of a previous actor run to associate this run with. Used for chaining actors in multi-step pipelines."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
