# Bulk Text to Speech — MP3 + SRT Subtitles (No API Key) (`fayoussef/bulk-text-to-speech`) Actor

Convert text to natural AI speech in bulk. 322 neural voices, 75+ languages, no API key. Every text becomes an MP3 voiceover plus perfectly timed SRT/VTT subtitles — ideal for TikTok & YouTube faceless videos, e-learning and podcasts.

- **URL**: https://apify.com/fayoussef/bulk-text-to-speech.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Automation, MCP servers, Integrations
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 1,000 characters converteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Convert **text to speech in bulk** — no API key, no subscription, no character limits from expensive TTS providers. This Actor turns every text you give it into a natural-sounding **MP3 voiceover** using **322 neural AI voices in 75+ languages**, and generates **perfectly timed SRT/VTT subtitles** next to every file. Run it from the Apify Console, on a schedule, through the API, or call it from an AI agent via [Apify MCP](https://docs.apify.com/platform/integrations/mcp).

### What does Bulk Text to Speech do?

- 🎙️ **Text to MP3 at scale** — paste 1 or 500 texts; each becomes its own MP3 voiceover, generated in parallel
- 📝 **Subtitles included** — every clip ships with a matching **SRT or VTT** file, timed from the actual speech engine (not guessed), in **sentence blocks** or **word-by-word TikTok-style captions**
- 🌍 **322 neural voices, 75+ languages** — US/UK/AU English, Spanish, French, German, Arabic, Hindi, Japanese, Chinese, Portuguese and more, including multilingual voices that switch language automatically
- ⚡ **Speed & pitch control** — from half speed to 2×, deeper or higher pitch
- 🔗 **Merge option** — combine all clips into one continuous `combined.mp3` with one continuous subtitle track (podcasts, audiobooks, full videos)
- 🔑 **No API key needed** — unlike ElevenLabs, OpenAI TTS or Google Cloud, there is nothing to sign up for and no key to paste

### Why use this text to speech API?

| Use case | How this Actor helps |
|---|---|
| **Faceless YouTube / TikTok channels** | Batch-generate voiceovers + word-by-word captions for every script in one run |
| **Shorts & Reels automation** | Chain with video tools via API, Make, Zapier or n8n — text in, MP3 + SRT out |
| **E-learning & courses** | Narrate lessons in 75+ languages with consistent voices |
| **Podcasts & audiobooks** | Merge chapters into a single MP3 with continuous subtitles |
| **IVR & product demos** | Professional prompts without studio costs |
| **Accessibility** | Give every article or newsletter an audio version automatically |

Compared to ElevenLabs (~$0.15–0.30 per 1,000 characters) or hiring voice talent, this Actor costs a fraction of a cent per clip — and it scales to thousands of clips per run on Apify's infrastructure with scheduling, webhooks and 6,000+ integrations.

### How to convert text to speech in bulk

1. Open the Actor and paste your texts into **Texts to convert** — one entry per clip.
2. Pick a **Voice** from the dropdown (or run once with **List all voices** to browse all 322).
3. Optionally set **speed**, **pitch**, and the **subtitle style** (sentence blocks or word-by-word).
4. Click **Start**. Each clip appears in the Output tab with an **MP3 download link** and a **subtitles download link**.
5. Download files individually, grab them via API, or export the whole table as JSON/CSV/Excel.

That's it — no account with a TTS provider, no API key, no setup.

### Input example

```json
{
    "texts": [
        "Did you know the average person spends six years dreaming?",
        "Follow for more daily facts that will blow your mind."
    ],
    "voice": "en-US-ChristopherNeural",
    "speed": "+25%",
    "generateSubtitles": true,
    "subtitleGranularity": "word",
    "subtitleFormat": "srt"
}
````

### Output example

Each clip becomes one dataset item with direct download links:

```json
{
    "index": 1,
    "kind": "audio",
    "text": "Did you know the average person spends six years dreaming?",
    "characters": 59,
    "voice": "en-US-ChristopherNeural",
    "audioUrl": "https://api.apify.com/v2/key-value-stores/.../records/audio-001.mp3",
    "subtitlesUrl": "https://api.apify.com/v2/key-value-stores/.../records/subtitles-001.srt",
    "durationSeconds": 4.32,
    "speed": "+25%",
    "pitch": "+0Hz",
    "status": "ok"
}
```

Download results as **JSON, CSV, Excel or XML**, or fetch the MP3/SRT files directly from the key-value store URLs.

### Data fields

| Field | Description |
|---|---|
| `index` | Position of the text in your input list |
| `text` | The converted text |
| `characters` | Characters synthesized (what you're billed on) |
| `voice` | Neural voice code used |
| `audioUrl` | Direct MP3 download link |
| `subtitlesUrl` | Direct SRT/VTT download link |
| `durationSeconds` | Audio length in seconds |
| `speed` / `pitch` | Voice settings used |
| `status` | `ok` when the clip generated successfully |

### How much does bulk text to speech cost?

You pay a tiny amount per 1,000 characters converted — see the **Pricing** tab for exact rates. There are no subscriptions and no minimums: 10 TikTok scripts of ~300 characters each cost less than a cent. **Free-plan users** can convert up to **10 texts / 3,000 characters per run**; subscribe to any [Apify plan](https://apify.com/pricing?fpr=youssef) to unlock unlimited texts and characters.

### Tips for the best AI voiceovers

- **TikTok/Shorts pacing:** use `+25%` speed with `subtitleGranularity: "word"` for snappy animated captions.
- **Voice discovery:** run once with **List all voices** ON — the dataset then contains all 322 voices with language, gender and personality tags. Put your favorite's code into **Custom voice code**.
- **Multilingual scripts:** pick a `Multilingual` voice (Ava, Emma, Andrew, Brian) and it will switch languages mid-text automatically.
- **Long content:** enable **merge** to get one continuous MP3 + subtitle track in input order.
- **Automation:** trigger this Actor from [Make](https://apify.com/integrations), Zapier, n8n, or an AI agent via **Apify MCP** — the input is a simple JSON array of strings.

### FAQ — Text to Speech on Apify

#### Is this a free text to speech API?

You can try it free (10 texts / 3,000 characters per run on the Apify free plan). Beyond that you pay per 1,000 characters — no monthly subscription, no API-key signup.

#### Do I need an ElevenLabs or OpenAI API key?

No. This Actor needs **no API key at all**. It uses Microsoft Edge's neural text-to-speech voices, which are free to use — you only pay the small Apify per-character fee.

#### Which languages and voices are supported?

322 neural voices across 75+ languages and dialects, including English (US, UK, AU, IN), Spanish, French, German, Italian, Portuguese, Arabic, Hindi, Japanese, Korean, Chinese, Russian, Turkish, Dutch, Polish, Vietnamese and Thai. Run the Actor with **List all voices** to export the full catalog.

#### Can it generate TikTok-style word-by-word captions?

Yes — set **Subtitle timing** to *word-by-word* and every word gets its own timed cue in the SRT/VTT file, ready for CapCut, Premiere or DaVinci Resolve caption animations.

#### How accurate are the subtitle timestamps?

The timestamps come from the speech engine's own word/sentence boundary events during synthesis, so they match the audio exactly — no re-alignment or guessing.

#### Can I call it from my own app or an AI agent?

Yes. Every Apify Actor is also an HTTP API: `POST` your input JSON and read the dataset when the run finishes. AI agents can call it directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

#### Is there a limit on text length?

Long texts are handled automatically — a 10,000-word article becomes one MP3. Free-plan runs are capped at 3,000 characters total; paid plans have no cap.

### Support & custom solutions

Found an issue or want a feature? Open a ticket in the **Issues** tab — it's monitored daily.

💼 Need a custom automation or a private version of this Actor (different voices, S3 upload, video rendering)? Reach out at **youssefarhan24@gmail.com**.

🌐 Got another tool or site in mind? [Suggest it here](https://automationbyexperts.com/apify).

*This Actor uses publicly available text-to-speech technology. You are responsible for how you use the generated audio and for complying with the laws applicable to your content.*

# Actor input Schema

## `texts` (type: `array`):

One entry = one MP3 voiceover (plus matching subtitles). Add as many as you want — they are all generated in parallel.

⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

## `voice` (type: `string`):

Neural voice used for all texts. 322 voices in 75+ languages are available — this list shows the most popular ones. Need another? Use the 'Custom voice code' field below, or tick 'List all voices' to export the full catalog.

## `speed` (type: `string`):

How fast the voice talks. TikTok/Shorts creators often use +25%.

## `pitch` (type: `string`):

Voice pitch adjustment.

## `customVoice` (type: `string`):

Any of the 322 supported voice codes, e.g. `el-GR-AthinaNeural`. Overrides the Voice dropdown. Tick 'List all voices' below and run once to export the full catalog.

## `generateSubtitles` (type: `boolean`):

Create a perfectly timed subtitle file (SRT or VTT) next to every MP3 — ready to drop into CapCut, Premiere, DaVinci or YouTube.

## `subtitleGranularity` (type: `string`):

'Word-by-word' gives you one cue per word — perfect for animated TikTok-style captions. 'Sentence' gives classic subtitle blocks.

## `subtitleFormat` (type: `string`):

SRT works everywhere (CapCut, Premiere, YouTube). VTT is for web players.

## `combineAudio` (type: `boolean`):

Additionally joins all clips into a single `combined.mp3` (and one continuous subtitle file) in the original order — handy for full videos, podcasts or audiobooks.

## `maxConcurrency` (type: `integer`):

How many texts are converted at the same time. 5 is a safe default; raise it for large batches.

## `listVoices` (type: `boolean`):

Run once with this ON to export the full catalog of 322 voices (name, language, gender, personality) to the dataset — then pick your favorite and put its code into 'Custom voice code'. Free, no characters charged.

## Actor input object example

```json
{
  "texts": [
    "Welcome to the future of content creation. This entire voiceover was generated in seconds, with subtitles included.",
    "Here is a second clip. Each text in this list becomes its own MP3 file with perfectly timed captions."
  ],
  "voice": "en-US-AriaNeural",
  "speed": "+0%",
  "pitch": "+0Hz",
  "generateSubtitles": true,
  "subtitleGranularity": "sentence",
  "subtitleFormat": "srt",
  "combineAudio": false,
  "maxConcurrency": 5,
  "listVoices": false
}
```

# Actor output Schema

## `voiceovers` (type: `string`):

One row per generated clip: text, voice, duration, MP3 and subtitle download links.

## `audioFiles` (type: `string`):

The generated MP3 voiceover files in the key-value store.

## `subtitleFiles` (type: `string`):

The generated SRT/VTT subtitle files in the key-value store.

# 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 = {
    "texts": [
        "Welcome to the future of content creation. This entire voiceover was generated in seconds, with subtitles included.",
        "Here is a second clip. Each text in this list becomes its own MP3 file with perfectly timed captions."
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/bulk-text-to-speech").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 = { "texts": [
        "Welcome to the future of content creation. This entire voiceover was generated in seconds, with subtitles included.",
        "Here is a second clip. Each text in this list becomes its own MP3 file with perfectly timed captions.",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/bulk-text-to-speech").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 '{
  "texts": [
    "Welcome to the future of content creation. This entire voiceover was generated in seconds, with subtitles included.",
    "Here is a second clip. Each text in this list becomes its own MP3 file with perfectly timed captions."
  ]
}' |
apify call fayoussef/bulk-text-to-speech --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fayoussef/bulk-text-to-speech",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulk Text to Speech — MP3 + SRT Subtitles (No API Key)",
        "description": "Convert text to natural AI speech in bulk. 322 neural voices, 75+ languages, no API key. Every text becomes an MP3 voiceover plus perfectly timed SRT/VTT subtitles — ideal for TikTok & YouTube faceless videos, e-learning and podcasts.",
        "version": "0.1",
        "x-build-id": "E1RFkmAl8YmCB43d1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~bulk-text-to-speech/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-bulk-text-to-speech",
                "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/fayoussef~bulk-text-to-speech/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-bulk-text-to-speech",
                "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/fayoussef~bulk-text-to-speech/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-bulk-text-to-speech",
                "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": [
                    "texts"
                ],
                "properties": {
                    "texts": {
                        "title": "Texts to convert",
                        "type": "array",
                        "description": "One entry = one MP3 voiceover (plus matching subtitles). Add as many as you want — they are all generated in parallel.\n\n⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).\n💼 Need a custom solution? Reach out at youssefarhan24@gmail.com\n🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "voice": {
                        "title": "Voice",
                        "enum": [
                            "en-US-AriaNeural",
                            "en-US-JennyNeural",
                            "en-US-MichelleNeural",
                            "en-US-AnaNeural",
                            "en-US-GuyNeural",
                            "en-US-ChristopherNeural",
                            "en-US-EricNeural",
                            "en-US-AvaMultilingualNeural",
                            "en-US-EmmaMultilingualNeural",
                            "en-US-AndrewMultilingualNeural",
                            "en-US-BrianMultilingualNeural",
                            "en-GB-SoniaNeural",
                            "en-GB-RyanNeural",
                            "en-AU-NatashaNeural",
                            "en-IN-NeerjaNeural",
                            "es-ES-ElviraNeural",
                            "es-MX-DaliaNeural",
                            "es-MX-JorgeNeural",
                            "fr-FR-DeniseNeural",
                            "fr-FR-HenriNeural",
                            "de-DE-KatjaNeural",
                            "de-DE-ConradNeural",
                            "it-IT-ElsaNeural",
                            "it-IT-DiegoNeural",
                            "pt-BR-FranciscaNeural",
                            "pt-BR-AntonioNeural",
                            "ar-SA-ZariyahNeural",
                            "ar-EG-SalmaNeural",
                            "hi-IN-SwaraNeural",
                            "ja-JP-NanamiNeural",
                            "ko-KR-SunHiNeural",
                            "zh-CN-XiaoxiaoNeural",
                            "zh-CN-YunxiNeural",
                            "ru-RU-SvetlanaNeural",
                            "tr-TR-EmelNeural",
                            "nl-NL-ColetteNeural",
                            "pl-PL-ZofiaNeural",
                            "sv-SE-SofieNeural",
                            "id-ID-GadisNeural",
                            "vi-VN-HoaiMyNeural",
                            "th-TH-PremwadeeNeural"
                        ],
                        "type": "string",
                        "description": "Neural voice used for all texts. 322 voices in 75+ languages are available — this list shows the most popular ones. Need another? Use the 'Custom voice code' field below, or tick 'List all voices' to export the full catalog.",
                        "default": "en-US-AriaNeural"
                    },
                    "speed": {
                        "title": "Speaking speed",
                        "enum": [
                            "-50%",
                            "-25%",
                            "-10%",
                            "+0%",
                            "+10%",
                            "+25%",
                            "+50%",
                            "+100%"
                        ],
                        "type": "string",
                        "description": "How fast the voice talks. TikTok/Shorts creators often use +25%.",
                        "default": "+0%"
                    },
                    "pitch": {
                        "title": "Pitch",
                        "enum": [
                            "-20Hz",
                            "-10Hz",
                            "+0Hz",
                            "+10Hz",
                            "+20Hz"
                        ],
                        "type": "string",
                        "description": "Voice pitch adjustment.",
                        "default": "+0Hz"
                    },
                    "customVoice": {
                        "title": "Custom voice code (optional)",
                        "type": "string",
                        "description": "Any of the 322 supported voice codes, e.g. `el-GR-AthinaNeural`. Overrides the Voice dropdown. Tick 'List all voices' below and run once to export the full catalog."
                    },
                    "generateSubtitles": {
                        "title": "Generate subtitles",
                        "type": "boolean",
                        "description": "Create a perfectly timed subtitle file (SRT or VTT) next to every MP3 — ready to drop into CapCut, Premiere, DaVinci or YouTube.",
                        "default": true
                    },
                    "subtitleGranularity": {
                        "title": "Subtitle timing",
                        "enum": [
                            "sentence",
                            "word"
                        ],
                        "type": "string",
                        "description": "'Word-by-word' gives you one cue per word — perfect for animated TikTok-style captions. 'Sentence' gives classic subtitle blocks.",
                        "default": "sentence"
                    },
                    "subtitleFormat": {
                        "title": "Subtitle format",
                        "enum": [
                            "srt",
                            "vtt"
                        ],
                        "type": "string",
                        "description": "SRT works everywhere (CapCut, Premiere, YouTube). VTT is for web players.",
                        "default": "srt"
                    },
                    "combineAudio": {
                        "title": "Also merge everything into one file",
                        "type": "boolean",
                        "description": "Additionally joins all clips into a single `combined.mp3` (and one continuous subtitle file) in the original order — handy for full videos, podcasts or audiobooks.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Parallel conversions",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many texts are converted at the same time. 5 is a safe default; raise it for large batches.",
                        "default": 5
                    },
                    "listVoices": {
                        "title": "List all voices (no audio)",
                        "type": "boolean",
                        "description": "Run once with this ON to export the full catalog of 322 voices (name, language, gender, personality) to the dataset — then pick your favorite and put its code into 'Custom voice code'. Free, no characters charged.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
