# Apple App Store Scraper (`maximedupre/apple-app-store-scraper`) Actor

Scrape public Apple App Store app data and reviews. Search apps by keyword, look up app IDs or URLs, collect top charts, and export ratings, prices, developers, genres, versions, and review text.

- **URL**: https://apify.com/maximedupre/apple-app-store-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 scraped apps

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 scraper for apps, charts, and reviews

Apple App Store Scraper collects public iOS app data from the [Apple App Store](https://apps.apple.com/). Search by keyword, look up apps by App Store URL or numeric app ID, pull top chart apps, or export public App Store reviews for product research, ASO work, competitor monitoring, and reporting.

Use this Apple App Store scraper when you need app names, developers, bundle IDs, genres, prices, ratings, versions, source URLs, storefronts, and public review text in one clean Apify dataset. You can export the results as JSON, CSV, Excel, XML, RSS, or HTML, run the Actor through the Apify API, schedule repeat checks, or connect the data to webhooks and integrations.

You do not need an Apple Developer account, App Store Connect access, cookies, or an API key. For a small first run, keep the prefilled Spotify App Store URL and run **App details** mode to preview the app row shape before adding more app IDs, URLs, search terms, or chart settings.

### ✅ What this Actor does

- Looks up public App Store app details from app URLs or numeric app IDs.
- Searches Apple App Store apps by keyword.
- Collects apps from Apple top chart feeds.
- Scrapes public App Store reviews for one or more apps.
- Can add public review rows alongside app rows in app details, search, and top chart modes.
- Supports country storefront settings such as United States, Canada, United Kingdom, Germany, France, Japan, India, and more.
- Saves one dataset item per app or review.
- Adds source target, target type, source URL, source rank, storefront country, and scrape time.
- Runs without user-provided Apple credentials.

This Actor is focused on public Apple App Store data. It does not scrape private App Store Connect analytics, paid campaign data, TestFlight builds, in-app purchase reports, subscriber data, private developer dashboards, or historical archives beyond what Apple exposes publicly.

### 📦 Data you can extract

#### 🍏 App rows

App rows can include:

- `rowType` - `app`
- `target` and `targetType`
- `sourceUrl` and `sourceRank`
- `appId` and `bundleId`
- `appName`
- `developer` and `developerUrl`
- `primaryGenre` and `primaryGenreId`
- `price`, `currency`, and `formattedPrice`
- `rating` and `ratingCount`
- `version`
- `country`
- `scrapedAt`

Some fields can be empty when Apple does not expose them for a specific app, country storefront, chart, or search result.

#### ⭐ Review rows

Review rows can include:

- `rowType` - `review`
- `target`, `targetType`, `sourceUrl`, and `sourceRank`
- `appId`
- `reviewId`
- `reviewTitle` and `reviewText`
- `reviewRating`
- `reviewAuthor`
- `country`
- `scrapedAt`

Apple review availability can vary by storefront and app. If a selected app has no public reviews in the chosen country, the Actor completes the run and reports that no public reviews were found for that app.

### 🚀 Common use cases

- Find iOS apps for App Store keywords such as `photo editor`, `habit tracker`, or `budget planner`.
- Build Apple App Store datasets for ASO research, category research, or app market maps.
- Track competitor app metadata, ratings, pricing, versions, and storefront availability.
- Collect public App Store reviews for product feedback, support triage, sentiment analysis, or feature request research.
- Pull top free, top paid, top grossing, and new app chart data for market monitoring.
- Schedule repeat App Store checks and send results to spreadsheets, BI tools, APIs, webhooks, or internal workflows.

### ▶️ How to run it

1. Choose a **Mode**: app details, search apps, app reviews, or top charts.
2. Add App Store targets when the mode needs them.
3. Pick the App Store **Country** storefront.
4. Keep the app and review limits low for a preview run.
5. Start the Actor and open the dataset.

Use App Store URLs or numeric app IDs for app details and reviews:

```json
{
  "mode": "lookup",
  "targets": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580",
    "570060128"
  ],
  "country": "us",
  "maxAppsPerTarget": 10,
  "includeReviews": false,
  "reviewLimit": 25,
  "reviewSort": "mostRecent",
  "chartCollection": "top-free"
}
````

Use keywords for search mode:

```json
{
  "mode": "search",
  "targets": ["photo editor", "fitness tracker"],
  "country": "us",
  "maxAppsPerTarget": 25,
  "includeReviews": true,
  "reviewLimit": 10,
  "reviewSort": "mostRecent",
  "chartCollection": "top-free"
}
```

Use top charts mode when you want Apple chart feeds. In this mode, the Actor uses the selected chart and country; the `targets` field is ignored.

### ⚙️ Input options

| Field | What it does |
| --- | --- |
| `mode` | Selects app lookup, app search, app reviews, or top charts. |
| `targets` | App Store URLs or numeric app IDs for lookup and reviews; keyword strings for search. Ignored in top charts mode. |
| `maxAppsPerTarget` | Caps app rows for each lookup target, search term, or chart run. |
| `reviewLimit` | Caps public review rows per app, up to Apple's RSS review limit. |
| `includeReviews` | Adds public review rows when running app details, search, or top charts. |
| `reviewSort` | Requests most recent or most helpful public reviews from Apple. |
| `country` | Chooses the two-letter Apple storefront country. |
| `chartCollection` | Chooses the Apple top chart feed for top charts mode. |
| `categoryIds` | Optional App Store genre IDs. Search uses the first ID; top charts filter fetched app details after lookup. |

### 🧾 Output example

```json
{
  "rowType": "app",
  "target": "photo editor",
  "targetType": "search",
  "sourceUrl": "https://apps.apple.com/us/app/example/id123456789",
  "sourceRank": 1,
  "appId": "123456789",
  "appName": "Example Photo Editor",
  "bundleId": "com.example.photo",
  "developer": "Example Developer",
  "developerUrl": "https://apps.apple.com/us/developer/example/id987654321",
  "primaryGenre": "Photo & Video",
  "primaryGenreId": "6008",
  "price": 0,
  "currency": "USD",
  "formattedPrice": "Free",
  "rating": 4.7,
  "ratingCount": 12345,
  "version": "1.2.3",
  "country": "us",
  "scrapedAt": "2026-05-28T12:00:00.000Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. App rows and review rows are charged as separate scraped results, so a run with **Include reviews with app rows** turned on can create both app charges and review charges.

Keep the default limits for a small preview, then raise `maxAppsPerTarget` or `reviewLimit` when the output matches your workflow.

### ⚠️ Limits and caveats

- Apple data can vary by country storefront.
- App search and top chart order follow the public Apple source for the selected storefront and settings.
- Public review availability depends on the app, country, and Apple RSS feed.
- Top chart category filtering is applied after app details are fetched, so a filtered chart can return fewer rows than the requested app limit.
- The Actor only returns data Apple exposes publicly. It does not access private developer, user, or analytics data.

### ❓ FAQ

#### Do I need an Apple account?

No. The Actor uses public Apple App Store surfaces and does not require an Apple Developer account, App Store Connect access, cookies, or an API key.

#### Can I scrape App Store reviews?

Yes. Use **App reviews** mode for review-only runs, or turn on **Include reviews with app rows** when running app details, search, or top charts.

#### Can I use this as an Apple App Store API?

Yes, for public App Store data returned by this Actor. You can run it through the Apify API, schedule it, export datasets, or connect it to webhooks and integrations.

#### Why did a run return fewer apps than my limit?

Apple may return fewer public results for a keyword, country, chart, or category filter than the limit you requested. Top chart category filtering can also reduce the final row count after app details are checked.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~apple-app-store-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Google Play Store Scraper ↗](https://apify.com/maximedupre/google-play-store-scraper) - Scrape Android app metadata, search results, categories, developer pages, and public Google Play reviews.
- [App Store Ratings Scraper ↗](https://apify.com/maximedupre/app-store-ratings-scraper) - Compare Apple App Store and Google Play ratings, metadata, prices, and review counts in one dataset.
- [Social Media Stats Checker ↗](https://apify.com/maximedupre/social-media-stats-checker) - Check public profile stats across major social platforms for creator, brand, and competitor research.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Collect TikTok autocomplete suggestions for social search, content planning, and keyword research.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - Export Pinterest autocomplete keyword suggestions for SEO, content planning, and niche research.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Choose the Apple App Store source to scrape: app details, app search, public reviews, or top charts.

## `targets` (type: `array`):

Add one target per line. Use App Store URLs or numeric app IDs for app details and reviews, or keyword phrases for search mode. Top charts mode ignores this field.

## `maxAppsPerTarget` (type: `integer`):

Maximum app rows to save for each lookup target, search keyword, or top chart run.

## `reviewLimit` (type: `integer`):

Maximum public review rows to save for each app. Apple's RSS feed usually returns up to 500 reviews per storefront.

## `includeReviews` (type: `boolean`):

Also save public App Store review rows for apps found in app details, search, or top charts mode.

## `reviewSort` (type: `string`):

Choose how Apple should order public RSS reviews.

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

Two-letter Apple App Store storefront code. App listings, prices, availability, and reviews can vary by country.

## `chartCollection` (type: `string`):

Apple top chart feed to scrape in top charts mode.

## `categoryIds` (type: `array`):

Optional App Store genre IDs. Search mode sends the first genre ID to Apple Search. Top charts mode filters fetched app details after lookup.

## Actor input object example

```json
{
  "mode": "lookup",
  "targets": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ],
  "maxAppsPerTarget": 25,
  "reviewLimit": 50,
  "includeReviews": false,
  "reviewSort": "mostRecent",
  "country": "us",
  "chartCollection": "top-free"
}
```

# Actor output Schema

## `results` (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 = {
    "mode": "lookup",
    "targets": [
        "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
    ],
    "maxAppsPerTarget": 25,
    "reviewLimit": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/apple-app-store-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 = {
    "mode": "lookup",
    "targets": ["https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"],
    "maxAppsPerTarget": 25,
    "reviewLimit": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/apple-app-store-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 '{
  "mode": "lookup",
  "targets": [
    "https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580"
  ],
  "maxAppsPerTarget": 25,
  "reviewLimit": 50
}' |
apify call maximedupre/apple-app-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Scraper",
        "description": "Scrape public Apple App Store app data and reviews. Search apps by keyword, look up app IDs or URLs, collect top charts, and export ratings, prices, developers, genres, versions, and review text.",
        "version": "0.0",
        "x-build-id": "PbFiUvQJlqguNRj6I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~apple-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-apple-app-store-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/maximedupre~apple-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-apple-app-store-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/maximedupre~apple-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-apple-app-store-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",
                    "maxAppsPerTarget",
                    "reviewLimit",
                    "includeReviews",
                    "reviewSort",
                    "country",
                    "chartCollection"
                ],
                "properties": {
                    "mode": {
                        "title": "Scrape mode",
                        "enum": [
                            "lookup",
                            "search",
                            "reviews",
                            "topCharts"
                        ],
                        "type": "string",
                        "description": "Choose the Apple App Store source to scrape: app details, app search, public reviews, or top charts.",
                        "default": "lookup"
                    },
                    "targets": {
                        "title": "App Store targets",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add one target per line. Use App Store URLs or numeric app IDs for app details and reviews, or keyword phrases for search mode. Top charts mode ignores this field.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxAppsPerTarget": {
                        "title": "App limit",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum app rows to save for each lookup target, search keyword, or top chart run.",
                        "default": 25
                    },
                    "reviewLimit": {
                        "title": "Review limit",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum public review rows to save for each app. Apple's RSS feed usually returns up to 500 reviews per storefront.",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Also save public App Store review rows for apps found in app details, search, or top charts mode.",
                        "default": false
                    },
                    "reviewSort": {
                        "title": "Review order",
                        "enum": [
                            "mostRecent",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "Choose how Apple should order public RSS reviews.",
                        "default": "mostRecent"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "ca",
                            "gb",
                            "au",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "br",
                            "mx",
                            "jp",
                            "in",
                            "pt"
                        ],
                        "type": "string",
                        "description": "Two-letter Apple App Store storefront code. App listings, prices, availability, and reviews can vary by country.",
                        "default": "us"
                    },
                    "chartCollection": {
                        "title": "Chart feed",
                        "enum": [
                            "top-free",
                            "top-paid",
                            "top-grossing",
                            "new-apps",
                            "new-free",
                            "new-paid"
                        ],
                        "type": "string",
                        "description": "Apple top chart feed to scrape in top charts mode.",
                        "default": "top-free"
                    },
                    "categoryIds": {
                        "title": "Category IDs",
                        "type": "array",
                        "description": "Optional App Store genre IDs. Search mode sends the first genre ID to Apple Search. Top charts mode filters fetched app details after lookup.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```