# App Store Reviews Scraper | Ratings Across All Countries (`abotapi/app-store-reviews-scraper`) Actor

Collect Apple App Store reviews and ratings for any app across 150+ country storefronts. Get rating, title, body, author, date, app version, and country in clean JSON. Search by app name or paste app URLs; optional app metadata enrichment.

- **URL**: https://apify.com/abotapi/app-store-reviews-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** Developer tools, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 reviews

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

## App Store Reviews Scraper

Collect Apple App Store reviews and ratings for any app, across country storefronts. Give it an app name or an App Store link and it returns a clean, one-row-per-review dataset: the star rating, review title and body, author, date, the app version reviewed, and the storefront country. Reviews are storefront-specific, so you can sweep many countries to gather the full picture for a single app.

### Why this scraper

- Reviews are the primary output: rating, title, body, author, date, app version, and country on every row.
- Two ways in: search by app name, or paste one or more App Store app links.
- Multi-country sweep: pass a list of storefronts, or use "all" for a broad built-in set of major markets.
- Sort by most recent or most helpful.
- Filter by minimum and maximum star rating.
- Optional app-metadata enrichment: developer, average rating, rating count, genre, icon, price, and release notes attached to each review.
- 25+ output fields, more than typical alternatives, at a predictable per-result price.

### Data you get

> Sample shape, values are illustrative placeholders, not from a live review.

| Field | Example |
|---|---|
| reviewId | 14000000000 |
| appId | 389801252 |
| appName | Sample App |
| country | us |
| rating | 5 |
| title | Sample review title |
| body | Full review text appears here. |
| author | Reviewer Name |
| authorId | 1500000000 |
| authorUri | https://itunes.apple.com/us/reviews/id1500000000 |
| reviewUrl | https://itunes.apple.com/us/review?id=389801252&type=Purple%20Software |
| appVersion | 1.0.0 |
| reviewDate | 2026-01-01T00:00:00-07:00 |
| voteSum | 0 |
| voteCount | 0 |
| contentType | Application |

With enrichment enabled, each review also carries: appSellerName, appAverageRating, appRatingCount, appAverageRatingCurrentVersion, appRatingCountCurrentVersion, appPrimaryGenre, appContentRating, appBundleId, appIconUrl, appStoreUrl, appPrice, appCurrency, appMinimumOsVersion, appCurrentVersion, appCurrentVersionReleaseDate, appReleaseNotes.

### How to use

Search by app name, US storefront:

```json
{
  "mode": "search",
  "queries": ["Instagram", "Spotify"],
  "appsPerQuery": 1,
  "countries": ["us"],
  "sortBy": "mostRecent",
  "maxItems": 100
}
````

Sweep several countries for one app via its link:

```json
{
  "mode": "url",
  "urls": ["https://apps.apple.com/us/app/instagram/id389801252"],
  "countries": ["us", "gb", "de", "jp"],
  "maxItems": 500
}
```

Only high-rated reviews, with app details attached:

```json
{
  "mode": "url",
  "urls": ["https://apps.apple.com/us/app/instagram/id389801252"],
  "countries": ["us"],
  "minRating": 4,
  "fetchDetails": true,
  "maxItems": 200
}
```

Multiple app links at once:

```json
{
  "mode": "url",
  "urls": [
    "https://apps.apple.com/us/app/instagram/id389801252",
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ],
  "countries": ["us"],
  "maxItems": 200
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| mode | string | search | "search" (by app name) or "url" (paste app links). |
| queries | array | \["Instagram"] | App names or keywords (search mode). |
| appsPerQuery | integer | 1 | Top matching apps to take per search term. |
| urls | array | (example) | App Store app links (url mode). |
| countries | array | \["us"] | Storefront codes to collect from. Empty uses the link's storefront or us. "all" sweeps major markets. |
| sortBy | string | mostRecent | "mostRecent" or "mostHelpful". |
| minRating | integer | (none) | Keep reviews at or above this star rating. |
| maxRating | integer | (none) | Keep reviews at or below this star rating. |
| fetchDetails | boolean | false | Attach app metadata to each review. |
| maxItems | integer | 20 | Total review cap. 0 means no limit. |
| maxPages | integer | 10 | Pages per country (50 reviews per page). |
| proxy | object | Apify proxy | Connection settings. |

### Output example

> Sample shape, values are illustrative placeholders.

```json
{
  "reviewId": "14000000000",
  "appId": "389801252",
  "appName": "Sample App",
  "country": "us",
  "rating": 5,
  "title": "Sample review title",
  "body": "Full review text appears here.",
  "author": "Reviewer Name",
  "authorId": "1500000000",
  "authorUri": "https://itunes.apple.com/us/reviews/id1500000000",
  "reviewUrl": "https://itunes.apple.com/us/review?id=389801252&type=Purple%20Software",
  "appVersion": "1.0.0",
  "reviewDate": "2026-01-01T00:00:00-07:00",
  "voteSum": 0,
  "voteCount": 0,
  "contentType": "Application"
}
```

### Send results into your apps (MCP connectors)

You can optionally pipe results into the apps you already use through Model Context Protocol (MCP) connectors. Authorize a connector under Apify, Settings, API & Integrations, then select it in the input. For Notion, set a parent page URL and each review is written as a page. Other connectors receive a best-effort write.

The connector receives a condensed, human-readable summary of each review (a heading plus the key fields and body text), not the full JSON. The complete record always stays in the Apify dataset. Leave the connector field empty to skip this step; it never changes the dataset output.

### Plan requirement

Runs on any Apify plan. For very large multi-country sweeps, a proxy with more exit rotation can help.

# Actor input Schema

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

How to select apps. 'search' resolves app names to apps via the App Store; 'url' takes App Store app links directly.

## `queries` (type: `array`):

App names or keywords to look up (for example 'Instagram', 'Spotify'). Each term resolves to the top matching app(s) and its reviews are collected. Ignored in URL mode.

## `appsPerQuery` (type: `integer`):

How many top matching apps to take for each search term. Use 1 for the single best match. Ignored in URL mode.

## `urls` (type: `array`):

App Store app links, for example https://apps.apple.com/us/app/instagram/id389801252 . Multiple URLs supported. The app id is read from the /id{digits} part; the storefront in the link is used only if you leave Countries empty.

## `countries` (type: `array`):

ISO 2-letter storefront codes to collect reviews from (for example us, gb, de, jp). Each country is a separate review stream. Leave empty to use the storefront from each URL (URL mode) or 'us' (search mode). Use 'all' to sweep a broad built-in set of major storefronts.

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

Order reviews are returned in per country.

## `minRating` (type: `integer`):

Keep only reviews with at least this star rating (1 to 5). Leave empty for all.

## `maxRating` (type: `integer`):

Keep only reviews with at most this star rating (1 to 5). Leave empty for all.

## `fetchDetails` (type: `boolean`):

Also attach app metadata (developer, average rating, rating count, genre, icon, price, release notes) to each review. Adds an extra lookup per app.

## `maxItems` (type: `integer`):

Maximum number of reviews to collect in total. 0 means no limit (stops at Max pages per country across all countries). Predictable, keeps the first run cheap.

## `maxPages` (type: `integer`):

How many review pages to walk per country (50 reviews per page, up to 10 pages available per storefront). Leave at the maximum; the run stops at Max reviews.

## `proxy` (type: `object`):

Connection settings. The default works on any Apify plan.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write. Leave empty to skip; never changes the dataset output. Supported: Notion, Linear, Airtable, Apify.

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "Instagram"
  ],
  "appsPerQuery": 1,
  "urls": [
    "https://apps.apple.com/us/app/instagram/id389801252"
  ],
  "countries": [
    "us"
  ],
  "sortBy": "mostRecent",
  "fetchDetails": false,
  "maxItems": 20,
  "maxPages": 10,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# 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 = {
    "queries": [
        "Instagram"
    ],
    "urls": [
        "https://apps.apple.com/us/app/instagram/id389801252"
    ],
    "countries": [
        "us"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/app-store-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 = {
    "queries": ["Instagram"],
    "urls": ["https://apps.apple.com/us/app/instagram/id389801252"],
    "countries": ["us"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/app-store-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 '{
  "queries": [
    "Instagram"
  ],
  "urls": [
    "https://apps.apple.com/us/app/instagram/id389801252"
  ],
  "countries": [
    "us"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "App Store Reviews Scraper | Ratings Across All Countries",
        "description": "Collect Apple App Store reviews and ratings for any app across 150+ country storefronts. Get rating, title, body, author, date, app version, and country in clean JSON. Search by app name or paste app URLs; optional app metadata enrichment.",
        "version": "1.0",
        "x-build-id": "hXrNE7m4rAzSprA4P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~app-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-app-store-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/abotapi~app-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-app-store-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/abotapi~app-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-app-store-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "How to select apps. 'search' resolves app names to apps via the App Store; 'url' takes App Store app links directly.",
                        "default": "search"
                    },
                    "queries": {
                        "title": "App name searches",
                        "type": "array",
                        "description": "App names or keywords to look up (for example 'Instagram', 'Spotify'). Each term resolves to the top matching app(s) and its reviews are collected. Ignored in URL mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appsPerQuery": {
                        "title": "Apps per search term",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many top matching apps to take for each search term. Use 1 for the single best match. Ignored in URL mode.",
                        "default": 1
                    },
                    "urls": {
                        "title": "App Store URLs",
                        "type": "array",
                        "description": "App Store app links, for example https://apps.apple.com/us/app/instagram/id389801252 . Multiple URLs supported. The app id is read from the /id{digits} part; the storefront in the link is used only if you leave Countries empty.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "ISO 2-letter storefront codes to collect reviews from (for example us, gb, de, jp). Each country is a separate review stream. Leave empty to use the storefront from each URL (URL mode) or 'us' (search mode). Use 'all' to sweep a broad built-in set of major storefronts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "mostRecent",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "Order reviews are returned in per country.",
                        "default": "mostRecent"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep only reviews with at least this star rating (1 to 5). Leave empty for all."
                    },
                    "maxRating": {
                        "title": "Maximum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep only reviews with at most this star rating (1 to 5). Leave empty for all."
                    },
                    "fetchDetails": {
                        "title": "Enrich with app details",
                        "type": "boolean",
                        "description": "Also attach app metadata (developer, average rating, rating count, genre, icon, price, release notes) to each review. Adds an extra lookup per app.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect in total. 0 means no limit (stops at Max pages per country across all countries). Predictable, keeps the first run cheap.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages per country",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many review pages to walk per country (50 reviews per page, up to 10 pages available per storefront). Leave at the maximum; the run stops at Max reviews.",
                        "default": 10
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Connection settings. The default works on any Apify plan.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write. Leave empty to skip; never changes the dataset output. Supported: Notion, Linear, Airtable, Apify."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
