# Apple Podcasts Show Lookup & RSS URL Resolver (`technicaldost/apple-podcasts-show-lookup`) Actor

Resolve Apple Podcasts show IDs or URLs to catalog metadata and RSS feed URLs. Bounded official API lookups, deduplication and explicit statuses. No search, audio or feed scraping.

- **URL**: https://apify.com/technicaldost/apple-podcasts-show-lookup.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 successful 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

## Apple Podcasts Show Lookup & RSS URL Resolver

Turn Apple Podcasts show IDs or show URLs into clean catalog records with their RSS feed URLs. This Actor uses Apple's documented, public iTunes **root lookup API**, not a browser scraper. No Apple login, API key or proxy is required.

Useful for resolving known podcast lists, checking which supplied shows are listed in a storefront, joining podcast IDs to public publisher and category metadata, and obtaining feed URLs for a separate, authorized feed-processing workflow.

### Pricing

$1 per 1,000 found shows. $0.00005 per run. Standard-run platform usage is included. Only successful eligible rows in the default dataset trigger the result charge. Error, not-found, skipped and robots-denied diagnostics do not trigger a result charge. The run fee, where listed, still applies to empty or failed runs. Memory is limited to 256–512 MB. Set a maximum run cost in Apify; inspect the actual dataset and run charge breakdown after an interruption. Input item limits bound work and do not replace the run spending limit.

### What this does

- Accepts 1–100 show IDs or HTTPS Apple Podcasts show URLs per run.
- Deduplicates IDs, including an ID supplied both directly and in a URL.
- Returns show title, publisher, Apple Podcasts URL, catalog-provided RSS URL, genres, episode count, explicitness, catalog date and storefront.
- Returns successful `found` records in the default dataset. Preserves `not_found`, `error` and `skipped` records separately in `LOOKUP_DIAGNOSTICS` so they do not trigger a per-result dataset charge.
- Checks the current iTunes robots policy before lookup, batches at most 20 IDs and spaces sequential requests by 4 seconds by default.

### What this does not do

**This is not keyword discovery or a podcast review scraper.** You must already know the show IDs or URLs. It does not call the search endpoint, scrape Apple Podcasts pages, inspect publisher websites, fetch or validate RSS feeds, collect episodes, download artwork or audio, retrieve transcripts, or find private contact details. It does not maintain cross-run state or emit a change feed.

`feedUrl` is the URL reported by Apple's catalog. It is not proof that the feed is accessible or valid. `episodeCount` and `catalogReleaseDate` are Apple's catalog fields; the date is not a verified latest-episode publication timestamp. Catalog data may be stale, incomplete or different across storefronts. A not-found result can mean a wrong ID, a non-podcast ID, a removed show or regional unavailability.

### Example input

```json
{
  "shows": [
    "1200361736",
    "https://podcasts.apple.com/us/podcast/planet-money/id290783428"
  ],
  "country": "US",
  "requestIntervalMillis": 4000
}
```

The show component of an episode link is accepted, but the result is the **parent show**, not the episode. Only exact `podcasts.apple.com` and `itunes.apple.com` HTTPS show URLs are accepted. Numeric IDs must be strings. Other hosts, credentials, alternate ports and search URLs are rejected before network activity.

#### Inputs

| Field | Default | Limits |
|---|---|---|
| `shows` | Required | 1–100 numeric strings or Apple Podcasts show URLs |
| `country` | `US` | Two-letter storefront code, such as `US`, `GB` or `IN` |
| `requestIntervalMillis` | `4000` | Integer 3500–30000 |

Defaults apply only when an optional field is omitted. Explicit `null` values are rejected, matching the input schema.

### Output

The default dataset contains only successful `found` podcast matches, with at most one row per unique requested ID. `LOOKUP_DIAGNOSTICS` is a separate key-value record with a `records` array containing all `not_found`, `error` and `skipped` outcomes. The Output tab links to both. For a normally completed run without a storage or spending-limit interruption, submitted successful rows plus diagnostic records account for every unique requested ID. The `successfulRowsSubmitted` counter counts rows handed to resolved SDK push calls, not independently verified saved rows or billed events. Apify’s synthetic-event JavaScript push returns no saved/charged count; inspect the real dataset and run charge breakdown when a budget cap or storage failure occurs. An input or robots-policy failure can stop before any lookup; its reason appears in `SUMMARY`.

```json
{
  "recordType": "podcast",
  "status": "found",
  "showId": "1200361736",
  "title": "The Daily",
  "publisher": "The New York Times",
  "showUrl": "https://podcasts.apple.com/us/podcast/the-daily/id1200361736?uo=4",
  "feedUrl": "https://feeds.simplecast.com/Sl5CSM3S",
  "primaryGenre": "Daily News",
  "genres": ["Daily News", "Podcasts", "News"],
  "requestedCountry": "US",
  "feedFetched": false,
  "errorCode": null,
  "errorMessage": null
}
```

The example is shortened. Actual rows also contain `episodeCount`, `catalogReleaseDate`, `explicitness`, `catalogCountry`, `sourceUrl` and `collectedAt`. Values absent from the API stay null; they are not guessed. Data strings are plain text, not HTML-safe markup.

The `SUMMARY` key-value store record includes found/not-found/error/skipped counts, number of HTTP requests, stop reasons and limits. A robots failure stops the run before lookup. A lookup HTTP error, invalid response or timeout stops further requests and marks later batches skipped; the run is failed with successful dataset rows and nonbillable diagnostic records retained. There are no retries, proxy rotations, login attempts or CAPTCHA handling. A not-found-only run can succeed because lookup completed accurately.

### Rate limits and costs

Apple documents an approximate limit of 20 calls per minute, subject to change. This Actor uses a default interval of 4 seconds and never sends parallel requests. Do not launch overlapping runs that collectively exceed the upstream allowance; each run has its own limiter. There are at most six requests for 100 distinct IDs: one robots request and five lookup requests. Each request has a 30-second timeout and a response-size limit. This code does not invoke paid Actors or external paid APIs.

#### Billing separation

If the Actor is configured with Apify’s synthetic `apify-default-dataset-item` event, only successful default-dataset records incur that event charge. Not-found, error and skipped outcomes are saved to key-value storage, which that event does not charge. A separately configured `apify-actor-start` fee can still apply to a failed or empty run; standard-run platform usage is included in the listed event prices. Do not add a second result-charge event on top of the synthetic dataset event.

The source uses a 256–512 MB memory range. See [Apify synthetic event documentation](https://docs.apify.com/actors/monetize/pay-per-event#use-apify-default-dataset-item).

### Access and use

The documented root route is `https://itunes.apple.com/lookup?id=...&entity=podcast&country=US`. As checked on November 4, 2026, iTunes robots rules disallow keyword search and country-prefixed lookup paths but not this documented root lookup route. The Actor checks the current policy each run and stops if the selected route becomes disallowed. It does not substitute another endpoint when a request is denied.

Use the catalog records to support legitimate podcast discovery and linking. Keep Apple Podcasts links with displayed metadata, respect the source's terms and publisher rights, and do not imply Apple endorsement. Artwork, promotional previews and audio are deliberately omitted; their use has additional restrictions. Obtaining a feed URL does not grant permission to download, republish or commercially reuse the feed's content. This Actor is independent and not affiliated with Apple.

Sources: [Apple's current Search API and lookup documentation](https://performance-partners.apple.com/search-api), [iTunes robots policy](https://itunes.apple.com/robots.txt).

# Actor input Schema

## `shows` (type: `array`):

1–100 numeric ID strings or HTTPS Apple Podcasts show URLs. Duplicate IDs are resolved once. Episode links that include a show ID resolve the parent show, not the episode.

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

Two-letter Apple storefront country code, for example US, GB or IN. Availability varies by country.

## `requestIntervalMillis` (type: `integer`):

Minimum spacing between sequential API requests. Default 4 seconds stays below Apple's documented approximate 20 calls/minute limit for this run. Separate concurrent runs share no limiter.

## Actor input object example

```json
{
  "shows": [
    "1200361736"
  ],
  "country": "US",
  "requestIntervalMillis": 4000
}
```

# Actor output Schema

## `shows` (type: `string`):

Only found podcast records. Not-found, error and skipped records are stored separately and do not incur a dataset-result event charge.

## `diagnostics` (type: `string`):

Not-found, error and skipped outcomes excluded from the default dataset and its synthetic per-item event. A configured start fee, storage or other platform costs may still apply.

## `summary` (type: `string`):

Counts, errors, stop reasons and collection limits.

# 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 = {
    "shows": [
        "1200361736"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/apple-podcasts-show-lookup").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 = { "shows": ["1200361736"] }

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/apple-podcasts-show-lookup").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 '{
  "shows": [
    "1200361736"
  ]
}' |
apify call technicaldost/apple-podcasts-show-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,technicaldost/apple-podcasts-show-lookup"
        }
    }
}
```

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/MF4GvRVITtR3FxVPF/builds/1m1ZhAkTuAKmmkkdm/openapi.json