Text-to-speech API for VTT subtitles

Most text-to-speech (TTS) APIs do not natively export a .vtt file directly in a single call. Instead, modern TTS workflows handle this via a two-step pattern:

1. The TTS API generates the audio and returns word- or character-level alignment timestamps (indicating precisely when each word or letter is spoken).
2. A lightweight script or utility function on your backend parses those timestamps, groups them into subtitle lines/sentences, and formats them into standard WebVTT syntax.

Alternatively, if you already have an audio or video file and need to go backward (generating VTT from audio), you use a Speech-to-Text/Transcription API.docs.cloud.google.com

Phase 1: Top TTS APIs that Return Alignment Timestamps

If you are generating the voiceover from text and need the timing data to build your VTT files, these APIs provide the necessary timestamp payloads:

• ElevenLabs Text-to-Speech with Timestamps : The /v1/text-to-speech/{voice_id}/with-timestamps endpoint returns the generated audio alongside character-start and character-end times. You can write a small script to aggregate these character times into word and phrase blocks for a VTT file.elevenlabs.io
• Amazon Polly (Speech Marks) : Polly can return "Speech Marks" (OutputFormat=json with SpeechMarkTypes=['word', 'sentence'] ) which give exact time offsets (in milliseconds) for when each word or sentence begins and ends.
• Hume AI TTS Timestamps : The Hume TTS endpoints allow you to request include_timestamp_types for words and phonemes, streaming or returning precise boundary data alongside the audio buffer.dev.hume.ai
• Typecast API with Timestamps : Returns base64 audio paired with word- or character-level timing granularity that can be mapped to subtitle containers.typecast.ai

Phase 2: Converting TTS Timestamps into a VTT String

Once you receive the JSON timestamp array from your chosen TTS provider, you can convert it to WebVTT format programmatically.

A standard WebVTT structure looks like this:

WEBVTT

1
00:00:01.000 --> 00:00:04.000
This is the first generated subtitle line.

2
00:00:04.500 --> 00:00:07.000
This is the second line synced to the audio.

A helper function in Node.js or Python takes your timestamp array, converts raw millisecond or second offsets into HH:MM:SS.mmm , and outputs the .vtt text string to save on your server or push to your video player.

To help narrow down the ideal choice, let me know:

• Are you looking to synthesize new voiceovers from text (TTS) or transcribe existing media (STT)?
• What programming language or backend stack are you using to handle the integration?

For your video player integration, I’d prioritize a text-to-speech API that returns synchronized audio and subtitle timing, ideally with a downloadable .vtt (WebVTT) file or word-level timestamps you can convert to VTT.

There’s an important distinction: some APIs generate speech and subtitles in one workflow, while others only return audio timestamps or generate subtitles by transcribing the finished audio. For a production video player, the first option is usually simpler.

Best API options

1. ElevenLabs

(Best for voice quality + timing)

Its TTS API has a dedicated endpoint that returns generated audio alongside character-level start and end timestamps. You can convert those alignments into properly segmented WebVTT cues for your player.elevenlabs.io+1

• Output: Audio plus alignment data; your application creates the .vtt.
• Best for: Natural-sounding narration, voiceovers, and word highlighting.
• Trade-off: You need a subtitle-generation step in your backend.

TTS with timestamps API documentation

2. Narakeet

(Best for direct VTT output)

Narakeet documents a workflow that can return the generated audio and VTT/SRT subtitle content together. Its API supports requesting JSON output containing the audio result and subtitle files.www.narakeet.com

• Output: Audio plus VTT and SRT.
• Best for: Narrated videos, educational content, and straightforward backend integration.
• Trade-off: Its documentation describes subtitle synchronization around paragraphs, so you should test timing with your script and chosen voice.

Text-to-speech API documentation

3. TTS.ai

(Direct subtitle endpoint)

TTS.ai documents a subtitle endpoint for completed TTS jobs that generates synchronized .vtt or .srt files using audio alignment.www.narakeet.com+3

• Output: Downloadable VTT or SRT.
• Best for: An API workflow where your backend can submit a job and retrieve subtitles afterward.
• Trade-off: The subtitle endpoint is a separate step after speech generation.

API documentation

4. Everlit

Everlit documents a captions endpoint that returns VTT, SRT, or JSON cue data from a speech job, provided word timings were enabled during generation.everlit.audio

• Output: VTT, SRT, or structured caption cues.
• Best for: Applications that need configurable subtitle line length and duration.
• Trade-off: You must request timing information when creating the speech job.

TTS API documentation

How I’d integrate it with your video player

A typical pipeline would look like this:

1. Submit text to the TTS API

Script + voice + language

2. Generate synchronized speech

Audio file + word/phrase timings

3. Create or retrieve the VTT file

Format timestamps into WebVTT cues

4. Load audio and subtitles in your player

Serve both files from your backend or CDN

For an HTML5 video or audio player, WebVTT is supported through the <track> element. The cues need valid start and end times to stay synchronized with playback.developer.mozilla.org+1

For example, the output file looks like this:

WEBVTT

00:00:00.000 --> 00:00:02.400
Welcome to our product demo.

00:00:02.400 --> 00:00:04.800
Let's explore the main features.

My recommendation

• Choose ElevenLabs if natural voice quality and precise word-level synchronization are priorities.
• Choose Narakeet if you prefer an API documented to return audio and subtitle files together.
• Evaluate TTS.ai or Everlit if a dedicated subtitle endpoint fits your asynchronous job-processing architecture better.

One final question that will help me narrow this down: What video player and backend are you using?

Video player

Web player (HTML5 / custom)

Video.js

Shaka Player

React Native / mobile player

Other

Backend

Node.js / TypeScript

Python

Java / .NET

Serverless / no dedicated backend

Other

Subtitle synchronization

Phrase-level subtitles (normal reading)

Word-level timing (highlight each spoken word)

Either is fine

Main priority

Best voice quality

Direct VTT output with minimal code

Lowest cost at scale

Self-hosting / data privacy

[Find the best fit]

My top recommendation is ElevenLabs if you want to generate narration for a video player and provide synchronized captions in .vtt format.

One important distinction: most text-to-speech (TTS) APIs generate audio, not a ready-made WebVTT subtitle file. For video integration, you need either an API that returns speech timestamps or a workflow that converts those timestamps into VTT cues.

Best options for your integration

1. ElevenLabs

(Best overall)

Generates natural-sounding speech and provides a timestamp-enabled TTS endpoint with character-level alignment data, so you can build captions synchronized to the generated audio.elevenlabs.io+1

• Audio: Yes
• Timing data: Yes
• Ready-made VTT: Convert the timing data into VTT yourself
• Best for: High-quality narration, voice-driven applications, and synchronized playback

API documentation — TTS with timestamps

2. Amazon Polly

A strong option if your backend already runs on AWS. Polly can return speech audio and speech marks, including word- or sentence-level timing information, which you can convert to WebVTT.docs.aws.amazon.com+1

• Audio: Yes
• Timing data: Yes, through speech marks
• Ready-made VTT: Typically requires conversion
• Best for: AWS-based applications and predictable backend integration

Amazon Polly API documentation

3. Google Cloud Speech-to-Text

This is especially useful if you require actual VTT file output. Its V2 batch transcription API supports WebVTT and SRT caption generation. However, it is a speech-to-text service, so you'd need to generate the narration separately and transcribe the resulting audio.docs.cloud.google.com

• Audio generation: No
• Timing data: Yes, through transcription
• Ready-made VTT: Yes, supported
• Best for: Existing audio, caption generation, or a two-stage TTS-plus-transcription pipeline

WebVTT and SRT caption documentation

How I would implement it

For ElevenLabs, the architecture would look like this:

1. Input text

Script, article, or video narration

2. TTS API

Generate audio + character timestamps

3. Backend VTT converter

Group timestamped characters into readable phrases

narration.mp3

captions.vtt

4. Video player

Load audio and attach VTT as a text track

A VTT file would look like this:

WEBVTT

00:00:00.000 --> 00:00:02.000
Welcome to our video.

00:00:02.000 --> 00:00:04.500
Today, we'll explore the topic.

For an HTML5 video player, you can attach the file using a <track> element with kind="captions" or kind="subtitles", depending on your use case. Make sure the VTT timestamps match the exact audio file being played.

My final recommendation

Start with ElevenLabs + a small server-side VTT converter. It gives you speech generation and timing information from the same synthesis request, avoiding a separate transcription step.elevenlabs.io+1

One question that could change my recommendation: Which video player are you integrating with?

Video player

HTML5 video / custom web player

Video.js

Plyr

Vimeo or another hosted player

iOS / Android app player

What should the API workflow return?

Both generated audio and a VTT file

VTT only — I already have the audio

One API call that returns audio and ready-made VTT

Backend language

Node.js / TypeScript

Python

PHP

Other / not decided

[Tailor the recommendation]