Podcast Lookup — Apple Podcasts Show & Episode Data

Paste a list of Apple Podcasts collection IDs and get each show's full record — title, publisher, genres, episode count, artwork, RSS feed URL — plus its recent episodes with titles, descriptions, release dates, durations and direct audio URLs. This calls Apple's own public iTunes lookup endpoint: no API key, no scraping, no feed parsing on your side.

Who it's for

Podcast directory and discovery apps use this to populate show pages with real artwork, publisher and episode data instead of maintaining their own scraper. Media researchers and analysts pull episode counts and release cadence across a list of shows to spot which ones have gone quiet versus which are still actively publishing. Advertisers and sponsorship platforms check latestReleaseDate before pitching a show, since a large episodeCount on a dead feed is a wasted outreach. And it's the fast path to a show's real RSS feed URL when you need to go deeper than the recent-episodes window this actor returns.

Why this one

• Apple's own lookup endpoint, not a scrape. The same public API Apple's own clients use — no HTML selectors, no rate-limit games with a rendered page.
• You don't pay for IDs that don't resolve. An invalid, delisted or non-podcast ID comes back found: false and is never billed.
• Show and episodes in one call. You get the show record and its recent episodes, including the direct audioUrl, without a second request or an RSS parser.
• The RSS feed URL comes with it. feedUrl is the show's real feed, so you can go deeper yourself whenever the recent-episodes window isn't enough.
• One row per show, or one per episode. Turn on expandRows when you want episodes as their own rows for a table.

What you get

One row per show by default, with episodes nested in episodes. Turn on expandRows to get one row per episode instead. Field names are stable and won't be renamed between runs.

Field	Type / format	Description
query	text	The collection ID exactly as submitted.
found	boolean	Whether the ID resolved to a podcast. Gates billing — false rows are never charged.
status	text	OK, NOT_FOUND (invalid, delisted, or not a podcast), or BAD_FORMAT.
collectionId	number	Apple's numeric collection ID for the show.
name	text	Show title.
publisher	text	Publisher or network name.
genres	array	Apple's genre labels for the show.
episodeCount	number	Total episodes Apple reports for the show.
feedUrl	link	The show's RSS feed — the door to full history.
artworkUrl	link	Show artwork, 600px where available.
explicitness	text	Apple's explicit-content marker, e.g. explicit, notExplicit.
latestReleaseDate	date (ISO 8601)	Release date of the most recent episode — the activity signal.
storeUrl	link	Public Apple Podcasts page for the show.
country	text	Storefront the record came from.
episodes	array	Recent episodes, each with the fields below.
episodeTitle	text	Episode title.
episodeDescription	text	Episode show notes.
episodeReleaseDate	date (ISO 8601)	When the episode was published.
episodeDurationMs	number	Episode length in milliseconds.
audioUrl	link	Direct audio file URL for the episode.
episodeUrl	link	Apple Podcasts page for the episode.
episodeGuid	text	The episode's GUID from the feed — stable across runs.
newEpisodeCount	number / null	How many episodes in this row's list are new since the last monitoring run. null when monitoring is off.
isNew / firstSeenAt	boolean / date	Per-episode stamps when monitoring (or a named watchlist) is on; otherwise null.
scrapedAt	date (ISO 8601)	When the lookup ran.

Monitoring: only new episodes

Turn on Only return episodes that are new since the last run and this actor becomes an episode alert. Each show's recent episodes are checked against the GUIDs your previous run already delivered, and anything you have seen is dropped from episodes. Every show is still looked up and billed once, as usual, and its stats row always comes back, so a quiet show shows newEpisodeCount: 0 instead of vanishing. Each run logs a count like 1 new of 10 fetched.

The first run has nothing to compare against, so it returns every recent episode and remembers it. From the second run on you get only episodes published since.

Paste a Send alerts to webhook (Discord, Slack, Telegram bot, or any HTTPS URL) to have each new episode delivered as a message after the show is billed. Messages are free; a delivery failure never fails the run.

Memory lives in a named key-value store, podcast-lookup-delta, one record per show. Leave the checkbox off but fill in Watchlist name and every episode comes back stamped with isNew and firstSeenAt.

Shows, episodes, and the RSS feed

This actor returns two different things in one call, and knowing which is which matters for how you use the output. The show-level fields (name, publisher, episodeCount, feedUrl, and the rest) come from Apple's lookup endpoint and describe the whole podcast. episodes is a recent window, not the archive — Apple's endpoint hands back the latest run of episodes, capped well short of episodeCount on any long-running show.

If you need every episode a 500-episode show has ever published, this actor isn't the right tool for that step — feedUrl is. It's the show's real RSS feed, the same one podcast apps subscribe to, and it carries the full history. Treat this actor as the fast way to get the show record and a recent activity signal (latestReleaseDate tells you if it's still live); treat feedUrl as the door to everything beyond that.

Price

$4 per 1,000 podcasts, plus a $0.003 start fee. Misses (found:false) are never charged.

You're billed per collection ID that resolves to a podcast, however many episodes come back with it. An invalid, delisted or non-podcast ID costs nothing, no matter how many are in the list. Run 1,000 shows and, at the live FREE-tier price, that's roughly $4 if every one resolves — cheaper in practice, since delisted or invalid IDs cost nothing, and cheaper again on paid Apify tiers. Nothing is billed between runs.

How to use

1. In the Apify Console. Open the actor page and click Start — the items field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. Via the API. Call it directly with a POST request — no Console needed once you have an API token:

   curl "https://api.apify.com/v2/acts/accountable_eel~podcast-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"items":["1200361736"]}'
   

3. On a schedule. Save this actor as an Apify Task with the input you want, then add a Schedule (hourly, daily, weekly) so it runs on its own — no server of your own required.

1. Paste your collection IDs into items — the number after /id in any Apple Podcasts URL.
2. Run the actor. Each ID is looked up against Apple's endpoint, in parallel up to maxConcurrency.
3. Turn on expandRows if you want one row per episode rather than episodes nested per show.
4. Read the dataset. Misses are written as found: false rows so you can see what failed, and are never charged.

Common ways teams use this:

• Build a podcast directory with artwork, genres, publisher and episode counts from a list of IDs.
• Monitor whether a show is still active by reading latestReleaseDate rather than trusting episode count alone.
• Feed a transcription or analysis pipeline using audioUrl straight from the episode rows.
• Research a niche by running a candidate ID list and sorting on episodeCount and latestReleaseDate.
• Grab the RSS feed at scale via feedUrl when you need full history beyond the recent window.

Input

{
  "items": [
    "1200361736"
  ]
}

One numeric Apple Podcasts collection ID per line — found in a show's podcasts.apple.com URL, e.g. 1200361736 in .../the-daily/id1200361736. Accepted formats: 1200361736.

{
  "items": ["1200361736", "1435076502"],
  "expandRows": false,
  "onlyFound": false,
  "maxConcurrency": 5
}

items is your list of Apple Podcasts collection IDs — the digits after /id in a URL like podcasts.apple.com/us/podcast/the-daily/id1200361736. Turn on testRun to try the list against a small sample first. expandRows switches between one row per show and one row per episode. onlyFound drops miss rows, maxResults stops the run early, includeKeywords and excludeKeywords filter rows by content, and columns picks which fields come back — useful for keeping a table narrow when you don't need full episode descriptions.

Sample output

query	found	status	collectionId	name	publisher	genres	episodeCount	feedUrl	artworkUrl	explicitness	latestReleaseDate	storeUrl	country	episodes	episodeTitle	episodeDescription	episodeReleaseDate	episodeDurationMs	audioUrl	episodeUrl	episodeContentRating	episodeArtworkUrl	episodeGuid	newEpisodeCount	isNew	firstSeenAt	scrapedAt
1200361736	true	OK	1200361736	The Daily	The New York Times	["Daily News","Podcasts","News"]	2741	https://feeds.simplecast.com/Sl5CSM3S	https://is1-ssl.mzstatic.com/image/thumb/Podcasts221/v4/ab/64/66/ab6466a9-9a7d-e20e-7a3d-bc5be37d29ce/mza_15084852813176276273.jpg/600x600bb.jpg	notExplicit	2026-10-06T09:46:00Z	https://podcasts.apple.com/us/podcast/the-daily/id1200361736?uo=4	USA	[{"episodeTitle":"Call My A.I. Agent","episodeDescription":"Over the past few weeks, millions of people have rushed to download a new type of artificial intelligence app — agents. They are useful, ...				<episode duration (ms)>									2026-10-07T06:10:17.047Z

That table lists every available column. Episode descriptions are long, so a real row is easier to read as JSON:

{
  "query": "1200361736",
  "found": true,
  "status": "OK",
  "collectionId": 1200361736,
  "name": "The Daily",
  "publisher": "The New York Times",
  "genres": ["Daily News", "Podcasts", "News"],
  "episodeCount": 2698,
  "feedUrl": "https://feeds.simplecast.com/Sl5CSM3S",
  "explicitness": "notExplicit",
  "latestReleaseDate": "2026-08-21T09:52:00Z",
  "storeUrl": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736",
  "country": "USA",
  "episodes": [
    {
      "episodeTitle": "An Expert on Conflict Says Your Relationships Are Doomed Without It",
      "episodeReleaseDate": "2026-08-22T10:00:00Z",
      "episodeDurationMs": 2533000,
      "audioUrl": "https://dts.podtrac.com/redirect.mp3/..."
    }
  ],
  "scrapedAt": "2026-08-23T21:04:47.132Z"
}

An ID that doesn't resolve still returns a row, and is never charged:

{
  "query": "0000000000",
  "found": false,
  "status": "NOT_FOUND",
  "message": "No podcast found for this Apple Podcasts collection ID.",
  "scrapedAt": "2026-08-23T21:04:47.132Z"
}

Miss rows are written so you can see exactly which IDs failed rather than diffing your input list against the output. Set onlyFound to drop them.

Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

curl "https://api.apify.com/v2/acts/accountable_eel~podcast-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"items":["1200361736"]}'

n8n. Add an HTTP Request node: Method POST, URL https://api.apify.com/v2/acts/accountable_eel~podcast-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>, Body Content Type JSON, JSON Body {"items":["1200361736"]} (swap in an expression from an earlier node for a real value).

Clay. Add an "HTTP API" column: Method POST, URL https://api.apify.com/v2/acts/accountable_eel~podcast-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>, Body {"items":["{{podcast}}"]}, mapping the row's podcast into the items array.

MCP. In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Podcast Lookup API: Apple Podcasts Shows & Episodes" — the agent will find and run this actor.

Tips

• Use latestReleaseDate to spot dead shows. A podcast with 800 episodes and nothing published in two years is an archive, not an active show.
• Turn on expandRows before exporting episodes to a spreadsheet. Nested episodes arrays are painful to flatten downstream; the actor does it better than a formula will.
• Use columns to drop episodeDescription on big runs. Show notes are by far the widest field and usually not what you're filtering on.
• Go to feedUrl when you need full history. The lookup returns a recent-episodes window, not every episode ever — the RSS feed is the complete record.
• Match on episodeGuid, not episode title. Titles get edited; GUIDs don't.

vs. alternatives

	What it costs	What you get	Trade-off
This actor (podcast-lookup)	$4 per 1,000 resolved shows (less on paid tiers), $0.003 actor start, nothing for an ID that doesn't resolve	Show record plus recent episodes with audio URLs, one flat row per show or per episode, from Apple's own endpoint	Takes collection IDs, not show names — it won't search for you. Recent-episode window rather than full history.
logiover/apple-podcasts-episode-scraper (37 users)	$0.0025 per result, $0.003 start	Episode-focused extraction, billed per episode	Cheaper per row if episodes are what you're counting. This bills per show, which is better when shows have many episodes.
taroyamada/apple-podcast-scraper (24 users)	$0.01 per result, $0.005 start	A general Apple Podcasts scraper	Roughly two and a half times the per-row price here, for a broadly similar job.
Parsing the RSS feed yourself	Your time + one HTTP fetch and an XML parser per show	Full episode history, deeper than this returns	If you need every episode ever published, the feed is the right source — and this actor hands you its URL. This is for when you want the show record and recent episodes without building that.

(logiover's and taroyamada's prices above are their published August 2026 list prices — check their own pages before relying on a straight comparison.)

FAQ

Where do I find a collection ID? It's the number after /id in any Apple Podcasts URL — podcasts.apple.com/us/podcast/the-daily/id1200361736 gives you 1200361736.

Can I search by show name instead? No. This is an ID-keyed lookup by design, so every input maps to exactly one row. Name search returns ranked guesses, which is a different shape.

Do I need an Apple API key? No. The iTunes lookup endpoint is public and unauthenticated.

How many episodes come back per show? A recent window rather than the complete history. episodeCount tells you the true total, and feedUrl is the door to the rest if you need it.

What counts as "not found"? An ID that's invalid, delisted, or belongs to something that isn't a podcast. All return found: false with a message explaining which, and are never charged.

Does it work outside the US store? Yes. country on each row tells you which storefront the record came from.

Can an agent run this on its own? Yes. It's registered with the Apify MCP server, so a Claude or Cursor agent with that MCP connected can find "Podcast Lookup" and pull dataset rows back without any integration code.

Related actors

• Apple App Store Lookup — iOS app metadata and reviews, using the same iTunes infrastructure.
• Telegram Channel Lookup — channel profile and subscriber counts by handle.
• Substack Publication Lookup — publication profile and recent posts by subdomain.