# Spotify Podcast Scraper — Shows, Episodes, Ratings & Contacts (`foxlabs/spotify-podcast-scraper`) Actor

Scrape Spotify podcasts and episodes without API keys. Extracts show ratings, review counts, episode chapters, MP3 previews, RSS/social links, sponsor URLs, and contact emails from descriptions.

- **URL**: https://apify.com/foxlabs/spotify-podcast-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Social media, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 spotify podcast shows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

<p align="center">
  <img src="https://img.shields.io/badge/Pay--Per--Event-Shows_%2B_Episodes-00C853?style=for-the-badge" alt="Pay-Per-Event" />&nbsp;
  <img src="https://img.shields.io/badge/Listener_Ratings-RSS_%C2%B7_Socials_%C2%B7_Emails-2962FF?style=for-the-badge" alt="Listener Ratings & Emails" />&nbsp;
  <img src="https://img.shields.io/badge/AI_Agent_Ready-MCP_%26_x402-7C4DFF?style=for-the-badge" alt="MCP & x402 Ready" />&nbsp;
  <img src="https://img.shields.io/badge/Dual_Runtime-Batch_%2B_Standby_API-FF6D00?style=for-the-badge" alt="Batch + Standby API" />
</p>

## Spotify Podcast Scraper — Shows, Episodes, Ratings & Contacts 🚀

**foXLabs Creator, Media & Influencer Lead Series:** [Apple App Store Scraper](https://apify.com/foxlabs/apple-app-store-scraper) · [Threads Scraper](https://apify.com/foxlabs/threads-scraper) · [Telegram Channel Scraper](https://apify.com/foxlabs/telegram-channel-scraper) · [Skool Community Scraper](https://apify.com/foxlabs/skool-community-scraper) · [Whop Marketplace Scraper](https://apify.com/foxlabs/whop-marketplace-scraper)

🎉 Extract structured **Spotify podcast shows, full episode catalogs, listener star ratings (`ratingAverage`) & rating counts (`ratingCount`), timestamped episode chapters, MP3 audio previews, video-podcast flags, RSS feed links, 8 creator social channels, sponsor URLs and guest-booking/sponsorship emails** — **with zero Spotify Developer OAuth keys and zero login**.

Built for podcast PR & guest-booking agencies, creator sponsorship & ad-buying platforms, media monitoring teams, audio RAG/transcription pipelines and influencer outreach workflows.

### 🔍 What is the Spotify Podcast Scraper — and when should you use it?

Spotify is the world's largest podcast discovery ecosystem, yet Spotify's official Web API **omits listener star ratings (`ratingAverage`), total rating counts (`ratingCount`), episode chapters, creator social links and RSS URLs** — and restricts developer app quotas aggressively. Meanwhile, PR agencies and brand sponsors waste hours manually opening show notes one by one to find host booking emails, YouTube channels and active sponsors.

This Actor unlocks all **44 structured podcast & episode intelligence fields** inside a fast `256 MB` HTTP runtime (~6.1s for 20 enriched shows):

- **3 Flexible Discovery Modes + Direct Show/Episode URLs** — search by niche/topic/host in `searchQueries` (`"shows"`, `"episodes"`, or `"shows_with_episodes"`), or pass direct `open.spotify.com/show/...` (`showUrls`) and `open.spotify.com/episode/...` (`episodeUrls`) links, URIs or 22-character Spotify IDs.
- **Exclusive Listener Star Ratings & Social Proof** — captures `ratingAverage` (e.g., `4.75`) and `ratingCount` (`83,270` ratings) alongside `totalEpisodes`, `topics[]`, `publisher` and `mediaType` (`AUDIO` vs. `MIXED` video podcasts).
- **Automated Outreach & Sponsor Link Extraction** — parses both show bios and episode HTML descriptions (`htmlDescription`) to extract `extractedEmails[]`, `extractedSponsorUrls[]` (promo/affiliate landing pages), `rssFeedUrl`, `websiteUrl`, `youtubeUrl`, `twitterUrl`, `instagramUrl`, `linkedinUrl`, `tiktokUrl`, `patreonUrl` and `applePodcastsUrl`.
- **Deep Episode Telemetry** — captures `durationMs`/`durationMinutes`, `releaseDate`, `audioPreviewUrl` (`.mp3`), `hasVideo`, `isPaywalled` and timestamped `chapters[]`.

**Use it when you need:** B2B podcast guest-booking & host outreach lists with verified emails and listener rating counts; sponsor & competitor ad-spend intelligence (`extractedSponsorUrls[]`); topic-level episode discovery; or audio RAG feed indexing.

**Use something else when:** you need **full-length raw episode audio downloads or Whisper speech-to-text transcripts** (this Actor provides official `audioPreviewUrl` MP3 clips, `rssFeedUrl` discovery and timestamped `chapters[]`, not full DRM stream ripping).

### 🤖 Use with AI agents (MCP, Claude, Cursor & x402)

**Already connected to the Apify MCP server?** Ask your AI assistant to call `foxlabs/spotify-podcast-scraper`.

- **Hosted MCP URL (zero install):** `https://mcp.apify.com?tools=foxlabs/spotify-podcast-scraper`
- **Local stdio config (Claude Desktop, Cursor, Cline, Windsurf):**

```json
{
  "mcpServers": {
    "spotify-podcast-scraper": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "foxlabs/spotify-podcast-scraper"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

**Your agent can pay for its own runs.** Priced transparently per event (`$0.002` per `show`, `$0.0012` per `episode`, `$0.00` for diagnostic `status` rows), this Actor supports autonomous micropayments via **x402 (USDC on Base)** or **Skyfire** alongside standard Apify tokens.

Copy-paste prompt for Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```text
Use the Apify Actor `foxlabs/spotify-podcast-scraper` to find Spotify podcasts, listener star ratings, recent episodes, sponsor links, social profiles and host booking emails.

Input fields:
- `searchQueries`: array of keywords, topics or host/guest names (e.g. ["B2B SaaS", "Artificial Intelligence"])
- `searchMode`: "shows" (default) | "episodes" | "shows_with_episodes"
- `showUrls`: optional array of https://open.spotify.com/show/... URLs, URIs or 22-char IDs
- `episodeUrls`: optional array of https://open.spotify.com/episode/... URLs or URIs
- `enrichShowMetadata`: boolean (default true) — populates ratingAverage, ratingCount, socials & emails
- `episodesPerShow`: integer 0..500 (default 5; used for showUrls or searchMode="shows_with_episodes")
- `maxResultsPerQuery`: integer 1..500 (default 20)

Start with:
{"searchQueries":["B2B SaaS","Founder Interviews"],"searchMode":"shows_with_episodes","enrichShowMetadata":true,"episodesPerShow":3,"maxResultsPerQuery":15}
```

**Things you can ask your AI agent:**

- *"Find the top 20 `Cybersecurity` podcasts on Spotify with at least 100 listener ratings (`ratingCount >= 100`), plus their latest 3 episodes, booking emails (`extractedEmails`) and LinkedIn/YouTube links."*
- *"Search full Spotify `episodes` mentioning `'Model Context Protocol'` and list the episode title, showName, releaseDate, durationMinutes and extractedUrls."*
- *"Audit the last 20 episodes of these 5 competitor-sponsored podcasts (`showUrls`) and extract every brand domain inside `extractedSponsorUrls`."*

The machine-readable Actor summary, MCP metadata and schema live at `https://apify.com/foxlabs/spotify-podcast-scraper.md`.

### 📋 Overview

Everything needed to turn Spotify podcast search and show catalogs into structured PR, sponsorship and media datasets — in one 44-column schema.

| Property | Details |
|---|---|
| **Public data source** | Public Spotify Web podcast & episode catalog (`open.spotify.com`) |
| **Authentication required** | None — zero Spotify Developer client ID/secret, login or cookies |
| **Container footprint** | Lightweight `256 MB` HTTP runtime (**6.1s** for 20 enriched shows on verified QA) |
| **Output row types (`rowType`)** | `show` (`$0.002` / `$2.00 per 1K`), `episode` (`$0.0012` / `$1.20 per 1K`), `status` (`$0.00`) |
| **Deduplication & restart safety** | Deterministic `rowKey` (`spotify:show:<showId>` & `spotify:episode:<episodeId>`) |
| **Execution modes** | Standard Batch Dataset runs + synchronous Standby HTTP API (`GET /`, `POST /scrape`) |

**Why PR agencies & sponsorship teams pick this Actor:**

- ⭐ **Star ratings & review counts Spotify's API hides** — qualify active shows immediately using `ratingAverage` (`1.0–5.0`) and `ratingCount` instead of pitching dead 3-episode pods.
- 📧 **Host emails + 8 social channels extracted automatically** — pulls `extractedEmails[]`, `websiteUrl`, `rssFeedUrl`, `youtubeUrl`, `twitterUrl`, `instagramUrl`, `linkedinUrl`, `tiktokUrl`, `patreonUrl` and `applePodcastsUrl` from show & episode notes.
- 💸 **Sponsor & promo URL intelligence (`extractedSponsorUrls[]`)** — identifies advertisers buying host-read spots (`brand.com/showcode`, UTM links, Linktree/partner links) inside episode show notes.
- 🎬 **Video podcast & paywall detection** — flags Spotify video episodes (`hasVideo: true`, `mediaType: "MIXED"`) and subscriber-locked episodes (`isPaywalled`).

### ✨ Key Features

- 🎙️ **Three Search Modes in One Actor** — Run `"shows"` (fast podcast directory discovery), `"episodes"` (find specific guest appearances or keyword mentions across individual episodes), or `"shows_with_episodes"` (discover shows AND pull their latest `episodesPerShow` episodes in one pass).
- ⏱️ **Timestamped Episode `chapters[]`** — Captures `(MM:SS)` chapter markers and topic breakdowns straight from episode descriptions.
- 🔗 **Flexible URL, URI & ID Input** — Accepts `https://open.spotify.com/show/2MAi0BvDc6GTFvKFPXnkCL`, `spotify:show:2MAi0BvDc6GTFvKFPXnkCL`, or bare 22-character base62 IDs.
- ⚡ **Real-Time Standby HTTP (`POST /scrape`)** — Plug directly into Clay, n8n, Make or autonomous PR-pitching AI agents.

### 🎬 Quick Start (API & Standby HTTP)

**1. Synchronous Batch API call (returns JSON array directly):**

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~spotify-podcast-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["Artificial Intelligence"],"searchMode":"shows","enrichShowMetadata":true,"maxResultsPerQuery":20}'
```

**2. Real-time Standby HTTP API (`POST /scrape`):**

```bash
curl -X POST "https://foxlabs--spotify-podcast-scraper.apify.actor/scrape?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["B2B SaaS"],"searchMode":"shows_with_episodes","episodesPerShow":3,"maxResultsPerQuery":5}'
```

### 🚀 Getting Started (3 steps)

1. **Enter niche keywords or Spotify URLs** — Add topics, industries or guest names in **Search Queries** (`"Artificial Intelligence"`, `"Ecommerce"`), or paste direct `showUrls` / `episodeUrls`.
2. **Choose search mode & episode depth** — Pick `"shows"` (shows only), `"episodes"` (episode search), or `"shows_with_episodes"` (shows + latest `episodesPerShow` episodes, where episode show notes often hold the best host emails & sponsor links!).
3. **Run & export** — Click **Start** and export your 44-column dataset to Clay, CSV, Excel, Airtable or HubSpot.

### 📥 Input & Filters

```json
{
  "searchQueries": ["Artificial Intelligence", "B2B SaaS"],
  "searchMode": "shows_with_episodes",
  "showUrls": [],
  "episodeUrls": [],
  "enrichShowMetadata": true,
  "episodesPerShow": 5,
  "maxResultsPerQuery": 20
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | `array<string>` | `["Artificial Intelligence"]` | Keywords, topics, guest names or niches to search on Spotify. |
| `searchMode` | `string` | `"shows"` | `"shows"` (podcast shows), `"episodes"` (individual episodes), or `"shows_with_episodes"` (shows + recent episodes). |
| `showUrls` | `array<string>` | `[]` | Direct `open.spotify.com/show/...` URLs, `spotify:show:...` URIs, or 22-char Spotify show IDs. |
| `episodeUrls` | `array<string>` | `[]` | Direct `open.spotify.com/episode/...` URLs, `spotify:episode:...` URIs, or 22-char episode IDs. |
| `enrichShowMetadata` | `boolean` | `true` | Populate `ratingAverage`, `ratingCount`, `topics[]`, full `htmlDescription`, social links & `extractedEmails[]` on searched shows. |
| `episodesPerShow` | `integer` | `5` | Number of latest episodes fetched per show in `showUrls` or when `searchMode: "shows_with_episodes"` (`0` = show metadata only). |
| `maxResultsPerQuery` | `integer` | `20` | Maximum shows or episodes returned per search query (`1`–`500`). |
| `proxyConfiguration` | `object` | `{"useApifyProxy": true}` | Managed automatically via standard Apify Proxy. |

**Copy-paste input recipes:**

- **Podcast PR guest-booking lead list (`shows_with_episodes` surfaces emails inside episode notes):**
  `{"searchQueries":["FinTech","CFO","Venture Capital"],"searchMode":"shows_with_episodes","enrichShowMetadata":true,"episodesPerShow":3,"maxResultsPerQuery":25}`
- **Competitor brand/founder guest-appearance tracker (`searchMode: "episodes"`):**
  `{"searchQueries":["\"Sam Altman\"","\"Guillermo Rauch\""],"searchMode":"episodes","maxResultsPerQuery":30}`
- **Deep sponsor & back-catalog audit on specific `showUrls`:**
  `{"searchQueries":[],"showUrls":["https://open.spotify.com/show/7gKwwMLFLc6RmjmRpbMtEO"],"episodesPerShow":25}`

### 📤 Output Schema & Real Sample Record

Each item carries `rowType` (`"show"`, `"episode"` or free diagnostic `"status"`) and deterministic `rowKey` (`spotify:show:<showId>` or `spotify:episode:<episodeId>`).

| Field Group | Fields (44 Columns Total) |
|---|---|
| **Show Identity & Ratings (`show`)** | `rowKey`, `rowType`, `showId`, `uri`, `url`, `name`, `publisher`, `description`, `htmlDescription`, `topics[]`, `totalEpisodes`, `ratingAverage`, `ratingCount`, `mediaType`, `mediaTypes`, `consumptionOrder`, `isExplicit`, `coverArtUrl`, `searchQuery`, `scrapedAt` |
| **Creator Contacts & Socials** | `extractedEmails[]`, `extractedUrls[]`, `extractedSponsorUrls[]`, `websiteUrl`, `rssFeedUrl`, `applePodcastsUrl`, `youtubeUrl`, `twitterUrl`, `instagramUrl`, `linkedinUrl`, `tiktokUrl`, `patreonUrl` |
| **Episode Telemetry (`episode`)** | `episodeId`, `showId`, `showName`, `showUrl`, `name`, `description`, `htmlDescription`, `releaseDate`, `releaseDatePrecision`, `durationMs`, `durationMinutes`, `audioPreviewUrl`, `playable`, `hasVideo`, `isPaywalled`, `chapters[]` |

#### Real sample record (from verified platform pre-publish run `pVNYJhJUFGlqBsj5r`, 2026-11-14)

```json
{
  "rowKey": "spotify:show:7gKwwMLFLc6RmjmRpbMtEO",
  "rowType": "show",
  "showId": "7gKwwMLFLc6RmjmRpbMtEO",
  "uri": "spotify:show:7gKwwMLFLc6RmjmRpbMtEO",
  "url": "https://open.spotify.com/show/7gKwwMLFLc6RmjmRpbMtEO",
  "name": "The AI Daily Brief: Artificial Intelligence News and Analysis",
  "publisher": "Nathaniel Whittemore",
  "description": "A daily news analysis show on all things artificial intelligence. NLW looks at AI from multiple angles, from the explosion of creativity brought on by new tools like Midjourney and ChatGPT to the potential disruptions to work and industries as we know them...",
  "htmlDescription": "A daily news analysis show on all things artificial intelligence. NLW looks at AI from multiple angles...",
  "mediaType": "MIXED",
  "consumptionOrder": "RECENT",
  "isExplicit": true,
  "topics": [
    "Business",
    "Technology"
  ],
  "totalEpisodes": 642,
  "ratingAverage": 4.35,
  "ratingCount": 3067,
  "coverArtUrl": "https://i.scdn.co/image/ab6765630000ba8a797fe5aeae1fbb9493153617",
  "extractedEmails": [],
  "extractedUrls": [],
  "websiteUrl": null,
  "rssFeedUrl": null,
  "applePodcastsUrl": null,
  "youtubeUrl": null,
  "twitterUrl": null,
  "instagramUrl": null,
  "linkedinUrl": null,
  "tiktokUrl": null,
  "patreonUrl": null,
  "searchQuery": "Artificial Intelligence",
  "scrapedAt": "2026-11-14T05:07:52.868Z"
}
```

Every run also writes a `SOURCE_REPORT` telemetry summary to the default Key-Value Store.

### 🧪 Data Quality — Measured

Verified on the Apify platform across QA runs (`lPvGu5bUY4uW2qmfq`, `CIjlQ9tftbAYfBu6J`, `PefhESN1wQVZlSbbA`) and pre-publish live billing verification (`pVNYJhJUFGlqBsj5r` on 2026-11-14):

- **100% show & episode uniqueness:** Cross-deduplicated via `spotify:show:<id>` and `spotify:episode:<id>` across overlapping queries and combined `showUrls` + `episodeUrls` batches (`50` sampled rows, `0` duplicates).
- **100% listener rating & publisher accuracy:** Verified real `ratingAverage` (`4.35`, `4.75`) and `ratingCount` (`3,067`, `83,270`) values unavailable in Spotify's public REST API, with strict `ratingAverage: null` on unrated shows.
- **Verified two-event PPE billing:** Settled `chargedEventCounts` on run `pVNYJhJUFGlqBsj5r` matched `show` (`$0.002`) and `episode` (`$0.0012`) deliveries `1:1`, with diagnostic `status` rows at `$0.00`.

### ⏱️ Performance — Measured

Measured on the Apify platform at the default **`256 MB`** memory tier:

- **6.1 seconds for 20 enriched podcast shows:** Platform QA run `lPvGu5bUY4uW2qmfq` (`searchQueries: ["Artificial Intelligence"]`, `enrichShowMetadata: true`, `20` shows) finished in **`6.1s`** on standard Datacenter proxies inside `256 MB` RAM.
- **Restart-idempotent Dataset tracking:** Hydrates existing `spotify:show:<id>` and `spotify:episode:<id>` keys on startup so container migrations never re-emit or double-bill items.

### 💼 Use Cases

1. **Podcast PR & Founder Guest-Booking Outreach**
   - *Input:* `{"searchQueries":["B2B SaaS","DevTools","Cloud Security"],"searchMode":"shows_with_episodes","episodesPerShow":3,"maxResultsPerQuery":30}`
   - *Output:* Qualified active shows (`ratingCount >= 50`, recent `releaseDate` within 14 days) + host `publisher` name, `extractedEmails[]`, `linkedinUrl` and `twitterUrl`.
   - *Business action:* Pitch founders onto active niche podcasts referencing the host's exact latest episode topic.

2. **Podcast Advertising & Competitor Sponsorship Intelligence**
   - *Input:* `{"searchQueries":[],"showUrls":["https://open.spotify.com/show/2MAi0BvDc6GTFvKFPXnkCL"],"episodesPerShow":50}`
   - *Output:* `extractedSponsorUrls[]` across the last 50 episodes (`brand.com/lex`, promo codes, affiliate landing pages) + release cadence.
   - *Business action:* Discover which podcasts your competitors renew month after month (proven positive ad ROI!).

3. **Executive & Brand Mention Monitoring (`searchMode: "episodes"`)**
   - *Input:* Weekly scheduled search for your brand, product or CEO name in `"episodes"` mode.
   - *Output:* New episodes mentioning your brand, complete with `audioPreviewUrl`, `durationMinutes`, `chapters[]` and `showUrl`.
   - *Business action:* Track organic word-of-mouth across thousands of podcasts automatically.

4. **AI Podcast Recommendation & Research Agents (MCP / Standby)**
   - *Input:* Synchronous `POST /scrape` call from Claude, Cursor or a newsletter curation workflow.
   - *Output:* Top-rated shows + recent episode summaries, chapter timestamps and direct Spotify URIs.
   - *Business action:* Curate weekly niche audio digests in seconds.

### 🔗 Integrations (Node.js, Python, n8n, Make & Clay)

#### JavaScript / Node.js (`apify-client`)

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('foxlabs/spotify-podcast-scraper').call({
    searchQueries: ['Artificial Intelligence'],
    searchMode: 'shows_with_episodes',
    enrichShowMetadata: true,
    episodesPerShow: 3,
    maxResultsPerQuery: 15,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Fetched ${items.length} Spotify shows & episodes`, items[0]);
```

#### Python (`apify-client` v3)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("foxlabs/spotify-podcast-scraper").call(
    run_input={
        "searchQueries": ["Artificial Intelligence"],
        "searchMode": "shows",
        "enrichShowMetadata": True,
        "maxResultsPerQuery": 20,
    }
)

for item in client.dataset(run.default_dataset_id).iterate_items():
    if item["rowType"] == "show":
        print(item["name"], "| Rating:", item["ratingAverage"], f"({item['ratingCount']})", "| Emails:", item["extractedEmails"])
```

*(Written for `apify-client` v3 where `call()` returns a `Run` object exposing `run.default_dataset_id`; on `apify-client` v1/v2 use `run["defaultDatasetId"]`.)*

#### n8n, Make, Zapier & Clay

- **Clay Podcast Host Waterfall:** Run `"shows_with_episodes"` (`episodesPerShow: 3`) → push `publisher`, `name`, `extractedEmails[]`, `linkedinUrl` and latest episode title into Clay to personalize guest pitches automatically.

### 📊 Pricing (Pay-Per-Event)

Granular two-event **Pay-Per-Event (PPE)** billing — pay `$0.002` per podcast show and `$0.0012` per episode:

| Event Name | Trigger | Price per Item | Price per 1,000 |
|---|---|---|---|
| `show` | Once per unique Spotify podcast show (`rowType: "show"`, including `enrichShowMetadata`) | **$0.002** | **$2.00 / 1,000** |
| `episode` | Once per unique Spotify podcast episode (`rowType: "episode"`) | **$0.0012** | **$1.20 / 1,000** |
| `status` *(diagnostic)* | Empty input, malformed Spotify URI/URL, or zero-match query note | **$0.00 (Free)** | **$0.00** |

**Worked cost examples:**

- **100 enriched podcast shows (`searchMode: "shows"`):** `100 × $0.002` = **$0.20**
- **50 podcast shows + 3 latest episodes each (`shows_with_episodes`, `150` episodes):** `(50 × $0.002) + (150 × $0.0012)` = **$0.28**
- **1,000 episodes in `searchMode: "episodes"`:** `1,000 × $0.0012` = **$1.20**

**Billing guarantees:**

- **`enrichShowMetadata: true` is included free in `show`:** Listener star ratings, rating counts, full HTML bios and contact extraction carry zero extra fee beyond `$0.002`.
- **Proxy traffic included:** Runs on standard Apify Proxy with zero external proxy charges.
- **Exact spend cap support:** Configure **Maximum cost per run** in Apify options; `ChargingManager` halts cleanly at your budget limit. *(Note: if Apify applies its platform `apify-actor-start` fee on your plan, that start event applies when a run starts, including zero-result runs.)*

### ❓ Frequently Asked Questions (FAQ)

#### Do I need a Spotify Developer client ID, OAuth secret, or premium account?

No. You do not need to register a Spotify Developer application, rotate OAuth client secrets, or supply personal Spotify cookies. The Actor manages anonymous public catalog sessions automatically on standard Apify Datacenter proxies with zero user configuration required.

#### Why are `ratingAverage` and `ratingCount` so important compared to Spotify's official Web API?

Spotify's documented REST Web API (`GET /v1/shows/{id}`) intentionally excludes listener star ratings (`ratingAverage`) and total rating counts (`ratingCount`). Because over 70% of indexed podcasts are inactive "podfaded" shows with `< 5` listeners, `ratingCount` + latest episode `releaseDate` are the two most reliable metrics on earth for filtering active, high-reach podcasts.

#### Why do I find many more emails and social links when using `searchMode: "shows_with_episodes"` instead of `"shows"` alone?

Many podcast creators write a short 2-sentence summary in their top-level Show About bio (`extractedEmails: []`), while pasting their full production footer — booking email, host LinkedIn/X/YouTube links, Patreon, newsletter URL and active sponsors — at the bottom of every **episode** description! Setting `searchMode: "shows_with_episodes"` with `episodesPerShow: 3` checks both the show bio and the latest 3 episodes for pennies (`+$0.0036` per show).

#### How are `extractedSponsorUrls[]` distinguished from creator social links?

As the Actor parses HTML `<a>` tags and raw URLs inside episode descriptions, official platform links (`youtube.com`, `linkedin.com`, `x.com`/`twitter.com`, `instagram.com`, `tiktok.com`, `patreon.com`, `podcasts.apple.com`, RSS hosts) are routed into dedicated structured columns, while external commercial promo URLs, vanity slash-links (e.g. `athleticgreens.com/myshow`) and UTM sponsor links are isolated into `extractedSponsorUrls[]`.

#### Why is `rssFeedUrl` `null` on certain shows?

Spotify does not publicly expose the underlying RSS XML URL for every show on `open.spotify.com` unless the creator included their Anchor/Megaphone/Libsyn/Substack RSS link in their public description or external links. Whenever an RSS feed URL is present in show or episode metadata, `rssFeedUrl` captures it; otherwise it emits `null` honestly.

#### How does chapter extraction (`chapters[]`) work on episodes?

Most professional podcasts embed structured `(00:00)` / `(01:14:20)` timestamp outlines in their episode notes. The Actor automatically parses those timestamp lines into a clean `chapters[]` array (`timestamp`, `seconds`, `title`) so AI agents and researchers can jump straight to relevant segments.

#### What input formats are accepted in `showUrls` and `episodeUrls`?

You can pass full browser URLs (`https://open.spotify.com/show/7gKwwMLFLc6RmjmRpbMtEO?si=...`), native Spotify URIs (`spotify:show:7gKwwMLFLc6RmjmRpbMtEO`), or bare 22-character base62 IDs (`7gKwwMLFLc6RmjmRpbMtEO`). Query tracking parameters (`?si=...`) are stripped automatically.

#### How do I scrape only specific `showUrls` without running the default `"Artificial Intelligence"` search?

Clear the prefilled `"Artificial Intelligence"` entry in **Search Queries** inside Apify Console, or pass `"searchQueries": []` in your JSON payload alongside `"showUrls": ["https://open.spotify.com/show/..."]` and your desired `"episodesPerShow"` count so only your target podcasts are processed.

#### Can I fetch only show metadata for `showUrls` without fetching any episodes?

Yes. Set `"episodesPerShow": 0` alongside `"showUrls": [...]` and `"searchQueries": []`. The Actor will emit strictly one `rowType: "show"` record (`$0.002`) per show URL containing listener ratings, publisher info, social links and emails while skipping episode pagination completely.

#### Does the Actor detect video podcasts (`hasVideo`) and Spotify subscriber-only episodes (`isPaywalled`)?

Yes. Shows blending video and audio report `mediaType: "MIXED"`, and individual episode records expose explicit boolean `hasVideo` and `isPaywalled` flags alongside `playable`, `durationMinutes` and `audioPreviewUrl` (`.mp3` preview clip) so you can filter video-first creators or free episodes easily.

#### Can AI agents call this Actor synchronously via MCP or Standby HTTP?

Yes. Connect Claude Desktop, Cursor, Windsurf or custom MCP clients directly to `https://mcp.apify.com?tools=foxlabs/spotify-podcast-scraper`, or `POST` JSON payloads to `https://foxlabs--spotify-podcast-scraper.apify.actor/scrape` in Apify Standby mode for sub-10-second synchronous JSON responses.

#### Is the Actor idempotent across overlapping queries and container restarts?

Yes. Every show (`spotify:show:<showId>`) and episode (`spotify:episode:<episodeId>`) is deduplicated both in-memory across overlapping `searchQueries` / `episodeUrls` and against the existing Dataset on container startup, guaranteeing zero duplicate rows and zero double charges.

### 🐛 Troubleshooting

- **`extractedEmails` and social URLs are mostly empty on `"shows"` mode:** Switch `searchMode` to `"shows_with_episodes"` (`episodesPerShow: 3`) — most hosts place their contact/social footer in episode show notes rather than the short show header!
- **Default `"Artificial Intelligence"` ran alongside `showUrls` or `episodeUrls`:** Pass `"searchQueries": []` when running URL-only inputs.
- **Dataset contains only `rowType: "status"` (`EMPTY_INPUT`):** `searchQueries`, `showUrls` and `episodeUrls` were all empty.
- **Music album/track URL passed instead of a podcast:** `showUrls` and `episodeUrls` target Spotify podcasts (`/show/` and `/episode/`), not music `/album/` or `/track/` URLs.

### 🚧 What It Does Not Do

- Does **not** rip full DRM-protected audio/video streams (provides official `audioPreviewUrl` MP3 previews, episode metadata and `chapters[]`).
- Does **not** expose private Spotify for Creators analytics (listener demographics/completion rates visible only to the show owner).

### ⚠️ Trademark Notice

This Actor is an independent software tool built by **foXLabs** and is not affiliated with, endorsed by, or sponsored by Spotify AB. "Spotify" is a registered trademark of Spotify AB, referenced solely to describe compatibility with publicly accessible web pages.

### ⚖️ Is It Legal to Scrape Public Spotify Podcast Metadata?

This Actor collects publicly published podcast catalog metadata, public show/episode descriptions and business/booking links voluntarily published by creators for public outreach and discovery — with zero login, zero DRM circumvention and zero private listener data collected. Ensure any email outreach complies with CAN-SPAM, GDPR and applicable regulations.

### 🤝 Support, Custom Data & Contact

- 🌐 **Website & full portfolio:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Custom data & enterprise inquiries:** info@foxlabs.com.tr
- 🐛 **Bug reports & feature requests:** open an issue in the Actor's **Issues** tab on Apify Store (include your Run ID)
- 🧰 **Browse all foXLabs Actors:** [apify.com/foxlabs](https://apify.com/foxlabs)

### Changelog

#### 0.1.2 (2026-11-14)

- Upgraded Store README to full SIÁN standard with MCP & x402 AI agent configuration, Standby HTTP `POST /scrape` examples, verified QA & PPE billing metrics, worked cost tables, and expanded 12-question FAQ.

#### 0.1.0 (2026-11-13)

- Initial release of `foxlabs/spotify-podcast-scraper` supporting `shows`, `episodes` and `shows_with_episodes` search modes, direct `showUrls`/`episodeUrls`, listener star ratings & counts, chapters, sponsor/social/email extraction, and Batch + Standby HTTP modes.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/spotify-podcast-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords, topics, host names, or niche terms to search on Spotify (e.g. 'Artificial Intelligence', 'B2B SaaS', 'Real Estate Investing').

## `searchMode` (type: `string`):

Choose whether keyword searches return Podcast Shows, Full Episodes, or Podcast Shows together with their latest episodes.

## `showUrls` (type: `array`):

Optional Spotify podcast URLs (https://open.spotify.com/show/2MAi0BvDc6GTFvKFPXnkCL), URIs (spotify:show:...), or 22-char IDs.

## `episodeUrls` (type: `array`):

Optional Spotify episode URLs (https://open.spotify.com/episode/...) or URIs (spotify:episode:...).

## `enrichShowMetadata` (type: `boolean`):

Queries Spotify's show metadata endpoint for each searched show to populate star ratings, total rating counts, full HTML descriptions, social profiles, and contact emails.

## `episodesPerShow` (type: `integer`):

Number of recent episodes to extract for each show in 'Direct Show URLs' or when Search Mode is 'Podcast Shows + Recent Episodes' (0 = show metadata only).

## `maxResultsPerQuery` (type: `integer`):

Maximum shows or episodes to extract per search query (1–500).

## `proxyConfiguration` (type: `object`):

Apify Proxy settings. Runs fast and reliably on standard Datacenter proxies by default.

## Actor input object example

```json
{
  "searchQueries": [
    "Artificial Intelligence"
  ],
  "searchMode": "shows",
  "showUrls": [],
  "episodeUrls": [],
  "enrichShowMetadata": true,
  "episodesPerShow": 5,
  "maxResultsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `dataset` (type: `string`):

No description

## `sourceReport` (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 = {
    "searchQueries": [
        "Artificial Intelligence"
    ],
    "maxResultsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/spotify-podcast-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 = {
    "searchQueries": ["Artificial Intelligence"],
    "maxResultsPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/spotify-podcast-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "Artificial Intelligence"
  ],
  "maxResultsPerQuery": 20
}' |
apify call foxlabs/spotify-podcast-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/spotify-podcast-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3CL8Ec8sKTqEuJcC7/builds/yRK8JF9Efc3m5qBwU/openapi.json
