# Apple App Store Reviews Scraper (`automation-lab/apple-app-store-reviews-scraper`) Actor

Scrape Apple App Store reviews, ratings, dates, versions, countries, and app metadata from public iTunes review feeds.

- **URL**: https://apify.com/automation-lab/apple-app-store-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **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

## Apple App Store Reviews Scraper

Extract Apple App Store reviews from public iTunes review feeds.

Use this actor to collect review text, star ratings, app versions, review dates, reviewer names, helpful-vote counts, countries, and app metadata for iOS apps.

### What does Apple App Store Reviews Scraper do?

Apple App Store Reviews Scraper turns public iOS review feeds into a clean dataset.

It accepts Apple App Store app URLs or numeric app IDs.

It then fetches public customer reviews from the Apple iTunes RSS endpoint.

Each saved row is one review.

The actor also enriches each row with app metadata from Apple's public lookup endpoint.

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML from Apify.

### Who is it for?

🧑‍💼 Product managers use it to monitor app feedback after releases.

📣 App marketers use it to track sentiment, keywords, and campaign impact.

⭐ ASO agencies use it to compare review language across clients and competitors.

🎧 Support teams use it to find recurring complaints and urgent bug reports.

🛡️ Trust, safety, and compliance teams use it to preserve review evidence.

📊 Data teams use it to feed BI dashboards and text analytics pipelines.

### Why scrape App Store reviews?

App reviews are one of the fastest public signals for product quality.

They include star ratings and free-form customer language.

They often mention bugs, pricing objections, feature requests, and competitor comparisons.

Review monitoring is recurring work.

Most teams need fresh data daily or weekly.

This actor is designed for repeat runs and simple automation.

### Why use this actor?

✅ HTTP-only implementation using public Apple endpoints.

✅ No account, login, cookie, browser, or CAPTCHA required.

✅ Supports multiple apps in one run.

✅ Supports multiple App Store countries in one run.

✅ Uses Apple's reliable most-recent public review feed.

✅ Includes app metadata when available.

✅ Produces flat review rows ready for spreadsheets and databases.

### Data you can extract

| Field | Description |
| --- | --- |
| `appId` | Numeric Apple App Store app ID |
| `appName` | App name from Apple lookup |
| `bundleId` | iOS bundle identifier |
| `developerName` | Developer or publisher name |
| `genre` | Primary App Store genre |
| `genres` | Genre list from Apple lookup |
| `averageUserRating` | Current average user rating |
| `userRatingCount` | Current total rating count |
| `currentVersion` | Current app version |
| `country` | App Store country code used for the feed |
| `sortBy` | Review sorting mode |
| `reviewId` | Apple review ID |
| `reviewUrl` | Public review URL when provided |
| `reviewTitle` | Review headline |
| `reviewText` | Review body text |
| `rating` | Review star rating from 1 to 5 |
| `reviewVersion` | App version reviewed |
| `reviewDate` | Review timestamp |
| `authorName` | Reviewer display name |
| `voteSum` | Helpful vote score |
| `voteCount` | Helpful vote count |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to scrape Apple App Store reviews?

This actor uses pay-per-event pricing.

There is a small run-start charge.

There is also a per-review charge for each review saved to the dataset.

Always check the actor pricing panel on Apify for the exact current tiered price, because your Apify plan can change the tiered per-review price.

Typical cost examples at the current Bronze tier are:

| Reviews saved | Estimated actor charge |
| ---: | ---: |
| 20 reviews | about $0.008 |
| 100 reviews | about $0.020 |
| 500 reviews | about $0.080 |
| 1,000 reviews | about $0.155 |

These examples include the run-start event plus a per-review event.

The Apify free plan includes monthly platform credits, so small tests such as 20 or 100 reviews are usually suitable for evaluation within free-plan credits.

Large recurring monitoring jobs should still review the pricing panel before scheduling daily or hourly runs.

### Input overview

You can provide app URLs.

You can provide app IDs.

You can provide both.

Duplicates are removed automatically by app ID.

You can choose one or more countries.

You can set a maximum number of reviews per app per country.

### Example input

```json
{
  "appUrls": [
    { "url": "https://apps.apple.com/us/app/youtube/id544007664" }
  ],
  "countries": ["us"],
  "sortBy": "mostRecent",
  "maxReviewsPerApp": 50,
  "includeAppMetadata": true
}
````

### Input fields

#### `appUrls`

Paste one or more Apple App Store URLs.

The actor extracts the numeric app ID from URLs such as `https://apps.apple.com/us/app/facebook/id284882215`.

#### `appIds`

Use numeric app IDs directly when you already have them.

For example, YouTube is `544007664`.

#### `countries`

Use two-letter App Store country codes.

Examples include `us`, `gb`, `ca`, `de`, `fr`, `jp`, and `au`.

The actor fetches each app/country pair separately.

#### `sortBy`

The actor uses `mostRecent` for newest public reviews first.

#### `maxReviewsPerApp`

Set the maximum review count per app per country.

Apple's public RSS feed normally exposes up to about 500 reviews per app/country.

#### `includeAppMetadata`

Keep this enabled when you want app name, developer, genre, version, rating count, and artwork fields included on every row.

Disable it only if you want the smallest possible request footprint.

### Output example

```json
{
  "appId": "544007664",
  "appName": "YouTube",
  "developerName": "Google",
  "country": "us",
  "sortBy": "mostRecent",
  "reviewId": "14153383959",
  "reviewTitle": "Useless",
  "reviewText": "Can’t lock my profile without reason",
  "rating": 1,
  "reviewVersion": "564.0.0",
  "reviewDate": "2026-06-06T22:45:43-07:00",
  "authorName": "Nikniknikmorenik",
  "voteSum": 0,
  "voteCount": 0,
  "scrapedAt": "2026-06-08T00:00:00.000Z"
}
```

### How to run the actor

1. Open the actor on Apify.

2. Click **Try for free** or **Start**.

3. Paste one or more App Store URLs or app IDs.

4. Choose country codes.

5. Select the sort mode.

6. Set the review limit.

7. Start the run.

8. Download the dataset when the run succeeds.

### Tips for best results

Start with one app and one country while testing a workflow.

Use `mostRecent` for release monitoring.

Run the same input daily or weekly for review monitoring.

Use country-specific runs when your app has localized support teams.

Export to CSV when handing review lists to non-technical stakeholders.

Export to JSON when feeding NLP pipelines.

### Common workflows

#### Release monitoring

Run the actor after every iOS release.

Filter reviews by `reviewVersion`.

Watch for one-star reviews mentioning crashes or login issues.

#### Competitor tracking

Add your competitor app IDs.

Run the actor weekly.

Compare ratings and review themes across apps.

#### ASO keyword research

Export review text.

Extract repeated phrases from five-star reviews.

Use those phrases to improve App Store listing language.

#### Support triage

Search review text for billing, password, crash, subscription, or cancellation terms.

Send matching reviews to your support queue.

### Integrations

Connect the dataset to Google Sheets for stakeholder reporting.

Send results to Slack through an Apify webhook.

Load the dataset into BigQuery, Snowflake, or S3 for warehouse analysis.

Trigger the actor from Zapier or Make when a release checklist is completed.

Use Apify API clients to schedule review ingestion from your own backend.

### 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/apple-app-store-reviews-scraper').call({
  appIds: ['544007664'],
  countries: ['us'],
  maxReviewsPerApp: 50
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/apple-app-store-reviews-scraper').call(run_input={
    'appIds': ['544007664'],
    'countries': ['us'],
    'maxReviewsPerApp': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~apple-app-store-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"appIds":["544007664"],"countries":["us"],"maxReviewsPerApp":50}'
```

### MCP usage

You can use the actor through Apify MCP from Claude Code, Claude Desktop, or other MCP clients.

Use this MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/apple-app-store-reviews-scraper
```

Add it in Claude Code with:

```bash
claude mcp add apify-apple-app-store-reviews --transport http "https://mcp.apify.com/?tools=automation-lab/apple-app-store-reviews-scraper"
```

For Claude Desktop or another JSON-based MCP client, add a server entry like this:

```json
{
  "mcpServers": {
    "apify-apple-app-store-reviews": {
      "url": "https://mcp.apify.com/?tools=automation-lab/apple-app-store-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Run the Apple App Store Reviews Scraper for app ID 544007664 in the US and summarize one-star complaints."
- "Collect the 100 most recent reviews for these iOS app IDs and group them by app version."
- "Compare review themes for my app and two competitors across US and GB storefronts."

### Scheduling

Use Apify schedules to run the same input repeatedly.

Daily schedules work well for active consumer apps.

Weekly schedules work well for competitor monitoring.

Monthly schedules work well for market research snapshots.

### Limitations

Apple controls the public RSS review feed.

The feed normally exposes recent or helpful reviews rather than every historical review ever written.

Availability can vary by app and country.

Some apps or countries may return no public reviews.

The actor does not scrape private App Store Connect data.

The actor does not require or use Apple developer credentials.

### FAQ and troubleshooting

#### Why did I get zero reviews?

Check that the app ID is correct.

Try country `us` first.

Try another popular app to confirm your input shape.

Some app/country combinations have no public reviews in Apple's RSS feed.

#### Why are there fewer than my requested reviews?

Apple's public feed has a practical page limit.

The app may have fewer visible reviews for that country and sort mode.

Try another country or reduce the review limit.

#### Why does metadata differ by country?

Apple lookup data is storefront-specific.

Names, ratings, pricing, and availability can vary by country.

### Legality and ethics

This actor uses public Apple endpoints.

It does not log in.

It does not access private App Store Connect data.

You should still use the data responsibly.

Respect applicable laws, privacy obligations, platform terms, and your organization's data policies.

If you are unsure whether your use case is permitted, consult legal counsel.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/apple-app-store-scraper
- https://apify.com/automation-lab/google-play-scraper
- https://apify.com/automation-lab/google-play-reviews-scraper

### Changelog

#### 0.1

Initial version with public Apple RSS review extraction, multi-app input, country support, per-review charging, and app metadata enrichment.

### Support

If a run fails, include the run URL and the input you used when reporting the issue.

For best troubleshooting, start with one app ID, one country, and a low review limit.

# Actor input Schema

## `appUrls` (type: `array`):

Paste one or more public Apple App Store app URLs. The actor extracts the numeric app ID automatically.

## `appIds` (type: `array`):

Optional numeric App Store IDs, for example 284882215 for Facebook. Use this when you already know the app IDs.

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

Two-letter App Store storefront country codes. Reviews are fetched separately for each country.

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

Apple RSS review-feed sorting mode. Apple's public JSON feed currently returns reliable review rows for most recent sorting.

## `maxReviewsPerApp` (type: `integer`):

Maximum reviews to save for each app/country pair. Apple exposes up to about 500 reviews per app/country through the public RSS feed.

## `includeAppMetadata` (type: `boolean`):

Add app name, developer, genre, current version, rating count, artwork URL, and App Store URL using Apple's public lookup endpoint.

## Actor input object example

```json
{
  "appUrls": [
    {
      "url": "https://apps.apple.com/us/app/youtube/id544007664"
    }
  ],
  "appIds": [
    "544007664"
  ],
  "countries": [
    "us"
  ],
  "sortBy": "mostRecent",
  "maxReviewsPerApp": 20,
  "includeAppMetadata": true
}
```

# 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 = {
    "appUrls": [
        {
            "url": "https://apps.apple.com/us/app/youtube/id544007664"
        }
    ],
    "appIds": [
        "544007664"
    ],
    "countries": [
        "us"
    ],
    "maxReviewsPerApp": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/apple-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 = {
    "appUrls": [{ "url": "https://apps.apple.com/us/app/youtube/id544007664" }],
    "appIds": ["544007664"],
    "countries": ["us"],
    "maxReviewsPerApp": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/apple-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 '{
  "appUrls": [
    {
      "url": "https://apps.apple.com/us/app/youtube/id544007664"
    }
  ],
  "appIds": [
    "544007664"
  ],
  "countries": [
    "us"
  ],
  "maxReviewsPerApp": 20
}' |
apify call automation-lab/apple-app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Reviews Scraper",
        "description": "Scrape Apple App Store reviews, ratings, dates, versions, countries, and app metadata from public iTunes review feeds.",
        "version": "0.1",
        "x-build-id": "q23ihQBjgdDXLrFT9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~apple-app-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-apple-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/automation-lab~apple-app-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-apple-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/automation-lab~apple-app-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-apple-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",
                "properties": {
                    "appUrls": {
                        "title": "Apple App Store app URLs",
                        "type": "array",
                        "description": "Paste one or more public Apple App Store app URLs. The actor extracts the numeric app ID automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "appIds": {
                        "title": "Apple App Store app IDs",
                        "type": "array",
                        "description": "Optional numeric App Store IDs, for example 284882215 for Facebook. Use this when you already know the app IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Country codes",
                        "type": "array",
                        "description": "Two-letter App Store storefront country codes. Reviews are fetched separately for each country.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Review sorting",
                        "enum": [
                            "mostRecent"
                        ],
                        "type": "string",
                        "description": "Apple RSS review-feed sorting mode. Apple's public JSON feed currently returns reliable review rows for most recent sorting.",
                        "default": "mostRecent"
                    },
                    "maxReviewsPerApp": {
                        "title": "Maximum reviews per app per country",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum reviews to save for each app/country pair. Apple exposes up to about 500 reviews per app/country through the public RSS feed.",
                        "default": 100
                    },
                    "includeAppMetadata": {
                        "title": "Include app metadata",
                        "type": "boolean",
                        "description": "Add app name, developer, genre, current version, rating count, artwork URL, and App Store URL using Apple's public lookup endpoint.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
