Text to Speech App (2026): Pick One or Build Your Own

A text to speech app reads written words aloud, and the right one depends on what you want to listen to and where. If you just want your phone to read an article while you cook, you probably already have a capable reader installed. If you want lifelike voices for a podcast, an audiobook draft or a feature inside your own product, you need something different: a speech model you can call from code. This guide covers both, with concrete settings for iPhone, Android and PC, a way to choose between paid apps, and a working Python example for building your own reader.

What a text to speech app actually does

Text to speech (TTS) is software that converts written text into spoken audio. Every text to speech app does three jobs, and the quality of each one decides whether you enjoy listening or give up after two minutes.

1. Getting the text. The app has to pull clean text out of a web page, PDF, ebook, email or photo. Photos and scanned pages need OCR (optical character recognition), which turns an image of letters into actual text. This step is where most apps fail quietly: they read page numbers, footers, image captions and navigation menus aloud.
2. Normalising the text. “Dr.” might be “doctor” or “drive”. “1/2” might be a fraction or a date. The engine expands numbers, abbreviations and symbols into words before it speaks.
3. Synthesising the voice. Older engines stitched together recorded fragments of speech, which is why they sound choppy. Modern neural voices are generated by a model that predicts pitch, timing and emphasis from the surrounding sentence, so they sound much closer to a person reading.

You will also see SSML mentioned in settings and documentation. SSML (Speech Synthesis Markup Language) is an XML format for giving a speech engine instructions such as “pause here” or “spell this out”. Consumer apps rarely expose it, but it explains why some apps let you add pronunciation rules.

On top of those three jobs, a good reader app adds the things that make long listening comfortable: adjustable speed, a highlight that follows the spoken word, a library that remembers your place, and offline playback.

Free text to speech app options already on your device

Before you download anything, try the reader your operating system ships with. For short articles and emails, a built-in reader is often the best free text to speech app you can get, because it works everywhere on the device without importing files.

Text to speech app for iPhone and iPad

Open Settings, then Accessibility, then Spoken Content. Turn on Speak Selection to get a “Speak” button whenever you highlight text, and Speak Screen to have the whole screen read when you swipe down with two fingers from the top. You can download higher-quality voices from the same menu and set a default speaking rate. Speak Screen works in Safari, Mail, Books and most PDF viewers, though it may read page furniture you would rather skip.

Text to speech app for Android

Android’s reader is called Select to Speak, found under Settings, then Accessibility. Once enabled, you tap its shortcut and then tap or drag over anything on screen to hear it. The voice comes from the device’s speech engine, usually Speech Recognition and Synthesis from Google, which also powers reading in other apps such as Google Play Books. You can change the engine, language and rate under the text-to-speech output settings.

Text to speech app for PC and Mac

On Windows, Narrator is a full screen reader, which is more than most people need for casual listening. For articles, the Read aloud option in Microsoft Edge is simpler and uses natural-sounding voices. On a Mac, Spoken Content lives in System Settings under Accessibility, and once “Speak selection” is on you can highlight text and press the keyboard shortcut (Option and Esc by default) to hear it.

The limits of built-in readers are consistent across platforms: weak PDF handling, no library or bookmarks, no export to an audio file, and voices that vary in quality by language.

How to choose the best text to speech app

Once the built-in reader stops being enough, you are choosing between dedicated reader apps (such as Voice Dream Reader, Speech Central, NaturalReader or Speechify) and building something yourself with an API. Rankings of the best text to speech app change every year, so judge apps on the criteria that matter for your use rather than on a list position.

• Input formats. If you mostly listen to PDFs or scanned pages, OCR and clean PDF parsing matter more than anything else. Test with your worst document, not a tidy web article.
• Voice quality over a long session. A voice that sounds fine for one sentence can become tiring over an hour. Listen to ten minutes before deciding.
• Offline and privacy. Some apps run voices on the device; others send your text to a server. If you read contracts, medical notes or unpublished work, check which kind you are using.
• Pricing model. Consumer apps typically use either a one-time purchase or a subscription, and free tiers usually cap hours, voices or features. Read where the free plan stops before you build a habit around it.
• Export. Many reader apps play audio but will not give you an MP3 you can publish. If you need files, you need an app that exports, or an API.

Option	Best for	Main limitation
Built-in reader (Spoken Content, Select to Speak, Narrator)	Quick listening to web pages and email, free	Messy PDFs, no library, no audio export
Dedicated reader app	Books, long PDFs, study, accessibility	Subscription or purchase; usually personal use only
Online TTS website	One-off conversions without installing anything	Character caps, uploads go to a third party
Speech API	Publishing audio, batch jobs, your own product	Needs a little code; you pay per character

Students and people with dyslexia or low vision usually do best with a dedicated reader app, because word highlighting and saved positions matter more than voice variety. Creators, developers and anyone producing audio for other people usually end up at the last row.

When to build your own text to speech app with an API

A reader app is designed for one person listening. The moment your needs look like a pipeline, an API is the more practical text to speech app. Typical signs:

• You want to turn every new blog post into an audio version automatically.
• You are drafting an audiobook or course and need consistent files per chapter.
• You need several languages from the same script.
• You want a scripted conversation with two or more voices, for a podcast intro or a language-learning dialogue.
• You are adding a “listen” button to your own website or app.

Unicorn API gives you one key and one credit balance for speech, music, image, video and chat models. For speech, three models cover most needs:

• Elevenlabs Text to Speech Turbo V2.5 at 6 credits per 1,000 characters. The cheaper choice for long-form reading where cost per hour of audio matters.
• Elevenlabs Text to Speech Multilingual V2 at 12 credits per 1,000 characters. Built for multiple languages; set language_code to pin the language.
• Elevenlabs Text to Dialogue V3 at a flat 14 credits per request. Takes a list of lines, each with its own voice, and returns one conversation.

Both single-voice models accept the same input fields: text, voice, speed, stability, similarity_boost, style, language_code, timestamps, and two context fields, previous_text and next_text, which help intonation stay natural when you split a long document into pieces. If you want a background bed under narration, Ai Music API Sounds generates short tracks at 2.5 credits each.

You can try any of these voices in the browser at the audio studio before writing code, which is the fastest way to pick a voice and speed.

Build a simple text to speech app in Python

Here is a complete, minimal text to speech app: it reads a text file, splits it into chunks on paragraph boundaries, sends each chunk to the speech model as a job, waits for it to finish and saves the audio. Media models on Unicorn API are asynchronous: you POST to /v1/jobs, then poll GET /v1/jobs/{id} until the status is "succeeded", then read outputs[0].url.

First, create a key at your API keys page and export it as UNICORN_API_KEY.

import os
import sys
import time
import requests
from urllib.parse import urlparse

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}
MODEL = "elevenlabs-text-to-speech-turbo-2-5"
VOICE = "EkK5I93UQWFDigLMpZcX"
CHUNK_LIMIT = 3000  # characters; check /docs for the per-request maximum


def chunk_paragraphs(text, limit=CHUNK_LIMIT):
    """Pack whole paragraphs into chunks of at most `limit` characters."""
    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) <= limit:
            current = candidate
        else:
            if current:
                chunks.append(current)
            current = para
    if current:
        chunks.append(current)
    return chunks


def run_job(body, poll_seconds=2, max_wait=300):
    r = requests.post(f"{API}/v1/jobs", json=body, headers=HEADERS, timeout=30)
    r.raise_for_status()
    job = r.json()
    waited = 0
    while job["status"] != "succeeded":
        if job["status"] in ("failed", "canceled"):
            raise RuntimeError(f"Job {job['id']} ended with status {job['status']}")
        if waited >= max_wait:
            raise TimeoutError(f"Job {job['id']} did not finish in {max_wait}s")
        time.sleep(poll_seconds)
        waited += poll_seconds
        r = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS, timeout=30)
        r.raise_for_status()
        job = r.json()
    return job["outputs"][0]["url"]


def speak_file(path):
    with open(path, encoding="utf-8") as f:
        chunks = chunk_paragraphs(f.read())

    for i, chunk in enumerate(chunks):
        body = {
            "model": MODEL,
            "input": {
                "text": chunk,
                "voice": VOICE,
                # Context from neighbouring chunks keeps intonation consistent.
                "previous_text": chunks[i - 1][-500:] if i > 0 else "",
                "next_text": chunks[i + 1][:500] if i + 1 < len(chunks) else "",
            },
        }
        url = run_job(body)
        ext = os.path.splitext(urlparse(url).path)[1] or ".mp3"
        out = f"part_{i + 1:03d}{ext}"
        with open(out, "wb") as f:
            f.write(requests.get(url, timeout=60).content)
        print(f"Saved {out} ({len(chunk)} characters)")


if __name__ == "__main__":
    speak_file(sys.argv[1])

Run it with python reader.py article.txt. To switch to the multilingual model, change MODEL to elevenlabs-text-to-speech-multilingual-v2 and add a language_code to the input. Joining the parts into one file is a one-line job for a tool like ffmpeg.

A two-voice dialogue with curl

For a scripted conversation, the dialogue model takes a dialogue array. Replace SECOND_VOICE_ID with any other voice ID from the audio studio.

curl -X POST 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": "Welcome back to the show. Today we are talking about reading apps.", "voice": "EkK5I93UQWFDigLMpZcX"},
        {"text": "Which, fittingly, I listened to on the way here.", "voice": "SECOND_VOICE_ID"}
      ]
    }
  }'

The response contains a job ID; poll GET /v1/jobs/{id} exactly as in the Python example. If you work in Cursor or Claude Code, the same models are available to your agent through the MCP integration, and the full request reference is in the docs.

What a text to speech app costs per article, chapter or episode

The single-voice models charge per request, multiplied by the character count divided by 1,000 and rounded up. So 2,500 characters counts as three units, not two and a half. Credits cost $0.01 each on monthly plans (Starter $25, Creator $50, Studio $100, Pro $200) and $0.015 each as top-ups, which never expire. Full details are on the pricing page.

Job	Model	Credits	On a plan	As top-up
9,000-character article	Turbo V2.5	54	$0.54	$0.81
9,000-character article	Multilingual V2	108	$1.08	$1.62
30,000-character book chapter	Turbo V2.5	180	$1.80	$2.70
Same chapter in a second language	Multilingual V2	360	$3.60	$5.40
One dialogue scene	Text to Dialogue V3	14	$0.14	$0.21

Those figures assume the text goes in as single requests of exact thousands. When you chunk, each chunk rounds up on its own, so a 9,000-character article split into chunks of 2,200 to 2,500 characters ends up billed as four chunks of three units each: 12 units, or 72 credits on Turbo rather than 54. The fix is simple: size your chunks just under a multiple of 1,000. If you want the exact number before running anything, POST /v1/models/price returns the price of a request ahead of time.

The useful comparison is not against other services’ price sheets but against your own time. Recording a chapter yourself means a quiet room, retakes and editing. Generating a draft lets you hear the pacing of a script before you commit to recording, or publish an audio version of every post with no studio at all.

Mistakes people make with a text to speech app

Most complaints about robotic or confusing audio come from the input, not the voice. These are the problems that show up again and again, whether you use a consumer text to speech app or an API.

• Feeding it raw page text. Navigation menus, cookie banners, image alt text and footnote markers all get read aloud. Strip them before converting, or use an app with a reader view.
• Leaving abbreviations and symbols in. Write “about 3 times” instead of “~3x”, and expand unusual acronyms the first time. Tables and bullet fragments read badly; rewrite them as sentences for audio.
• Splitting mid-sentence. Chunking on character counts alone cuts sentences in half and produces odd pauses. Split on paragraphs, and pass neighbouring text through previous_text and next_text.
• Sending many tiny requests. Because each request rounds up to the next 1,000 characters, converting a document one sentence at a time can cost several times more than converting it in paragraph-sized chunks.
• Cranking the speed in the request. Listeners can speed up playback themselves. Generate at a natural pace and let the player handle the rest; very fast generated speech often sounds clipped.
• Choosing a voice from one sentence. Test with a full paragraph that includes a question, a list and a number. That is where differences between voices show.
• Ignoring licensing. A personal reader app is not a licence to publish its audio. If the output is going into a product, video or podcast, use a service whose terms cover that.

If you only want to listen, start with the free reader on your device, and move to a dedicated text to speech app when PDFs or books become the bulk of your reading. If you want to produce audio, browse the speech models in the model catalog, try a few voices in the studio, and turn the script above into the reader you actually need.