# Apple Podcasts Charts & Reviews Scraper (`logiover/apple-podcast-charts-scraper`) Actor

Scrape Apple Podcasts top charts by category & country, plus podcast metadata and listener reviews. Ranks, publishers, genres, episode counts, ratings & review text for podcast advertising, competitor and sentiment research. No API key.

- **URL**: https://apify.com/logiover/apple-podcast-charts-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Marketing, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Charts & Reviews Scraper

Scrape **Apple Podcasts top charts** by category and country, enrich every show with rich metadata, and pull **listener reviews** — all without an API key. Track podcast rankings, benchmark competitors, mine review sentiment, and discover the fastest-growing shows in any market.

Built for podcast advertisers, PR and media agencies, podcast networks, hosting platforms, and creators who need reliable Apple Podcasts market-intelligence data on demand.

### What does the Apple Podcasts Charts & Reviews Scraper do?

This actor connects directly to Apple's public iTunes RSS and Lookup endpoints — the same data that powers the Apple Podcasts charts — and turns it into clean, structured, export-ready rows. In a single run it:

- **Pulls the Top Podcasts charts** for up to 19 categories (Arts, Business, Comedy, News, True Crime, Technology, Sports, and more) across 35 storefronts, up to 100 ranked shows per category. Ranks are preserved as real numbers.
- **Enriches every charted show** with metadata from the iTunes Lookup API: all genres, primary genre, episode/track count, RSS feed URL, cover artwork, content advisory (Clean/Explicit), and latest release date.
- **Scrapes listener reviews** (1-5 star rating, headline, full review text, author nickname, post date, and helpful-vote counts) from the customer-reviews feed, with resilient multi-page probing that survives Apple's habit of returning empty pages.

Run it with **empty input** and you get 1,000+ top-chart entries across every category for the US, each enriched with metadata. No account, no token, no scraping headaches.

### Who is it for?

- **Podcast advertisers & media buyers** sizing the market, finding brand-safe shows, and spotting which podcasts are climbing the charts before rates rise.
- **PR & media agencies** building pitch lists of the top shows per category and country for client placements.
- **Podcast networks & studios** monitoring their own catalog's rank, tracking competitors, and scouting shows to acquire or represent.
- **Hosting & analytics platforms** enriching their product with chart position, category, and review data.
- **Creators & producers** benchmarking against category leaders and reading listener feedback at scale.
- **Data & growth teams** building dashboards on chart movement and review sentiment over time.

### Use cases

- **Podcast advertising research** — export the top 100 shows in *Business* across the US, UK, and Germany, complete with publisher, episode count, and content rating, to build a media plan.
- **Chart tracking** — run daily and diff `chartRank` per `podcastId` to see who is rising or falling in any category or country.
- **Competitor analysis** — compare episode counts, release cadence, categories, and review ratings between your show and the category leaders.
- **Review sentiment mining** — pull thousands of reviews for a set of shows and score them for sentiment, themes, complaints, and feature requests.
- **Podcast discovery** — sweep all categories in a niche market to surface fast-growing shows before they hit the mainstream charts.
- **Lead generation for podcast tools** — build a list of active shows (with RSS feed URLs and publishers) to prospect networks, hosts, and agencies.

### Why use this scraper?

- **No API key required** — Apple's chart, lookup, and review feeds are public; there is nothing to register or authenticate.
- **Charts + metadata + reviews in one run** — three data types combined, deduped, and normalized into a single dataset.
- **Ranks and ratings as real numbers** — `chartRank`, `rating`, `trackCount`, and vote counts are numeric, ready for sorting and math.
- **35 storefronts, 19 categories** — cover any major market or focus on a single niche.
- **Resilient by design** — automatic proxy with direct-connection fallback, a ~4-minute time budget with graceful early exit, and multi-page review probing so you never lose data to Apple's empty-page quirk.
- **Zero-input friendly** — empty input returns 1,000+ enriched chart entries; raise `maxResults` to pull far more.
- **Export to CSV / JSON / Excel** — one-click export from the Apify dataset, or pull via the API.

### Input

Every field is optional. Run with empty input `{}` to get 1,000+ top-chart entries across all categories for the US.

| Field | Type | Description |
|---|---|---|
| `mode` | select | `Both` (charts + metadata + reviews), `Top charts only`, or `Reviews only`. Default `Both`. |
| `country` | select | Storefront to pull from (US, UK, CA, AU, DE, FR, ES, IT, JP, BR, and 25 more), or **All top markets** to sweep US/UK/CA/AU/DE. Default `us`. |
| `genres` | multi-select | Apple categories to pull top charts for. Leave empty or pick **All categories** to sweep all 19. |
| `includeReviews` | boolean | Force listener reviews on (or off) regardless of mode. Default `false`. |
| `podcastIds` | list | Apple Podcasts collection IDs to fetch reviews & metadata for directly (used instead of chart discovery in Reviews/Both mode). |
| `maxReviewsPerPodcast` | integer | Cap on reviews pulled per show (Apple serves ~50/page, up to 10 pages). Default `50`. |
| `maxResults` | integer | Maximum rows (chart entries + reviews) to return. Default `1000`. |
| `proxy` | object | Apify Proxy config. Defaults to automatic proxy with direct fallback. |

#### Example inputs

**Everything on (default) — 1,000+ enriched chart entries for the US:**

```json
{}
````

**Top Business & Technology charts across the biggest markets:**

```json
{
  "mode": "charts",
  "country": "all",
  "genres": ["1321", "1318"],
  "maxResults": 1000
}
```

**Reviews for specific shows:**

```json
{
  "mode": "reviews",
  "country": "us",
  "podcastIds": ["1200361736", "1434243584"],
  "maxReviewsPerPodcast": 200
}
```

### Output

Each row is either a `chart_entry` or a `review`. Chart rows carry rank + metadata; review rows carry the review fields plus a snapshot of the show they belong to. Numeric fields are real numbers.

| Field | Type | Description |
|---|---|---|
| `rowType` | string | `chart_entry` or `review`. |
| `podcastId` | string | Apple Podcasts collection ID. |
| `podcastName` | string | Show title. |
| `artistName` | string | Show author / creator. |
| `publisher` | string | Publisher name. |
| `chartRank` | number | Rank within the chart (1 = top). Null on reviews. |
| `chartGenre` | string | Category the chart was pulled from (e.g. News). |
| `chartGenreId` | number | Apple genre ID of the chart. |
| `country` | string | Storefront country code (uppercase). |
| `category` | string | Fine-grained Apple sub-genre for the entry (e.g. Daily News). |
| `categoryId` | number | Apple sub-genre ID. |
| `summary` | string | Show description from the chart feed. |
| `releaseDate` | string | Latest episode / release date (ISO 8601). |
| `artworkUrl` | string | Cover artwork URL (largest available). |
| `podcastUrl` | string | Apple Podcasts page URL. |
| `genres` | array | All Apple genres the show is listed under. |
| `primaryGenre` | string | Primary Apple genre. |
| `trackCount` | number | Episodes Apple has indexed. |
| `episodeCount` | number | Alias of `trackCount`. |
| `feedUrl` | string | The show's RSS feed URL. |
| `contentAdvisory` | string | Content rating (Clean / Explicit). |
| `reviewId` | string | Unique review ID. Null on chart rows. |
| `reviewTitle` | string | Review headline. Null on chart rows. |
| `reviewText` | string | Full review body. Null on chart rows. |
| `rating` | number | Star rating 1-5. Null on chart rows. |
| `reviewAuthor` | string | Reviewer nickname. Null on chart rows. |
| `reviewDate` | string | When the review was posted (ISO 8601). |
| `reviewVoteSum` | number | Net helpful votes on the review. |
| `reviewVoteCount` | number | Total votes cast on the review. |

#### Sample output — chart entry

```json
{
  "rowType": "chart_entry",
  "podcastId": "1200361736",
  "podcastName": "The Daily",
  "artistName": "The New York Times",
  "publisher": "The New York Times",
  "chartRank": 1,
  "chartGenre": "News",
  "chartGenreId": 1489,
  "country": "US",
  "category": "Daily News",
  "categoryId": 1526,
  "summary": "This is what the news should sound like...",
  "releaseDate": "2026-07-12T10:00:00.000Z",
  "artworkUrl": "https://is1-ssl.mzstatic.com/image/.../600x600bb.jpg",
  "podcastUrl": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736",
  "genres": ["Daily News", "Podcasts", "News"],
  "primaryGenre": "Daily News",
  "trackCount": 2658,
  "episodeCount": 2658,
  "feedUrl": "https://feeds.simplecast.com/Sl5CSM3S",
  "contentAdvisory": "Clean",
  "reviewId": null,
  "reviewTitle": null,
  "reviewText": null,
  "rating": null,
  "reviewAuthor": null,
  "reviewDate": null
}
```

#### Sample output — review

```json
{
  "rowType": "review",
  "podcastId": "1200361736",
  "podcastName": "The Daily",
  "publisher": "The New York Times",
  "country": "US",
  "primaryGenre": "Daily News",
  "reviewId": "14115441174",
  "reviewTitle": "Another Interesting Report",
  "reviewText": "Today's report on loneliness and AI had me feeling all the feels...",
  "rating": 5,
  "reviewAuthor": "News girl junkie",
  "reviewDate": "2026-05-28T12:27:41.000Z",
  "reviewVoteSum": 0,
  "reviewVoteCount": 0
}
```

### Exporting your data

Every run saves to an Apify **dataset**. Export with one click as **CSV, JSON, Excel, XML, or RSS** from the Storage tab, or pull programmatically:

```
https://api.apify.com/v2/datasets/{datasetId}/items?format=csv
```

You can also fetch results with the Apify API or any of the official Apify client libraries (JavaScript, Python), or wire the actor into Make, Zapier, or n8n to keep a chart-tracking sheet fresh automatically.

### Frequently asked questions

#### How do I scrape Apple Podcast charts?

Just run this actor. Leave the input empty to get the top charts across all 19 categories for the US, or set `country` and pick specific `genres` to target a market and niche. Each chart returns up to 100 ranked shows with `chartRank` as a real number, enriched with publisher, episode count, artwork, and category. No API key or login is needed.

#### How do I export Apple Podcast reviews?

Set `mode` to `Reviews` (or `Both`) and the actor pulls listener reviews — rating, title, full text, author, and date — for each charted show, or for the exact shows you list in `podcastIds`. Reviews export to CSV, JSON, or Excel like any other dataset. Apple serves roughly 50 reviews per page and up to 10 pages per show; use `maxReviewsPerPodcast` to control depth.

#### How do I get the top podcasts by category?

Use the `genres` multi-select to choose one or more Apple categories (e.g. Business, Comedy, True Crime), pick a `country`, and run. The actor pulls that category's Top Podcasts chart for the storefront. Leave `genres` empty to sweep every category at once — the default behavior that returns 1,000+ entries.

#### Do I need an Apple Podcasts API key or account?

No. Apple's chart, lookup, and customer-review feeds are public. This actor uses no API key, no login, and no cookies — so there is nothing to register and no account to get rate-limited or banned.

#### How many results can I get?

Empty input returns 1,000+ rows (100 shows × 19 categories, capped by `maxResults`). Raising `maxResults` and enabling reviews or **All top markets** can push this into the tens of thousands. Each category chart tops out at 100 shows (Apple's limit), so breadth comes from combining categories, countries, and reviews.

#### How is this different from the Apple Podcasts Episode Scraper?

The **Episode Scraper** extracts the episode list of specific shows you already know. This **Charts & Reviews Scraper** is a market-intelligence tool: it discovers the top shows per category and country, enriches them with metadata, and pulls listener reviews — ideal for advertising research, competitor tracking, and sentiment analysis rather than episode-level exports.

#### Can I track chart rankings over time?

Yes. Schedule the actor (daily or weekly) and each run snapshots the current charts with `chartRank` and a timestamped `releaseDate`. Diff `chartRank` per `podcastId` between runs to build a rank-movement dataset, or append every run to one dataset for a full historical time series.

#### Which countries and categories are supported?

Charts are available for 35 storefronts including the US, UK, Canada, Australia, Germany, France, Spain, Italy, Japan, Brazil, Mexico, and more — plus an **All top markets** option. Categories cover all 19 official Apple Podcasts genres: Arts, Business, Comedy, Education, Fiction, Government, Health & Fitness, History, Kids & Family, Leisure, Music, News, Religion & Spirituality, Science, Society & Culture, Sports, TV & Film, Technology, and True Crime.

### Related actors

- **Apple Podcasts Episode Scraper** — extract full episode lists and show notes for specific podcasts.
- **App Store Data API** — scrape app rankings, metadata, and reviews from the Apple App Store.
- **Crossref Scholarly Scraper** — DOIs, citations, and journal metadata for research.

### Notes & disclaimer

This actor collects publicly available data from Apple's iTunes RSS and Lookup endpoints for research and analytics. Apple's customer-reviews feed is intermittent by nature — individual pages can return empty even when a show has reviews — so the actor probes multiple pages to maximize coverage. Respect Apple's terms of service and applicable laws when using the data.

# Actor input Schema

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

What to collect. 'Top charts' = ranked podcasts per category & country. 'Reviews' = listener reviews for chart podcasts (or your own Podcast IDs). 'Both' = charts enriched with metadata plus reviews (default).

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

Apple Podcasts storefront to pull charts & reviews from. Rankings differ by country. Choose 'All top markets' to sweep the five biggest storefronts (US, UK, CA, AU, DE).

## `genres` (type: `array`):

Apple Podcasts categories to pull the top charts for. Leave empty (or pick 'All categories') to sweep all 19 categories — the default, which yields 1,000+ chart entries per country.

## `includeReviews` (type: `boolean`):

Also fetch listener reviews (rating, title, text, author, date) for each chart podcast. Overrides the mode's default. Reviews are collected from the selected storefront.

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

Optional list of Apple Podcasts collection IDs to fetch reviews & metadata for directly. The ID is the number in a podcast URL, e.g. for https://podcasts.apple.com/us/podcast/the-daily/id1200361736 the ID is '1200361736'. When provided in Reviews / Both mode, these are used instead of chart discovery.

## `maxReviewsPerPodcast` (type: `integer`):

Cap on how many reviews to pull per podcast (Apple serves ~50 per page, up to 10 pages = ~500). Lower this to spread review coverage across more shows.

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

Maximum number of rows (chart entries + reviews) to return. Default 1,000 keeps the empty-input run fast & cheap. Raise it to pull more.

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

Apify Proxy configuration. Automatic proxy works well for Apple's public endpoints; the Actor also falls back to a direct connection if a proxy IP fails.

## Actor input object example

```json
{
  "mode": "both",
  "country": "us",
  "genres": [],
  "includeReviews": false,
  "podcastIds": [],
  "maxReviewsPerPodcast": 50,
  "maxResults": 1000,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All rows extracted by this run (chart entries + reviews). Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/apple-podcast-charts-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 = { "proxy": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("logiover/apple-podcast-charts-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 '{
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call logiover/apple-podcast-charts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple Podcasts Charts & Reviews Scraper",
        "description": "Scrape Apple Podcasts top charts by category & country, plus podcast metadata and listener reviews. Ranks, publishers, genres, episode counts, ratings & review text for podcast advertising, competitor and sentiment research. No API key.",
        "version": "1.0",
        "x-build-id": "4LpQwkawVHsa5HqTO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~apple-podcast-charts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-apple-podcast-charts-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/logiover~apple-podcast-charts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-apple-podcast-charts-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/logiover~apple-podcast-charts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-apple-podcast-charts-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": "Mode — what to scrape",
                        "enum": [
                            "both",
                            "charts",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to collect. 'Top charts' = ranked podcasts per category & country. 'Reviews' = listener reviews for chart podcasts (or your own Podcast IDs). 'Both' = charts enriched with metadata plus reviews (default).",
                        "default": "both"
                    },
                    "country": {
                        "title": "Country / Storefront",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "se",
                            "no",
                            "dk",
                            "fi",
                            "ie",
                            "pl",
                            "br",
                            "mx",
                            "ar",
                            "jp",
                            "kr",
                            "in",
                            "nz",
                            "za",
                            "ae",
                            "sa",
                            "tr",
                            "ru",
                            "ch",
                            "at",
                            "be",
                            "pt",
                            "gr",
                            "cz",
                            "hu",
                            "all"
                        ],
                        "type": "string",
                        "description": "Apple Podcasts storefront to pull charts & reviews from. Rankings differ by country. Choose 'All top markets' to sweep the five biggest storefronts (US, UK, CA, AU, DE).",
                        "default": "us"
                    },
                    "genres": {
                        "title": "Podcast categories",
                        "type": "array",
                        "description": "Apple Podcasts categories to pull the top charts for. Leave empty (or pick 'All categories') to sweep all 19 categories — the default, which yields 1,000+ chart entries per country.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "26",
                                "1301",
                                "1321",
                                "1303",
                                "1304",
                                "1483",
                                "1511",
                                "1512",
                                "1487",
                                "1305",
                                "1502",
                                "1310",
                                "1489",
                                "1314",
                                "1533",
                                "1324",
                                "1545",
                                "1309",
                                "1318",
                                "1488"
                            ],
                            "enumTitles": [
                                "All categories",
                                "Arts",
                                "Business",
                                "Comedy",
                                "Education",
                                "Fiction",
                                "Government",
                                "Health & Fitness",
                                "History",
                                "Kids & Family",
                                "Leisure",
                                "Music",
                                "News",
                                "Religion & Spirituality",
                                "Science",
                                "Society & Culture",
                                "Sports",
                                "TV & Film",
                                "Technology",
                                "True Crime"
                            ]
                        },
                        "default": []
                    },
                    "includeReviews": {
                        "title": "Include listener reviews",
                        "type": "boolean",
                        "description": "Also fetch listener reviews (rating, title, text, author, date) for each chart podcast. Overrides the mode's default. Reviews are collected from the selected storefront.",
                        "default": false
                    },
                    "podcastIds": {
                        "title": "Podcast IDs (for Reviews mode)",
                        "type": "array",
                        "description": "Optional list of Apple Podcasts collection IDs to fetch reviews & metadata for directly. The ID is the number in a podcast URL, e.g. for https://podcasts.apple.com/us/podcast/the-daily/id1200361736 the ID is '1200361736'. When provided in Reviews / Both mode, these are used instead of chart discovery.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerPodcast": {
                        "title": "Max reviews per podcast",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on how many reviews to pull per podcast (Apple serves ~50 per page, up to 10 pages = ~500). Lower this to spread review coverage across more shows.",
                        "default": 50
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of rows (chart entries + reviews) to return. Default 1,000 keeps the empty-input run fast & cheap. Raise it to pull more.",
                        "default": 1000
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Automatic proxy works well for Apple's public endpoints; the Actor also falls back to a direct connection if a proxy IP fails.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
