# Apple App Store Scraper — Details, Search & Reviews (`freshactors/app-store-scraper`) Actor

Reliable, always-fresh Apple App Store data: app details, search, and customer reviews. Monitored daily, throttle-resistant. By FreshActors.

- **URL**: https://apify.com/freshactors/app-store-scraper.md
- **Developed by:** [Freshactors](https://apify.com/freshactors) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 app details fetcheds

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 — App Details, Keyword Search & Customer Reviews

Scrape Apple App Store data — full **app details**, ranked keyword **search**, and customer **reviews** — as clean, structured JSON, with no account, no login, and no API key.

![App Store Scraper example output — 32 structured fields](https://raw.githubusercontent.com/Freshactors/freshactors-assets/main/appstore-screenshot.png)

> ✅ **Last verified working: 2026-06-12.** This Apple App Store scraper is monitored by an automated daily canary. When Apple changes something, we patch fast and note it in the changelog below — so your data pipeline doesn't silently break.

---

### Why this Apple App Store scraper

If you've used other App Store scrapers, you've probably hit the "stopped working / returns nothing" problem. The usual cause: most scrapers depend on Apple's legacy review RSS feed, which **silently returns an empty `200` response when it's rate-limited**. Your job "succeeds," your dataset is empty, and nobody finds out until a dashboard goes blank. This actor is built to avoid exactly that.

- **Throttle-resistant reviews.** We detect Apple's empty-but-`200` throttle response and **retry with backoff and proxy rotation** instead of reporting a false "0 reviews." Reviews come from Apple's public review feed, which paginates to roughly 500 per app/storefront.
- **Rock-solid details and search.** App details and keyword search run on Apple's stable public endpoints — fast, reliable, and proxy-free.
- **Stable output schema.** Every record carries a `_schemaVersion` so your downstream code never breaks on a surprise field rename.
- **Monitored daily.** A canary tests every mode against known apps each day. Breakage gets patched fast and logged in the changelog at the bottom of this page — that "last verified working" date is real.

The moat here isn't a clever trick — it's **operational reliability**. This scraper is maintained to keep working, which is the one thing a scraper in a production pipeline actually needs to do.

### What data you get

The actor runs in three modes. Pick one with the `mode` input.

#### Mode: `details` — full app metadata

Look up apps by **App ID** or **Bundle ID**, one at a time or in bulk.

| Field | Type | Description |
|---|---|---|
| `title` | string | App name |
| `appId` | string | Numeric App Store ID |
| `bundleId` | string | Bundle identifier (e.g. `com.burbn.instagram`) |
| `sellerName` | string | Developer / seller name |
| `averageUserRating` | number | Overall star rating |
| `userRatingCount` | number | Total number of ratings |
| `version` | string | Current app version |
| `price` | number | Numeric price (0 for free) |
| `formattedPrice` | string | Display price (e.g. "Free", "$4.99") |
| `primaryGenre` | string | Primary category |
| `contentRating` | string | Age / content rating |
| `currentVersionReleaseDate` | string | Latest version release date |
| `icon` | string | App icon URL |
| `url` | string | App Store page URL |

Details records also include release notes, genres, size, supported languages, description, and screenshots.

#### Mode: `search` — find apps by keyword

Ranked search results carrying the same rich fields as `details`, for any keyword and storefront. Ideal for ASO keyword tracking and competitor discovery.

#### Mode: `reviews` — customer reviews

| Field | Type | Description |
|---|---|---|
| `appId` | string | App the review belongs to |
| `reviewId` | string | Unique review ID |
| `rating` | number | 1–5 stars |
| `title` | string | Review headline |
| `body` | string | Review text |
| `userName` | string | Reviewer display name |
| `appVersion` | string | App version reviewed |
| `voteSum` | number | Net helpful votes (RSS review feed reports 0) |
| `voteCount` | number | Total votes cast (RSS review feed reports 0) |
| `country` | string | Storefront code |

Sort reviews by most-recent or most-helpful, across any storefront.

### Use cases

- **App developers & founders — track ratings and version sentiment.** Pull `reviews` for your own app and competitors, segment by `appVersion`, and catch a post-release crash wave before it tanks your rating. Searches like *Apple App Store reviews API* and *scrape App Store reviews* land here.
- **ASO & growth marketers — keyword rank tracking.** Run `search` on your target keywords across storefronts to see who ranks where, then enrich the top results with `details` to study titles, genres, and rating counts. Covers *App Store keyword scraper* and *ASO data*.
- **Market & investment research — category landscapes.** Use `search` plus `details` to build a structured snapshot of any App Store category: pricing, developers, rating volume, and update cadence. Covers *Apple App Store data* and *app market research*.
- **Data teams & ML pipelines — review mining at scale.** Feed `reviews` into sentiment models, support-triage tooling, or feature-request mining. Stable JSON and `_schemaVersion` mean your *App Store data API* alternative won't break your ETL.

### Input

| Field | Type | Notes |
|---|---|---|
| `mode` | string | `details` \| `search` \| `reviews` (required) |
| `appIds` | string[] | Numeric App Store IDs (e.g. `389801252`). For `details` + `reviews`. |
| `bundleIds` | string[] | Alternative for `details` mode (e.g. `com.burbn.instagram`). |
| `searchTerms` | string[] | Keywords. For `search` mode. |
| `country` | string | Two-letter storefront code (`us`, `gb`, `de`, `jp`, …). Default `us`. |
| `lang` | string | Language tag for reviews (e.g. `en-US`). Default `en-US`. |
| `maxReviewsPerApp` | int | Reviews cap per app (1–500; Apple's public feed paginates to ~500). Default `200`. |
| `reviewsSort` | string | `mostRecent` \| `mostHelpful`. Default `mostRecent`. |
| `maxSearchResults` | int | Per search term (1–200). Default `50`. |

#### Example — details

```json
{ "mode": "details", "appIds": ["389801252", "324684580"], "country": "us" }
````

#### Example — search

```json
{ "mode": "search", "searchTerms": ["habit tracker", "budget app"], "maxSearchResults": 50, "country": "us" }
```

#### Example — reviews

```json
{ "mode": "reviews", "appIds": ["389801252"], "maxReviewsPerApp": 500, "reviewsSort": "mostRecent", "country": "us", "lang": "en-US" }
```

### Output sample

A `reviews` record:

```json
{
  "_type": "review",
  "_schemaVersion": "1.0",
  "appId": "389801252",
  "reviewId": "11583920002",
  "country": "us",
  "rating": 1,
  "title": "Keeps crashing",
  "body": "Crashes on launch since the update on my iPad.",
  "userName": "mark_p",
  "appVersion": "430.1.0",
  "voteSum": 0,
  "voteCount": 0,
  "_scrapedAt": "2026-06-01T07:57:08.714Z"
}
```

A `details` record carries `title`, `appId`, `bundleId`, `sellerName`, `averageUserRating`, `userRatingCount`, `version`, `price`, `formattedPrice`, `primaryGenre`, `contentRating`, `currentVersionReleaseDate`, `icon`, and `url`.

### Use with AI agents (MCP)

This scraper is callable as a tool by AI agents via the **[Apify MCP server](https://mcp.apify.com)** — so assistants like **Claude, Cursor, and VS Code** can run it and use the structured results mid-conversation, with no glue code.

Simplest path: in a recent **Claude Desktop**, add the hosted server `https://mcp.apify.com` under **Settings → Connectors** and authorize with OAuth. For any config-file client:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then ask in plain language, e.g. *"Get the App Store details and 50 most recent reviews for Instagram (app ID 389801252)."* — the agent calls **`freshactors/app-store-scraper`** with the right input and reads back the JSON. Full setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Pricing

Pay-per-event — you pay only for the data you actually get, with no subscription:

| Event | Price (USD) |
|---|---|
| App details fetched | $0.002 per app |
| Search result fetched | $0.001 per app |
| Review fetched | $0.0001 per review |

**How much does 100 results cost?**

- 100 **app details** → 100 × $0.002 = **$0.20**
- 100 **search results** → 100 × $0.001 = **$0.10**
- 100 **reviews** → 100 × $0.0001 = **$0.01**

For example, scraping 500 reviews of a single app costs about **$0.05**. (Apify platform compute usage is billed separately by Apify, as with any actor.)

### FAQ

**Is scraping the Apple App Store legal?**
This actor collects **public, non-personal** App Store data (app metadata, search rankings, and publicly posted reviews) through Apple's public endpoints. It performs no login and accesses no private account data. As with any scraping, use the data responsibly and in line with applicable terms and laws; if you're unsure about a specific use, consult a lawyer.

**Do I need an Apple Developer account or API key?**
No. There's no account, no login, and no API key. You provide App IDs, bundle IDs, or search terms — the actor handles the rest.

**Where do I find an App ID?**
It's the number in the App Store URL. For `apps.apple.com/us/app/instagram/id389801252`, the App ID is `389801252`. You can also use `bundleIds` (e.g. `com.burbn.instagram`) in `details` mode.

**Can I get reviews?**
Yes — set `mode` to `reviews`, pass `appIds`, and optionally set `maxReviewsPerApp` (up to 500), `reviewsSort` (`mostRecent` or `mostHelpful`), `country`, and `lang`.

**Why do other App Store scrapers return zero reviews?**
Apple's legacy review feed silently returns an empty `200` response when rate-limited, so naive scrapers report "0 reviews" when there are plenty. This actor detects that throttle response and retries with backoff and proxy rotation instead of handing you an empty dataset.

**Which countries / storefronts are supported?**
Any App Store storefront — pass a two-letter `country` code such as `us`, `gb`, `de`, or `jp`. Default is `us`.

**How many reviews can I pull per app?**
Up to about 500 per app via `maxReviewsPerApp` — Apple's public review feed paginates to roughly 500 reviews per app/storefront, and we return as many as Apple exposes.

**Can I look up many apps at once?**
Yes. `appIds`, `bundleIds`, and `searchTerms` all accept lists, so you can batch many apps or keywords in a single run.

**How often is the data updated?**
Every run fetches live data directly from Apple, so results are current as of run time. Each record includes a `_scrapedAt` timestamp.

**How do I export the data?**
Results land in the actor's dataset and can be exported as JSON, CSV, or Excel, or pulled via the Apify API / clients in your own code.

### Other FreshActors tools

| FreshActors actor | What it scrapes |
|---|---|
| [Google Play Scraper](https://apify.com/freshactors/google-play-scraper) | Google Play — app details, reviews, search |
| [Microsoft Store Scraper](https://apify.com/freshactors/microsoft-store-scraper) | Microsoft Store — app details, rating windows, search, reviews |
| [VS Code Marketplace Scraper](https://apify.com/freshactors/vscode-marketplace-scraper) | VS Code extensions — install/trending stats, search, reviews |
| [Shopify App Store Scraper](https://apify.com/freshactors/shopify-app-store-scraper) | Shopify App Store — app details, reviews, discovery |
| [Redfin Scraper](https://apify.com/freshactors/redfin-scraper) | Redfin — US real-estate listings |
| [Greenhouse & Lever Jobs Scraper](https://apify.com/freshactors/greenhouse-lever-jobs-scraper) | Greenhouse + Lever — normalized job postings |
| [Workable Jobs Scraper](https://apify.com/freshactors/workable-jobs-scraper) | Workable — normalized job postings, full descriptions |
| [SmartRecruiters Jobs Scraper](https://apify.com/freshactors/smartrecruiters-jobs-scraper) | SmartRecruiters — normalized job postings, full descriptions |
| [Recruitee Jobs Scraper](https://apify.com/freshactors/recruitee-jobs-scraper) | Recruitee — normalized job postings + salary |
| [Teamtailor Jobs Scraper](https://apify.com/freshactors/teamtailor-jobs-scraper) | Teamtailor — normalized job postings, full descriptions |
| [Personio Jobs Scraper](https://apify.com/freshactors/personio-jobs-scraper) | Personio — normalized job postings, departments + seniority |

### Reliability

This actor is monitored by an **automated daily canary** that exercises every mode (`details`, `search`, `reviews`) against known apps. If Apple changes an endpoint or response shape, the canary catches it, we patch fast, and we record the fix in the changelog so you can see exactly what changed and when. The "Last verified working" date at the top of this page reflects that monitoring — staying fresh is the whole point of FreshActors.

**Changelog**

- **2026-06-10** — First-run polish: the one-click default example now fetches **three** well-known apps (Instagram, Spotify, WhatsApp) instead of one, so your first run shows the full 32-field output across multiple apps. Still ~3 seconds and under a cent.
- **2026-06-06** — Made the reviews cap honest: `maxReviewsPerApp` is now 1–500 (was 1–5000). Apple's public review feed paginates to ~500 per app/storefront and the modern amp-api path needs a bearer token Apple no longer exposes publicly, so runs above 500 were silently returning only ~500. The cap now matches what's actually deliverable, and a deeper canary check guards it.
- **2026-06-04** — Docs: corrected the reviews output sample — `voteSum`/`voteCount` come back 0 on the RSS review feed (now clarified in the field table).
- **2026-06-01** — v1.0 launch. Details, search, reviews. Throttle-aware reviews engine (RSS + modern API fallback), daily canary monitoring.

#### Legal note

Scrapes **public, non-personal** App Store data via Apple's public endpoints. No login, no personal account data. Use responsibly and in line with applicable terms and laws.

*Found a problem? Open an issue on the actor — issues are answered fast.*

# Actor input Schema

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

What to scrape: app details, a keyword search, or customer reviews.

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

Numeric App Store IDs (the number in the app URL, e.g. 389801252 for Instagram). Used by 'details' and 'reviews' modes.

## `bundleIds` (type: `array`):

Alternative to App IDs for 'details' mode (e.g. com.burbn.instagram).

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

Keywords to search the App Store. Used by 'search' mode.

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

Two-letter App Store storefront code (us, gb, de, jp, ...).

## `lang` (type: `string`):

Language tag for reviews (e.g. en-US).

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

Reviews mode only. Cap on reviews returned per app (1–500; Apple's public review feed paginates to ~500).

## `reviewsSort` (type: `string`):

Order reviews by most recent or most helpful (reviews mode).

## `maxSearchResults` (type: `integer`):

Search mode only. Results per term (1–200).

## Actor input object example

```json
{
  "mode": "details",
  "appIds": [
    "389801252",
    "324684580",
    "310633997"
  ],
  "country": "us",
  "lang": "en-US",
  "maxReviewsPerApp": 200,
  "reviewsSort": "mostRecent",
  "maxSearchResults": 50
}
```

# Actor output Schema

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

App details / search results / reviews, depending on the selected mode.

# 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 = {
    "appIds": [
        "389801252",
        "324684580",
        "310633997"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Scraper — Details, Search & Reviews",
        "description": "Reliable, always-fresh Apple App Store data: app details, search, and customer reviews. Monitored daily, throttle-resistant. By FreshActors.",
        "version": "1.0",
        "x-build-id": "x2w2GqQpBV6OVnpjI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/freshactors~app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-freshactors-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/freshactors~app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-freshactors-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/freshactors~app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-freshactors-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": [
                            "details",
                            "search",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to scrape: app details, a keyword search, or customer reviews.",
                        "default": "details"
                    },
                    "appIds": {
                        "title": "App IDs",
                        "type": "array",
                        "description": "Numeric App Store IDs (the number in the app URL, e.g. 389801252 for Instagram). Used by 'details' and 'reviews' modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "bundleIds": {
                        "title": "Bundle IDs",
                        "type": "array",
                        "description": "Alternative to App IDs for 'details' mode (e.g. com.burbn.instagram).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search the App Store. Used by 'search' mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country (storefront)",
                        "type": "string",
                        "description": "Two-letter App Store storefront code (us, gb, de, jp, ...).",
                        "default": "us"
                    },
                    "lang": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language tag for reviews (e.g. en-US).",
                        "default": "en-US"
                    },
                    "maxReviewsPerApp": {
                        "title": "Max reviews per app",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Reviews mode only. Cap on reviews returned per app (1–500; Apple's public review feed paginates to ~500).",
                        "default": 200
                    },
                    "reviewsSort": {
                        "title": "Reviews sort",
                        "enum": [
                            "mostRecent",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "Order reviews by most recent or most helpful (reviews mode).",
                        "default": "mostRecent"
                    },
                    "maxSearchResults": {
                        "title": "Max search results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Search mode only. Results per term (1–200).",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
