Text to Speech Read Aloud: Free Tools and API Code (2026)

A text to speech read aloud feature takes the words on your screen (a webpage, a PDF, an email, a chapter of a book) and speaks them in a synthetic voice, so you can listen instead of read. Most people searching for this want one of two things: a free way to have something read to them right now, or a way to turn text into an audio file they can keep, publish or build into an app. This post covers both. The first half shows the free readers already on your phone, browser and computer. The second half shows how to generate speech from code, what it costs per 1,000 characters, and the mistakes that make long audio sound wrong or cost more than it should.

What text to speech actually does

Text to speech (TTS) is software that turns written text into spoken audio. Older systems stitched together recorded fragments of speech or used rule-based synthesizers, which is why classic screen readers sound robotic. Modern TTS uses neural networks trained on large amounts of recorded speech. These models work out how a whole sentence should sound, including rhythm, stress and pauses, so the result is much closer to a person reading.

Every text to speech read process goes through roughly the same stages:

1. Text normalization. Numbers, dates, abbreviations and symbols are expanded into words. “Dr. Lee paid $40 on 3/4” has to become something speakable, and the system has to guess whether “3/4” is a date or a fraction.
2. Pronunciation. Words are mapped to sounds. Names, brands and technical terms are where this goes wrong most often.
3. Prosody. Prosody is the pitch, pace and emphasis of speech. It is the difference between a voice that sounds engaged and one that sounds like it is reading out a phone book.
4. Audio generation. The voice is rendered as sound and either played through your speakers or saved as a file.

A few related terms come up often. A screen reader is an accessibility tool that reads out the whole interface, buttons and menus included, for people who cannot see the screen. A read-aloud tool is narrower: it reads only the content you pick. SSML (Speech Synthesis Markup Language) is an XML format that some engines accept for controlling pauses, emphasis and pronunciation. You rarely need it for casual listening, but it matters once you produce audio at scale.

How to get text to speech read aloud on any device

You probably don’t need to install anything. Every major operating system and browser ships with a text to speech read option, and the built-in voices have improved a lot. Here is where to find each one.

Windows and Microsoft Edge

• Edge Read Aloud: open a webpage or PDF in Microsoft Edge and press Ctrl+Shift+U, or right-click and choose Read aloud. The toolbar that appears lets you change the voice and speed.
• Microsoft Word: on the Review tab, choose Read Aloud. Word highlights each word as it reads.
• Narrator: the full Windows screen reader, switched on and off with Windows+Ctrl+Enter. Use it when you need the whole interface spoken, not just one document.

Chrome and ChromeOS

Chrome’s Reading mode strips a page down to its text and adds a play button that reads it aloud. Open it from the side panel or by right-clicking the page. On Chromebooks, Select-to-speak in the accessibility settings reads any text you highlight.

Mac, iPhone and iPad

• Mac: go to System Settings, Accessibility, Spoken Content and turn on Speak selection. Then select text in any app and press Option+Esc.
• iPhone and iPad: go to Settings, Accessibility, Spoken Content. Speak Selection adds a Speak button when you highlight text. Speak Screen reads the whole page when you swipe down from the top with two fingers.

Android

Turn on Select to Speak under Settings, Accessibility. Tap its icon, then tap or drag over the text you want read. On many Android phones you can also ask Google Assistant to read the page that is open in Chrome.

Platform	Built-in option	How to start it
Windows / Edge	Read Aloud	Ctrl+Shift+U on a page or PDF
Microsoft Word	Read Aloud	Review tab, Read Aloud
Chrome	Reading mode	Side panel or right-click, then play
Mac	Speak selection	Select text, Option+Esc
iPhone / iPad	Speak Selection, Speak Screen	Highlight text, or two-finger swipe down
Android	Select to Speak	Tap the icon, then tap the text

For PDFs, the easiest free option on a desktop is to open the file in Edge and use Read Aloud. For ebooks, check whether the reading app you already use has a read-aloud mode before you look for a separate tool.

Can ChatGPT or Google read text aloud?

Yes, both can, with limits worth knowing.

ChatGPT can read its replies aloud in the web and mobile apps, and it has a voice mode where you talk and it answers out loud. Because it reads its own responses, hearing your own text means pasting it in and asking ChatGPT to repeat it word for word. That works for a paragraph or two. For a long document it is clumsy: the model may summarize or reword things, and you don’t get an audio file at the end.

Google has no single “read this” button, but several of its products cover the job: Reading mode in Chrome, Select to Speak on Android, and Google Assistant reading webpages on supported phones. Google also sells a cloud TTS service for developers, which is separate from these consumer features.

The same pattern holds for every assistant. They are fine when you want a quick text to speech read of something short. They are the wrong tool when you need consistent narration, a specific voice, a downloadable file, or hundreds of pieces of content processed automatically.

Free text to speech voices vs paid readers and APIs

The online readers, Chrome extensions and mobile apps at the top of search results mostly follow the same model: a free tier with basic voices, and a paid plan for realistic voices, longer limits and downloads. Before you pick one, it helps to know what you are comparing.

Option	Cost	Voice quality	Audio file?	Best for
Built-in OS and browser readers	Free	Decent to good, varies by device	No	Having pages, PDFs and docs read to you
Online reader sites	Free tier, paid upgrades	Basic voices free, premium voices paid	Often paid only	Pasting text for occasional listening
Browser extensions	Free tier, paid upgrades	Similar to online readers	Sometimes	Reading webpages and email in place
Assistants (ChatGPT, Google)	Included with the app	Good	No	Short passages, hands-free use
TTS API	Pay per character	Highest available, many voices	Yes, one per request	Apps, podcasts, narration, bulk audio

If you’re looking for text to speech voices for free, the built-in voices on your own device are the best option for personal listening. They have no word limit, need no account, and don’t upload your documents to someone else’s server. Free online tools make sense when you want a nicer voice for one short piece, but expect caps, sign-ups or limits on downloads.

Paid tools earn their place once the text to speech read becomes part of a product: an audio version of every blog post, narration for a course, voice prompts in an app, or a listen button for your users. At that point you want an API, a web endpoint your code sends text to and gets audio back from.

How to build a text to speech reader with an API

Unicorn API gives you one key and one bill for every model, and audio jobs are priced in credits. Three ElevenLabs speech models fit this job:

• ElevenLabs Text to Speech Turbo V2.5: 6 credits per 1,000 characters. The cheaper option and a sensible default for long reads.
• ElevenLabs Text to Speech Multilingual V2: 12 credits per 1,000 characters. Twice the price. Test it when you work in several languages or want to compare quality on your own content.
• ElevenLabs Text to Dialogue V3: 14 credits per request. It takes a list of lines, each with its own voice, which suits conversations rather than single-narrator reads.

Monthly plan credits cost $0.01 each, so Turbo V2.5 works out to $0.06 per 1,000 characters and Multilingual V2 to $0.12. Top-up credits cost $0.015 each and never expire. Plan details are on the pricing page, and the AI voice generator comparison covers voice choice in more depth.

Get a key and test voices

Create a key on the API keys page and export it as UNICORN_API_KEY. To hear the models before you write any code, the audio playground runs them in the browser.

Submit a job

Speech generation is asynchronous: you POST a job, get back an id, and poll until it finishes. Here is the minimal request in curl:

curl https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "elevenlabs-text-to-speech-turbo-2-5",
    "input": {
      "text": "Chapter one. The rain had not stopped for three days.",
      "voice": "EkK5I93UQWFDigLMpZcX"
    }
  }'

Then check the job with GET /v1/jobs/{id}. When status is "succeeded", the audio URL is at outputs[0].url.

Read long text in chunks

Send a full article or book chapter in pieces. A failed piece is cheaper to retry, and you can start playback before the end is ready. This Python script packs whole paragraphs into chunks of up to 3,000 characters, generates each chunk, and prints the audio URLs in order.

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}
MODEL = "elevenlabs-text-to-speech-turbo-2-5"
VOICE = "EkK5I93UQWFDigLMpZcX"
MAX_CHARS = 3000  # billing rounds up per 1,000 characters, so cap at a multiple


def chunk_text(text, max_chars=MAX_CHARS):
    """Pack whole paragraphs into chunks of at most max_chars.
    A single paragraph longer than max_chars is sent as its own chunk."""
    chunks, current = [], ""
    for para in [p.strip() for p in text.split("\n\n") if p.strip()]:
        candidate = f"{current}\n\n{para}" if current else para
        if len(candidate) <= max_chars:
            current = candidate
        else:
            if current:
                chunks.append(current)
            current = para
    if current:
        chunks.append(current)
    return chunks


def speak(text, previous_text=None, next_text=None):
    payload = {"model": MODEL, "input": {"text": text, "voice": VOICE}}
    if previous_text:
        payload["input"]["previous_text"] = previous_text
    if next_text:
        payload["input"]["next_text"] = next_text

    r = requests.post(f"{API}/v1/jobs", json=payload, headers=HEADERS, timeout=30)
    r.raise_for_status()
    job_id = r.json()["id"]

    while True:
        job = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS, timeout=30).json()
        if job["status"] == "succeeded":
            return job["outputs"][0]["url"]
        if job["status"] == "failed":
            raise RuntimeError(f"Job {job_id} failed: {job}")
        time.sleep(2)


if __name__ == "__main__":
    with open("article.txt", encoding="utf-8") as f:
        chunks = chunk_text(f.read())

    for i, chunk in enumerate(chunks):
        prev = chunks[i - 1][-300:] if i > 0 else None
        nxt = chunks[i + 1][:300] if i + 1 < len(chunks) else None
        url = speak(chunk, prev, nxt)
        print(f"{i + 1:02d}  {len(chunk):5d} chars  {url}")

The previous_text and next_text fields pass in the text around a chunk, so its intonation follows on from the sentences before and after it instead of sounding like a fresh start. Only the length of text affects the price, so this context costs nothing extra. The full field list for each model, including speed, stability, style, similarity_boost, language_code and timestamps, is in the API documentation. If you work in Cursor or Claude Code, your coding agent can call the same models over MCP. See agents for setup.

Worked example: turning a blog post into audio

Say you want a listen button on a 9,400-character blog post. Here is what a text to speech read of that post costs, and how chunking changes the bill.

Both speech models price each request as the per-1,000 rate times the character count divided by 1,000, rounded up. So a 9,400-character request is billed as 10 blocks.

Setup	Blocks billed	Credits	On a plan ($0.01)	With top-ups ($0.015)
Turbo V2.5, chunks of 2,950 + 2,880 + 2,710 + 860	3 + 3 + 3 + 1 = 10	60	$0.60	$0.90
Multilingual V2, same chunks	10	120	$1.20	$1.80
Turbo V2.5, eight chunks of about 1,200	15	90	$0.90	$1.35

The last row is the trap. Seven chunks of 1,200 characters each spill just past a block boundary, so each one costs two blocks, and the bill comes out 50% higher for the same audio. Cap chunks at a multiple of 1,000 characters, as the script does, and only the final chunk can waste part of a block.

At this size, the Starter plan ($25 for 2,500 credits) covers about 41 posts a month on Turbo V2.5, or about 20 on Multilingual V2. If your content mixes languages, generate one post with each model and compare before you commit. The extra cost per post is small, but it adds up across a whole archive.

To check the exact price of any request before you run it, use POST /v1/models/price. That helps when you’re queueing up a backlog of hundreds of articles.

For a two-voice format, such as a host and a guest discussing the post, Text to Dialogue V3 takes a dialogue array of lines, each with its own voice, at 14 credits per request:

curl https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "elevenlabs-text-to-dialogue-v3",
    "input": {
      "dialogue": [
        {"text": "So what is this post actually about?", "voice": "EkK5I93UQWFDigLMpZcX"},
        {"text": "How to have any page read aloud, for free or by API.", "voice": "EkK5I93UQWFDigLMpZcX"}
      ]
    }
  }'

Swap the second voice for a different voice id to get two distinct speakers.

Common mistakes that make TTS sound wrong

Most bad text to speech read output comes from the input, not the model. These are the problems that come up most often:

• Sending raw HTML or Markdown. The voice will read out link URLs, image alt text, table cells in odd order, and sometimes the symbols themselves. Strip markup and turn tables into sentences first.
• Leaving numbers and abbreviations ambiguous. “1/2”, “St.”, “10m” and “v2” can each be read more than one way. Write out the version you mean (“half”, “Street”, “10 minutes”) anywhere it matters.
• Splitting mid-sentence. A chunk that starts halfway through a thought sounds like it does. Split on paragraph boundaries, and pass previous_text and next_text.
• Changing settings between chunks. Keep the same voice, model, speed and stability across a piece, or the narrator will seem to change partway through.
• Ignoring the rounding. A 1,001-character request is billed as two blocks. Chunk sizes should land just under multiples of 1,000.
• Using a chat assistant for long documents. It may summarize or reword. For faithful reading, use a reader or an API that speaks exactly the text you send.
• Uploading private documents to free sites. Contracts, medical letters and internal documents are safer with your device’s built-in reader, which doesn’t send the file anywhere.
• Not listening to the output. Spot-check names and technical terms in the first generated file before you batch the rest.

Which text to speech read option should you use?

Pick based on what you need at the end:

• You want to listen to something now: use your device’s built-in reader. Edge Read Aloud for PDFs, Chrome Reading mode for articles, Speak Screen on iPhone, Select to Speak on Android.
• You want a nicer voice for a short piece: a free online reader or extension is fine, within its limits.
• You want audio files, or a listen feature in your own product: use an API. Start with Turbo V2.5 at 6 credits per 1,000 characters, compare it with Multilingual V2 on your own content, and chunk at multiples of 1,000 characters.

The same key also covers music, image, video and chat models if your project grows beyond speech. The full list is in the model catalog. For most people, the free reader on their own device handles the everyday text to speech read, and the API takes over once the audio has to be saved, shared or shipped.