# Apple App Store App Search & Reviews Scraper (`herus13/apple-app-store-scraper`) Actor

Search the Apple App Store by keyword and scrape reviews — rating, title, text, author, date. Search or direct app IDs/URLs. Fan out across countries for broader coverage. No login, no anti-bot handling. Pairs with the Google Play Reviews Scraper for cross-platform ASO coverage.

- **URL**: https://apify.com/herus13/apple-app-store-scraper.md
- **Developed by:** [bootforge](https://apify.com/herus13) (community)
- **Categories:** Automation, Integrations, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 per reviews

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 App Search & Reviews Scraper

The Apple App Store App Search & Reviews Scraper is an Apify actor that extracts **app search results** and **reviews** from the [Apple App Store](https://apps.apple.com) by keyword search or direct app ID/URL, fanned out across any number of country storefronts. It returns rating, review title, text, author, and date, plus app metadata (developer, icon, price, category) when searching by keyword.

Use it to track app ratings over time, mine user feedback for feature requests and bug reports, benchmark competitor apps, or feed an ASO (App Store Optimization) dashboard — exported to JSON, CSV, or Excel.

### Table of contents

- [What the Apple App Store scraper does](#what-the-apple-app-store-scraper-does)
- [How to scrape Apple App Store reviews](#how-to-scrape-apple-app-store-reviews)
- [Apple App Store scraper input](#apple-app-store-scraper-input)
- [Apple App Store data output](#apple-app-store-data-output)
- [How much it costs](#how-much-it-costs)
- [Recommended proxies for the App Store](#recommended-proxies-for-the-app-store)
- [Why this Apple App Store scraper](#why-this-apple-app-store-scraper)
- [FAQ](#faq)
- [Rate this actor](#rate-this-actor-)
- [Related actors](#related-actors)

### What the Apple App Store scraper does

- 🔎 **Keyword search** — search any term and the actor resolves matching apps, ranked as the App Store returns them.
- 🔗 **Direct app IDs or URLs** — skip search and scrape reviews for specific apps by numeric ID (`324684580`) or a pasted `apps.apple.com` URL.
- 🌍 **Country fan-out** — run any number of storefront codes (`us`, `gb`, `de`, ...); each country's product page carries a genuinely distinct review set, so more countries means more total coverage.
- ⭐ **Rating and date filters** — keep only the star ratings and date range you care about.
- 🧬 **Cross-platform pairing** — the same `platform` discriminator and matching field names as the [Google Play App Search & Reviews Scraper](https://apify.com/herus13/google-play-reviews-scraper), so both datasets merge without remapping columns.
- ⚡ **HTTP-only, no anti-bot** — no login, no CAPTCHA, no browser tier; runs are fast and proxy is optional.

### How to scrape Apple App Store reviews

1. Click **Try for free** and open the actor.
2. Enter one or more `app_ids` (numeric IDs or full `apps.apple.com` URLs) **or** `search_queries`.
3. Choose your `countries` (e.g. `us`, `gb`, `de`) — each adds its own distinct review set.
4. Optional: set `rating_filter`, `date_from`/`date_to`, or `max_apps_per_search` for search mode.
5. Click **Start** and watch results stream into the dataset.
6. Export as **JSON, CSV, or Excel**, or pull from the [Apify API](https://docs.apify.com/api/v2).

Scrape reviews for specific apps across multiple storefronts:

```json
{
  "app_ids": ["324684580"],
  "countries": ["us", "gb", "de"],
  "rating_filter": ["1", "2"]
}
````

Search by keyword, capped to the top 5 matches per query:

```json
{
  "search_queries": ["meditation app"],
  "max_apps_per_search": 5,
  "countries": ["us"]
}
```

### Apple App Store scraper input

| Field | Type | Default | Description |
|---|---|---|---|
| `app_ids` | string\[] | — | Numeric App Store IDs or full `apps.apple.com` URLs. At least one of `app_ids` or `search_queries` is required. |
| `search_queries` | string\[] | — | Keywords; the actor resolves matching apps first, then scrapes their reviews. |
| `countries` | string\[] | `["us"]` | Storefront codes. Each country returns its own distinct up-to-8-review set. |
| `max_apps_per_search` | int | `10` | Cap on how many apps to take from each search query's results (1–250). |
| `rating_filter` | enum\[] | — | Keep only reviews with these star ratings (1–5). Filters what's already returned; can't fetch beyond the App Store's fixed per-country set. |
| `date_from` | date | — | Keep only reviews on/after this date (`YYYY-MM-DD`). |
| `date_to` | date | — | Keep only reviews on/before this date (`YYYY-MM-DD`). |
| `transport` | enum | `auto` | HTTP engine: `auto` (curl\_cffi), `curl_cffi`, `httpx`, or `primp`. |
| `proxy` | object | — | Optional Apify Proxy configuration. Not required for correctness — see [Recommended proxies](#recommended-proxies-for-the-app-store). |

### Apple App Store data output

Each review is one dataset row. Sample from a live run:

```json
{
  "platform": "app_store",
  "review_id": "11994640656",
  "app_id": "324684580",
  "author_name": "l.lacx",
  "rating": 5,
  "title": "Favorite app ever",
  "text": "I personally love this app. I have had it for over 4 years, and it's been an app I use daily...",
  "review_date": "2024-11-26T17:10:59.000Z",
  "country": "us",
  "scraped_at": "2026-07-10T13:36:13.824529+00:00"
}
```

| Field | Description |
|---|---|
| `platform` | Always `"app_store"` — matches the discriminator on the Google Play actor for merged datasets. |
| `review_id`, `app_id` | Apple's review ID and the app's numeric App Store ID. |
| `author_name`, `rating`, `title`, `text` | Reviewer name, 1–5 star rating, and review title/body. |
| `review_date` | ISO 8601 timestamp as returned by Apple. |
| `country`, `scraped_at` | Storefront the review came from and capture timestamp. |

When using `search_queries`, matched apps are also pushed as rows:

```json
{
  "platform": "app_store",
  "app_id": "571800810",
  "title": "Calm",
  "developer": "Calm.com",
  "icon_url": "https://is1-ssl.mzstatic.com/image/thumb/.../512x512bb.jpg",
  "rating": 4.77337,
  "rating_count": 1964301,
  "is_free": true,
  "price": null,
  "currency": "USD",
  "category": "Health & Fitness",
  "url": "https://apps.apple.com/us/app/calm/id571800810?uo=4",
  "country": "us",
  "scraped_at": "2026-07-10T13:36:22.244929+00:00"
}
```

| Field | Description |
|---|---|
| `app_id`, `title`, `developer`, `url` | App identity and canonical App Store link. |
| `icon_url`, `category` | App icon and App Store category. |
| `rating`, `rating_count` | Aggregate app rating and total rating count (not per-review). |
| `is_free`, `price`, `currency` | Pricing; `price`/`currency` are `null` for free apps. |
| `country`, `scraped_at` | Storefront searched and capture timestamp. |

### How much it costs

This actor uses **pay-per-event** pricing — you pay for what you scrape, not for time.

| Event | USD |
|---|---|
| Actor start (per run) | $0.001 |
| App search result | $0.003 |
| Review scraped | $0.003 |

Reviews are priced above Google Play's per-review rate to reflect scarcity — the App Store's public surface caps at 8 reviews per country per app, so each one carries more marginal value.

| Typical run | Cost |
|---|---|
| 1 app, 1 country (≤8 reviews) | ~$0.03 |
| 10 apps, 3 countries (≤240 reviews) | ~$0.73 |
| Search query, 10 apps returned, 3 countries (≤240 reviews + 10 search results) | ~$0.76 |

### Recommended proxies for the App Store

**Proxy is optional.** The App Store's public search and review endpoints have no known anti-bot layer, so a proxy is not required for correctness — only useful for scale (avoiding shared-IP rate limits on very large runs) or to make sure a given country's storefront resolves consistently.

If you run your own scrapers (inside or outside Apify) and need reliable proxies for scale, we use **[DataImpulse](https://dataimpulse.com/?aff=404588\&utm_source=apify)** — pay-as-you-go IPs with per-country targeting and no monthly minimum:

👉 **[Get DataImpulse proxies](https://dataimpulse.com/?aff=404588\&utm_source=apify)** (referral link)

### Why this Apple App Store scraper

- **No anti-bot tax** — HTTP-only, no browser, no CAPTCHA solving; runs are fast and cheap because the App Store's public surface needs none of that.
- **Country fan-out that actually adds coverage** — verified live: zero review-ID overlap between US/GB/DE for the same app, so adding countries genuinely multiplies your review sample instead of returning duplicates.
- **Built for cross-platform ASO** — shares field names and a `platform` discriminator with our [Google Play App Search & Reviews Scraper](https://apify.com/herus13/google-play-reviews-scraper); merge both datasets with no remapping.
- **Validated output** — every row is Pydantic-validated before it's pushed; malformed entries are dropped, not shipped with garbage fields.
- **Open source** — the underlying `apple-app-store-scraper` Python package ships a Typer CLI and a FastAPI server; the Apify wrapper is a thin layer.

### FAQ

**Why do I only get 8 reviews per app per country?** That's Apple's own limit, not this scraper's. The App Store's public web surface (no login, no native app) exposes a fixed set of up to 8 reviews per country per product page — there is no bulk pagination endpoint available without Apple's private, device-authenticated mobile API. Add more `countries` to increase total coverage; each storefront's 8 are a genuinely distinct set.

**Do I need a proxy?** No. The App Store's search and review endpoints have no known anti-bot layer, so a proxy is optional. It only helps at scale or for consistent per-country resolution. For your own scrapers, we recommend [DataImpulse](https://dataimpulse.com/?aff=404588\&utm_source=apify).

**Can I scrape by URL instead of app ID?** Yes. Paste a full `apps.apple.com` URL into `app_ids` — the numeric ID is extracted automatically.

**What happens if I provide both `app_ids` and `search_queries`?** Both run: the actor scrapes reviews for the given IDs and also resolves and scrapes apps matching each search query.

**Why are `price` and `currency` null for some apps?** They're `null` for free apps; App Store metadata doesn't carry a price for `is_free: true` listings.

**Is scraping the Apple App Store legal?** This actor collects only publicly available app listing and review data. You are responsible for complying with Apple's terms and applicable laws. Do not collect personal data without a lawful basis.

### Rate this actor ⭐

If the Apple App Store App Search & Reviews Scraper saved you time, please **leave a review on its Apify Store page** — ratings help other people find it and tell us what to build next. Hit a bug or missing field? Open an issue or contact us through the actor's **Issues** tab and we'll fix it fast — recency and reliability are what keep this actor ranking.

### Related actors

Building a cross-platform ASO pipeline? Pair this actor with our other scrapers — same proxy config format, same Pydantic-validated output, all open source.

- **[Google Play App Search & Reviews Scraper](https://apify.com/herus13/google-play-reviews-scraper)** — the direct Android counterpart; matching field names and a shared `platform` column for merged datasets.
- **[Trustpilot Scraper](https://apify.com/herus13/trustpilot-scraper)** — pull company reviews to compare app-store sentiment against broader brand reputation.
- **[Indeed Job Scraper](https://apify.com/herus13/indeed-scraper)** — track hiring signals for the same companies you're monitoring in the App Store.

# Actor input Schema

## `app_ids` (type: `array`):

<p>App Store numeric app IDs or full URLs.</p><p>Examples: <code>324684580</code>, <code>https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580</code></p>
## `search_queries` (type: `array`):

<p>Keywords to search the App Store; the scraper resolves each into apps, then scrapes their reviews.</p><p>Example: <code>meditation app</code></p>
## `countries` (type: `array`):

<p>App Store country/storefront codes. Drives both search results and review coverage — each country has a genuinely distinct set of up to 8 reviews per app, so adding more countries means more total reviews.</p><p>Example: <code>us</code>, <code>gb</code>, <code>de</code></p>
## `max_apps_per_search` (type: `integer`):

Cap on how many apps to take from each search query's results.

## `rating_filter` (type: `array`):

Only keep reviews with these star ratings (1-5). Leave empty for all ratings. Note: the App Store's public review surface returns a fixed set of up to 8 reviews per country per app, so this only filters what's already returned — it cannot fetch beyond that set.

## `date_from` (type: `string`):

Only keep reviews on/after this date (YYYY-MM-DD).

## `date_to` (type: `string`):

Only keep reviews on/before this date (YYYY-MM-DD).

## `transport` (type: `string`):

HTTP engine used to fetch pages. Auto uses curl\_cffi.

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

<p>Optional — the App Store's search and review endpoints have no known anti-bot layer, so a proxy is not required for correctness, only for scale/geo-accuracy.</p>

## Actor input object example

```json
{
  "app_ids": [
    "324684580"
  ],
  "countries": [
    "us"
  ],
  "max_apps_per_search": 10,
  "transport": "auto"
}
```

# Actor output Schema

## `results` (type: `string`):

App search results and reviews for each requested/discovered app

# 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 = {
    "app_ids": [
        "324684580"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("herus13/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 = {
    "app_ids": ["324684580"],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("herus13/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 '{
  "app_ids": [
    "324684580"
  ],
  "countries": [
    "us"
  ]
}' |
apify call herus13/apple-app-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store App Search & Reviews Scraper",
        "description": "Search the Apple App Store by keyword and scrape reviews — rating, title, text, author, date. Search or direct app IDs/URLs. Fan out across countries for broader coverage. No login, no anti-bot handling. Pairs with the Google Play Reviews Scraper for cross-platform ASO coverage.",
        "version": "0.1",
        "x-build-id": "G6KHTzaPJ8alaUzie"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/herus13~apple-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-herus13-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/herus13~apple-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-herus13-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/herus13~apple-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-herus13-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",
                "properties": {
                    "app_ids": {
                        "title": "App IDs or URLs",
                        "type": "array",
                        "description": "<p>App Store numeric app IDs or full URLs.</p><p>Examples: <code>324684580</code>, <code>https://apps.apple.com/us/app/spotify-music-and-podcasts/id324684580</code></p>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "search_queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "<p>Keywords to search the App Store; the scraper resolves each into apps, then scrapes their reviews.</p><p>Example: <code>meditation app</code></p>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "<p>App Store country/storefront codes. Drives both search results and review coverage — each country has a genuinely distinct set of up to 8 reviews per app, so adding more countries means more total reviews.</p><p>Example: <code>us</code>, <code>gb</code>, <code>de</code></p>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_apps_per_search": {
                        "title": "Max Apps Per Search Query",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Cap on how many apps to take from each search query's results.",
                        "default": 10
                    },
                    "rating_filter": {
                        "title": "Rating Filter",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only keep reviews with these star ratings (1-5). Leave empty for all ratings. Note: the App Store's public review surface returns a fixed set of up to 8 reviews per country per app, so this only filters what's already returned — it cannot fetch beyond that set.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ]
                        }
                    },
                    "date_from": {
                        "title": "Reviews From Date",
                        "type": "string",
                        "description": "Only keep reviews on/after this date (YYYY-MM-DD)."
                    },
                    "date_to": {
                        "title": "Reviews To Date",
                        "type": "string",
                        "description": "Only keep reviews on/before this date (YYYY-MM-DD)."
                    },
                    "transport": {
                        "title": "Transport",
                        "enum": [
                            "auto",
                            "curl_cffi",
                            "httpx",
                            "primp"
                        ],
                        "type": "string",
                        "description": "HTTP engine used to fetch pages. Auto uses curl_cffi.",
                        "default": "auto"
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "<p>Optional — the App Store's search and review endpoints have no known anti-bot layer, so a proxy is not required for correctness, only for scale/geo-accuracy.</p>"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```