# Chrome Web Store Extension Reviews Scraper (`automation-lab/chrome-webstore-extension-reviews-scraper`) Actor

Scrape public Chrome Web Store extension reviews, ratings, reviewer names, dates, helpful votes, and source URLs for monitoring and competitor analysis.

- **URL**: https://apify.com/automation-lab/chrome-webstore-extension-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Chrome Web Store Extension Reviews Scraper

Extract public Chrome Web Store extension reviews for product monitoring, competitor intelligence, support triage, and sentiment analysis.

The actor opens Chrome Web Store review pages, accepts the public consent dialog when shown, loads review pages, and saves structured review rows to an Apify dataset.

### What does Chrome Web Store Extension Reviews Scraper do?

Chrome Web Store Extension Reviews Scraper collects visible user reviews from public Chrome Web Store extension review pages.

It can extract:

- ⭐ Review rating
- 🧑 Reviewer display name
- 🖼️ Reviewer profile image URL when visible
- 🗓️ Review date
- 💬 Review text
- 👍 Helpful vote counts
- 🧩 Extension ID and extension name
- 🔗 Source review URL
- 🕒 Scrape timestamp

### Who is it for?

This actor is useful for several buyer workflows:

- 🧩 Chrome extension publishers tracking new reviews after every release
- 🛟 Support teams triaging complaints and bug reports in review text
- 📈 Growth teams monitoring rating quality over time
- 🕵️ Competitor intelligence teams comparing rival extension feedback
- 🧪 Product managers analyzing feature requests from public reviews
- 📊 Agencies building dashboards for browser-extension clients

### Why use this scraper?

Chrome Web Store reviews are valuable but difficult to monitor manually. The Store UI is JavaScript-heavy, review pages paginate, and users often need repeat runs for the same extension.

This actor turns those public pages into a clean dataset you can export to CSV, JSON, Excel, Google Sheets, or your own pipeline.

### Typical use cases

- Track reviews for your own extension every day
- Compare review complaints across competing ad blockers, productivity tools, or developer extensions
- Build a sentiment dashboard from review text
- Export recent negative reviews for support follow-up
- Monitor review volume after a new extension release
- Collect customer quotes for product research

### Input options

You can provide Chrome Web Store sources in two ways.

#### Extension review URLs

Paste one or more Chrome Web Store detail or reviews URLs:

```json
{
  "startUrls": [
    { "url": "https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm/reviews" }
  ],
  "maxReviews": 20
}
````

#### Raw extension IDs

You can also provide raw Chrome extension IDs:

```json
{
  "extensionIds": ["cjpalhdlnbpafiamejdnhcphjbkeiagm"],
  "maxReviews": 50
}
```

### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Chrome Web Store extension detail or reviews URLs. |
| `extensionIds` | array | Raw 32-character extension IDs. |
| `maxReviews` | integer | Maximum reviews to save per extension. |
| `useApifyProxy` | boolean | Optional proxy fallback; off by default. |
| `proxyCountryCode` | string | Optional country code when proxy is enabled. |

### Output data

Each dataset item is one Chrome Web Store review.

| Field | Description |
| --- | --- |
| `extensionId` | Chrome extension ID. |
| `extensionName` | Extension name from the reviews page title. |
| `reviewId` | Deterministic ID generated from extension, reviewer, date, and text. |
| `reviewerName` | Reviewer display name. |
| `reviewerProfileImageUrl` | Public avatar image URL when visible. |
| `rating` | Numeric star rating from 1 to 5. |
| `reviewDate` | Visible review date. |
| `reviewText` | Full visible review text. |
| `helpfulVotes` | Number of users who found the review helpful. |
| `totalVotes` | Total helpful-vote denominator. |
| `developerResponse` | Developer response when visible; currently null if not present. |
| `sourceUrl` | Review page URL used for extraction. |
| `scrapedAt` | ISO timestamp for the run. |

### Example output

```json
{
  "extensionId": "cjpalhdlnbpafiamejdnhcphjbkeiagm",
  "extensionName": "uBlock Origin",
  "reviewId": "d871e0cc715702874643298e4aa5b9bf93be30d1",
  "reviewerName": "Google User",
  "rating": 3,
  "reviewDate": "Jun 20, 2026",
  "reviewText": "Version updated to 1.71...",
  "helpfulVotes": null,
  "totalVotes": null,
  "developerResponse": null,
  "sourceUrl": "https://chromewebstore.google.com/detail/cjpalhdlnbpafiamejdnhcphjbkeiagm/reviews",
  "scrapedAt": "2026-06-20T22:42:42.706Z"
}
```

### How much does it cost to scrape Chrome Web Store reviews?

This actor uses pay-per-event pricing.

- A small start fee is charged per run.
- A per-review event is charged for each dataset item produced.
- Keep `maxReviews` low for your first test run.

The exact live price is shown on the Apify actor page before you start a run.

### How to run it

1. Open the actor on Apify.
2. Add one or more Chrome Web Store extension URLs or IDs.
3. Set `maxReviews` to the number of reviews you need per extension.
4. Start the actor.
5. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for best results

- Use review URLs when you have them; extension IDs are best for automated pipelines.
- Start with `maxReviews: 20` to validate the output cheaply.
- Run the same extension daily or weekly for review monitoring.
- Use `reviewId` to deduplicate repeated monitoring runs.
- Enable proxy only if your run location has access issues.

### Integrations

Common integration patterns include:

- Send new negative reviews to Slack or Discord.
- Export reviews to Google Sheets for support triage.
- Load dataset rows into BigQuery, Snowflake, or PostgreSQL.
- Run the actor on a schedule and deduplicate by `reviewId`.
- Combine review text with an LLM classifier for sentiment and topic labels.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/chrome-webstore-extension-reviews-scraper').call({
  extensionIds: ['cjpalhdlnbpafiamejdnhcphjbkeiagm'],
  maxReviews: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/chrome-webstore-extension-reviews-scraper').call(run_input={
    'extensionIds': ['cjpalhdlnbpafiamejdnhcphjbkeiagm'],
    'maxReviews': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~chrome-webstore-extension-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"extensionIds":["cjpalhdlnbpafiamejdnhcphjbkeiagm"],"maxReviews":20}'
```

### Use with AI agents via MCP

Chrome Web Store Extension Reviews Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one.

**Setup for Claude Code**

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

**Setup for Claude Desktop, Cursor, or VS Code**

Add this to your MCP config file:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

Example prompts:

- "Use automation-lab/chrome-webstore-extension-reviews-scraper to collect 30 uBlock Origin reviews and summarize the top complaints."
- "Scrape the latest Chrome Web Store reviews for these extension IDs and group them by rating."
- "Run a weekly Chrome extension review monitoring workflow and alert me when new one-star reviews mention YouTube."

Learn more in the Apify MCP documentation: https://docs.apify.com/platform/integrations/mcp

### Scheduling

For review monitoring, schedule the actor to run daily or weekly with the same extension IDs. Store the latest dataset, compare against prior `reviewId` values, and alert only on new reviews.

### Data quality notes

The actor extracts the public review UI visible to an unauthenticated visitor. If Chrome Web Store changes class names or hides a field, the actor may return null for that field until updated.

### Proxy notes

Proxy is disabled by default because Chrome Web Store public pages usually load directly. If your location sees consent or access friction, enable Apify Proxy and choose a country code.

### FAQ

**How fast is the Chrome Web Store reviews scraper?**

Small runs usually finish in under a minute. Larger runs depend on how many times the actor needs to click `Load more` for each extension.

**How much does it cost to monitor Chrome extension reviews?**

The actor uses pay-per-event pricing, so cost depends mainly on how many reviews are saved. Start with 20 reviews to estimate your workflow.

**Is there an official Chrome Web Store reviews API?**

Chrome Web Store does not provide a simple public review export API for most monitoring workflows. This actor extracts the public review page instead.

### Troubleshooting

#### Why did I get fewer reviews than `maxReviews`?

Chrome Web Store may stop offering more reviews for a filter/language, or the extension may have fewer public reviews available in the currently visible stream.

#### Why is `developerResponse` null?

Developer responses are not always visible on Chrome Web Store review pages. The field is reserved for compatibility when a response is visible.

#### Why did the run fail on an extension ID?

Make sure the ID is a 32-character Chrome extension ID containing letters from `a` to `p`, or paste the full Chrome Web Store URL instead.

### Legality

This actor extracts publicly visible Chrome Web Store review data. You are responsible for using the data in a lawful way, respecting privacy, platform terms, and applicable regulations.

### Related scrapers

Explore other automation-lab actors for adjacent workflows:

- App review scrapers for marketplace monitoring
- Browser extension metadata scrapers
- Website contact and product feedback scrapers
- Review sentiment and classification workflows

### Changelog

#### 0.1

Initial version: scrape public Chrome Web Store reviews by extension URL or ID, with review text, rating, date, reviewer, helpful votes, and source metadata.

### Support

If a Chrome Web Store page stops loading or a field disappears, open an Apify issue with a sample extension URL and the run ID so the actor can be updated quickly.

# Actor input Schema

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

Chrome Web Store extension URLs. Reviews URLs and detail URLs are accepted; the scraper extracts the extension ID automatically.

## `extensionIds` (type: `array`):

Optional raw 32-character Chrome extension IDs, for example cjpalhdlnbpafiamejdnhcphjbkeiagm.

## `maxReviews` (type: `integer`):

Maximum number of reviews to save for each extension. Keep this low for first tests.

## `useApifyProxy` (type: `boolean`):

Usually not needed for Chrome Web Store. Enable only if your run location is blocked by Google consent or access restrictions.

## `proxyCountryCode` (type: `string`):

Optional two-letter country code used only when Apify Proxy is enabled.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm/reviews"
    }
  ],
  "extensionIds": [
    "cjpalhdlnbpafiamejdnhcphjbkeiagm"
  ],
  "maxReviews": 20,
  "useApifyProxy": false,
  "proxyCountryCode": "US"
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm/reviews"
        }
    ],
    "extensionIds": [
        "cjpalhdlnbpafiamejdnhcphjbkeiagm"
    ],
    "maxReviews": 20,
    "useApifyProxy": false,
    "proxyCountryCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/chrome-webstore-extension-reviews-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 = {
    "startUrls": [{ "url": "https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm/reviews" }],
    "extensionIds": ["cjpalhdlnbpafiamejdnhcphjbkeiagm"],
    "maxReviews": 20,
    "useApifyProxy": False,
    "proxyCountryCode": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/chrome-webstore-extension-reviews-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 '{
  "startUrls": [
    {
      "url": "https://chromewebstore.google.com/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm/reviews"
    }
  ],
  "extensionIds": [
    "cjpalhdlnbpafiamejdnhcphjbkeiagm"
  ],
  "maxReviews": 20,
  "useApifyProxy": false,
  "proxyCountryCode": "US"
}' |
apify call automation-lab/chrome-webstore-extension-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/chrome-webstore-extension-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chrome Web Store Extension Reviews Scraper",
        "description": "Scrape public Chrome Web Store extension reviews, ratings, reviewer names, dates, helpful votes, and source URLs for monitoring and competitor analysis.",
        "version": "0.1",
        "x-build-id": "FofMigorjfzSefyZk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~chrome-webstore-extension-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-chrome-webstore-extension-reviews-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/automation-lab~chrome-webstore-extension-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-chrome-webstore-extension-reviews-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/automation-lab~chrome-webstore-extension-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-chrome-webstore-extension-reviews-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": {
                    "startUrls": {
                        "title": "Extension review or detail URLs",
                        "type": "array",
                        "description": "Chrome Web Store extension URLs. Reviews URLs and detail URLs are accepted; the scraper extracts the extension ID automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "extensionIds": {
                        "title": "Extension IDs",
                        "type": "array",
                        "description": "Optional raw 32-character Chrome extension IDs, for example cjpalhdlnbpafiamejdnhcphjbkeiagm.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews per extension",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each extension. Keep this low for first tests.",
                        "default": 20
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Usually not needed for Chrome Web Store. Enable only if your run location is blocked by Google consent or access restrictions.",
                        "default": false
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code",
                        "type": "string",
                        "description": "Optional two-letter country code used only when Apify Proxy is enabled."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```