Does this tool upload my video or audio file anywhere?

No. Everything happens in your browser. The file's caption track, or for a plain subtitle file its text, is read locally with a hand-rolled MP4/Matroska/ID3/WAV reader. It's never sent over the network. Only the finished transcript ever leaves your machine, and only if you choose to copy or download it.

Does it transcribe speech from the audio or video?

No. Just like txtfetch's API, this tool does not transcribe audio or video. Nothing here listens to audio and guesses words. It reads TEXT that already exists in the file: an embedded caption or subtitle track, or tags like ID3 lyrics. If your file has no caption track, the verdict says so plainly, with a concrete next step. Run it through a speech-to-text tool, such as whisper.cpp or a hosted ASR API, to produce a .srt. Then bring that back here, or send it straight to the API.

What does txtfetch's API return for a video or audio file?

txtfetch's API is a text extractor. A successful response carries the extracted text plus the content type, byte count, character count, and whether OCR ran. It has no field for tags, durations, or track lists, and it never transcribes speech. For a media file with no text in it, expect an extraction error rather than a transcript or a tag dump. A .srt or .vtt file is different. It's a plain text file, so it goes through the API like any other text file. Raw cue numbers and timestamps are included, since the API doesn't clean captions the way this tool does.

Which containers and caption formats does it read?

Two container families: MP4/QuickTime (.mp4/.mov/.m4v), reading tx3g, QuickTime text, WebVTT-in-MP4, and TTML-in-MP4 tracks, and Matroska/WebM (.mkv/.webm), reading S_TEXT/UTF8, S_TEXT/ASS, and S_TEXT/WEBVTT tracks. It also reads MP3 and WAV for their metadata tags. Standalone caption formats covered: .srt, .vtt, .ass/.ssa, .ttml/.dfxp, or pasted subtitle text.

What about burned-in captions, or bitmap subtitle formats like VobSub/PGS?

Named honestly, not decoded. Burned-in captions are pixels painted into the video frame; there's no separate text to read at all. VobSub (.sub/.idx) and Blu-ray/DVD PGS subtitles ARE a separate track, but it's a track of IMAGES of text, not text. This tool flags them as bitmap subtitles rather than attempting to guess at them. OCR is the honest next step; see the image extraction guide.

Can I paste a YouTube URL instead of a file?

No. This tool can't fetch a URL itself; that's a browser sandbox restriction (CORS) every client-side tool on this site shares. Download the video or its caption file first, then drop it here.

Is there a file size limit?

This tool reads up to 25 MB entirely in your browser. It has its own caps on cue count and container-box counts. So a malformed or hostile file can't hang the tab. For a subtitle file, larger inputs, or a batch you want to automate, go through the API, which has no such limit. For a video or audio file, sending it to the API won't get you this tool's transcript. The API extracts text, and never transcribes speech.

Your video's captions, as a real transcript.

Drop a real .mp4/.mkv/.mp3/.wav or an .srt/.vtt/.ass/.ttml file below. Watch its caption track become clean, readable prose right here, in your browser. No caption track? You get the honest verdict instead of a guess.

Drop an .mp4/.mov/.mkv/.webm/.mp3/.wav, an .srt/.vtt/.ass/.ttml file, or paste subtitle text below. See the clean transcript it extracts to. It runs entirely in your browser, and nothing is uploaded.

txtfetch — extract

transcript

curl

curl -X POST https://api.txtfetch.com/v1/extract \
  -H "Authorization: Bearer $TXTFETCH_KEY" \
  -F file=@__FILENAME__

Python

import os
import requests

with open("__FILENAME__", "rb") as f:
    r = requests.post(
        "https://api.txtfetch.com/v1/extract",
        headers={"Authorization": f"Bearer {os.environ['TXTFETCH_KEY']}"},
        files={"file": f},
    )

print(r.json()["extracted_text"])

JavaScript

import { readFile } from "node:fs/promises";

const file = new Blob([await readFile("__FILENAME__")]);
const form = new FormData();
form.append("file", file, "__FILENAME__");

const res = await fetch("https://api.txtfetch.com/v1/extract", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.TXTFETCH_KEY}` },
  body: form,
});

const { extracted_text } = await res.json();
console.log(extracted_text);

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
)

type extractResponse struct {
	Status        string `json:"status"`
	ExtractedText string `json:"extracted_text"`
}

func main() {
	f, err := os.Open("__FILENAME__")
	if err != nil {
		panic(err)
	}
	defer f.Close()

	var body bytes.Buffer
	writer := multipart.NewWriter(&body)
	part, err := writer.CreateFormFile("file", "__FILENAME__")
	if err != nil {
		panic(err)
	}
	if _, err := io.Copy(part, f); err != nil {
		panic(err)
	}
	writer.Close()

	req, err := http.NewRequest("POST", "https://api.txtfetch.com/v1/extract", &body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("TXTFETCH_KEY"))
	req.Header.Set("Content-Type", writer.FormDataContentType())

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	var result extractResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		panic(err)
	}
	fmt.Println(result.ExtractedText)
}

whats-hard-about-captions

A caption track is not a transcript. It's short cue fragments, each with its own cue number, start and end timestamp, and markup like <i>, <v Speaker>, and {\an8} position overrides. A naive read prints all of that verbatim: numbers, arrows, and tags mixed in with the words. This tool strips the framing and keeps the words.

Live and rolling captions make it worse. Many pipelines emit the SAME sentence two or three times, each cue a little longer than the last, as words arrive. First "Hello", then "Hello world", then "Hello world today". Read naively, a two-second sentence becomes three near-duplicate lines. This tool detects the overlap and keeps only the longest form.

The fragment itself rarely lines up with a sentence, either. Captions are cut to fit a screen width and a roughly two-second reading window, not to grammar. This tool re-joins fragments into real sentences and paragraphs using punctuation and timing gaps. It also normalises speaker turns, a WebVTT <v Name> tag or a NAME: prefix, into one consistent form.

One thing no amount of clean-up can fix: a video or audio file with no caption track has no text in it at all. Speech isn't text until something transcribes it. This tool, and txtfetch's API, reads what's already text in the file. Neither one ever reads audio.

no-captions-what-now

If the tool above told you your file has no text subtitle track, that's the honest answer, not a bug. Audio and video don't contain text, only sound. Neither this tool nor txtfetch's API listens to that sound and guesses at words. The audio & video row on /formats spells this out plainly: txtfetch does not transcribe audio or video. The API is a text extractor. A successful response carries the extracted text, the content type, the byte count, the character count, and whether OCR ran. It has no field for tags, a duration, or a track list. Send it a video with no text in it and you get an extraction error, not a transcript.

The fix is a real speech-to-text (ASR) step, run separately. Something like whisper.cpp locally, or a hosted speech-to-text API, will hand you back a .srt or .vtt file. Bring that file back to this tool for a clean transcript, or straight to txtfetch's API. A subtitle file is a text file, so it goes through the API like any other text file.

One more honest distinction: bitmap subtitle formats (VobSub .sub/.idx, Blu-ray/DVD PGS) ARE a real subtitle track. But it's a track of images of text, not text. This tool names them as such rather than guessing. OCR (see the image extraction guide) is the real next step for those, not ASR.

what-to-do-next

Got a clean transcript out and want the API call for the exact file you dropped? The panel above already has it, with your file's real name. Feeding this into a RAG pipeline next? See how it chunks → Working with a file bigger than this browser tool's 25 MB cap, or automating a whole batch? See the full audio & video extraction guide →

faq

Does this tool upload my video or audio file anywhere?: No. Everything happens in your browser. The file's caption track, or for a plain subtitle file its text, is read locally with a hand-rolled MP4/Matroska/ID3/WAV reader. It's never sent over the network. Only the finished transcript ever leaves your machine, and only if you choose to copy or download it.
Does it transcribe speech from the audio or video?: No. Just like txtfetch's API, this tool does not transcribe audio or video. Nothing here listens to audio and guesses words. It reads TEXT that already exists in the file: an embedded caption or subtitle track, or tags like ID3 lyrics. If your file has no caption track, the verdict says so plainly, with a concrete next step. Run it through a speech-to-text tool, such as whisper.cpp or a hosted ASR API, to produce a .srt. Then bring that back here, or send it straight to the API.
What does txtfetch's API return for a video or audio file?: txtfetch's API is a text extractor. A successful response carries the extracted text plus the content type, byte count, character count, and whether OCR ran. It has no field for tags, durations, or track lists, and it never transcribes speech. For a media file with no text in it, expect an extraction error rather than a transcript or a tag dump. A .srt or .vtt file is different. It's a plain text file, so it goes through the API like any other text file. Raw cue numbers and timestamps are included, since the API doesn't clean captions the way this tool does.
Which containers and caption formats does it read?: Two container families: MP4/QuickTime (.mp4/.mov/.m4v), reading tx3g, QuickTime text, WebVTT-in-MP4, and TTML-in-MP4 tracks, and Matroska/WebM (.mkv/.webm), reading S_TEXT/UTF8, S_TEXT/ASS, and S_TEXT/WEBVTT tracks. It also reads MP3 and WAV for their metadata tags. Standalone caption formats covered: .srt, .vtt, .ass/.ssa, .ttml/.dfxp, or pasted subtitle text.
What about burned-in captions, or bitmap subtitle formats like VobSub/PGS?: Named honestly, not decoded. Burned-in captions are pixels painted into the video frame; there's no separate text to read at all. VobSub (.sub/.idx) and Blu-ray/DVD PGS subtitles ARE a separate track, but it's a track of IMAGES of text, not text. This tool flags them as bitmap subtitles rather than attempting to guess at them. OCR is the honest next step; see the image extraction guide.
Can I paste a YouTube URL instead of a file?: No. This tool can't fetch a URL itself; that's a browser sandbox restriction (CORS) every client-side tool on this site shares. Download the video or its caption file first, then drop it here.
Is there a file size limit?: This tool reads up to 25 MB entirely in your browser. It has its own caps on cue count and container-box counts. So a malformed or hostile file can't hang the tab. For a subtitle file, larger inputs, or a batch you want to automate, go through the API, which has no such limit. For a video or audio file, sending it to the API won't get you this tool's transcript. The API extracts text, and never transcribes speech.

That was one file. The API does the queue.

This page read your subtitle on your own machine. The API reads a folder of them.

Read the quickstart →

Get an API key →