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

All-in-one Apple App Store scraper. Search apps by keyword, get full app details (rating, price, developer, screenshots, description), and extract customer reviews. Supports 50+ countries.

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

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 — Search, App Details & Reviews (All-in-One)

The only Apple App Store scraper you need. Search for apps by keyword, pull complete app details, and extract reviews — all in a single actor with three simple modes. No juggling multiple tools, no separate scrapers for each job.

---

### Why Use This All-in-One App Store Scraper?

- **3 modes in 1 actor** — search apps by keyword, fetch full app details, or scrape reviews, all from the same tool
- **44 fields per app** in details mode — the most complete Apple App Store data available in a single request
- **Search up to 200 apps per keyword** — see exactly how Apple ranks apps for any search term
- **50+ App Store countries supported** — pull localized rankings, details, and reviews from any storefront
- **Media type support** — search across apps, music, movies, and podcasts, not just software
- **No browser, no proxy, no API key required** — fully anonymous, zero setup, zero maintenance
- **Fast across every mode** — search, details, and reviews all return in seconds, not minutes

Whether you're doing App Store Optimization research, competitive analysis, or building an app intelligence dashboard, this scraper replaces three separate tools with one.

---

### The Three Modes

#### Search Mode
Enter one or more keywords and get back a ranked list of matching apps — exactly as they appear in Apple's own App Store search results. Perfect for keyword research, competitor discovery, and ASO ranking checks.

#### Details Mode
Provide an App Store ID or URL and get back the complete app profile: pricing, ratings, description, release notes, screenshots, file size, supported languages, and more — 44 fields in total.

#### Reviews Mode
Provide an App Store ID or URL and get back individual user reviews with ratings, review text, author info, helpful votes, and app version — the same review engine used by our dedicated App Store Reviews Scraper.

---

### Input Parameters

```json
{
  "mode": "search",
  "searchTerms": ["whatsapp"],
  "countries": ["us"],
  "maxResults": 200
}
````

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | string | Yes | — | Which mode to run: `search`, `details`, or `reviews`. |
| `searchTerms` | array | Search mode only | — | Keywords to search for. |
| `appIds` | array | Details / Reviews mode only | — | App Store numeric IDs or URLs. IDs are extracted automatically from URLs. |
| `countries` | array | No | `["us"]` | App Store country codes (e.g. `us`, `gb`, `de`, `jp`). |
| `maxResults` | integer | Search mode only | 200 | Maximum apps returned per search term per country. |
| `maxReviews` | integer | Reviews mode only | 500 | Maximum reviews returned per app per country. |
| `sortBy` | string | Reviews mode only | `mostrecent` | Review sort order: `mostrecent` or `mosthelpful`. |
| `sinceDate` | string | Reviews mode only | — | Only include reviews on or after this date. Format: `YYYY-MM-DD`. |
| `mediaType` | string | Search mode only | `software` | Media type to search: `software`, `music`, `movie`, or `podcast`. |

***

### What Data Do You Get?

#### Search & Details Mode (29 fields)

| Field | Description |
|---|---|
| **type** | Result type marker |
| **appId** | App Store numeric ID |
| **appName** | App name |
| **bundleId** | App's bundle identifier |
| **developer** | Publisher / developer name |
| **developerUrl** | Link to the developer's App Store page |
| **sellerName** | Legal seller name on record |
| **price** | Numeric app price |
| **formattedPrice** | Display-formatted price string (e.g. "Free", "$4.99") |
| **currency** | Currency code for the price |
| **rating** | Current overall average rating |
| **ratingCount** | Total number of ratings |
| **ratingCountCurrentVersion** | Ratings received for the current version |
| **contentRating** | Age content rating |
| **primaryGenre** | Primary App Store category |
| **genres** | All categories the app is listed under |
| **version** | Current app version |
| **currentVersionDate** | Release date of the current version |
| **releaseDate** | Original app release date |
| **releaseNotes** | "What's New" text for the current version |
| **description** | Full app description |
| **minimumOsVersion** | Minimum required iOS version |
| **fileSizeBytes** | App size in bytes |
| **languages** | Supported languages |
| **screenshotUrls** | URLs to app screenshots |
| **artworkUrl** | App icon URL |
| **appUrl** | Direct App Store link |
| **country** | Storefront the data was pulled from |
| **scrapedAt** | Timestamp of when the data was collected |

#### Reviews Mode (15 fields)

| Field | Description |
|---|---|
| **type** | Result type marker |
| **reviewId** | Unique identifier for the review |
| **title** | Review headline |
| **text** | Full review body text |
| **rating** | Star rating from 1 to 5 |
| **author** | Reviewer's display name |
| **authorUrl** | Link to the reviewer's App Store profile |
| **date** | Review submission date (ISO 8601) |
| **appVersion** | App version the review was written against |
| **helpfulVotes** | Number of users who marked the review helpful |
| **totalVotes** | Total helpfulness votes cast |
| **appId** | App Store numeric ID |
| **appName** | App name |
| **country** | Storefront the review was pulled from |
| **scrapedAt** | Timestamp of when the data was collected |

***

### How Fast Is It?

| Mode | Volume | Time |
|---|---|---|
| Search | 95 apps | ~2 seconds |
| Details | 6 apps | ~1 second |
| Details | 1 app | under 1 second |
| Reviews | 500 reviews | ~5 seconds |
| Reviews | 5,000 reviews | ~1 minute |

There's no browser to spin up and no proxy hops to wait on in any mode, so search, details, and reviews all return in seconds regardless of how many apps or countries you request.

***

### Use Cases

#### App Store Optimization (ASO) & Keyword Research

- **Check keyword rankings** by running Search mode with your target keywords and seeing exactly where your app lands
- **Discover competitor apps** ranking for the same keywords you're targeting
- **Track ranking changes over time** by running the same search terms on a schedule
- **Research media-type-specific rankings** for apps, podcasts, music, or movies using `mediaType`

#### Competitive Intelligence & Market Research

- **Build a full competitor profile** by combining Details mode (pricing, ratings, description, release notes) with Reviews mode (user sentiment) for the same app
- **Track competitor release cadence** using `currentVersionDate` and `releaseNotes` across scheduled runs
- **Compare pricing strategies** across a whole category using `formattedPrice` and `currency`
- **Monitor localized presence** by pulling details and rankings across 50+ App Store countries

#### App Store Due Diligence & Investment Research

- **Assess app health at a glance** using `rating`, `ratingCount`, and `ratingCountCurrentVersion` trends
- **Verify claims in a pitch deck or acquisition target** by pulling live App Store data instead of relying on self-reported numbers
- **Track a portfolio of apps** across search visibility, details, and review sentiment in one workflow

#### Content & Marketing Research

- **Analyze top screenshots and app store creative** across a category using `screenshotUrls` and `artworkUrl`
- **Study high-performing app descriptions** by pulling `description` and `releaseNotes` from top-ranked apps in Search mode
- **Find quotable customer testimonials** by combining Search mode discovery with Reviews mode extraction

#### AI, NLP & Machine Learning

- **Train ranking prediction models** using search position combined with app metadata
- **Build sentiment datasets** by pairing Reviews mode output with Details mode context (category, price, rating)
- **Power app recommendation engines** using genre, rating, and description data at scale

***

### Frequently Asked Questions

**Can I search, get details, and scrape reviews all in one run?**
Each run uses one `mode` at a time, but since all three modes live in the same actor, you can trigger them back-to-back with different `mode` values without switching tools or learning a new interface.

**How many apps can I search for per keyword?**
Up to 200 apps per search term per country, controlled by `maxResults`. This mirrors Apple's own App Store search depth.

**Does Details mode work without knowing the App Store ID in advance?**
You can paste a full App Store URL and the numeric ID is extracted automatically — no need to look up the raw ID yourself.

**What's included in the 44 fields for app details?**
Pricing, ratings, ranking, version history, release notes, descriptions, screenshots, supported languages, file size, minimum OS version, developer info, and more — everything needed for a complete app profile without a second lookup.

**Can I get App Store rankings for other countries, not just the US?**
Yes. Add any of the 50+ supported country codes to `countries` and get localized search results, details, and reviews for each storefront.

**Does this scraper support searching for things other than apps?**
Yes. Use the `mediaType` parameter to search music, movies, and podcasts in addition to software (apps).

**Is a proxy required to use this scraper?**
No. All three modes run without any proxy configuration and without a browser, keeping every run fast and lightweight.

**How does Reviews mode compare to a dedicated reviews-only scraper?**
It returns the same review fields and uses the same underlying review engine, so you get identical review data whether you use this all-in-one actor or a reviews-only scraper — the difference is just convenience of having search and details in the same tool.

**Can I filter reviews by date in this scraper?**
Yes. Use `sinceDate` in Reviews mode to only pull reviews submitted on or after a specific date.

**Do I need an Apple Developer account to use this?**
No. Every mode works from publicly available App Store data. You don't need developer credentials, app ownership, or any Apple authentication.

**Can I track how an app's ranking changes over time?**
Yes. Schedule Search mode to run daily or weekly with the same keywords and compare each app's position across runs.

**What does `ratingCountCurrentVersion` tell me that `ratingCount` doesn't?**
`ratingCount` is the app's all-time total rating count. `ratingCountCurrentVersion` isolates ratings received specifically for the current version, which is useful for measuring reaction to a recent release.

**Can I export results to Excel or Google Sheets?**
Yes. Apify datasets support exporting to JSON, CSV, Excel, XML, and other formats, plus direct integrations to Google Sheets and other tools.

**Can I run this on a schedule to monitor changes?**
Yes. Apify's built-in scheduler lets you run any mode daily, weekly, or on any custom interval to continuously track rankings, app updates, or new reviews.

***

### Output Formats

Results are available directly from your dataset in every format Apify supports:

- **JSON** — structured data for programmatic use and API integration
- **CSV** — flat table format, opens directly in Excel and Google Sheets
- **Excel (.xlsx)** — native spreadsheet format with proper headers
- **XML** — structured markup for enterprise integrations

***

### Integration & Automation

Connect this App Store scraper to your existing workflow:

- **Google Sheets** — append new search results, app details, or reviews automatically
- **Slack / Discord** — get notified when a scheduled run finds ranking changes or new reviews
- **Webhooks** — trigger your own systems when a run completes
- **Zapier / Make** — connect to thousands of apps without writing code
- **BigQuery / Snowflake / data warehouses** — load app intelligence data for long-term analysis

Set up a recurring schedule with Apify's built-in scheduler to track App Store rankings, monitor app updates, or watch for new reviews without lifting a finger.

# Actor input Schema

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

What to scrape: search for apps by keyword, look up app details by ID, or scrape reviews.

## `searchTerms` (type: `array`):

Keywords to search for (search mode only).

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

App Store numeric IDs or URLs (details / reviews mode only). ID extracted automatically from URLs.

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

App Store country codes (e.g. us, gb, de, jp).

## `maxResults` (type: `integer`):

Max apps returned per search term per country (search mode only). Apple caps at 200.

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

Max reviews per app per country (reviews mode only). Apple exposes at most 500 (10 pages x 50).

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

Review sort order (reviews mode only).

## `sinceDate` (type: `string`):

Only include reviews on or after this date (reviews mode only). Format: YYYY-MM-DD

## `mediaType` (type: `string`):

Media type to search for (search mode only).

## Actor input object example

```json
{
  "mode": "details",
  "searchTerms": [
    "whatsapp"
  ],
  "appIds": [
    "https://apps.apple.com/us/app/whatsapp-messenger/id310633997"
  ],
  "countries": [
    "us"
  ],
  "maxResults": 200,
  "maxReviews": 500,
  "sortBy": "mostrecent",
  "mediaType": "software"
}
```

# 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": "details",
    "searchTerms": [
        "whatsapp"
    ],
    "appIds": [
        "https://apps.apple.com/us/app/whatsapp-messenger/id310633997"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/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": "details",
    "searchTerms": ["whatsapp"],
    "appIds": ["https://apps.apple.com/us/app/whatsapp-messenger/id310633997"],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/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": "details",
  "searchTerms": [
    "whatsapp"
  ],
  "appIds": [
    "https://apps.apple.com/us/app/whatsapp-messenger/id310633997"
  ],
  "countries": [
    "us"
  ]
}' |
apify call scrapesmith/apple-app-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Scraper",
        "description": "All-in-one Apple App Store scraper. Search apps by keyword, get full app details (rating, price, developer, screenshots, description), and extract customer reviews. Supports 50+ countries.",
        "version": "0.0",
        "x-build-id": "TujbkqRDkPtUhWKBu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~apple-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-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/scrapesmith~apple-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-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/scrapesmith~apple-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-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"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "details",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to scrape: search for apps by keyword, look up app details by ID, or scrape reviews."
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search for (search mode only).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appIds": {
                        "title": "App Store IDs or URLs",
                        "type": "array",
                        "description": "App Store numeric IDs or URLs (details / reviews mode only). ID extracted automatically from URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "App Store country codes (e.g. us, gb, de, jp).",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per search term",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Max apps returned per search term per country (search mode only). Apple caps at 200.",
                        "default": 200
                    },
                    "maxReviews": {
                        "title": "Max reviews per app per country",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Max reviews per app per country (reviews mode only). Apple exposes at most 500 (10 pages x 50).",
                        "default": 500
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "mostrecent",
                            "mosthelpful"
                        ],
                        "type": "string",
                        "description": "Review sort order (reviews mode only).",
                        "default": "mostrecent"
                    },
                    "sinceDate": {
                        "title": "Reviews since date",
                        "type": "string",
                        "description": "Only include reviews on or after this date (reviews mode only). Format: YYYY-MM-DD"
                    },
                    "mediaType": {
                        "title": "Media type",
                        "enum": [
                            "software",
                            "music",
                            "movie",
                            "podcast"
                        ],
                        "type": "string",
                        "description": "Media type to search for (search mode only).",
                        "default": "software"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
