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

🍎 Export public Apple App Store reviews by app URL or ID. Get ratings, text, versions, authors, countries, and timestamps in clean datasets.

- **URL**: https://apify.com/fetch\_cat/apple-app-store-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 review saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Apple App Store Reviews Scraper

Scrape public Apple App Store reviews by app, country, and sort order. Export ratings, text, dates, versions, and metadata for ASO and product feedback analysis.

Use this actor for app store optimization (ASO), mobile app intelligence, product feedback mining, release monitoring, competitor review analysis, and customer-support triage.

### Who is it for?

Apple App Store Reviews Scraper is for product managers, ASO and growth teams, mobile app intelligence analysts, support teams, market researchers, founders, agencies, and data teams that need repeatable exports of public App Store review text, ratings, versions, dates, countries, and app metadata.

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

Apple App Store Reviews Scraper collects public customer reviews from Apple App Store app listings and saves one review per dataset row.

Paste Apple App Store URLs or numeric app IDs, choose a country such as `us`, `gb`, `ca`, `de`, `fr`, or `au`, pick `mostrecent` or `mosthelpful` review sorting, and set `maxReviewsPerApp` to control cost and run time.

Each exported row can include review text, star rating, review title, app version, country, author display name, review timestamp, review URL, app name, developer name, app ID, app URL, and source feed URL.

### Who uses App Store review data?

#### 📱 Product managers

Track new reviews after releases.

Find complaints that mention bugs, crashes, subscriptions, onboarding, performance, or missing features.

Compare review quality across markets.

#### ⭐ ASO, growth, and mobile app intelligence teams

Monitor rating trends and review language by country.

Collect quotes for review mining, competitor research, and app store optimization reports.

Export reviews into spreadsheets or BI tools.

#### 🧑‍💻 Support and customer success teams

Find urgent negative feedback.

Group complaints by app version.

Route common issues to engineering or support playbooks.

#### 🔎 Market researchers

Compare multiple apps in the same category.

Analyze what users like or dislike about competitor apps.

Build datasets for sentiment analysis or topic clustering.

### Why use this actor?

✅ Simple input: paste app URLs or IDs.

✅ Country-aware: collect localized public reviews.

✅ Clean dataset: one review per row.

✅ App metadata included: app name, developer name, and app URL when available.

✅ Version-aware: see which app version a review refers to.

✅ Automation-ready: run on schedule, through API, or from integrations.

✅ Cost-controlled: set a maximum number of reviews per app.

### What Apple App Store review data can I extract?

| Field | Description |
| --- | --- |
| `appId` | Numeric Apple App Store app ID |
| `appUrl` | App Store URL for the app |
| `country` | App Store country code used for the run |
| `appName` | App name when available |
| `developerName` | Developer or publisher name when available |
| `reviewId` | Review identifier |
| `reviewUrl` | Public review link when available |
| `authorName` | Reviewer display name |
| `authorUri` | Reviewer profile/review URL when available |
| `rating` | Star rating as a number |
| `version` | App version reviewed |
| `title` | Review title |
| `content` | Review text |
| `updatedAt` | Review update timestamp |
| `sourceFeedUrl` | Source page used for the review batch |
| `scrapedAt` | Time when the row was collected |

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

The actor uses pay-per-event pricing.

There is a small start event for each run and a per-review event for every saved review.

Use `maxReviewsPerApp` to keep first runs small while testing.

A typical test run with one app and 20 reviews is intentionally inexpensive.

Final public pricing may use tiered volume discounts after platform validation.

### How to scrape Apple App Store reviews

1. Open the actor on Apify.

2. Paste one or more Apple App Store URLs or numeric app IDs.

3. Choose the country code, for example `us`.

4. Choose `mostrecent` or `mosthelpful` sorting.

5. Set `maxReviewsPerApp`.

6. Start the run.

7. Download results as JSON, CSV, Excel, XML, or HTML from the Dataset tab.

### Quick start example

```json
{
  "appUrlsOrIds": ["https://apps.apple.com/us/app/whatsapp-messenger/id310633997"],
  "country": "us",
  "sortBy": "mostrecent",
  "maxReviewsPerApp": 50,
  "includeAppMetadata": true
}
````

### Example output

```json
{
  "appId": "284882215",
  "appUrl": "https://apps.apple.com/us/app/facebook/id284882215",
  "country": "us",
  "appName": "Facebook",
  "developerName": "Meta Platforms, Inc.",
  "reviewId": "14177411298",
  "reviewUrl": "https://itunes.apple.com/us/review?id=284882215&type=Purple%20Software",
  "authorName": "Example reviewer",
  "authorUri": "https://itunes.apple.com/us/reviews/id123456789",
  "rating": 1,
  "version": "565.0.0",
  "title": "Example title",
  "content": "Example review text",
  "updatedAt": "2026-06-13T04:03:53-07:00",
  "sourceFeedUrl": "https://itunes.apple.com/us/rss/customerreviews/id=284882215/sortby=mostrecent/json",
  "scrapedAt": "2026-06-14T00:00:00.000Z"
}
```

### Input fields

#### `appUrlsOrIds`

Required.

Add Apple App Store URLs or numeric app IDs.

Supported examples:

- `https://apps.apple.com/us/app/facebook/id284882215`
- `284882215`
- `https://apps.apple.com/gb/app/whatsapp-messenger/id310633997`

#### `country`

Optional.

Use a two-letter country code for the App Store market.

Default: `us`.

#### `sortBy`

Optional.

Choose `mostrecent` or `mosthelpful`.

Default: `mostrecent`.

#### `maxReviewsPerApp`

Optional.

Controls the maximum number of reviews saved for each app.

Default: `100`.

Prefill: `20` for cheap test runs.

Maximum: `500`.

#### `includeAppMetadata`

Optional.

When enabled, rows include app name, developer name, and canonical app URL when available.

Default: `true`.

### Tips for better results

Use the country where your customers leave reviews.

Run separate tasks for separate countries if you need market-by-market reporting.

Use `mostrecent` for monitoring release feedback.

Use `mosthelpful` for collecting high-signal historical complaints and praise.

Keep test runs small before scheduling larger jobs.

Use numeric IDs if you already store app IDs in your internal systems.

### Scheduling

You can schedule this actor to run daily, weekly, or after major app releases.

For release monitoring, run once before release and once after release so you can compare review themes.

For competitor monitoring, schedule the same app list across the same country and sort setting.

### AI-agent recipe

Goal: classify recent app reviews into bugs, feature requests, pricing complaints, and praise.

Input:

```json
{
  "appUrlsOrIds": ["https://apps.apple.com/us/app/whatsapp-messenger/id310633997"],
  "country": "us",
  "sortBy": "mostrecent",
  "maxReviewsPerApp": 50,
  "includeAppMetadata": true
}
```

Prompt to use with Claude / ChatGPT / MCP:
"Scrape the 50 newest US App Store reviews for this app. Group negative reviews by issue theme, include app version when available, and quote 5 representative reviews."

Follow-up automation:

- Schedule: Weekly review monitoring by app and country.
- Export: Product board, Sheets, BI dashboard, or Slack summary for support and ASO teams.
- Guardrail: Use only public App Store review data returned by the actor; do not infer private user information.

### Integrations

#### Google Sheets

Export the dataset to CSV or connect Apify integrations to keep a sheet updated.

#### Slack or email alerts

Use Apify webhooks to trigger alerts when a scheduled run finishes.

#### BI dashboards

Load datasets into BigQuery, Snowflake, Airtable, or your warehouse through Apify integrations.

#### Sentiment analysis

Send `title`, `content`, `rating`, `version`, and `updatedAt` to an LLM or NLP pipeline.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/apple-app-store-reviews-scraper').call({
  appUrlsOrIds: ['https://apps.apple.com/us/app/facebook/id284882215'],
  country: 'us',
  sortBy: 'mostrecent',
  maxReviewsPerApp: 20,
  includeAppMetadata: true,
});

console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/apple-app-store-reviews-scraper').call(run_input={
    'appUrlsOrIds': ['https://apps.apple.com/us/app/facebook/id284882215'],
    'country': 'us',
    'sortBy': 'mostrecent',
    'maxReviewsPerApp': 20,
    'includeAppMetadata': True,
})

print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~apple-app-store-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "appUrlsOrIds": ["https://apps.apple.com/us/app/facebook/id284882215"],
    "country": "us",
    "sortBy": "mostrecent",
    "maxReviewsPerApp": 20,
    "includeAppMetadata": true
  }'
```

### MCP usage

Use Apify MCP with Claude Desktop, Claude Code, or another MCP-compatible client.

MCP server URL:

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

Add it in Claude Code:

```bash
claude mcp add apify-apple-reviews https://mcp.apify.com/?tools=fetch_cat/apple-app-store-reviews-scraper
```

Claude Desktop configuration example:

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

Example prompts:

- "Scrape the 50 newest US reviews for this App Store URL and summarize the top complaints."
- "Compare recent reviews for these three apps and group issues by app version."
- "Export the most helpful reviews for this app in Canada and highlight feature requests."

### Data quality notes

Some apps have fewer public reviews in smaller countries.

Some review rows may not include every optional author or URL field.

Timestamps are returned as source timestamps and can include timezone offsets.

Ratings are numeric when available.

### Troubleshooting

#### Why did I get fewer reviews than requested?

The selected app, country, or sort order may expose fewer public reviews than your requested limit.

Try a larger country market or another sort setting.

#### Why are app metadata fields empty?

Metadata lookup can be unavailable for some country/app combinations.

Review rows can still be collected, and missing metadata fields are returned as `null`.

#### Why does my URL not work?

Make sure the URL contains a numeric Apple app ID, usually visible as `/id123456789`.

You can also paste only the numeric ID.

### Legality

This actor collects publicly available App Store review data.

You are responsible for using exported data in accordance with applicable laws, Apple terms, privacy rules, and your own compliance requirements.

Avoid collecting or storing data longer than necessary.

Do not use review data to harass, identify, or target individual users.

### Related scrapers

- [Reddit Scraper](https://apify.com/fetch_cat/reddit-scraper) — compare public app reviews with Reddit product discussions.
- [YouTube Transcript Scraper](https://apify.com/fetch_cat/youtube-transcript-scraper) — analyze public video feedback and announcements alongside reviews.

### FAQ

#### Can I scrape multiple apps in one run?

Yes. Add multiple app URLs or IDs to `appUrlsOrIds`.

#### Can I scrape reviews from different countries?

Yes. Run the actor once per country code to keep country-specific results clear.

#### Can I get reviews by app version?

The dataset includes the app version attached to each review when Apple provides it. You can filter by `version` after export.

#### Can I run this on a schedule?

Yes. Use Apify schedules for daily, weekly, or release-based review monitoring.

#### Can I export to Excel?

Yes. Apify datasets support Excel, CSV, JSON, XML, RSS, and HTML exports.

#### Does it require my Apple account?

No. The actor is designed for public App Store review data and does not need Apple login credentials.

### Changelog

Initial version:

- App URL and app ID input
- Country selection
- Most recent and most helpful review sorting
- App metadata option
- Normalized review dataset

# Actor input Schema

## `appUrlsOrIds` (type: `array`):

Apple App Store app URLs or numeric app IDs. Examples: https://apps.apple.com/us/app/facebook/id284882215 or 284882215.

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

Two-letter App Store country code to use for localized reviews, such as us, gb, ca, de, fr, or au.

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

Choose the App Store review ordering.

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

Maximum number of reviews to save for each app. Apple review feeds currently expose up to about 500 reviews per country/sort combination.

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

Add app name, developer name, and canonical App Store URL when available.

## Actor input object example

```json
{
  "appUrlsOrIds": [
    "https://apps.apple.com/us/app/facebook/id284882215"
  ],
  "country": "us",
  "sortBy": "mostrecent",
  "maxReviewsPerApp": 20,
  "includeAppMetadata": true
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "appUrlsOrIds": [
        "https://apps.apple.com/us/app/facebook/id284882215"
    ],
    "country": "us",
    "sortBy": "mostrecent",
    "maxReviewsPerApp": 20,
    "includeAppMetadata": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/apple-app-store-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "appUrlsOrIds": ["https://apps.apple.com/us/app/facebook/id284882215"],
    "country": "us",
    "sortBy": "mostrecent",
    "maxReviewsPerApp": 20,
    "includeAppMetadata": True,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/apple-app-store-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "appUrlsOrIds": [
    "https://apps.apple.com/us/app/facebook/id284882215"
  ],
  "country": "us",
  "sortBy": "mostrecent",
  "maxReviewsPerApp": 20,
  "includeAppMetadata": true
}' |
apify call fetch_cat/apple-app-store-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple App Store Reviews Scraper",
        "description": "🍎 Export public Apple App Store reviews by app URL or ID. Get ratings, text, versions, authors, countries, and timestamps in clean datasets.",
        "version": "0.1",
        "x-build-id": "N6t2pVSTTvXbUa6xY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~apple-app-store-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-apple-app-store-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~apple-app-store-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-apple-app-store-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~apple-app-store-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-apple-app-store-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "appUrlsOrIds"
                ],
                "properties": {
                    "appUrlsOrIds": {
                        "title": "App URLs or IDs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Apple App Store app URLs or numeric app IDs. Examples: https://apps.apple.com/us/app/facebook/id284882215 or 284882215.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter App Store country code to use for localized reviews, such as us, gb, ca, de, fr, or au.",
                        "default": "us"
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "mostrecent",
                            "mosthelpful"
                        ],
                        "type": "string",
                        "description": "Choose the App Store review ordering.",
                        "default": "mostrecent"
                    },
                    "maxReviewsPerApp": {
                        "title": "Maximum reviews per app",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each app. Apple review feeds currently expose up to about 500 reviews per country/sort combination.",
                        "default": 100
                    },
                    "includeAppMetadata": {
                        "title": "Include app metadata",
                        "type": "boolean",
                        "description": "Add app name, developer name, and canonical App Store URL when available.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
