# Apple Podcasts Chart & Reviews Scraper (`automation-lab/apple-podcasts-chart-reviews-scraper`) Actor

🎧 Scrape Apple Podcasts charts, reviews, show metadata, and RSS episodes by country for launch tracking and reputation reports.

- **URL**: https://apify.com/automation-lab/apple-podcasts-chart-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Podcasts Chart & Reviews Scraper

Scrape Apple Podcasts chart rankings, show metadata, public listener reviews, and RSS episode data across storefronts. Use it to monitor podcast launches, track reputation, compare rankings, and export structured podcast intelligence from public Apple endpoints.

### What does Apple Podcasts Chart & Reviews Scraper do?

Apple Podcasts Chart & Reviews Scraper collects public podcast data from Apple Podcasts and iTunes storefront feeds. It can return:

- 🎧 Top chart positions by country and category
- ⭐ Public listener reviews with rating, title, body, author, and date
- 🧾 Show metadata from Apple lookup data
- 📡 RSS episode metadata when a public feed is available
- 🌍 Country/storefront-specific results for monitoring multiple markets

### Who is it for?

Podcast agencies use it to build ranking and reputation reports for clients. Publishers use it to monitor launch performance and audience feedback. PR teams use it to detect review changes after campaigns. Market researchers use it to compare show categories, publishers, and chart positions. Sponsorship teams use it to discover shows in a category and enrich them with public metadata.

### Why use this scraper?

Apple Podcasts data is split across chart feeds, lookup records, review RSS feeds, and publisher RSS feeds. This actor combines those sources into one dataset with predictable fields. You can run a quick chart export, pull recent reviews for known shows, or start with charts and enrich shows in the same run.

### What data can you extract?

| Field | Description |
| --- | --- |
| itemType | chart, show, review, or episode |
| country | Apple storefront country code |
| podcastId | Apple Podcasts collection ID |
| podcastName | Show name |
| podcastUrl | Apple Podcasts URL |
| artistName | Publisher / creator |
| chartRank | Rank in selected chart |
| reviewRating | Public listener rating |
| reviewTitle | Review headline |
| reviewBody | Review text |
| reviewAuthor | Reviewer display name |
| reviewDate | Review timestamp |
| episodeTitle | RSS episode title |
| feedUrl | Public RSS feed URL |

### How much does it cost to scrape Apple Podcasts reviews?

This actor uses pay-per-event pricing. You pay a $0.005 run-start event and then per saved dataset item. Current per-item pricing is approximately $0.000031 on Free, $0.000027 on Starter/BRONZE, $0.000021 on Scale/SILVER, and lower for higher tiers. Keep `maxItems` low for test runs, then increase it for monitoring jobs. The final price shown on Apify is authoritative and may include tier discounts for higher usage.

### Input options

- `mode` — choose `charts`, `reviews`, `show`, `episodes`, or `all`
- `podcastUrls` — Apple Podcasts show URLs
- `podcastIds` — numeric Apple collection IDs
- `countries` — two-letter storefront codes such as `us`, `gb`, `ca`, or `au`
- `chartGenre` — Apple chart genre ID or `all`
- `chartLimit` — number of chart positions per country
- `maxItems` — global dataset cap
- `maxReviewsPerShow` — review cap per show/storefront
- `maxEpisodesPerShow` — RSS episode cap per show
- `sortReviewsBy` — most recent or most helpful reviews

### Example input

```json
{
  "mode": "reviews",
  "podcastUrls": [
    { "url": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736" }
  ],
  "countries": ["us"],
  "maxItems": 100,
  "maxReviewsPerShow": 100,
  "sortReviewsBy": "mostRecent"
}
````

### Output example

```json
{
  "itemType": "review",
  "country": "us",
  "podcastId": "1200361736",
  "podcastName": "The Daily",
  "podcastUrl": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736?uo=4",
  "artistName": "The New York Times",
  "reviewRating": 5,
  "reviewTitle": "Great reporting",
  "reviewBody": "Useful daily news summary.",
  "reviewAuthor": "listener123",
  "reviewDate": "2026-07-01T08:00:00-07:00",
  "scrapedAt": "2026-07-09T00:00:00.000Z"
}
```

### How to scrape chart rankings

1. Set `mode` to `charts`.
2. Add storefronts in `countries`.
3. Set `chartGenre` to `all` or an Apple genre ID.
4. Set `chartLimit` to the number of ranks you need.
5. Run the actor and export the dataset.

### How to monitor podcast reviews

1. Set `mode` to `reviews`.
2. Add one or more `podcastUrls` or `podcastIds`.
3. Choose the storefront countries you monitor.
4. Set `maxReviewsPerShow` and `maxItems`.
5. Schedule the actor daily or weekly and compare new review IDs.

### How to extract episode RSS data

Use `episodes` mode with podcast URLs or IDs. The actor looks up the public RSS feed URL from Apple and parses episode title, description, publication date, duration, GUID, and URL where available.

### Tips for reliable runs

- Start with one country and a small `maxItems` value.
- Use numeric `podcastIds` when you already have them.
- Use `charts` mode for discovery and `reviews` mode for monitoring.
- Apple review availability differs by storefront and show.
- RSS episode fields depend on the publisher's feed quality.

### Integrations

Connect the actor to Google Sheets for weekly ranking reports. Send review records to Slack for reputation alerts. Store chart exports in a database for trend analysis. Use Apify webhooks to trigger downstream dashboards after each run.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/apple-podcasts-chart-reviews-scraper').call({
  mode: 'charts',
  countries: ['us'],
  chartLimit: 100,
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/apple-podcasts-chart-reviews-scraper').call(run_input={
    'mode': 'reviews',
    'podcastIds': ['1200361736'],
    'countries': ['us'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~apple-podcasts-chart-reviews-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"mode":"charts","countries":["us"],"chartLimit":100,"maxItems":100}'
```

### MCP usage

Use the Apify MCP server with `?tools=automation-lab/apple-podcasts-chart-reviews-scraper` to run this scraper from Claude Code or Claude Desktop.

Claude Code setup:

```bash
claude mcp add apify-podcasts "https://mcp.apify.com/?tools=automation-lab/apple-podcasts-chart-reviews-scraper"
```

Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify-podcasts": {
      "url": "https://mcp.apify.com/?tools=automation-lab/apple-podcasts-chart-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the top 100 Apple Podcasts in the US and summarize publishers."
- "Get recent Apple Podcasts reviews for this show ID and flag low ratings."
- "Export episode metadata for this Apple Podcasts URL."

### Legality and ethical use

This actor collects public Apple Podcasts and RSS data. Review Apple's terms and applicable laws for your use case. Do not use scraped data for spam, harassment, or misleading review manipulation. Respect privacy and only process data you are allowed to use.

### Related scrapers

- https://apify.com/automation-lab/app-store-reviews-scraper
- https://apify.com/automation-lab/apple-music-scraper
- https://apify.com/automation-lab/google-play-reviews-scraper
- https://apify.com/automation-lab/youtube-channel-scraper

### Troubleshooting

If a show returns no reviews, try a different storefront country or verify that Apple displays reviews for that podcast. If episodes are missing, the publisher may not expose a public RSS feed through Apple lookup data. If you hit the item cap before reviews appear in `all` mode, reduce `chartLimit` or increase `maxItems`.

### FAQ

#### Can I scrape multiple countries?

Yes. Add multiple two-letter country codes to `countries`. The actor saves the storefront code on every row.

#### Can I monitor new reviews only?

Run the actor on a schedule and compare `reviewId` or `reviewDate` against your previous dataset.

#### Does it require login?

No. It uses public Apple/iTunes endpoints and public RSS feeds.

#### Why do some shows have fewer than 100 reviews?

Apple exposes different review counts by country and show. Some shows have limited or no public reviews in a storefront.

### Support

Open an Apify issue if you need a missing Apple Podcasts field, a new chart mode, or help with a storefront-specific run.

# Actor input Schema

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

Choose which Apple Podcasts data to collect. 'All' starts from charts, enriches shows, then collects reviews and episodes until maxItems is reached.

## `podcastUrls` (type: `array`):

Apple Podcasts show URLs to monitor, e.g. https://podcasts.apple.com/us/podcast/the-daily/id1200361736. Required for reviews/show/episodes unless podcastIds are provided.

## `podcastIds` (type: `array`):

Apple Podcasts numeric collection IDs. Use this instead of URLs when you already have IDs.

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

Two-letter Apple storefront country codes to scrape, such as us, gb, ca, au, de, or fr.

## `chartGenre` (type: `string`):

Apple Podcasts chart genre ID. Use 'all' for top podcasts overall, 1310 for Music, 1301 for Arts, 1303 for Comedy, 1324 for Society & Culture.

## `chartLimit` (type: `integer`):

How many chart positions to fetch per storefront (1-200).

## `maxItems` (type: `integer`):

Global cap across charts, shows, reviews, and episodes. Keep low for a cheap first run; raise for monitoring/reporting jobs.

## `maxReviewsPerShow` (type: `integer`):

Review cap for each podcast and storefront. Apple normally returns about 50 public reviews per page.

## `maxEpisodesPerShow` (type: `integer`):

Episode cap per show when episode mode is enabled and a public RSS feed is available.

## `sortReviewsBy` (type: `string`):

Apple review RSS sort order.

## Actor input object example

```json
{
  "mode": "all",
  "podcastUrls": [
    {
      "url": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736"
    }
  ],
  "podcastIds": [
    "1200361736"
  ],
  "countries": [
    "us"
  ],
  "chartGenre": "all",
  "chartLimit": 20,
  "maxItems": 20,
  "maxReviewsPerShow": 20,
  "maxEpisodesPerShow": 10,
  "sortReviewsBy": "mostRecent"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "all",
    "podcastUrls": [
        {
            "url": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736"
        }
    ],
    "podcastIds": [
        "1200361736"
    ],
    "countries": [
        "us"
    ],
    "chartGenre": "all",
    "chartLimit": 20,
    "maxItems": 20,
    "maxReviewsPerShow": 20,
    "maxEpisodesPerShow": 10,
    "sortReviewsBy": "mostRecent"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/apple-podcasts-chart-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 = {
    "mode": "all",
    "podcastUrls": [{ "url": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736" }],
    "podcastIds": ["1200361736"],
    "countries": ["us"],
    "chartGenre": "all",
    "chartLimit": 20,
    "maxItems": 20,
    "maxReviewsPerShow": 20,
    "maxEpisodesPerShow": 10,
    "sortReviewsBy": "mostRecent",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/apple-podcasts-chart-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 '{
  "mode": "all",
  "podcastUrls": [
    {
      "url": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736"
    }
  ],
  "podcastIds": [
    "1200361736"
  ],
  "countries": [
    "us"
  ],
  "chartGenre": "all",
  "chartLimit": 20,
  "maxItems": 20,
  "maxReviewsPerShow": 20,
  "maxEpisodesPerShow": 10,
  "sortReviewsBy": "mostRecent"
}' |
apify call automation-lab/apple-podcasts-chart-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple Podcasts Chart & Reviews Scraper",
        "description": "🎧 Scrape Apple Podcasts charts, reviews, show metadata, and RSS episodes by country for launch tracking and reputation reports.",
        "version": "0.1",
        "x-build-id": "5I0gGcexVlvjaH39V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~apple-podcasts-chart-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-apple-podcasts-chart-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/automation-lab~apple-podcasts-chart-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-apple-podcasts-chart-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/automation-lab~apple-podcasts-chart-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-apple-podcasts-chart-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",
                "properties": {
                    "mode": {
                        "title": "📡 Data mode",
                        "enum": [
                            "all",
                            "charts",
                            "reviews",
                            "show",
                            "episodes"
                        ],
                        "type": "string",
                        "description": "Choose which Apple Podcasts data to collect. 'All' starts from charts, enriches shows, then collects reviews and episodes until maxItems is reached.",
                        "default": "all"
                    },
                    "podcastUrls": {
                        "title": "Podcast URLs",
                        "type": "array",
                        "description": "Apple Podcasts show URLs to monitor, e.g. https://podcasts.apple.com/us/podcast/the-daily/id1200361736. Required for reviews/show/episodes unless podcastIds are provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "podcastIds": {
                        "title": "Podcast IDs",
                        "type": "array",
                        "description": "Apple Podcasts numeric collection IDs. Use this instead of URLs when you already have IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Storefront countries",
                        "type": "array",
                        "description": "Two-letter Apple storefront country codes to scrape, such as us, gb, ca, au, de, or fr.",
                        "default": [
                            "us"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "chartGenre": {
                        "title": "Chart genre ID",
                        "type": "string",
                        "description": "Apple Podcasts chart genre ID. Use 'all' for top podcasts overall, 1310 for Music, 1301 for Arts, 1303 for Comedy, 1324 for Society & Culture.",
                        "default": "all"
                    },
                    "chartLimit": {
                        "title": "Chart size per country",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many chart positions to fetch per storefront (1-200).",
                        "default": 20
                    },
                    "maxItems": {
                        "title": "Maximum dataset items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Global cap across charts, shows, reviews, and episodes. Keep low for a cheap first run; raise for monitoring/reporting jobs.",
                        "default": 20
                    },
                    "maxReviewsPerShow": {
                        "title": "Maximum reviews per show",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Review cap for each podcast and storefront. Apple normally returns about 50 public reviews per page.",
                        "default": 20
                    },
                    "maxEpisodesPerShow": {
                        "title": "Maximum RSS episodes per show",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Episode cap per show when episode mode is enabled and a public RSS feed is available.",
                        "default": 20
                    },
                    "sortReviewsBy": {
                        "title": "Review sort order",
                        "enum": [
                            "mostRecent",
                            "mostHelpful"
                        ],
                        "type": "string",
                        "description": "Apple review RSS sort order.",
                        "default": "mostRecent"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
