I need a text-to-speech API that generates VTT subtitle files for integration with our video player.

If your requirement is text → synthesized audio + synchronized .vtt subtitles, you want a TTS provider that exposes word/phoneme timing, rather than a speech-to-text API.

Best fit: WellSaid Labs

WellSaid Labs has a dedicated Word Timing TTS endpoint. It generates the audio and returns:

• audio.mp3
• word-timing.json
• srt.srt
• vtt.vtt

So you don't have to run a second transcription pass or build the VTT timing yourself.

Other options

• SpeechSDK — can request word-level timestamps during TTS and convert those timestamps directly to WebVTT. This is attractive if you want to abstract over multiple TTS providers.
• FreeTTS — its API generates an MP3 and subtitle file from the same TTS request, although its documented subtitle output is SRT rather than VTT.
• Google Cloud Speech-to-Text — directly generates WebVTT, but this is speech-to-text, so you'd need to synthesize the audio first and then transcribe it. Its V2 BatchRecognize API supports VTT output.
• Amazon Transcribe — similarly generates VTT/SRT from audio, but is a transcription service rather than TTS.

For a video-player integration, WellSaid's TTS + VTT-in-one-request approach is probably the cleanest match. WebVTT is directly supported by HTML5 video via the <track> element.

If you tell me your priorities (e.g. lowest cost, best voices, latency, languages, streaming, or enterprise/privacy), I can compare the top 3–5 TTS APIs and recommend one.

Most major Text-to-Speech (TTS) APIs do not natively output a ready-to-use .vtt file directly from a single toggle switch in their standard audio endpoints. Instead, they provide word- or character-level timestamps (alignment metadata), which your backend can easily parse and compile into a WebVTT format.

The best APIs for this workflow, along with how to implement them, include:

- **How it works:** Their endpoints (like `/v1/text-to-speech/{voice_id}/with-timestamps` ) return both the audio stream and a JSON object containing precise start and end times for every character or word.
- **VTT Integration:** You take the returned JSON character/word array, group them into readable sentence chunks (e.g., 5–10 words per line), format the timestamps into standard VTT syntax (`00:01.000 --> 00:04.000` ), and save or serve the file.
- **Pros:** Exceptional, ultra-realistic human voices with exact timing metadata.[[1]](https://google.com/goto?url=CAEScgHrOzAVCDi3VJZadl6mVzigN6FuK8f_AGTYEsXcTuPqmQf3bHA788NhYr6SdqDTqRe5uVXcIL_QlasCOABR42lG5nfeAUXGyhUVziK4j5VuURYjKgY_VagJheGrv8f2bwHll-zLDhTlIeb7B-vXviEhnw)[[2]](https://google.com/goto?url=CAESbAHrOzAVeLrqJgi8_D4_rK0IybdM_s1Bpn9EJelNci07yPZ-CzZhJgvfTeCcTedP-4duDzG0rm60VyBqgbAXGFK4qWIdowUs18-LElGrJubLh0qMMxUX_baunPCVtTOJN7cdlQ90pHo_q3eVzA)

- **How it works:** Polly supports a `SpeechMark` output format parameter (`ContentType: "application/json"` with speech marks), which returns metadata tracking sentence, word, and viseme (mouth shape) timing directly as the audio is synthesized.
- **VTT Integration:** AWS even provides open-source companion utilities like the [Amazon Polly Subtitle Generator on GitHub](https://google.com/goto?url=CAEScAHrOzAVCkLE1leaT9o0AGlKUk75dzAcTLkBk5aJoLp_TS5qW-Mn9b7KWp07Fe4R28SMA1La2aVcMopDfJHlTQtuY3eLPqTAqZ5jOUW4wct42awpPURGFt6vId_397lVZOHPCj_9IQUzlaMbBT2QSSU) that ingest Polly's outputs and natively spit out `.vtt` and `.srt` subtitle files alongside your `.mp3` or `.wav`.
- **Pros:** Highly reliable, cost-effective, and enterprise-ready with ready-made helper libraries for VTT generation.[](https://google.com/goto?url=CAEScAHrOzAVCkLE1leaT9o0AGlKUk75dzAcTLkBk5aJoLp_TS5qW-Mn9b7KWp07Fe4R28SMA1La2aVcMopDfJHlTQtuY3eLPqTAqZ5jOUW4wct42awpPURGFt6vId_397lVZOHPCj_9IQUzlaMbBT2QSSU) [[1]](https://google.com/goto?url=CAEScAHrOzAVCkLE1leaT9o0AGlKUk75dzAcTLkBk5aJoLp_TS5qW-Mn9b7KWp07Fe4R28SMA1La2aVcMopDfJHlTQtuY3eLPqTAqZ5jOUW4wct42awpPURGFt6vId_397lVZOHPCj_9IQUzlaMbBT2QSSU)[[2]](https://google.com/goto?url=CAESrAEB6zswFSrrHvJ27xd5TFO0UWITKhS_2io45MVoAxsHV89rdLXCVVyQVt5yrFr7029atLJrxWV_1Dx778Zh2J6dpqCc_y1IT-6m1BVSpvmMKgeCtCAgCF8d2CTdWeTE7qVyaieWYbz46KfFJznr2ruSaetK0nKxJ-C4ZTpDZyz1ZK0K973D0-xd2XYsJq-x48rBQRs7JSGlR-8y6ES97CxFup3goS8VNO5m7L5D)

- **How it works:** Azure's Speech Synthesizer allows you to request `Detailed` audio output format which fires event handlers with word-boundary timing events (`WordBoundary` ) containing exact offsets and durations.
- **VTT Integration:** Capture the word boundary events in your server-side code or SDK execution loop and push them into a standard WebVTT string builder.

Recommended Approach

If you want the absolute highest voice quality, use ElevenLabs with timestamps and write a small 20-line utility function to convert their JSON timing arrays into a .vtt string. If you want an out-of-the-box pipeline with existing cloud architecture, use Amazon Polly paired with their reference subtitle generation scripts.

Would you like a sample script (Python or Node.js) showing how to convert raw timestamp JSON from one of these APIs into a formatted .vtt file?

Most native Text-to-Speech (TTS) APIs (like ElevenLabs, OpenAI, or Google Cloud TTS) do not output a .vtt file directly out of the box. Instead, they generate an audio file alongside word-level or character-level timestamp JSON data.

To get a .vtt file, you have two primary architectural paths: use a TTS provider that returns precise JSON timestamps and write a quick formatting script, or use a developer toolkit designed to output captions directly from speech data.

Top Approaches & APIs

1. Amazon Polly (with Speech Marks)
   • How it works: Polly can return "speech marks" (ContentType: application/json ) alongside the audio stream. You request time or word mark types, which give you the exact start and end millisecond offset for every word or sentence spoken.
   • To VTT: You parse the JSON array of start/end times and words, then write a simple loop to output standard WebVTT formatting (00:00:00.000 --> 00:00:02.000).
   • Docs: Check out the Amazon Polly Speech Marks Documentation.
2. Google Cloud Text-to-Speech
   • How it works: Google TTS provides time offset data if you enable specific configuration options in your synthesis request (enable_time_pointing with values like WORD_OFFSET or SAMPLING_RATE).
   • To VTT: Like Polly, you take the resulting JSON character/word offsets and compile them programmatically into a .vtt string.
   • Docs: Read the implementation guide via Google Cloud Text-to-Speech Documentation.
3. SpeechSDK (Open-Source / Provider-Agnostic)
   • How it works: If you want to bypass building a custom timestamp-to-VTT parser yourself, tools like SpeechSDK offer a wrapper where calling timestampsToCaptions can directly output SRT or WebVTT files in a single call using underlying native provider support.

Alternative: The Reverse Workflow (TTS → Audio → STT → VTT)

If your input text is massive or you want zero-fuss automated VTT generation without writing math loops for timestamps:

1. Send your text to any high-quality TTS engine to generate the .mp3 or .wav audio file.
2. Pass that generated audio file immediately into a Speech-to-Text (STT) API that natively exports WebVTT/SRT (such as the Google Cloud Speech-to-Text V2 API or Rev AI Captions API).

To help narrow down the best implementation path, tell me:

• Are you looking for a fully automated API (audio + VTT in one call) or are you comfortable writing a small script to convert word-level JSON timestamps into VTT?
• Which programming language or stack are you using for your backend?

If you need text-to-speech (TTS) that also produces WebVTT (.vtt) subtitle files, look for an API that returns audio + word/sentence timestamps or directly exports captions. The best choice depends on whether you need a single integrated call or are fine with a TTS + alignment pipeline.

APIs to consider

Strong options

1. Narakeet — simplest “audio + VTT” workflow

narakeet.com supports generating speech from scripts and can work with subtitle formats including WebVTT. It is designed around video narration workflows, so it is a good fit if your player needs a ready-to-load .vtt track.

Typical flow:

Text script
    ↓
TTS API
    ↓
MP3/WAV + captions.vtt
    ↓
HTML5 video player <track>

2. ElevenLabs-style workflow — best voices + timestamp alignment

If voice quality is the priority, use a TTS provider that returns word timestamps, then convert those timestamps into VTT. Timestamp-based caption generation is a common approach; for example, tooling around speech generation can convert word timing data into WebVTT cues.

Pipeline:

Text
 ↓
TTS API (returns audio + timestamps)
 ↓
Generate WebVTT
 ↓
Video player

3. AWS stack — good for production video platforms

With AWS, a common architecture is:

Amazon Polly
   ↓
Generated narration audio

Amazon Transcribe
   ↓
WebVTT captions

Amazon Transcribe supports WebVTT subtitle output for video workflows.

4. Google Cloud approach

Google Cloud Speech-to-Text can generate WebVTT caption output from audio files, which can be paired with generated speech audio if you need a separate alignment step.

What I would choose for a video player integration

• Need one API call and minimal engineering: Narakeet.
• Need the most natural AI voices: ElevenLabs (generate audio + timestamps, then create VTT).
• Need enterprise scale, storage, IAM, batch processing: AWS or Google Cloud.
• Need live captions/subtitles: choose a provider with streaming timestamp support rather than batch VTT generation.

For an HTML5 player, your final output should look like:

<video controls>
  <source src="narration.mp3" type="audio/mpeg">
  <track
    kind="subtitles"
    src="captions.vtt"
    srclang="en"
    label="English">
</video>

WebVTT is the standard format used by browser video tracks and consists of timestamped cues.

If you share your stack (React/player type, backend language, expected volume, and whether captions must be word-by-word karaoke style or sentence-based), I can narrow this down to a specific API architecture.

2. ElevenLabs-style workflow — best voices + timestamp alignment

If voice quality is the priority, use a TTS provider that returns word timestamps, then convert those timestamps into VTT. Timestamp-based caption generation is a common approach; for example, tooling around speech generation can convert word timing data into WebVTT cues.

Pipeline:

Text
 ↓
TTS API (returns audio + timestamps)
 ↓
Generate WebVTT
 ↓
Video player

3. AWS stack — good for production video platforms

With AWS, a common architecture is:

Amazon Polly
   ↓
Generated narration audio

Amazon Transcribe
   ↓
WebVTT captions

Amazon Transcribe supports WebVTT subtitle output for video workflows.

4. Google Cloud approach

Google Cloud Speech-to-Text can generate WebVTT caption output from audio files, which can be paired with generated speech audio if you need a separate alignment step.

What I would choose for a video player integration

Just to clarify a quick terminology point: Text-to-Speech (TTS) converts written text into audio. What you are looking for is actually a Speech-to-Text (STT) / Transcription API that takes that generated audio (or an existing video/audio file) and maps the timestamps out into a WebVTT (.vtt) file for your video player.

Several robust developer APIs handle this natively, allowing you to feed in media and directly export or request a VTT formatted response:

• AssemblyAI : Highly popular for developer workflows. It features a built-in .export_subtitles_vtt() method in their SDKs or a direct REST endpoint parameter to generate clean .vtt caption files with customized characters per caption.
• Deepgram : Known for ultra-low latency and high-accuracy speech models, Deepgram provides direct documentation and native parameters to output transcripts formatted in WebVTT and SRT.
• Google Cloud Speech-to-Text V2 : Supports native caption generation via its BatchRecognize operations, allowing you to request WebVTT outputs saved straight to a Cloud Storage bucket or returned inline.
• Azure AI Speech Services : Microsoft offers robust speech-to-text transcription capabilities that can programmatically output real-time or batch WebVTT streams suited for HTML5 video integration.

To help narrow down the best fit, tell me:

• Are you generating the audio first via TTS and then trying to align timestamps, or do you have existing audio/video files you need to transcribe?
• Are you looking for a batch processing workflow or real-time streaming captions?

Yes. The key distinction is whether you need TTS + subtitle timestamps in one API, or you're okay generating the audio first and producing VTT separately.

Best fit: ElevenLabs

For your use case, ElevenLabs is probably the cleanest option. Its TTS API has a with-timestamps endpoint that returns the generated audio plus timing information for the spoken characters.

You can then convert those timestamps into WebVTT cues for your video player. If you already have audio and text, ElevenLabs also has Forced Alignment, which produces word-level timing specifically for synchronizing subtitles with media.

There is an additional advantage if you're doing dubbing/video workflows: ElevenLabs' transcript API can directly return WebVTT (webvtt) or SRT.

Google Cloud

Google Cloud TTS is strong for large-scale multilingual synthesis, with 380+ voices across 75+ languages/variants. cloud.google.comdocs.cloud.google.comdeveloper.mozilla.org However, its TTS timepoint functionality is based around SSML <mark> tags rather than directly producing VTT.

Google does have a separate Speech-to-Text API that directly generates WebVTT and SRT, but that's intended for transcribing generated/recorded audio rather than TTS itself.

What I'd choose

For a video player, the resulting file can simply be a standard .vtt track; WebVTT cues contain start/end timestamps and the subtitle text.

Architecture I'd recommend:
text → ElevenLabs TTS → audio + timestamps → VTT generator → video player

If you tell me your stack (Node, Python, Go, etc.), I can also give you a minimal implementation that calls the TTS API and emits a ready-to-use .vtt file.

Most standard Text-to-Speech (TTS) APIs (such as standard Google Cloud TTS, Amazon Polly, or ElevenLabs) do not natively output a complete .vtt file out-of-the-box. Instead, they return an audio stream paired with raw word-level or character-level time offset metadata.

To get a VTT file, you generally have to use an API that supports time offsets/marks, and then write a short script to format those timestamps into the WebVTT standard structure, or use a specialized helper library.

The best approaches and APIs to achieve this include:

• Amazon Polly with the Polly Subtitle Generator : While Polly's core API only outputs audio and timing marks, AWS provides an official open-source utility (amazon-polly-closed-caption-subtitle-generator ) designed explicitly to parse text input and output synchronized .vtt and .srt files alongside audio.
• Google Cloud Text-to-Speech API : You can request time offsets by injecting <mark> tags into SSML input or utilizing the v1beta1 features to return timepoints. Your backend then maps these marks into standard WebVTT cue syntax.
• The "Two-Step" Alternative (TTS + STT) : Many development teams bypass formatting limits by generating the audio via a high-end TTS engine (like ElevenLabs or OpenAI TTS) and then passing the resulting audio file through a Speech-to-Text API that does natively export VTT/SRT (such as AssemblyAI, Deepgram , or Google Cloud Speech-to-Text V2).

If you'd like to narrow this down, please let me know:

• Are you looking for a direct one-step API/library (like Polly's wrapper), or do you already have a preferred TTS voice provider in mind?
• Do you need word-by-word karaoke highlighting or standard sentence-level subtitle chunks in the VTT file?

If your requirement is specifically “send text → get natural-sounding audio + timing data → produce a .vtt file for our video player,” I’d shortlist these:

My recommendation: ElevenLabs

ElevenLabs has a dedicated TTS-with-timestamps endpoint that returns both the generated audio and character-level start/end timestamps. That gives you everything needed to construct WebVTT cues on your server.

The basic architecture would be:

Your text
   ↓
ElevenLabs TTS + timestamps
   ↓
audio + character timing
   ↓
your VTT formatter
   ↓
audio.mp3 + subtitles.vtt
   ↓
HTML5 / video player

This is particularly useful if your subtitles need to track the exact generated speech, rather than simply displaying the source text at approximate timings.

If VTT generation itself is the priority

Deepgram is worth a close look. Its caption tooling explicitly generates WebVTT and SRT from timestamped transcripts, including helpers for serializing the timing data into a .vtt file.

One caveat: Deepgram's documented VTT workflow is primarily speech-to-text → captions, whereas your requirement sounds like text-to-speech → captions. So you'd likely want to use the TTS output and then obtain/derive its timing rather than treating Deepgram's transcription endpoint as the primary TTS timing mechanism. Deepgram does have a separate Aura TTS API.

Important implementation detail

You don't actually need an API that returns a .vtt file directly. For a video-player integration, timestamped TTS output is arguably the better API contract:

{
  "audio": "...",
  "timing": [
    { "text": "Hello", "start": 0.00, "end": 0.42 },
    { "text": "world", "start": 0.43, "end": 0.81 }
  ]
}

You can then group words/characters into cues such as:

WEBVTT

00:00:00.000 --> 00:00:01.200
Hello world

That gives you control over cue duration, line length, punctuation, reading speed, and styling instead of locking your player to whatever subtitle segmentation the provider chooses.

If you tell me your expected volume (e.g. 1,000 videos/month), languages, and whether you need word-level or sentence-level highlighting, I can compare the best APIs on pricing, latency, voice quality, and implementation complexity.

If you need text-to-speech (TTS) plus WebVTT (.vtt) subtitle generation for a video player, look for an API that returns word- or character-level timestamps. The TTS engine usually generates the audio; the timestamps are then converted into WebVTT cues. WebVTT is a standard timed-text format supported by HTML5 video players via <track> elements.

Good options:

Details:

1. ElevenLabs (simple TTS + timestamps)

ElevenLabs has a TTS endpoint that returns audio plus alignment data containing character timing information, which you can transform into .vtt cues. It also supports streaming responses with timestamps.

Typical pipeline:

Text
  ↓
TTS API
  ↓
Audio + timestamp alignment
  ↓
VTT generator
  ↓
video_player.load(audio, subtitles.vtt)

You would generate something like:

WEBVTT

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

00:00:02.500 --> 00:00:05.000
Today we will explore the new features.

2. AWS stack (more built-in subtitle handling)

If you need a production video workflow, AWS can pair speech generation with transcription/captioning. Amazon Transcribe supports WebVTT output as a subtitle format.

A common architecture:

Amazon Polly
      ↓
Generated narration audio
      ↓
Amazon Transcribe
      ↓
WebVTT (.vtt)
      ↓
Video player

3. Google Cloud

Google Cloud Speech-to-Text supports caption outputs including WebVTT and SRT formats for audio/video workflows.

---

For a video player integration, I would choose based on your needs:

• Fastest implementation: ElevenLabs timestamps → small VTT conversion service.
• Large-scale media platform: AWS or Google Cloud pipeline.
• Need subtitles in multiple languages: TTS + translation + timestamp alignment layer.

If you tell me your stack (HTML5 player, React, Video.js, Mux, Shaka, iOS/Android, etc.) and whether you need word-by-word highlighting or only normal subtitle cues, I can suggest the API design.

Most Text-to-Speech (TTS) APIs do not natively output a ready-to-use .vtt file out of the box because TTS takes text and generates audio , whereas a VTT file requires precise audio timestamps mapped back to text segments.

However, you have two reliable architecture patterns to achieve this: using a TTS API that provides word-level timestamps (and writing a lightweight script to format them into VTT), or using a standard 2-step pipeline.

Option 1: TTS APIs with Built-in Timestamp Support

Some advanced TTS providers return character- or word-level audio offset timestamps during generation. You can take these offsets and programmatically compile them into a WebVTT structure (using '.' for milliseconds instead of commas, and starting with WEBVTT).

• ElevenLabs API : Offers dedicated TTS endpoints that return precise timing and character/word-level offsets in both streaming and non-streaming requests. You can parse these offsets to build your VTT blocks.
• Microsoft Azure AI Speech Services : Fires WordBoundary events containing exact audio offsets during speech synthesis, which can be logged and converted into a .vtt track file.
• Google Cloud Text-to-Speech : Allows you to inject SSML <mark> tags into your input text to retrieve audio coordinate timestamps for synchronization.

Option 2: The Standard Pipeline (TTS → Speech-to-Text)

If you already know the exact text you are synthesizing, the most robust industry workaround is to generate the audio file via your preferred TTS engine, and then pass that generated audio file through a Speech-to-Text (STT) API that natively exports WebVTT. STT platforms are purpose-built to output millisecond-accurate .vtt and .srt files.

• AssemblyAI : Send the generated audio file to AssemblyAI and call .export_subtitles_vtt() to instantly get a clean, compliant WebVTT file.
• Deepgram : Provides native WebVTT and SRT caption generation parameters directly in their transcription responses.
• Google Cloud Speech-to-Text V2 : Supports direct output configuration parameters to export transcription results straight into WebVTT format.

To help narrow down the best implementation, are you trying to synthesize dynamic/real-time text on the fly, or are you pre-generating audio and subtitles for a static video library?