# Podcast & Audio Transcriber: MP3, Video to Text (`enisbodlli/podcast-audio-transcriber`) Actor

Transcribe podcasts, audio and video files to text with Whisper on Apify, no API key. Give MP3 or MP4 links, RSS feeds, Apple Podcasts pages or uploads; get text, timed segments and SRT or VTT subtitles in 99 languages. Uses the publisher's transcript when a feed has one.

- **URL**: https://apify.com/enisbodlli/podcast-audio-transcriber.md
- **Developed by:** [Enis Bodlli](https://apify.com/enisbodlli) (community)
- **Categories:** AI, Videos, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 audio minutes

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 & Audio Transcriber: MP3, Video to Text

Turn **podcasts, MP3s and video files into text** with OpenAI's open **Whisper** speech model, run on
Apify: no API key, no OpenAI account, no software to install. Give it a link to an audio or video
file, a **podcast RSS feed**, an **Apple Podcasts** page or just the show's name, or upload a file,
and get the transcript with **timed segments** and **SRT or WebVTT subtitles**, in 99 languages. It
is built for podcasters, researchers and journalists, marketers who repurpose episodes, and AI agents
that need what was said in an episode as text.

- **Podcasts by name or feed.** It finds the show, picks the newest episodes or those matching a date
  or title, and on a schedule transcribes each new episode once.
- **The publisher's own transcript when there is one.** Many feeds link a transcript made by the
  show. The Actor uses it for a flat **$0.005 an episode** instead of transcribing the audio.
- **Pay per audio minute, $10 per 1,000 minutes** ($7.50 on Gold), with nothing to pay for silent
  files, failed links or the part of a file you cut off.

The easiest way to try it: keep the example input and press **Start**. You get the first two minutes
of the newest Planet Money episode as text and SRT subtitles in under a minute.

### What one transcript looks like

```json
{
    "showTitle": "Planet Money",
    "episodeTitle": "Wanna slow down AI? These biologists can help.",
    "publishedAt": "2026-10-14T21:30:18.000Z",
    "durationSeconds": 1957,
    "transcribedSeconds": 120,
    "transcriptSource": "whisper",
    "model": "base",
    "language": "en",
    "text": "… There's a very strange puzzle at the center of the AI debate right now. …",
    "segments": [
        { "start": 30.33, "end": 33.05, "text": "- There's a very strange puzzle", "speaker": null },
        { "start": 33.05, "end": 35.37, "text": "at the center of the AI debate right now.", "speaker": null }
    ],
    "wordCount": 353,
    "billedEvent": "audio-minute",
    "billedCount": 2
}
```

These are 13 of the 29 fields of a result; full results are under [Output](#output) below.

### What you can do with it

- **Make a podcast searchable.** Transcribe a show's back catalogue once, then schedule a weekly run
  with *Only episodes not transcribed before* to add each new episode.
- **Write show notes, articles and social posts** from an episode, or feed the text to an LLM for
  summaries and quotes.
- **Add subtitles to a video.** The SRT and WebVTT files load into YouTube Studio, video players and
  editors.
- **Research and monitoring.** Follow what a set of shows says about a company, product or topic.
- **Give an AI agent or a spreadsheet** what was said, in one fixed format with timestamps.

### How to use it

1. Add your audio under **Links to audio, video or podcasts** (one per line), **Podcast names** or
   **Upload files**. You can mix them in one run.
   - A direct file link: MP3, M4A, WAV, OGG, OPUS, FLAC, AAC, MP4, M4V, WEBM, MOV and other formats
     ffmpeg reads.
   - A podcast RSS feed, an Apple Podcasts show page (`podcasts.apple.com/…/id1200361736`) or episode
     page (`…?i=1000…`), or a web page that embeds an audio file or names its feed.
   - A show name such as `Planet Money`, looked up in the Apple Podcasts directory.
2. For podcasts, choose how many **Episodes per podcast** (newest first), and optionally **Published
   after** a date or period such as `30 days`, or **Episode title contains**.
3. Choose the **Speech model** (`base` by default), the **Spoken language** (auto-detect by default)
   and whether to keep the language or **translate to English**. Add **Subtitle files** if you want
   SRT or WebVTT.
4. Set **Maximum minutes per file** or **Maximum minutes per run** if you only need the start of each
   file or want to cap the cost. Leave them empty to transcribe everything.
5. Press **Start**, then export the results as JSON, CSV or Excel, or read them through the API.

To transcribe every new episode of a show automatically, save the input as a task with **Only
episodes not transcribed before** switched on, and give the task a daily or weekly schedule. Each run
looks at the newest episodes, skips those your earlier runs already transcribed and costs only the
run start when nothing is new.

#### How long it takes

Measured on Apify on 2026-10-16 with the `base` model:

| Memory | Whisper workers | Speed | A 60-minute episode |
|---|---|---|---|
| 4 GB (default) | 1 | about 1 minute of audio every 13 to 15 seconds | about 14 minutes |
| 8 GB | 2 | 32.4 minutes of audio in 4 minutes 7 seconds | about 7 minutes |
| 16 GB | 4 | four parts at once (not yet timed) | about 4 minutes |

A run spends 15 to 25 seconds starting before the first file. `small` takes about three times as
long as `base` (10 minutes of audio in 6 minutes 21 seconds at 4 GB), `tiny` less. More memory
costs the same per audio minute, only the run start grows by $0.00005 per GB, so give a long
episode or a large batch 8 or 16 GB. The default timeout of 3 hours holds about 800 minutes of
audio at 4 GB with `base`; raise the memory or the timeout for more.

### Pricing

You pay per minute of audio transcribed, or a flat price per episode when the publisher's
transcript is used, plus Apify's run start of $0.00005 per GB of memory ($0.0002 at the default
4 GB). Platform usage is included, so there is nothing else to pay.

| Apify plan tier | Audio minute, tiny or base model | Audio minute, small model | Publisher transcript |
|---|---|---|---|
| Free, Bronze | $0.01 | $0.025 | $0.005 |
| Silver | $0.0088 | $0.022 | $0.0044 |
| Gold and above | $0.0075 | $0.01875 | $0.00375 |

Minutes are counted per file and rounded up: a 30-second clip counts as one minute, a 45 min 10 s
episode as 46. Worked examples at the Free and Bronze price:

- The example input, the first 2 minutes of one episode: 2 x $0.01 = **$0.02**.
- A 60-minute episode with the base model: **$0.60**; with the small model, $1.50.
- 1,000 minutes of audio: $10.00, or $8.80 on Silver and $7.50 on Gold.
- A weekly 45-minute show on a schedule: $0.45 a week, about $1.95 a month.
- An episode whose feed links a transcript: $0.005, whatever its length.
- A silent file, a file without words, or a link that fails: nothing.

**Maximum minutes per file** and **Maximum minutes per run** cap what a run transcribes, and only the
minutes transcribed are charged. You can also set a maximum charge per run: the Actor transcribes
only as many minutes as that amount pays for, cuts the last file where the money ends, and finishes
as succeeded with a message that says the limit stopped it. A run that Apify restarts on another
server carries on where it stopped and charges no file twice.

### Input

```json
{
    "mediaUrls": [
        "https://feeds.npr.org/510289/podcast.xml",
        "https://podcasts.apple.com/us/podcast/the-daily/id1200361736",
        "https://example.com/interviews/2026-10-01.mp3"
    ],
    "podcastNames": ["Freakonomics Radio"],
    "maxEpisodesPerFeed": 5,
    "publishedAfter": "30 days",
    "onlyNewEpisodes": false,
    "usePublisherTranscripts": true,
    "model": "base",
    "language": "auto",
    "task": "transcribe",
    "subtitleFormats": ["srt", "vtt"],
    "maxMinutesPerFile": 90
}
```

| Field | What it does |
|---|---|
| `mediaUrls` | Files, feeds, Apple Podcasts pages or web pages, one per line. |
| `podcastNames` | Show names to look up in the Apple Podcasts directory. |
| `audioFiles` | Files you upload, up to 1.5 GB each. |
| `maxEpisodesPerFeed` | Episodes per feed, show or name, newest first. Default 3. |
| `publishedAfter` | Only episodes published on or after a date (`2026-01-31`) or period (`30 days`). |
| `titleContains` | Only episodes whose title contains this text. |
| `onlyNewEpisodes` | Skip episodes an earlier run in your account transcribed. For schedules. |
| `usePublisherTranscripts` | Use the feed's own transcript when it links one. Default on. |
| `model` | `tiny`, `base` (default) or `small`. |
| `language` | `auto` or one of 99 language codes. |
| `task` | `transcribe` keeps the language; `translate` gives English text. |
| `subtitleFormats` | Add `srt`, `vtt` or both to each result. |
| `maxMinutesPerFile` | Transcribe at most this many minutes from the start of each file. |
| `maxTotalMinutes` | Stop once the run has transcribed this many minutes. |

### Output

One result per file or episode, in the order of your input. A transcribed episode, a publisher
transcript and a link that failed:

```json
[
    {
        "inputUrl": "https://feeds.npr.org/510289/podcast.xml",
        "sourceType": "feed",
        "status": "transcribed",
        "showTitle": "Planet Money",
        "feedUrl": "https://feeds.npr.org/510289/podcast.xml",
        "episodeTitle": "Wanna slow down AI? These biologists can help.",
        "episodeGuid": "b297c28a-87e4-4b96-92e0-e64b7b581948",
        "publishedAt": "2026-10-14T21:30:18.000Z",
        "mediaUrl": "https://tracking.swap.fm/track/…/default.mp3",
        "durationSeconds": 1957,
        "transcribedSeconds": 120,
        "truncated": true,
        "truncatedReason": "maxMinutesPerFile",
        "transcriptSource": "whisper",
        "publisherTranscriptFormat": null,
        "model": "base",
        "language": "en",
        "languageProbability": 0.999,
        "task": "transcribe",
        "text": "… There's a very strange puzzle at the center of the AI debate right now. …",
        "segments": [
            { "start": 30.33, "end": 33.05, "text": "- There's a very strange puzzle", "speaker": null },
            { "start": 33.05, "end": 35.37, "text": "at the center of the AI debate right now.", "speaker": null }
        ],
        "srt": "…\n12\n00:00:30,330 --> 00:00:33,050\n- There's a very strange puzzle\n…",
        "vtt": null,
        "wordCount": 353,
        "billedEvent": "audio-minute",
        "billedCount": 2,
        "error": null,
        "errorKind": null,
        "transcribedAt": "2026-10-16T12:00:18.578Z"
    },
    {
        "inputUrl": "https://feeds.megaphone.fm/darknetdiaries",
        "sourceType": "feed",
        "status": "transcribed",
        "showTitle": "Darknet Diaries",
        "feedUrl": "https://feeds.megaphone.fm/darknetdiaries",
        "episodeTitle": "180: Conti",
        "episodeGuid": "prx_7057_141e0c43-f935-41de-be94-708448052c4d",
        "publishedAt": "2026-10-06T07:00:00.000Z",
        "mediaUrl": "https://www.podtrac.com/pts/redirect.mp3/dovetail.prxu.org/7057/141e0c43-f935-41de-be94-708448052c4d/darknet-diaries-ep180-conti.mp3",
        "durationSeconds": 3557,
        "transcribedSeconds": null,
        "truncated": false,
        "truncatedReason": null,
        "transcriptSource": "publisher",
        "publisherTranscriptFormat": "vtt",
        "model": null,
        "language": null,
        "languageProbability": null,
        "task": null,
        "text": "[Music] There’s a kind of silence that follows a ransomware attack. …",
        "segments": [
            { "start": 0, "end": 1.18, "text": "[Music] There’s a kind of silence", "speaker": "JACK" },
            { "start": 1.18, "end": 3.22, "text": "that follows a ransomware attack.", "speaker": null }
        ],
        "srt": "1\n00:00:00,000 --> 00:00:01,180\nJACK: [Music] There’s a kind of silence\n…",
        "vtt": null,
        "wordCount": 10188,
        "billedEvent": "publisher-transcript",
        "billedCount": 1,
        "error": null,
        "errorKind": null,
        "transcribedAt": "2026-10-16T12:01:41.314Z"
    },
    {
        "inputUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "sourceType": "file",
        "status": "failed",
        "text": "",
        "segments": [],
        "wordCount": 0,
        "billedEvent": null,
        "billedCount": 0,
        "error": "YouTube links are not supported: this Actor transcribes audio and video files and podcast feeds. Use a direct link to the file, the show's RSS feed, or upload the file.",
        "errorKind": "unsupported-platform"
    }
]
```

(The failed result is shortened here; every result carries all 29 fields.)

- `status`: `transcribed`, `no-speech` (nothing to transcribe, not charged) or `failed`.
- `transcriptSource`: `whisper` when the audio was transcribed, `publisher` when the feed's
  transcript was used.
- `segments`: phrases of a few seconds with `start` and `end` in seconds from the start of the file.
  `speaker` is filled only when a publisher transcript names the speakers.
- `truncated` and `truncatedReason`: whether a limit cut the file, and which one.
- `billedEvent` and `billedCount`: what this result cost, so you can check every charge.
- `errorKind`: `unsupported-platform`, `not-found`, `refused`, `outage`, `too-large`, `not-media`,
  `no-audio`, `undecodable`, `no-public-feed`, `episode-not-found`, `invalid-input`, `engine` or
  `error`.

### Limits

- **No YouTube, TikTok, Instagram, Spotify or other platform pages.** Those links fail with
  `unsupported-platform` and cost nothing. Use the show's RSS feed, a direct file link or an upload.
- **Only audio that opens without a login.** Private, members-only and paywalled feeds are not
  supported.
- **No speaker labels from Whisper.** Speakers appear only when the publisher's transcript names
  them.
- **No word-level timestamps, custom vocabulary, summaries or chapters.** Names and jargon can come
  out misspelt; segments are phrases, not single words.
- **Translation goes to English only**, and publisher transcripts are not used when translating.
- **Accuracy follows the audio.** Clear speech comes out well with `base`; noisy recordings, heavy
  accents, crosstalk and music do better with `small` and can still contain mistakes. Like every
  Whisper system it can, rarely, repeat a phrase or write words over music.
- **The whole file is downloaded**, even when only its first minutes are transcribed. Files up to
  1.5 GB.
- **Publisher transcripts are used as published.** Their quality, and any missing language, is the
  publisher's.

### FAQ

#### Is it legal to transcribe podcasts?

The Actor reads only public feeds, pages and files that open without a login, and it does not get
around any blocking. Copyright in an episode stays with its publisher: transcripts for research,
search, accessibility, notes or quoting are common, while republishing whole transcripts usually
needs the publisher's permission. Check the terms of the show and the laws that apply to you; this
is not legal advice.

#### Why did a link fail?

The `error` field says why in plain words and `errorKind` gives the cause. The usual ones: the link
is a platform page (`unsupported-platform`), the server answered 404 (`not-found`) or refused the
download (`refused`), the file has no audio track (`no-audio`), or a page links no audio file and no
feed (`no-public-feed`). A failed link is never charged, and the other links in the run carry on.

#### How do I transcribe only new episodes?

Switch on **Only episodes not transcribed before**, save the input as a task and schedule it. The
Actor remembers which episodes your account transcribed. It looks at the newest episodes per feed
(**Episodes per podcast**) and never works back through the archive, so set that number to at least
the episodes a show releases between two runs.

#### Which languages does it understand?

The 99 languages Whisper knows, from English, Spanish and German to Japanese, Arabic and Hindi.
Auto-detect listens to two stretches of each file; set the language when you know it, especially for
short files. `translate` turns any of them into English text.

#### Which model should I choose?

`base` suits most clear speech at $0.01 a minute. `small` is more accurate on noisy audio, accents
and less common languages, at $0.025 a minute and about three times the time. `tiny` is the fastest and
roughest, at the base price.

#### Can I use it through the API or from an AI agent?

Yes. Start it through the Apify API, the Python or JavaScript client, Make, Zapier or n8n, or call it
from an agent through the Apify MCP server. Every result has the same fields.

### More Actors from this developer

- [ATS Job Postings: Workday, Greenhouse, Lever & Ashby](https://apify.com/enisbodlli/ats-job-postings):
  every open job of the companies you choose, with only the postings that are new since the last run
  if you want.
- [Company Jobs Search](https://apify.com/enisbodlli/company-jobs-search): open jobs by title on
  1,300 company career sites in one run.
- [Website Contact Scraper](https://apify.com/enisbodlli/website-contact-scraper): emails, phones
  and social profiles from company websites.
- [Email Validator & List Cleaner](https://apify.com/enisbodlli/email-validator): syntax and domain
  checks for a mailing list.
- [Handelsregister Scraper](https://apify.com/enisbodlli/handelsregister-scraper) and
  [European Company Registry Search](https://apify.com/enisbodlli/eu-company-registry-search):
  company records from official registers.

# Changelog

This Actor's version history is a separate document: https://apify.com/enisbodlli/podcast-audio-transcriber/changelog.md

# Actor input Schema

## `mediaUrls` (type: `array`):

One link per line. Works with direct audio or video files (MP3, M4A, WAV, OGG, FLAC, MP4, WEBM, MOV and more), podcast RSS feeds, Apple Podcasts show or episode pages, and web pages that embed an audio file or name a podcast feed. YouTube, Spotify and other platform pages are not supported.

## `podcastNames` (type: `array`):

Show names to look up in the Apple Podcasts directory, one per line. The exact name wins; otherwise the best match is used. Its RSS feed is then read like a feed link.

## `audioFiles` (type: `array`):

Audio or video files from your computer, stored in an Apify key-value store, or links to files. Up to 1.5 GB each.

## `maxEpisodesPerFeed` (type: `integer`):

How many episodes to transcribe from each feed, show or podcast name, newest first, after the filters below.

## `publishedAfter` (type: `string`):

Only episodes published on or after this date, as 2026-01-31 or a period such as "30 days" back from the run.

## `titleContains` (type: `string`):

Only episodes whose title contains this text, ignoring case.

## `onlyNewEpisodes` (type: `boolean`):

Of the newest episodes per feed (see the maximum above), skip those an earlier run of this Actor in your account already transcribed. Use it with a schedule to transcribe each new episode once; older episodes are never picked up instead.

## `usePublisherTranscripts` (type: `boolean`):

Many feeds link a transcript the publisher made (the podcast:transcript tag). When on, that transcript is used at the lower publisher-transcript price instead of transcribing the audio. Turn off to always transcribe with Whisper.

## `model` (type: `string`):

Whisper model run on Apify, no API key needed. base is the default balance of speed and accuracy; tiny is fastest and roughest; small is the most accurate and is charged as audio-minute-small.

## `language` (type: `string`):

The language spoken in the audio. Auto-detect listens to two stretches of each file; set the language when you know it, for better accuracy on short or mixed files.

## `task` (type: `string`):

transcribe keeps the spoken language; translate turns any language into English text. Publisher transcripts are not used when translating.

## `subtitleFormats` (type: `array`):

Add the transcript as SRT, WebVTT or both to each result, ready for video players and editors.

## `maxMinutesPerFile` (type: `integer`):

Transcribe at most this many minutes from the start of each file; the rest is skipped and not charged. Empty means the whole file.

## `maxTotalMinutes` (type: `integer`):

Stop once this many minutes of audio were transcribed in the run. Empty means no limit besides your maximum charge.

## Actor input object example

```json
{
  "mediaUrls": [
    "https://feeds.npr.org/510289/podcast.xml",
    "https://podcasts.apple.com/us/podcast/the-daily/id1200361736"
  ],
  "podcastNames": [
    "Planet Money"
  ],
  "audioFiles": [
    "https://api.apify.com/v2/key-value-stores/STORE_ID/records/interview.mp3"
  ],
  "maxEpisodesPerFeed": 5,
  "publishedAfter": "30 days",
  "titleContains": "interview",
  "onlyNewEpisodes": true,
  "usePublisherTranscripts": true,
  "model": "base",
  "language": "en",
  "task": "transcribe",
  "subtitleFormats": [
    "srt",
    "vtt"
  ],
  "maxMinutesPerFile": 60,
  "maxTotalMinutes": 600
}
```

# Actor output Schema

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

One item per episode or file in the run's default dataset: the transcript as text, timed segments, optional SRT and VTT subtitles, the language, the show and episode, and what the item was charged.

## `runSummary` (type: `string`):

What the run did: how many episodes or files were transcribed, how many minutes of audio, which inputs failed and why, what was charged, and why the run stopped.

# 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 = {
    "mediaUrls": [
        "https://feeds.npr.org/510289/podcast.xml"
    ],
    "maxEpisodesPerFeed": 1,
    "subtitleFormats": [
        "srt"
    ],
    "maxMinutesPerFile": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("enisbodlli/podcast-audio-transcriber").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 = {
    "mediaUrls": ["https://feeds.npr.org/510289/podcast.xml"],
    "maxEpisodesPerFeed": 1,
    "subtitleFormats": ["srt"],
    "maxMinutesPerFile": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("enisbodlli/podcast-audio-transcriber").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 '{
  "mediaUrls": [
    "https://feeds.npr.org/510289/podcast.xml"
  ],
  "maxEpisodesPerFeed": 1,
  "subtitleFormats": [
    "srt"
  ],
  "maxMinutesPerFile": 2
}' |
apify call enisbodlli/podcast-audio-transcriber --silent --output-dataset

```

## MCP server setup

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

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/LWHQtz3jDuhjUBKGG/builds/gkniLQmHElteZMz0c/openapi.json
