# Podchaser Podcast, Episode & Creator Scraper (`parseforge/podchaser-scraper`) Actor

Scrape podcast data from Podchaser, the largest podcast database. Search for podcasts, episodes, and creators by keyword. Get titles, descriptions, ratings, categories, episode counts, author info, Apple Podcasts and Spotify IDs, RSS feed URLs, power scores, and follower counts.

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

## Pricing

from $6.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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🎙️ Podchaser Podcast, Episode & Creator Scraper

Whether you're a podcast marketer researching trends, a media buyer looking for sponsorship opportunities, or a data analyst tracking the podcast industry, this tool makes it easy to collect structured podcast data from Podchaser's comprehensive database.

> **The Podchaser Scraper collects podcast, episode, and creator data including titles, descriptions, ratings, categories, episode counts, author info, and platform IDs. Search by keyword and filter by content type.**

### ✨ What Does It Do

- 🎙️ **Podcast search** - find podcasts by keyword with titles, descriptions, ratings, categories, and episode counts
- 📻 **Episode search** - discover episodes with air dates, duration, audio URLs, and podcast associations
- 👤 **Creator search** - look up podcast creators with bios, social links, appearance counts, and follower data
- 🔗 **Platform IDs** - get Apple Podcasts, Spotify, and RSS feed URLs for each podcast
- 📊 **Ratings & metrics** - collect power scores, follower counts, review counts, and audience estimates
- 🏷️ **Categories** - full category data for every podcast result

### 🔧 Input

- **Search Query** - search for podcasts, episodes, or creators by keyword (e.g., 'technology', 'true crime', 'business')
- **Max Items** - how many items to collect (free users get 10 items, paid users up to 1,000,000)
- **Search Type** - choose between Podcasts, Episodes, or Creators

```json
{
    "searchQuery": "technology",
    "maxItems": 10,
    "searchType": "podcasts"
}
````

### 📊 Output

Each result includes rich structured data. Download as JSON, CSV, or Excel.

#### Podcast Fields

| 📌 Field | 📄 Description |
|----------|---------------|
| 🖼️ imageUrl | Podcast cover art URL |
| 📋 title | Podcast title |
| 🔗 url | Podchaser URL |
| 📝 description | Podcast description |
| ⭐ rating | Podcast rating |
| 🏷️ categories | Genre categories |
| ✍️ author | Podcast author |
| 📊 totalEpisodes | Number of episodes |
| 🎵 spotifyId | Spotify ID |
| 🍎 itunesId | Apple Podcasts ID |
| 📡 feedUrl | RSS feed URL |
| 💪 powerScore | Podchaser power score |
| 👥 followerCount | Number of followers |

#### Episode Fields

| 📌 Field | 📄 Description |
|----------|---------------|
| 📋 title | Episode title |
| 📝 description | Episode description |
| 📅 airDate | Air date |
| ⏱️ length | Duration in seconds |
| 🔊 audioUrl | Audio stream URL |
| 🎙️ podcastTitle | Parent podcast title |

#### Creator Fields

| 📌 Field | 📄 Description |
|----------|---------------|
| 👤 name | Creator name |
| 📝 bio | Creator biography |
| 📍 location | Location |
| 🐦 twitterHandle | Twitter handle |
| 🎙️ podcastCreditCount | Number of podcast credits |
| 👥 followerCount | Follower count |

```json
{
    "imageUrl": "https://d3t3ozftmdmh3i.cloudfront.net/production/podcast_uploaded/5299823/5299823-1589568381264-9a979bd3c1c55.jpg",
    "title": "Technology's Storytellers",
    "url": "https://www.podchaser.com/podcasts/technologys-storytellers",
    "id": 1229655,
    "description": "Technology's Storytellers is a podcast developed by the Society for the History of Technology to explore present issues through the lens of the history of technology.",
    "rating": 3,
    "ratingCount": 0,
    "reviewCount": 0,
    "status": "idle",
    "category": "Society",
    "categories": ["Society", "Culture"],
    "author": "Nathaniel Stanton",
    "totalEpisodes": 10,
    "itunesId": "1515203696",
    "feedUrl": "https://anchor.fm/s/202f79dc/podcast/rss",
    "powerScore": 0,
    "followerCount": 0,
    "daysBetweenEpisodes": 56,
    "dateOfFirstEpisode": "2020-05-15 21:23:46",
    "dateOfLatestEpisode": "2020-08-24 21:46:56",
    "hasGuests": true,
    "scrapedAt": "2026-04-08T01:26:49.178Z"
}
```

### 💎 Why Choose the Podchaser Scraper?

| Feature | Our Tool | Manual Podchaser |
|---------|----------|-----------------|
| Batch collection | ✅ Up to 25 results per query | ❌ Browse one at a time |
| Multiple content types | ✅ Podcasts, episodes, creators | ⚠️ Switch between tabs |
| Platform IDs | ✅ Spotify, Apple, RSS in one call | ⚠️ Check each platform |
| Structured output | ✅ JSON, CSV, Excel | ❌ HTML pages only |
| Automated scheduling | ✅ Daily/weekly monitoring | ❌ Manual visits |
| Rating data | ✅ Ratings, reviews, power scores | ⚠️ Scattered across pages |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set your search query, content type, and how many items you want
3. **Run It** - click "Start" and get structured podcast data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 📈 **Podcast marketers** - research trending topics and discover sponsorship opportunities by category and audience size
- 🎙️ **Podcast networks** - track competitor shows, monitor ratings, and find acquisition targets
- 📊 **Media buyers** - build databases of podcasts by niche for targeted advertising campaigns
- 🔍 **Researchers** - analyze the podcast landscape with structured data on shows, episodes, and creators
- 🤝 **PR agencies** - find relevant podcast hosts and creators for client placements and interviews
- 📱 **App developers** - enrich podcast apps with Podchaser metadata, ratings, and creator info

### ❓ FAQ

🎙️ **What is Podchaser?**
Podchaser is the largest podcast database, often called "the IMDb of podcasts." It catalogs millions of podcasts and episodes with ratings, reviews, credits, and audience data.

🔍 **What search types are available?**
You can search for Podcasts (shows), Episodes (individual episodes), or Creators (hosts, guests, producers).

📊 **What data fields are included?**
Podcasts include 25+ fields: title, description, rating, categories, episode count, author, Spotify/Apple IDs, RSS feed, power score, followers, and more. Episodes include air date, duration, audio URL, and podcast info. Creators include bio, location, social links, and credit counts.

⏱️ **How long does a run take?**
Typically under 2 seconds for a full search. The API returns up to 25 results per content type.

📈 **How often should I run it?**
Set up a scheduled run to monitor podcast trends weekly or track new episodes daily.

### 🔗 Integrate Podchaser Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate podcast monitoring workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts when new podcasts match your criteria
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export podcast data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more data scraping tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Hugging Face Model Scraper | Collect AI model data from Hugging Face | [Link](https://apify.com/parseforge/hugging-face-model-scraper) |
| PR Newswire Scraper | Scrape press releases and news | [Link](https://apify.com/parseforge/pr-newswire-scraper) |
| Smart Apify Actor Scraper | Scrape Apify actor data with 70+ fields | [Link](https://apify.com/parseforge/smart-apify-actor-scraper) |
| Chrome Web Store Scraper | Extract extension data from Chrome Web Store | [Link](https://apify.com/parseforge/stripe-marketplace-scraper) |
| AWS Marketplace Scraper | Collect cloud product data from AWS | [Link](https://apify.com/parseforge/aws-marketplace-scraper) |

**Pro Tip:** 💡 Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to Podchaser or any of its parent companies. It accesses only publicly available data through Podchaser's public API.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for podcasts, episodes, or creators by keyword (e.g., 'technology', 'true crime', 'business').

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `searchType` (type: `string`):

Choose what type of content to search for.

## Actor input object example

```json
{
  "searchQuery": "technology",
  "maxItems": 10,
  "searchType": "podcasts"
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "searchQuery": "technology",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/podchaser-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 = {
    "searchQuery": "technology",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/podchaser-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 '{
  "searchQuery": "technology",
  "maxItems": 10
}' |
apify call parseforge/podchaser-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Podchaser Podcast, Episode & Creator Scraper",
        "description": "Scrape podcast data from Podchaser, the largest podcast database. Search for podcasts, episodes, and creators by keyword. Get titles, descriptions, ratings, categories, episode counts, author info, Apple Podcasts and Spotify IDs, RSS feed URLs, power scores, and follower counts.",
        "version": "1.0",
        "x-build-id": "Mq1ZlDc260A8kpDgz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~podchaser-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-podchaser-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~podchaser-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-podchaser-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~podchaser-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-podchaser-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for podcasts, episodes, or creators by keyword (e.g., 'technology', 'true crime', 'business')."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "searchType": {
                        "title": "Search Type",
                        "enum": [
                            "podcasts",
                            "episodes",
                            "creators"
                        ],
                        "type": "string",
                        "description": "Choose what type of content to search for.",
                        "default": "podcasts"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
