# Podcast Search — Apple Podcasts to JSON (`oblanceolate_mandola/podcast-search`) Actor

Podcast scraper & API: search Apple Podcasts by keyword for show title, creator, genre, episode count and RSS feed as JSON. For content-discovery AI agents.

- **URL**: https://apify.com/oblanceolate\_mandola/podcast-search.md
- **Developed by:** [Hassan Hashish](https://apify.com/oblanceolate_mandola) (community)
- **Categories:** News, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Podcast Search — Apple Podcasts to JSON

Search Apple Podcasts by keyword and get show title, creator, genre, episode count, feed and URL as JSON at $0.002 per result.

Podcasts are a fast-growing content and research surface. This actor turns a keyword into the matching shows on Apple Podcasts with their genre, episode count, and RSS feed, so content, research, and marketing agents can discover and analyze podcasts as structured data.

### What this actor does

- Search Apple Podcasts by keyword, topic, show, or creator
- Each result: show title, creator, genre, episode count, RSS feed URL, Apple Podcasts URL, latest release date
- The RSS feed URL lets agents fetch full episode lists downstream
- Batch many terms per run; cap spend with maxResults
- Agent-ready: flat JSON with the show URL + scrapedAt for citation

**You only pay for successful results** — failed or empty lookups cost nothing.

### Why pick this Actor

- Returns the RSS `feedUrl` where available, so agents go straight from discovery to episode ingestion
- Per-result pricing ($0.002/result) with a hard `maxResults` spend cap — empty lookups cost $0
- Flat, stable JSON schema with `sourceUrl` + `scrapedAt` on every item — citation-ready for RAG and grounding
- Batch many queries in one run; overlapping results are deduplicated and charged once
- MCP server, OpenAPI schema, and LangChain/CrewAI tool support out of the box — no glue code

### Sample output

Each dataset item is flat, typed JSON with a `sourceUrl` and `scrapedAt` for citation/grounding:

```json
{
  "query": "technology",
  "source": "itunes",
  "title": "The Future of Everything",
  "artist": "Stanford Engineering",
  "genre": "Science",
  "episodes": 380,
  "feedUrl": "https://feeds.example.com/future.xml",
  "url": "https://podcasts.apple.com/us/podcast/id1235836821",
  "postedAt": "2026-05-29T14:00:00.000Z",
  "sourceUrl": "https://itunes.apple.com/search?term=technology&entity=podcast",
  "scrapedAt": "2026-06-12T10:00:00.000Z"
}
```

### Input

```json
{"queries":["technology"]}
```

| Field | Type | Description |
|---|---|---|
| `queries` / `query` | array / string | Keyword or topic. One or many. |
| `maxResults` | integer | Hard spend cap (billed per result). |
| `keywords` / `postedAfter` | filters | Narrow results; enable delta/scheduled runs. |

### How much does it cost

Pay-per-result: **$0.002 per successful result.** No subscription, no compute-unit guesswork, no charge for empty results. An orchestrator can cap spend with `maxResults`.

### How to use it with AI agents (MCP), Claude, and the API

#### Claude Desktop / Claude Code via Apify MCP

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "oblanceolate_mandola/podcast-search"],
      "env": { "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>" }
    }
  }
}
```

#### Python (Apify API)

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("oblanceolate_mandola/podcast-search").call(run_input={"queries":["technology"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### TypeScript (Apify API)

```ts
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('oblanceolate_mandola/podcast-search').call({"queries":["technology"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### LangChain / CrewAI tool

```python
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("oblanceolate_mandola/podcast-search")  # agent calls it autonomously
```

OpenAPI schema for self-integrating GPT agents is auto-exposed at the Actor's API tab.

### Data & compliance

Reads only publicly accessible endpoints. No login, no credential harvesting, no CAPTCHA bypass. Every result carries its `sourceUrl` so downstream agents can cite and re-verify.

### FAQ

#### Does it return episodes?

It returns shows with their RSS feed URL; fetch that feed downstream for the full episode list.

#### Is it just podcasts?

This actor searches Apple Podcasts. The same iTunes Search API also covers apps, music, and audiobooks if you need those.

#### What is the source?

The public Apple iTunes Search API — no key required.

#### Can AI agents call this Actor directly?

Yes — via the Apify MCP server (snippet above), the OpenAPI schema on the Actor's API tab, or the LangChain/CrewAI tool wrapper. Results are flat JSON with `sourceUrl` and `scrapedAt` on every item, so downstream agents can cite and re-verify.

#### What happens when there are no results?

You pay nothing. Billing is per dataset item delivered, so an empty lookup costs $0, and the run log states why (no match, source rate limit) instead of failing silently.

### Changelog

- **1.0** — Initial release: itunes.

# Actor input Schema

## `queries` (type: `array`):

Term to search across Apple Podcasts, e.g. a topic, show name, or creator. Pass several to batch them in one run. Either this or "query" is required.

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

Single-value convenience alias for "queries". Term to search across Apple Podcasts, e.g. a topic, show name, or creator.

## `maxResults` (type: `integer`):

Hard cap on results across all queries — bounds spend programmatically (you are billed per result). Note: each query returns at most one page from the source (typically 50–100 results); pass multiple queries to gather more.

## `keywords` (type: `array`):

Only return results whose title/department/team contains one of these as a whole word (case-insensitive) — "ai" matches "AI Engineer" but not "Maintenance".

## `postedAfter` (type: `string`):

Only return results posted on/after this ISO date (strictly YYYY-MM-DD, e.g. 2026-01-01; anything else fails the run). Items with no posted date are excluded. Enables incremental/delta scheduled runs.

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

Most sources are public JSON APIs needing no proxy. Configure only if a source geo-restricts.

## Actor input object example

```json
{
  "queries": [
    "technology"
  ],
  "maxResults": 50
}
```

# Actor output Schema

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

Structured result rows in the default dataset (clean JSON).

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

// Run the Actor and wait for it to finish
const run = await client.actor("oblanceolate_mandola/podcast-search").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 = { "queries": ["technology"] }

# Run the Actor and wait for it to finish
run = client.actor("oblanceolate_mandola/podcast-search").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 '{
  "queries": [
    "technology"
  ]
}' |
apify call oblanceolate_mandola/podcast-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/17WYRoEl5WqybSu49/builds/bzeXaiY7K6911rr71/openapi.json