# Podcast Audiogram Generator - Waveform Video MP4 (`maksym_kotenko/podcast-audiogram-generator`) Actor

Turn a podcast episode or any audio link into social video clips: animated waveform, cover art, title, progress bar and captions from your SRT. Square, vertical and horizontal MP4 from an MP3 link or the RSS feed. Flat price per clip.

- **URL**: https://apify.com/maksym_kotenko/podcast-audiogram-generator.md
- **Developed by:** [Maksym Kotenko](https://apify.com/maksym_kotenko) (community)
- **Categories:** Videos, Social media
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 video clips

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/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

## Podcast Audiogram Generator - Waveform Video MP4

Turn a podcast episode, a voice note or any audio file into **audiogram videos for social media**: an animated waveform that moves with the voice, your cover art, the episode title, a progress bar and burned-in captions from your own subtitles. You get a ready-to-post **MP4** in square, vertical or horizontal format, plus a JPG thumbnail, for every clip.

Give it a direct audio link (MP3, M4A, WAV and more) or just the **podcast RSS feed** - the Actor finds the latest episode, downloads the audio, and takes the title, show name and artwork from the feed. Cut one clip or twenty clips from the same episode in one run. There is no editor to click through, no watermark and no monthly subscription: you pay a flat price per finished video.

- **Input:** audio URL or podcast RSS feed, start time and length of each clip, formats, colors, optional SRT or WebVTT captions.
- **Output:** MP4 videos (H.264 + AAC, fast start) and JPG thumbnails in the run's key-value store, one dataset row per video with direct download links.
- **Works with:** the Apify API, n8n, Make, Zapier, webhooks, scheduled runs and AI agents.

### What is an audiogram?

An audiogram is a short video made from audio: a static picture (usually the podcast cover and the episode title) with an animated sound wave, often with captions. Social networks do not let you post plain audio, and posts with video get far more reach than links. Podcasters use audiograms to promote every new episode on Instagram, TikTok, YouTube Shorts, LinkedIn, X and Facebook - typically 30 to 60 seconds of the best moment, with a link to the full episode.

Tools like Headliner, Wavve, Descript or Canva make audiograms by hand, one at a time, in a web editor. This Actor makes them **by API**, so a new episode can turn into ready clips automatically.

### What this Actor does

- **Animated waveform** in three styles: blocky equalizer bars, a filled wave, or a thin oscilloscope line. The animation is computed from the real audio, frame by frame.
- **Cover art** as a rounded square with a soft shadow, from your image link or straight from the RSS feed.
- **Title and subtitle** that wrap and shrink to fit, with emoji removed so nothing renders as an empty box.
- **Progress bar** that fills as the clip plays, in your accent color.
- **Burned-in captions** from your SRT or WebVTT file. Use the transcript your podcast host already generates; the Actor shows only the lines that fall inside each clip and re-times them.
- **Three formats** per clip: square 1080x1080, vertical 1080x1920, horizontal 1920x1080.
- **Solid or blurred background**: a color of your choice, or the cover art blurred across the whole frame.
- **Audio fade in and out** so the clip does not cut in mid-word.
- **Many clips per run**: up to 20 clips from one episode, each in every format you choose.
- **RSS episode picking**: the latest episode, the one before it, or the episode whose title contains a word.
- **Thumbnail** JPG for every video, for the post preview or a CMS.
- **Free demo**: leave the audio empty and you get a demo clip from built-in sample audio, free of charge, to see the look before you spend anything.

The Actor does not use AI models and does not send your audio to any third party. Rendering is done with FFmpeg inside the run.

### Who it is for

- **Podcasters** who want a clip for every episode without opening an editor.
- **Agencies and producers** who publish many shows and need consistent, branded clips at volume.
- **Automation builders** using n8n, Make or Zapier: new episode in the RSS feed, clip rendered, video posted or sent for review.
- **Developers and AI agents** that need an audio-to-video step through a simple API call.
- **Radio, newsletters, courses and webinars**: any spoken audio becomes a shareable video.

### How to use it

#### Quick start from an audio link

1. Paste a direct link to your audio file into **Audio file URL**. It must be the file itself (ending in .mp3, .m4a, .wav or similar), not a web page with a player.
2. Set **Clip start** (for example `12:30`) and **Clip length** (for example 45 seconds).
3. Type a **Title** and, if you like, a **Subtitle** with the show name.
4. Add a **Cover image URL** (JPG, PNG or WebP).
5. Choose the **Video formats** you need and click **Start**.
6. Open the **Output** tab: each row has an MP4 link and a preview image. The files are also in the run's key-value store.

#### From a podcast RSS feed

1. Paste the feed into **Podcast RSS feed URL**. Most hosts show it under "RSS feed" or "Distribution" (Buzzsprout, Libsyn, Transistor, Captivate, Podbean, Spotify for Podcasters, Acast and others).
2. Keep **Episode from the feed** at `1` for the newest episode, or set `2`, `3` and so on. To pick by name, type a word from the episode title into **Episode title contains**.
3. Leave **Title**, **Subtitle** and **Cover image URL** empty to use the episode title, the show name and the episode or show artwork from the feed. Fill them to override.
4. Set the clip start and length, pick formats, start the run.

#### Several clips in one run

Use the **Clip list** field. Each item is one clip; every clip is rendered in each selected format:

```json
[
  { "start": "2:15", "duration": 40, "title": "Why most launches fail" },
  { "start": "18:02", "end": "18:50" },
  "41:10-41:55"
]
```

`start` and `end` accept seconds (`135`), `mm:ss` (`2:15`) or `hh:mm:ss` (`1:02:15`). A clip may also be a range string like `"41:10-41:55"`. Give `duration` in seconds or `end` as a time. A per-clip `title` or `subtitle` overrides the run-wide text for that clip only.

#### Captions from your transcript

Paste SRT or WebVTT text into **Captions**, or give a link to the file in **Captions file URL**. With **Caption times are relative to** set to *The whole episode* (the default), the times in your file count from the start of the episode, as in a full transcript; the Actor shows only the lines inside each clip, shifted to the clip's own time. If your subtitle file was made for the clip itself, choose *The clip*.

The Actor does **not** transcribe audio. If you have no transcript, export one from your podcast host, from YouTube, or from a speech-to-text tool, as SRT or VTT.

### Input reference

| Field | What it does | Default |
|---|---|---|
| `audioUrl` | Direct link to the audio file, up to 500 MB | empty - demo clip |
| `rssUrl` | Podcast RSS feed; used when `audioUrl` is empty | - |
| `episode` | Episode from the feed: 1 = latest | 1 |
| `episodeTitle` | Pick the feed episode whose title contains this text, or whose GUID equals it | - |
| `startTime` | Clip start when `clips` is empty | 0:00 |
| `durationSeconds` | Clip length, 3 to 180 seconds | 30 |
| `clips` | List of clips, up to 20 | - |
| `formats` | `square`, `vertical`, `horizontal` | square |
| `title`, `subtitle` | Text on the video | from the feed |
| `coverImageUrl` | Cover art, JPG, PNG or WebP up to 15 MB | from the feed |
| `useFeedCover` | Use feed artwork when no cover link is given | true |
| `waveStyle` | `bars`, `wave` or `line` | bars |
| `background` | `color` or `blurred-cover` | color |
| `backgroundColor`, `waveColor`, `textColor`, `accentColor` | Hex colors like `#38BDF8` | dark navy, sky blue, white, pink |
| `showProgressBar` | Progress bar at the bottom | true |
| `fadeInOut` | Short audio fade at both ends | true |
| `quality` | `standard` (25 fps) or `high` (30 fps, finer detail) | standard |
| `captionsText` | SRT or WebVTT text | - |
| `captionsUrl` | Link to an SRT or WebVTT file | - |
| `captionsTimeline` | `episode` or `clip` | episode |

### Formats

| Format | Size | Best for |
|---|---|---|
| Square | 1080 x 1080 | Instagram feed, LinkedIn, X, Facebook |
| Vertical | 1080 x 1920 | Instagram Reels and Stories, TikTok, YouTube Shorts |
| Horizontal | 1920 x 1080 | YouTube, websites, presentations |

In the square and horizontal formats the cover sits on the left with the title beside it; in the vertical format the cover is large and centered at the top with the title below. The waveform fills the middle and the captions sit above the progress bar.

### Waveform styles

- **Bars** - blocky equalizer bars, mirrored around the center line. Clean, readable at small sizes and gives the smallest files. The default.
- **Wave** - a filled waveform that looks like an audio editor. Very lively, but its detail makes files several times larger; choose *High* quality if file size matters.
- **Line** - a thin oscilloscope line drawn from the audio samples. Minimal and elegant on dark backgrounds.

### Output

Every rendered video is one row in the dataset:

```json
{
  "type": "clip",
  "clip": 1,
  "format": "vertical",
  "width": 1080,
  "height": 1920,
  "videoUrl": "https://api.apify.com/v2/key-value-stores/<store>/records/clip-1-vertical.mp4",
  "thumbnailUrl": "https://api.apify.com/v2/key-value-stores/<store>/records/clip-1-vertical.jpg",
  "startTime": "12:30",
  "endTime": "13:15",
  "startSeconds": 750,
  "durationSeconds": 45,
  "trimmedToAudioEnd": false,
  "title": "Episode 42: Shipping your first product",
  "subtitle": "The Indie Builders Podcast",
  "waveStyle": "bars",
  "captionLines": 9,
  "bytes": 3456789,
  "source": {
    "type": "rss",
    "host": "feeds.example.com",
    "feedTitle": "The Indie Builders Podcast",
    "episodeTitle": "Episode 42: Shipping your first product",
    "episodePublishedAt": "2026-10-19T08:00:00.000Z",
    "audioSeconds": 3725.1,
    "audioCodec": "mp3"
  },
  "demo": false,
  "warnings": [],
  "videoKey": "clip-1-vertical.mp4",
  "thumbnailKey": "clip-1-vertical.jpg",
  "renderSeconds": 31.4,
  "createdAt": "2026-10-27T09:15:02.000Z"
}
```

The MP4 and JPG files are stored in the run's default key-value store under `clip-<number>-<format>.mp4` and `.jpg`. Open them from the run's **Storage** tab, or fetch the links with your API token if your storage access is restricted. Apify keeps run storages for the retention period of your plan; copy the files elsewhere if you need them longer.

When something cannot be rendered, the dataset gets a free error row instead, for example:

```json
{ "type": "error", "clip": 2, "format": "square", "error": "CLIP_OUT_OF_RANGE", "errorMessage": "Clip starts at 1:05:00, the audio is 58:12 long" }
```

### Pricing

Pay per event: one **clip** event for every finished MP4. One clip in three formats counts as three videos. The price is flat per video for any length up to 3 minutes, and it is lower on higher Apify plans - see the **Pricing** tab for the current numbers.

You are **not** charged for:

- the free demo clip (no audio given),
- clips that fail or fall outside the audio,
- clips skipped because the run's spending limit was reached,
- error rows of any kind.

Set **Maximum cost per run** in the run options to cap your spend: the Actor checks the limit before each render and stops cleanly, listing the clips it skipped.

### Automate it with n8n, Make, Zapier and the API

The Actor is built to be called by automations. A typical flow:

1. **Trigger**: a new item in your podcast RSS feed (RSS trigger in n8n, Make or Zapier), or a schedule.
2. **Run the Actor** with the feed URL and the clip times (or a fixed start like the first 45 seconds after the intro).
3. **Use the output**: take `videoUrl` from the dataset and post it to social media, upload it to Google Drive or Dropbox, or send it to Slack for approval.

Calling it from the API (replace `<YOUR_APIFY_TOKEN>`):

```bash
curl -X POST "https://api.apify.com/v2/acts/maksym_kotenko~podcast-audiogram-generator/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "rssUrl": "https://feeds.example.com/your-show.xml",
    "startTime": "1:30",
    "durationSeconds": 45,
    "formats": ["vertical", "square"]
  }'
```

`run-sync-get-dataset-items` waits for the run and returns the dataset rows, each with a `videoUrl`. For many or long clips use the asynchronous `runs` endpoint with a webhook, because synchronous calls time out after 5 minutes.

In n8n, Make and Zapier use the Apify integration to run the Actor, or a plain HTTP request with the call above. Map `videoUrl` from the dataset to the next step.

### Input examples

Latest episode from a feed, vertical and square, first 45 seconds after a 1:30 intro:

```json
{
  "rssUrl": "https://feeds.example.com/your-show.xml",
  "startTime": "1:30",
  "durationSeconds": 45,
  "formats": ["vertical", "square"]
}
```

Three highlights from one MP3 with your brand colors and captions:

```json
{
  "audioUrl": "https://cdn.example.com/episodes/episode-42.mp3",
  "clips": ["4:12-4:58", "17:40-18:25", "39:05-39:50"],
  "formats": ["vertical"],
  "title": "Episode 42: Shipping your first product",
  "subtitle": "The Indie Builders Podcast",
  "coverImageUrl": "https://cdn.example.com/art/show-cover.jpg",
  "waveStyle": "bars",
  "backgroundColor": "#111827",
  "waveColor": "#FBBF24",
  "accentColor": "#F87171",
  "captionsUrl": "https://cdn.example.com/episodes/episode-42.srt"
}
```

Blurred cover background with a filled wave, horizontal for YouTube:

```json
{
  "rssUrl": "https://feeds.example.com/your-show.xml",
  "episodeTitle": "interview",
  "startTime": "22:00",
  "durationSeconds": 60,
  "formats": ["horizontal"],
  "waveStyle": "wave",
  "background": "blurred-cover",
  "quality": "high"
}
```

### Tips for good clips

- **Length**: 30 to 60 seconds works best on Instagram, TikTok, Shorts and LinkedIn. Keep the strongest sentence in the first 3 seconds.
- **Captions**: much social video is watched with the sound off, so add your transcript whenever you have one.
- **Titles**: short titles read better on phones. The Actor shrinks long titles to fit, up to four lines.
- **Contrast**: keep the wave color bright against the background, and the text color light on dark backgrounds or dark on light ones.
- **Cover art**: a square image of at least 600 x 600 pixels looks sharp in every format.

### Limits

- Audio files up to 500 MB; any format FFmpeg reads: MP3, M4A/AAC, WAV, OGG, OPUS, FLAC and most others.
- Clips from 3 to 180 seconds; longer requests are shortened to 180 seconds with a warning.
- Up to 20 clips per run, each in up to three formats.
- A clip that runs past the end of the audio is cut at the end (`trimmedToAudioEnd: true`); a clip that starts after the end is an error row.
- Text uses the DejaVu Sans font: Latin, Cyrillic and Greek scripts render; Chinese, Japanese, Korean and emoji are not supported yet.
- Rendering speed with the default 2 GB memory: about 30 to 40 seconds for a 60-second clip. More memory gives more CPU and faster runs at about the same compute cost. Large batches may need a longer run timeout.

### FAQ

**Do I need an account anywhere else?** No. You only need the audio to be reachable by a public link or a public RSS feed.

**Does the Actor transcribe my audio?** No. It burns in captions you provide as SRT or WebVTT. Most podcast hosts can export a transcript in one of these formats.

**Is there a watermark?** No.

**Can I use a private or premium feed?** Yes, if the feed URL with its token works from the internet. The token stays in your input; the Actor logs only the host name.

**Why is my audio link rejected?** The link must lead straight to the file. Links to pages on Google Drive, Dropbox or a podcast website are web pages, not files. Use the direct download link or the RSS feed instead. Links to private or local network addresses are refused for security.

**Can I choose fonts or add a logo?** Not yet. Tell us in the Issues tab what you need.

**How long are the files kept?** As long as Apify keeps your run's storage. Download or copy them if you need them longer.

**Can I run it on a schedule?** Yes. Create a task with your feed, set **Episode from the feed** to 1, and schedule it after your usual release time.

### Troubleshooting

| Error | What it means | What to do |
|---|---|---|
| `INVALID_INPUT` | A field has a value the Actor cannot use | Read the message; it names the field |
| `AUDIO_DOWNLOAD_FAILED` | The audio host answered with an error or did not answer | Check that the link opens the file in a browser |
| `FILE_TOO_LARGE` | The audio is over 500 MB | Use a compressed MP3 or M4A version |
| `URL_NOT_ALLOWED` | The link points to a private or local address | Use a public link |
| `FEED_INVALID` | The feed link returned a web page, not RSS | Use the RSS URL from your podcast host |
| `EPISODE_NOT_FOUND` | No episode matches the number or title | Check `episode` or `episodeTitle` |
| `AUDIO_UNREADABLE` | The file is not audio FFmpeg can read | Check the file format |
| `CLIP_OUT_OF_RANGE` | The clip starts after the audio ends | Check the start time |
| `LIMIT_REACHED` | The run's spending limit stopped further clips | Raise the maximum cost per run |
| `RENDER_FAILED` | The video could not be rendered | Run again; if it repeats, report it in Issues with the run link |

Warnings in the `warnings` field (cover or captions skipped) do not stop the clip; the video is rendered without that element.

### Your rights to the audio

You are responsible for having the right to use the audio, artwork and captions you give the Actor - for example your own podcast, or content you have permission to share. The Actor only converts the files you point it to; it does not search for or collect other people's podcasts.

### Support

Found a bug or need a feature (custom fonts, logos, more styles, other sizes)? Open an issue in the **Issues** tab with a link to the run. Feedback shapes the next versions.

# Actor input Schema

## `audioUrl` (type: `string`):

Direct link to an MP3, M4A, AAC, WAV, OGG, OPUS or FLAC file, up to 500 MB. Leave this and the RSS feed empty to render a free demo clip.

## `rssUrl` (type: `string`):

The podcast's RSS feed. The Actor picks the episode below, downloads its audio and uses its title, show name and cover art.

## `episode` (type: `integer`):

1 = latest episode, 2 = the one before it, and so on.

## `episodeTitle` (type: `string`):

Pick the episode whose title contains this text (or whose GUID equals it) instead of using the number above.

## `startTime` (type: `string`):

Where the clip starts in the audio: seconds (95), mm:ss (1:35) or hh:mm:ss (1:01:35). Used when the clip list below is empty.

## `durationSeconds` (type: `integer`):

Length of each clip, 3 to 180 seconds. 30-60 seconds suits Instagram, TikTok, Shorts and LinkedIn.

## `clips` (type: `array`):

Several clips from the same audio, up to 20. Each item is {"start": "12:30", "duration": 45, "title": "optional own title"} or {"start": "12:30", "end": "13:15"} or a range string "12:30-13:15".

## `formats` (type: `array`):

Every clip is rendered in each selected format and each video is one charged clip. Square 1080x1080, vertical 1080x1920 (Reels, TikTok, Shorts), horizontal 1920x1080 (YouTube).

## `title` (type: `string`):

Big text on the video, for example the episode name. Defaults to the episode title from the RSS feed.

## `subtitle` (type: `string`):

Smaller text under the title, for example the show name or guest. Defaults to the show name from the RSS feed.

## `coverImageUrl` (type: `string`):

JPG, PNG or WebP, up to 15 MB, shown as a rounded square. Defaults to the episode or show artwork from the RSS feed.

## `useFeedCover` (type: `boolean`):

When no cover image URL is given, use the episode artwork or the show artwork from the RSS feed.

## `waveStyle` (type: `string`):

Bars - blocky equalizer-style waveform; Wave - filled waveform; Line - thin oscilloscope line.

## `background` (type: `string`):

A solid color, or the cover art blurred across the whole frame.

## `backgroundColor` (type: `string`):

Hex color, for example #0F172A.

## `waveColor` (type: `string`):

Hex color, for example #38BDF8.

## `textColor` (type: `string`):

Hex color of the title, subtitle and captions.

## `accentColor` (type: `string`):

Hex color of the progress bar.

## `showProgressBar` (type: `boolean`):

A thin bar at the bottom that fills up as the clip plays.

## `fadeInOut` (type: `boolean`):

Short fade at the start and the end so the clip does not cut in mid-word.

## `quality` (type: `string`):

Standard (25 fps) is right for social networks. High (30 fps) has finer detail and smaller files but renders about twice as long.

## `captionsText` (type: `string`):

Paste subtitles in SRT or WebVTT to burn them into the video. Only the lines inside each clip are shown. The Actor does not transcribe audio.

## `captionsUrl` (type: `string`):

Link to an SRT or WebVTT file, used when the captions box above is empty.

## `captionsTimeline` (type: `string`):

Episode - times count from the start of the whole episode (a full transcript). Clip - times count from the start of the clip.

## Actor input object example

```json
{
  "episode": 1,
  "durationSeconds": 15,
  "formats": [
    "square"
  ],
  "title": "Episode 42: Shipping your first product",
  "subtitle": "The Indie Builders Podcast",
  "useFeedCover": true,
  "waveStyle": "bars",
  "background": "color",
  "backgroundColor": "#0F172A",
  "waveColor": "#38BDF8",
  "textColor": "#F8FAFC",
  "accentColor": "#F472B6",
  "showProgressBar": true,
  "fadeInOut": true,
  "quality": "standard",
  "captionsTimeline": "episode"
}
```

# Actor output Schema

## `clips` (type: `string`):

One row per video: clip number, format, MP4 link, thumbnail link, start and end time, title and length.

## `files` (type: `string`):

The MP4 videos and JPG thumbnails, named clip-<number>-<format>.

# 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 = {
    "durationSeconds": 15,
    "title": "Episode 42: Shipping your first product",
    "subtitle": "The Indie Builders Podcast"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maksym_kotenko/podcast-audiogram-generator").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 = {
    "durationSeconds": 15,
    "title": "Episode 42: Shipping your first product",
    "subtitle": "The Indie Builders Podcast",
}

# Run the Actor and wait for it to finish
run = client.actor("maksym_kotenko/podcast-audiogram-generator").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 '{
  "durationSeconds": 15,
  "title": "Episode 42: Shipping your first product",
  "subtitle": "The Indie Builders Podcast"
}' |
apify call maksym_kotenko/podcast-audiogram-generator --silent --output-dataset

```

## MCP server setup

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

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/ZEnUWqtgympFjuiNK/builds/dgyv5UM2YmnCCL72n/openapi.json