Does this tool upload my .epub anywhere?

No. Everything happens in your browser using the Web Platform's own DecompressionStream API. The file is read locally and never sent over the network. Only the finished text ever leaves your machine, and only if you choose to copy or download it.

Does it get the chapter order right?

Yes. Chapters come out in the order the OPF's defines, which is the book's own declared reading order. Zip entry order is never used. A spine-first book with its files written to the archive out of order still reads correctly.

Where do the chapter titles come from?

From the book's own table of contents: the EPUB 3 navigation document when one exists, otherwise the older EPUB 2 NCX file. A chapter with no entry in either falls back to its own first heading, or shows as untitled rather than a guess.

What happens with a DRM-protected book?

An honest refusal naming the reason. If META-INF/encryption.xml covers the book's actual text, this tool says so plainly and stops. Neither this tool nor txtfetch's API can read DRM-protected content, and removing DRM isn't something we do. A book that only encrypts its embedded fonts, a common and harmless scheme, still extracts normally, with a note.

What about a fixed-layout EPUB, where pages are really images?

Named honestly, rather than returned as an empty success. A fixed-layout (pre-paginated) book's pages are typically images with little or no real text behind them. This tool says so and points at OCR, the same answer as a scanned PDF.

Does it work on .mobi or .azw Kindle files?

Not this in-browser tool; it reads EPUB's zip-of-XHTML structure specifically. txtfetch's API extracts .mobi and .azw through Apache Tika's own parsers. EPUB is the best-tested path today.

Is there a file size limit?

This tool reads up to 25 MB entirely in your browser. Larger books, or a batch you want to automate, go through the same extraction via the API, which has no such limit.

Your EPUB, as text. In the book's real reading order.

Drop a real .epub below. Watch it become plain text right here, in your browser. It follows the order the book actually defines, not the order the zip happens to store it in. Nothing is uploaded. It's the same read txtfetch's API gives you, just local.

Drop a real .epub below to see its plain text, chapter by chapter, in the book's actual reading order. It runs entirely in your browser, and nothing is uploaded.

txtfetch — extract

Extracted text

The exact API call for :

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-epub

An EPUB is a zip archive of XHTML files. Reading order lives in exactly one place: the OPF's <spine>, a list of manifest items by id. It has nothing to do with the order those files happen to sit in the zip. Unzip an EPUB and read the files in whatever order the archive lists them, and you get real problems. Chapters come out shuffled. The navigation document ends up mixed in with the story. The cover page and copyright boilerplate land wherever the packaging tool happened to write them.

Every book also carries a table of contents, but which one depends on when it was made. EPUB 3 books ship a real XHTML nav document with a marked-up <nav> element, its epub:type set to "toc". Older EPUB 2 books use a separate NCX file with its own <navMap> of nested <navPoint> elements. A reader built for only one format loses chapter titles on every book using the other.

Then there's the DRM question, which most converters get wrong in both directions. A META-INF/encryption.xml file in the archive doesn't necessarily mean the book is locked. Plenty of legitimately-downloaded EPUBs use it only to obfuscate their embedded fonts, a common scheme with no effect on the text. Treating every encrypted entry as a dead book fails on those. Treating true content encryption as readable produces garbage. Telling the two apart means checking exactly what encryption.xml's cipher references point at, not just whether the file exists.

what-to-do-next

Got the text out and want the API call for it directly? The panel above already has it, with your book's real name. Extracting many books, or files bigger than this browser tool's 25 MB cap? See the full EPUB extraction guide →

faq

Does this tool upload my .epub anywhere?: No. Everything happens in your browser using the Web Platform's own DecompressionStream API. The file is read locally and never sent over the network. Only the finished text ever leaves your machine, and only if you choose to copy or download it.
Does it get the chapter order right?: Yes. Chapters come out in the order the OPF's <spine> defines, which is the book's own declared reading order. Zip entry order is never used. A spine-first book with its files written to the archive out of order still reads correctly.
Where do the chapter titles come from?: From the book's own table of contents: the EPUB 3 navigation document when one exists, otherwise the older EPUB 2 NCX file. A chapter with no entry in either falls back to its own first heading, or shows as untitled rather than a guess.
What happens with a DRM-protected book?: An honest refusal naming the reason. If META-INF/encryption.xml covers the book's actual text, this tool says so plainly and stops. Neither this tool nor txtfetch's API can read DRM-protected content, and removing DRM isn't something we do. A book that only encrypts its embedded fonts, a common and harmless scheme, still extracts normally, with a note.
What about a fixed-layout EPUB, where pages are really images?: Named honestly, rather than returned as an empty success. A fixed-layout (pre-paginated) book's pages are typically images with little or no real text behind them. This tool says so and points at OCR, the same answer as a scanned PDF.
Does it work on .mobi or .azw Kindle files?: Not this in-browser tool; it reads EPUB's zip-of-XHTML structure specifically. txtfetch's API extracts .mobi and .azw through Apache Tika's own parsers. EPUB is the best-tested path today.
Is there a file size limit?: This tool reads up to 25 MB entirely in your browser. Larger books, or a batch you want to automate, go through the same extraction via the API, which has no such limit.

That was one file. The API does the queue.

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

Read the quickstart →

Get an API key →