# iTunes Podcast Search Scraper (`parseforge/itunes-podcast-search-scraper`) Actor

Search Apple Podcasts catalog and extract show metadata: title, host, artwork, RSS feed URL, primary genre, episode count, country, last release date, content advisory and ratings. Bypasses Apple's 100-result search cap to return up to 5,000 unique podcasts per keyword. Top Charts mode included.

- **URL**: https://apify.com/parseforge/itunes-podcast-search-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Marketing, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 result items

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎙️ iTunes Podcast Search Scraper

> 🚀 **Search Apple Podcasts catalog and bypass the 100-result cap to pull up to 5,000 unique podcasts per keyword.**

> 🕒 **Last updated:** 2026-05-06 · **📊 24 fields** per record · **5M+ podcasts** · Apple Podcasts catalog · genres, ratings, RSS feeds, episode counts, Top Charts mode

The **iTunes Podcast Search Scraper** searches the Apple Podcasts catalog and returns structured records for any podcast: title, host, artwork, RSS feed URL, primary genre, episode count, content advisory, country, and last release date.

Apple's stock search caps any single query at ~100 results. This Actor bypasses that limit with a keyword-expansion strategy that returns up to **5,000 unique podcasts per keyword** while keeping every result relevant. A separate Top Charts mode pulls up to 200 of Apple's officially ranked podcasts per genre.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Podcast networks, ad platforms, content marketers, journalists, audio researchers, recommendation engines | Podcast discovery, ad-target prospecting, niche-genre mapping, content trend research, RSS feed enrichment |

---

### 📋 What the iTunes Podcast Search Scraper does

Five filtering workflows in a single run:

- 🔍 **Search by keyword.** Match across title, host, description, and genres.
- 🚀 **Bypass the 100-cap.** Auto-expansion with a-z and 0-9 suffixes; relevance filtered, deduped.
- 📊 **Top Charts mode.** Skip query, pick a genre, pull up to 200 ranked podcasts.
- 🏷️ **Genre filter.** 17 Apple genres including News, Business, Technology, True Crime, Comedy.
- 🌍 **Country filter.** Switch iTunes store country (US, GB, DE, JP, BR, ES).

> 💡 **Why it matters:** clean, server-side filtering removes the parser-and-pagination work from your team and keeps your dataset fresh on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
<tr><td><code>query</code></td><td>string</td><td><code>"daily news"</code></td><td>Free-text keyword. Empty + genre = Top Charts.</td></tr>
<tr><td><code>country</code></td><td>string</td><td><code>"US"</code></td><td>ISO 3166-1 alpha-2 iTunes store country.</td></tr>
<tr><td><code>genre</code></td><td>string</td><td><code>""</code></td><td>Apple podcast genre ID. Empty = all.</td></tr>
</tbody>
</table>

**Example: top 200 news podcasts (Top Charts mode).**

```json
{
    "maxItems": 200,
    "genre": "1311",
    "country": "US"
}
````

**Example: 500 podcasts about Bitcoin.**

```json
{
    "maxItems": 500,
    "query": "bitcoin",
    "country": "US"
}
```

***

### 📊 Output

Each record contains **24 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🎨 `artworkUrl` | string | `"https://is1-ssl.mzstatic.com/.../600x600.jpg"` |
| 🆔 `collectionId` | string | `"1200361736"` |
| 📛 `title` | string | `"The Daily"` |
| 🎤 `artist` | string | `"The New York Times"` |
| 🌐 `podcastUrl` | string | `"https://podcasts.apple.com/..."` |
| 📡 `feedUrl` | string | `"https://feeds.simplecast.com/54nAGcIl"` |
| 🏷️ `primaryGenre` | string | `"Daily News"` |
| 🏷️ `genres` | array | `["Daily News","News"]` |
| 🌍 `country` | string | `"USA"` |
| 🔢 `trackCount` | number | `2456` |
| 🔞 `explicit` | boolean | `false` |
| 📅 `releaseDate` | ISO 8601 | `"2026-05-06T10:00:00Z"` |

#### 📦 Sample records

<details>
<summary><strong>📰 Top news podcast</strong></summary>

```json
{"collectionId":"1200361736","title":"The Daily","artist":"The New York Times","primaryGenre":"Daily News","trackCount":2456,"feedUrl":"https://feeds.simplecast.com/54nAGcIl","country":"USA"}
```

</details>

<details>
<summary><strong>🔍 True crime</strong></summary>

```json
{"collectionId":"1322200189","title":"Crime Junkie","artist":"audiochuck","primaryGenre":"True Crime","trackCount":620,"explicit":true}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🚀 | **Bypasses the 100-cap.** Auto-expansion returns up to 5,000 unique podcasts per keyword while keeping every result relevant. |
| 📊 | **Top Charts on demand.** Skip the query and pull Apple's ranked list of up to 200 per genre. |
| 🌍 | **Multi-country.** Switch iTunes store countries to capture regional podcast catalogs. |
| 📡 | **RSS feed URLs included.** Direct feed links per podcast for downstream ingestion. |
| ⚡ | **Fast.** 100 results in under 30 seconds; 5,000 in a few minutes. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ This Actor** | $5 free credit | **5M+** podcasts | Live per run | query, country, genre, Top Charts | ⚡ 2 min |
| Apple's stock search | Free | Capped at ~100 | Live | Limited | 🐢 Manual |
| Podcastindex bulk dumps | Free | Cross-platform | Variable | Bulk only | 🐢 ETL |
| Listen Notes API | $144+/month | Cross-platform | Live | Yes | 🐢 Account |

Pick this Actor when you want broad coverage, server-side filtering, and no pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the iTunes Podcast Search Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick your filters and `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📊 Podcast Networks

- Discover networks acquiring shows in growing genres
- Track competitor catalog size
- Monitor top-charts rotation
- Map host-driven networks

</td>
<td width="50%" valign="top">

#### 📣 Ad Targeting

- Build niche audience segments by genre
- Identify high-frequency ad opportunities
- Create podcast-host targeting lists
- Cross-reference with brand-safety lists

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Journalism & Research

- Track misinformation podcasts by keyword
- Survey political-podcast ecosystems
- Compile background research lists
- Monitor topic-specific shows

</td>
<td width="50%" valign="top">

#### 🤖 Recommendation Engines

- Train similar-podcast embeddings
- Build niche recommendation pipelines
- Power discovery features
- Enrich apps with RSS metadata

</td>
</tr>
</table>

***

### 🔌 Automating iTunes Podcast Search Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Hourly, daily, or weekly refreshes keep downstream databases in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Media-studies research on podcast ecosystems
- Topic-modeling courseware
- Reproducible podcast snapshots
- Linguistic analysis of show titles

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal podcast discovery tools
- Niche newsletter content
- Indie podcast directories
- Hobby tracking of favorite shows

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Civic literacy podcast directories
- Public-radio cataloging
- Health-information podcast indexes
- OSS podcast metadata projects

</td>
<td width="50%">

#### 🧪 Experimentation

- Train recommender models on metadata
- Prototype semantic podcast search
- Test discovery UI concepts
- Build ranking experiments

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20iTunes%20Podcast%20Search%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20iTunes%20Podcast%20Search%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20iTunes%20Podcast%20Search%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20iTunes%20Podcast%20Search%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Provide a query (and optionally genre/country) and the Actor searches Apple Podcasts. With no query and a genre, it pulls Apple's Top Charts instead.

#### 🚀 How does the 100-cap bypass work?

Apple caps any single search at ~100 results. The Actor expands by appending each letter and digit to your keyword, dedupes by collectionId, and filters every result to ensure your keyword still appears in the title, artist, description, or genre.

#### 📊 How many fields per record?

24, including artwork, title, host, RSS feed URL, primary genre, episode count, country, content advisory, and ratings.

#### 📡 Does it include the RSS feed URL?

Yes. `feedUrl` returns the canonical podcast feed for downstream ingestion or RSS reader integration.

#### 🌍 Which countries are supported?

All iTunes store countries. Pass any ISO 3166-1 alpha-2 code (US, GB, DE, JP, ES, BR, AU).

#### 🔁 Can I schedule recurring runs?

Yes. Use Apify Schedules to track Top Charts rotation, monitor a competitor's catalog, or refresh a discovery dataset.

#### 🎵 Does it return episode-level data?

No. The Actor returns podcast-level metadata. For per-episode data, fetch the `feedUrl` directly.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers preview runs (10 records). A paid plan unlocks higher item counts and scheduling.

#### 🆘 What if a run fails?

Apify retries transient errors. Inspect logs in the Runs tab; partial datasets are preserved.

#### ⚖️ Is this data public?

Yes. Apple Podcasts metadata is publicly browsable. Only public catalog data is collected.

***

### 🔌 Integrate with any app

iTunes Podcast Search Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes.

***

### 🔗 Recommended Actors

- [**📰 Hacker News Search**](https://apify.com/parseforge/hackernews-algolia-scraper) - Every HN story since 2007
- [**📊 Stack Exchange Questions**](https://apify.com/parseforge/stackexchange-questions-scraper) - Search 170+ Stack Exchange sites
- [**🎬 TVMaze TV Shows**](https://apify.com/parseforge/tvmaze-shows-scraper) - TV show metadata and episodes
- [**🎌 AniList Anime/Manga**](https://apify.com/parseforge/anilist-anime-manga-scraper) - Search anime, manga, light novels
- [**🎨 Openverse Media**](https://apify.com/parseforge/openverse-media-scraper) - 800M+ openly licensed images and audio

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Apple Inc., Apple Podcasts, or any podcast publisher. All trademarks mentioned are the property of their respective owners. Only publicly available open data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: max 5,000. Apple's hard cap per query is ~100, but the actor's suffix-expansion bypass routinely returns 2,000+ unique podcasts per keyword.

## `query` (type: `string`):

Keyword to search podcasts (title, host, description). Apple's search is capped at ~100 per query but the actor auto-expands with suffix variations (a–z, 0–9) and dedupes, returning up to ~2,000+ relevant podcasts that mention your keyword.

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

Country code for iTunes store (e.g. 'US', 'GB', 'DE', 'JP').

## `genre` (type: `string`):

iTunes podcast genre. With a search query: filters search results. Without a query: returns Apple's Top Charts for that genre (up to 200).

## Actor input object example

```json
{
  "maxItems": 10,
  "query": "daily news",
  "country": "US",
  "genre": ""
}
```

# 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 = {
    "maxItems": 10,
    "query": "daily news",
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/itunes-podcast-search-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 = {
    "maxItems": 10,
    "query": "daily news",
    "country": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/itunes-podcast-search-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 '{
  "maxItems": 10,
  "query": "daily news",
  "country": "US"
}' |
apify call parseforge/itunes-podcast-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iTunes Podcast Search Scraper",
        "description": "Search Apple Podcasts catalog and extract show metadata: title, host, artwork, RSS feed URL, primary genre, episode count, country, last release date, content advisory and ratings. Bypasses Apple's 100-result search cap to return up to 5,000 unique podcasts per keyword. Top Charts mode included.",
        "version": "1.0",
        "x-build-id": "SAaGDoJTzMnjf1cvH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~itunes-podcast-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-itunes-podcast-search-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/parseforge~itunes-podcast-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-itunes-podcast-search-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/parseforge~itunes-podcast-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-itunes-podcast-search-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: max 5,000. Apple's hard cap per query is ~100, but the actor's suffix-expansion bypass routinely returns 2,000+ unique podcasts per keyword."
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search podcasts (title, host, description). Apple's search is capped at ~100 per query but the actor auto-expands with suffix variations (a–z, 0–9) and dedupes, returning up to ~2,000+ relevant podcasts that mention your keyword."
                    },
                    "country": {
                        "title": "Country (ISO-2)",
                        "type": "string",
                        "description": "Country code for iTunes store (e.g. 'US', 'GB', 'DE', 'JP')."
                    },
                    "genre": {
                        "title": "Genre filter",
                        "enum": [
                            "",
                            "1301",
                            "1303",
                            "1304",
                            "1305",
                            "1307",
                            "1309",
                            "1310",
                            "1311",
                            "1314",
                            "1315",
                            "1316",
                            "1318",
                            "1320",
                            "1321",
                            "1323",
                            "1324",
                            "1325"
                        ],
                        "type": "string",
                        "description": "iTunes podcast genre. With a search query: filters search results. Without a query: returns Apple's Top Charts for that genre (up to 200).",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
