# Podcast Transcriber & Analyzer (`hgservices/podcast-transcriber`) Actor

Download, Transcribe and analyze any podcast from an RSS feed, Apple Podcasts link, show name, or episode URL.

- **URL**: https://apify.com/hgservices/podcast-transcriber.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** AI, MCP servers, Agents
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 speech to text transcriptions

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Downloader, Transcriber & Analyzer** turns any podcast into **searchable text and structured insights**. Paste an **RSS feed**, an **Apple Podcasts link**, a **show name**, or a **direct episode link** — and get back an **accurate, speaker-labeled transcript with inline timestamps** for every episode, plus optional **AI summaries, chapters, topics, named people and brands, guest names, sentiment, ad reads, and keyword mentions** — and downloadable **SRT/VTT subtitle files**.

Transcribe a single episode in seconds, or point it at a whole show to process the **entire back catalog**. Because it runs on the [Apify platform](https://apify.com), you also get a full [API](https://docs.apify.com/api/v2), [scheduling](https://docs.apify.com/platform/schedules), and one-click [integrations](https://apify.com/integrations) with Make, Zapier, Google Sheets, Slack, and more.

### What can you do with Podcast Transcriber & Analyzer?

- **Media & brand monitoring** — track every mention of your brand, product, competitors, or executives across the podcasts that matter to you.
- **Content repurposing** — generate show notes, blog posts, newsletters, and social clips from a transcript.
- **Video & social captions** — export **SRT/VTT subtitle files** to caption a YouTube or social-video cut of an episode, with timecodes ready to drop into any editor.
- **Research & due diligence** — read instead of listen, and search across hours of audio in seconds.
- **SEO & discoverability** — publish episode transcripts to rank for what your guests actually said.
- **Accessibility** — provide transcripts for listeners who are deaf or hard of hearing.

### How to use Podcast Transcriber & Analyzer

1. Click **Try for free**.
2. On the **Input** tab, provide **one** source: an RSS feed URL, an Apple Podcasts link, a show name, or a direct episode URL.
3. Choose **which episodes** to process — the **latest** (default), **all**, or a filter (by date range, position, title, or GUID).
4. **Analysis runs by default** (summaries, chapters, topics, entities, guests, sentiment, and ad reads). Optionally turn on **Subtitle export** (SRT/VTT) or **Store audio file**, or add **Mention keywords** to track brands.
5. Click **Start**. Timestamped transcripts and insights appear on the **Output** tab; any subtitle/audio files land in the **Storage** (key-value store) tab.

### Input

You only need **one** of these to get started:

| Input | Example |
| --- | --- |
| **RSS feed URL** | `https://feeds.buzzsprout.com/1195244.rss` |
| **Apple Podcasts link** | `https://podcasts.apple.com/us/podcast/.../id1434243584` |
| **Show name** | `Lex Fridman Podcast` |
| **Direct episode URL** | `https://.../episode.mp3` or an episode web page |

Then fine-tune with options like **which episodes** (latest / all / by date / by title), **speaker labels**, **timestamps**, **subtitle export (SRT/VTT)**, **store the audio file**, and **which analyses** to run. See the **Input** tab for the full list with descriptions and defaults.

### Output

You get **one record per episode**, with show and episode metadata, the transcript, and (optionally) analysis:

```json
{
  "showTitle": "The Interview",
  "episodeTitle": "Danny McBride Thinks Men Learned All the Wrong Lessons From Movies",
  "publishedAt": "2026-06-20T09:00:00+00:00",
  "durationSeconds": 2255,
  "transcript": "[Speaker 1 00:00:25] From The New York Times, this is the interview. I'm David Marchese...",
  "transcriptLength": 44755,
  "detectedLanguage": "en",
  "speakerCount": 5,
  "analysis": {
    "summary": "Danny McBride discusses his short-story collection and how it satirizes modern masculinity...",
    "chapters": [{ "title": "The Crisis of Modern Masculinity", "summary": "How 1980s media sold a macho ideal..." }],
    "topics": ["masculinity", "satire", "parenting", "storytelling"],
    "entities": [{ "name": "Danny McBride", "type": "person" }],
    "guests": ["Danny McBride"],
    "sentiment": { "overall": "positive", "rationale": "Lighthearted yet introspective..." },
    "adReads": [{ "brand": "Apple Card", "excerpt": "No annual fee, no late fees, and no foreign transaction fees..." }],
    "mentions": [{ "keyword": "HBO", "count": 3, "quotes": ["...my great HBO shows..."] }]
  },
  "subtitleKvsKeys": { "srt": "subtitles-<guid>.srt", "vtt": "subtitles-<guid>.vtt" }
}
````

You can download the dataset in **JSON, CSV, Excel, or HTML**, or pull it from the API.

#### Data fields

| Field | Description |
| --- | --- |
| `showTitle`, `showAuthor`, `feedUrl`, `language`, `categories` | Podcast (show) details. |
| `episodeTitle`, `publishedAt`, `durationSeconds`, `episodeNumber`, `season`, `enclosureUrl` | Episode details. |
| `transcript`, `transcriptLength`, `detectedLanguage`, `speakerCount` | The transcription — speaker-labeled, with inline `[Speaker N HH:MM:SS]` timestamps when **Timestamps** is on. |
| `analysis.summary`, `.chapters`, `.topics`, `.entities`, `.guests`, `.sentiment`, `.adReads`, `.mentions` | AI insights (when **Analyze** is on). |
| `subtitleKvsKeys` | Keys of the generated **SRT/VTT** subtitle files in the key-value store (when **Subtitle export** is on). |
| `audioKvsKey` | Where the saved audio file lives (when **Store audio** is on). |

### How much does it cost to transcribe a podcast?

This Actor uses **pay-per-event** pricing, so you pay only for the work each run actually does, across four events:

| Event | Unit | Charged when |
| --- | --- | --- |
| Episode metadata | per episode | An episode is returned (a flat baseline charge for every delivered episode, including metadata-only runs). |
| Media downloaded | per MB | The episode's audio file is downloaded — needed for transcription, and for **Store audio** when enabled. |
| Transcription | per audio minute | An episode is transcribed. |
| Analysis | per episode | AI analysis runs for an episode (one flat charge per episode, regardless of episode length or how many analysis types you select). |

Cost scales mainly with the **total audio minutes** you process, so a 5-minute news episode is a few cents while a 3-hour interview costs more. Keyword **mentions** are computed locally and are not charged. To keep runs cheap, leave **episode selection** on **latest**, or set **Max episodes**. You can try the Actor for free with your Apify free-tier credits before scaling up.

### Tips

- **Transcribe a whole show:** set episode selection to **all**. Use **Max episodes** to cap a large back catalog.
- **Build a podcast monitor:** add your brand and competitor names to **Mention keywords**, then [schedule](https://docs.apify.com/platform/schedules) the Actor over your favorite shows to get a running feed of mentions.
- **Faster, cheaper runs:** turn off **Store audio** if you only need text, and lower **Max audio minutes** to skip very long episodes.
- **Free subtitles & timestamps:** **Subtitle export** (SRT/VTT) and inline **Timestamps** are generated from the transcription you're already paying for — they add **no extra charge**.

### Frequently asked questions

**Can it transcribe a Spotify link?** No — Spotify hosts its audio in a closed format. Use the show's RSS feed or its Apple Podcasts link instead (most shows are on both).

**What about video podcasts on YouTube?** Use the [Speech-to-Text Transcription](https://apify.com/hgservices/speech-to-text) Actor with the video URL.

**Which languages are supported?** The language is detected automatically, covering 30+ languages.

**Can it transcribe private or members-only feeds?** No — the Actor only accesses publicly available episodes.

**Is this legal?** Transcribing publicly available podcasts for analysis is generally fine, but you are responsible for how you use the output (respect copyright and the show's terms).

Found a podcast that doesn't resolve, or have a feature request? Open an issue on the **Issues** tab — we read every one.

# Actor input Schema

## `source` (type: `string`):

Provide exactly one podcast reference — the type is auto-detected:

- **RSS/Atom feed** — e.g. https://feeds.buzzsprout.com/1195244.rss
- **Apple Podcasts link** — any podcasts.apple.com URL; add `?i=<episodeId>` to pin a single episode
- **Show name** — resolved to its feed via the iTunes Search API
- **Direct episode/audio URL** — an .mp3/.m4a/etc. file (or an episode web page); transcribed as a single episode

## `episodeSelection` (type: `string`):

How to pick episodes from a feed/show. 'latest' = newest episode only.

## `maxEpisodes` (type: `integer`):

Optional convenience cap for 'all'/'dateRange'. Leave empty for no cap — your run is bounded by your Apify credits and the run timeout.

## `fromDate` (type: `string`):

For 'dateRange': only episodes published on/after this ISO date.

## `toDate` (type: `string`):

For 'dateRange': only episodes published on/before this ISO date.

## `episodeIndex` (type: `integer`):

For 'index': 0 = newest, 1 = next, ...

## `episodeGuid` (type: `string`):

For 'guid': the exact episode GUID to select.

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

For 'titleMatch': select episodes whose title contains this text (case-insensitive).

## `includeTranscript` (type: `boolean`):

Produce a transcript for each episode (transcribed in-process with Deepgram).

## `includeAnalysis` (type: `boolean`):

Run AI analysis on each transcript — summaries, topics, entities, guests, and more. Keyword 'mentions' run independently and don't require this.

## `analysis` (type: `array`):

Which AI analyses to produce per episode.

## `mentions` (type: `array`):

Keywords/brands to find in each transcript (deterministic; no API key needed). Powers podcast monitoring.

## `includeAudio` (type: `boolean`):

Download each episode's audio and store it in the key-value store (key 'audio-<guid>').

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

Generate subtitle files from the transcript timings and store them in the key-value store (key 'subtitles-<guid>.<ext>'). Their keys appear on each record as 'subtitleKvsKeys'. Requires transcription.

## `diarize` (type: `boolean`):

Label different speakers in the transcript.

## `smartFormat` (type: `boolean`):

Apply punctuation/formatting to the transcript.

## `timestamps` (type: `boolean`):

Prefix each speaker turn in the transcript with its start time (HH:MM:SS), e.g. `[Speaker 1 00:01:58]`.

## `maxAudioMinutes` (type: `integer`):

Skip (don't transcribe) episodes longer than this. Podcasts are long-form (some interview shows run 4–5 hours), so the default is generous.

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

Proxy used when downloading episode audio for transcription.

## Actor input object example

```json
{
  "source": "https://podcasts.apple.com/us/podcast/the-interview/id1624946521",
  "episodeSelection": "latest",
  "episodeIndex": 0,
  "includeTranscript": true,
  "includeAnalysis": true,
  "analysis": [
    "summary",
    "chapters",
    "topics",
    "entities",
    "guests",
    "sentiment",
    "adReads"
  ],
  "mentions": [],
  "includeAudio": false,
  "subtitleFormats": [],
  "diarize": true,
  "smartFormat": true,
  "timestamps": true,
  "maxAudioMinutes": 600,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `episodes` (type: `string`):

One record per episode: show/episode metadata, transcript, and optional analysis.

## `audio` (type: `string`):

Downloaded episode audio stored in the key-value store (only when includeAudio is enabled).

## `subtitles` (type: `string`):

Exported SRT/VTT subtitle files stored in the key-value store (only when subtitleFormats are requested).

# 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 = {
    "source": "https://podcasts.apple.com/us/podcast/the-interview/id1624946521"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/podcast-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 = { "source": "https://podcasts.apple.com/us/podcast/the-interview/id1624946521" }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/podcast-transcriber").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 '{
  "source": "https://podcasts.apple.com/us/podcast/the-interview/id1624946521"
}' |
apify call hgservices/podcast-transcriber --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Podcast Transcriber & Analyzer",
        "description": "Download, Transcribe and analyze any podcast from an RSS feed, Apple Podcasts link, show name, or episode URL.",
        "version": "0.0",
        "x-build-id": "j6Sddc1qrWtWYTlP9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~podcast-transcriber/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-podcast-transcriber",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/hgservices~podcast-transcriber/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-podcast-transcriber",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/hgservices~podcast-transcriber/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-podcast-transcriber",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "source"
                ],
                "properties": {
                    "source": {
                        "title": "Podcast source (RSS feed, Apple link, show name, or episode URL)",
                        "type": "string",
                        "description": "Provide exactly one podcast reference — the type is auto-detected:\n- **RSS/Atom feed** — e.g. https://feeds.buzzsprout.com/1195244.rss\n- **Apple Podcasts link** — any podcasts.apple.com URL; add `?i=<episodeId>` to pin a single episode\n- **Show name** — resolved to its feed via the iTunes Search API\n- **Direct episode/audio URL** — an .mp3/.m4a/etc. file (or an episode web page); transcribed as a single episode"
                    },
                    "episodeSelection": {
                        "title": "Which episodes",
                        "enum": [
                            "latest",
                            "all",
                            "dateRange",
                            "index",
                            "guid",
                            "titleMatch"
                        ],
                        "type": "string",
                        "description": "How to pick episodes from a feed/show. 'latest' = newest episode only.",
                        "default": "latest"
                    },
                    "maxEpisodes": {
                        "title": "Max episodes",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional convenience cap for 'all'/'dateRange'. Leave empty for no cap — your run is bounded by your Apify credits and the run timeout."
                    },
                    "fromDate": {
                        "title": "From date (ISO)",
                        "type": "string",
                        "description": "For 'dateRange': only episodes published on/after this ISO date."
                    },
                    "toDate": {
                        "title": "To date (ISO)",
                        "type": "string",
                        "description": "For 'dateRange': only episodes published on/before this ISO date."
                    },
                    "episodeIndex": {
                        "title": "Episode index",
                        "minimum": 0,
                        "type": "integer",
                        "description": "For 'index': 0 = newest, 1 = next, ...",
                        "default": 0
                    },
                    "episodeGuid": {
                        "title": "Episode GUID",
                        "type": "string",
                        "description": "For 'guid': the exact episode GUID to select."
                    },
                    "titleContains": {
                        "title": "Title contains",
                        "type": "string",
                        "description": "For 'titleMatch': select episodes whose title contains this text (case-insensitive)."
                    },
                    "includeTranscript": {
                        "title": "Transcribe",
                        "type": "boolean",
                        "description": "Produce a transcript for each episode (transcribed in-process with Deepgram).",
                        "default": true
                    },
                    "includeAnalysis": {
                        "title": "Analyze (beta)",
                        "type": "boolean",
                        "description": "Run AI analysis on each transcript — summaries, topics, entities, guests, and more. Keyword 'mentions' run independently and don't require this.",
                        "default": true
                    },
                    "analysis": {
                        "title": "Analyses to run",
                        "type": "array",
                        "description": "Which AI analyses to produce per episode.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "summary",
                                "chapters",
                                "topics",
                                "entities",
                                "guests",
                                "sentiment",
                                "adReads"
                            ],
                            "enumTitles": [
                                "Summary",
                                "Chapters",
                                "Topics",
                                "Entities",
                                "Guests",
                                "Sentiment",
                                "Ad reads"
                            ]
                        },
                        "default": [
                            "summary",
                            "chapters",
                            "topics",
                            "entities",
                            "guests",
                            "sentiment",
                            "adReads"
                        ]
                    },
                    "mentions": {
                        "title": "Mention keywords",
                        "type": "array",
                        "description": "Keywords/brands to find in each transcript (deterministic; no API key needed). Powers podcast monitoring.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeAudio": {
                        "title": "Store audio file",
                        "type": "boolean",
                        "description": "Download each episode's audio and store it in the key-value store (key 'audio-<guid>').",
                        "default": false
                    },
                    "subtitleFormats": {
                        "title": "Subtitle export",
                        "type": "array",
                        "description": "Generate subtitle files from the transcript timings and store them in the key-value store (key 'subtitles-<guid>.<ext>'). Their keys appear on each record as 'subtitleKvsKeys'. Requires transcription.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "srt",
                                "vtt"
                            ],
                            "enumTitles": [
                                "SRT (.srt)",
                                "WebVTT (.vtt)"
                            ]
                        },
                        "default": []
                    },
                    "diarize": {
                        "title": "Identify speakers",
                        "type": "boolean",
                        "description": "Label different speakers in the transcript.",
                        "default": true
                    },
                    "smartFormat": {
                        "title": "Smart formatting",
                        "type": "boolean",
                        "description": "Apply punctuation/formatting to the transcript.",
                        "default": true
                    },
                    "timestamps": {
                        "title": "Timestamps",
                        "type": "boolean",
                        "description": "Prefix each speaker turn in the transcript with its start time (HH:MM:SS), e.g. `[Speaker 1 00:01:58]`.",
                        "default": true
                    },
                    "maxAudioMinutes": {
                        "title": "Max audio minutes per episode",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Skip (don't transcribe) episodes longer than this. Podcasts are long-form (some interview shows run 4–5 hours), so the default is generous.",
                        "default": 600
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used when downloading episode audio for transcription.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
