TTS local vs API: the break-even math

Local TTS versus a hosted API is a volume question, and volume questions have answers in arithmetic: this guide gives the crossover formula in characters per day, works it across two real GPU tiers at September 2026 street prices and the official United States electricity price, and shows the latency and long-text physics that stay identical on both sides of the choice, so the decision lands on your numbers rather than on someone else's rig.

All amounts below are US dollar amounts, written as bare numerals; electricity is quoted in cents per kilowatt-hour. Rates for this platform's own speech lanes are never typed by hand: they render live from the catalog in the table further down, and every worked example substitutes only externally sourced anchors.

What the search results give you instead of an answer

The pages that rank for this question are good pages, and none of them hands you the math.

The strongest is a build log. On 28 February 2026 a research site published how it replaced a paid text-to-speech API with Kokoro, an 82M-parameter open-weight model, on a rig of four used RTX 3090 cards: about 4,000 of hardware, one URL changed, per-character spend at zero. Its own tip box admits the rig is overkill for speech: a used RTX 3060 at about 200 would be enough for Kokoro alone. That sentence, not the four-GPU rig, is where a reader's decision actually lives, and the article never develops it.

A production-economics post from December 2025 did put a number on the question: against one ElevenLabs plan, a dedicated rented L40S at 619 a month breaks even near 29,000 utterances, and against a budget speech API near 165,000, figures a dev-shop blog echoed in May 2026. Real answers, wrong unit: one rented data-center card against two specific plans, in utterances of about 250 characters, and it stops there. You cannot put your own GPU, your electricity price, or a different rate into them.

A March 2026 writeup did the most careful measured version, one narrator model on three machines with wall draw in watts and cents per narration, and never generalized it into a rule. A break-even calculator that appeared on the results page this week targets token-based language models on rented clusters, not characters of speech on the card in your desk. Meanwhile a February 2026 forum thread pitching a local speech server as an ElevenLabs alternative drew 45 comments, and a March 2025 thread on a local server with an OpenAI-compatible endpoint drew 111. People are not asking whether local speech is possible. They are asking when it is cheaper.

What local TTS actually costs

Local speech has three cost pieces: the hardware, the power it draws, and the price of that power.

Hardware, at September 2026 reads. A used RTX 3060 12GB, the floor for comfortable Kokoro-class work, traded around 200 in a practitioner report from February 2026 and around 280 in a used-price tracker read from August 2026; it launched at 329. A used RTX 3090 spread from about 650 to 1,050 across four September 2026 trackers, sold-listing averages near 1,000; it launched at 1,499 in September 2020. Use whatever number your own listings show; the formula does not care which source you trust.

Power draw, from the manufacturer. NVIDIA's RTX 3060 specification page lists graphics card power at 170 W with a 550 W required system supply; the RTX 3090 page lists 350 W with a 750 W system supply. Speech draws less than gaming maximums: the worked tiers use 250 W at the wall for the 3060 box and 450 W for the 3090 box, board power as the anchor.

Electricity, from the government. The EIA Short-Term Energy Outlook puts the average United States residential price at 18.2 cents per kilowatt-hour for 2026, up from 17.3 in 2025. Your bill is the number that matters; 18.2 is the anchor.

Then the piece nobody prices: synthesis is fast, and speed is money. The hosted Kokoro lane's measured basis, taken on an RTX 3060 12GB-class card and re-verified in September 2026, is about 0.0149 seconds per input character. A million characters, roughly seventeen hours of finished audio, costs about 19 cents of electricity at the national price on a 250 W box. The marginal cost of local speech, once the box exists, is close to nothing. The decision is almost entirely hardware amortization, which is why the crossover formula is mostly a hardware formula.

The break-even formula

Rates for this platform's speech lanes render below from the live catalog, and the formula reads its hosted-rate variable, P, straight off that table; any provider's published rate substitutes the same way. The worked examples use two external anchors: a major provider's standard speech model at 15 per million characters and its high-definition tier at 30, from that provider's own pricing page, read September 2026.

hosted cost per day  =  D x P / 1,000,000

local cost per day   =  G / (30 x A)  +  D x s x E x R / 3,600,000

crossover D*         =  G / (30 x A)  /  ( P / 1,000,000  -  s x E x R / 3,600,000 )

The named variables:

• D: characters you synthesize per day. The crossover D* is the volume where both sides cost the same.
• P: hosted rate per million characters, read off the fence above or off any provider's pricing page.
• G: what the hardware cost you: a used card, a whole build, or zero if the box already exists.
• A: amortization months; twenty-four is this guide's default.
• s: seconds of synthesis per character: about 0.0149 for Kokoro class on a 3060-class card, this platform's measured basis. Heavier narrator models carry their own, larger number.
• E: wall draw in watts while synthesizing, whole system.
• R: electricity price per kilowatt-hour, in dollars: 0.182 is the 2026 national average in decimal form.

Two rules fall out of the shape. First, the denominator is a gap: hosted rate per character minus your marginal electricity per character. At premium hosted rates electricity is a rounding error, and the formula is effectively amortization times a million over P. At hosted-open-weights rates near 1 per million, the model author's own April 2025 market note put hosted Kokoro under that mark, electricity becomes about a quarter of the denominator and shifts the answer materially: cheap hosted rates are exactly where naive math forgets electricity. Second, the crossover moves inversely with the rate: halve the rate and the crossover climbs past double, because the electricity term shrinks the denominator at the same time.

The sensitivity rule in one line: every one-dollar move in P per million characters shifts the crossover by about the crossover divided by P, in characters per day. At the 15 anchor that is about 1,700 characters per day on the used-3060 tier; near hosted-open-weights rates of 1, one dollar moves it by hundreds of thousands, which says plainly that against a rate that low, only heavy daily volume justifies a dedicated card.

Three worked tiers

Every number below regenerates from the six inputs by a small script kept beside this guide.

The model card's rule of thumb is 1,000 characters to a minute of finished audio, so the 26,000-character crossover is roughly 26 minutes of audio a day: a daily narration habit, a course builder, a busy accessibility surface. The 95,000 crossover is an hour and a half a day: a publisher. Below those volumes the hosted side is cheaper; above them the card pays for itself inside its amortization window, and everything after is nearly free except power.

Two variants the table skips. An always-on box burns idle power around the clock: at a 60 W idle estimate the 3060 tier adds about 0.26 a day and moves the 15-anchor crossover from 26,000 to about 44,000 characters a day, so let sleeping boxes sleep. And a rig you already own for other work assigns speech only a slice of the amortization, which is the February build log's real economics: with G at exactly zero the crossover disappears, your marginal cost is electricity alone, and the hosted side wins only on convenience.

The rented burst lane breaks the frame: that December 2025 economics post measured burst-priced GPU time at about 24 a month for 100,000 utterances, cheaper than any owned card at that volume. A nightly batch on someone else's card is a separate comparison; the formula prices hardware you own.

For scale, one 3060-class card synthesizing flat out tops out near 5.8 million characters a day, and this platform's hosted Kokoro lane measured 7.0 million a day at concurrency eight on day one. Both are physics-grade ceilings, not promises; one modest card and a hosted lane sit in the same order of magnitude, so the decision is cost shape, not capacity.

Latency and long text: the physics does not care where the GPU sits

The same buffering physics governs both sides, and it is the part of the decision marketing copy never states.

On the hosted side, this platform's speech lanes carry two shipped registry facts, both from measurement in September 2026. Per-model input caps, enforced at the gateway with a 400 rejection before any synthesis work or billing: chatterbox-tts 400, kokoro-tts 3500, pocket-tts 2500, audio8-tts 250 input characters. Per-model first-byte budgets, sized from the same measured curves and enforced at the gateway: chatterbox-tts 45 s, kokoro-tts 55 s, pocket-tts 55 s, audio8-tts 60 s. The budgets exist because the card synthesizes the whole request before the first byte crosses: a full-cap Kokoro request is about 52.8 seconds of synthesis, and a request that cannot reach first byte inside its budget dies at the edge. The operations monitor watches the same budgets with alert bars at 45, 55, 50, and 60 seconds, pocket-tts's bar sitting five seconds under its enforced wall. Text longer than a cap is the client's to split, at sentence boundaries, one request per piece, joined at playback.

On the local side, nothing exempts you. The local speech server thread with 111 comments from March 2025 is a public lesson: commenters hit a 14-second output ceiling from a default token limit far below the model's maximum, and called it too slow for realtime use. A speech-to-speech assistant thread from April 2025 with 41 comments reported 610 milliseconds end to end on fully local hardware and still named turn detection the missing piece. The numbers differ, the walls are the same shape, and local buys you control of those walls, not their absence.

Where the sides genuinely differ is the spend model. On this platform the wallet is prepaid and in active use, and a key whose balance reaches zero is denied at request time, so a chunking bug's worst case is a top-up, not a surprise balance; the enforcement flag's production posture was verified on 11 September 2026. The deeper treatment of metered-spend failure modes is its own guide: how to avoid API bill shock.

The same request, two ways

The OpenAI-compatible speech shape is the quiet standard here: one request body works against your own box and against this platform's endpoint, which makes the local-versus-hosted choice reversible.

Local, the model author's own library path:

# pip install kokoro soundfile
# plus espeak-ng for out-of-dictionary words
from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code="a")   # American English
text = "This line is synthesized on my own machine."
for i, (gs, ps, audio) in enumerate(pipeline(text, voice="af_heart")):
    sf.write(f"part{i}.wav", audio, 24000)

That is the official usage from the Kokoro repository, 24 kHz wav out, fixed voice packs, espeak-ng as the fallback for odd words. To give your own box the OpenAI speech shape, the community standard is Kokoro-FastAPI, a Docker wrapper serving the /v1/audio/speech route on port 8880.

Hosted, the same synthesis through this platform's endpoint:

curl -sS $IRONSTRATUM_BASE_URL/v1/audio/speech \
  -H "Authorization: Bearer $IRONSTRATUM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "kokoro-tts", "input": "Same model class, hosted lane.", "voice": "af_heart"}' \
  --output speech.mp3

Three contract facts before the first call. The body requires model, input, and voice; the model string is the registry alias, kokoro-tts here, not the display name. Voices are per model, and one catalog call, GET /v1/audio/voices with the model query, lists every valid id. The response is chunked binary audio with no Content-Length, so keep client read timeouts above the synthesis time; the caps and budgets two sections up are the honest timeout guide. Metering is per input character, counted at the gateway.

Quality, cloning, and what nobody can show you yet

Two honest limits on the quality debate. First, premium hosted speech still leads on naturalness. A forum thread asking which local models can match ElevenLabs opened with its author's own verdict: the best local output was "not even close" to what that hosted service gives, a service the same author called "very pricey for me". The real trade, in one post. Premium hosted speech runs about 50 to 100 per million characters at the market leader's published API rates (0.05 and 0.10 per thousand characters for its fast and full-quality tiers, official pricing page, read September 2026), the expensive end of hosted and the reason crossovers arrive earliest there.

Second, no page on this platform carries audio samples this round; that decision has not shipped. Judge with your own ears, against a small prepaid wallet or the open weights on your own card, before committing a narrator. Structurally: Kokoro speaks in fixed voice packs with no cloning, which also means no cloned-reference consent questions; the cloning-capable open lanes on this platform are Pocket TTS, about five seconds of reference audio, and Audio8, a reference clip plus transcript, with Chatterbox doing zero-shot cloning from a few seconds of audio. One cloned narrator plus hours of stock narration is usually the right split: clone once, run volume through a fixed-voice lane.

Decision rules

The models on this platform's speech lanes are the same open-weight families people run locally, Kokoro, Pocket, Audio8, and Chatterbox classes, behind one OpenAI-compatible endpoint, metered per input character against the prepaid wallet. Whichever side of the crossover you land on, the model class is the same; current per-unit rates sit on the pricing page, and a wallet plus a key takes minutes on the signup page.

Frequently asked questions

Can I run AI text-to-speech locally?

Yes, on hardware you probably own. Kokoro is an 82M-parameter model with Apache-licensed weights that runs usefully on a plain CPU and comfortably on any modern discrete GPU; the install is one pip package, and the official model card documents the StyleTTS 2 architecture with an ISTFTNet decoder that keeps it that small. For the Raspberry Pi end of the scale, Piper, now developed by the Open Home Foundation, is the long-standing fast-and-small option. XTTS v2 completes that local spectrum at the heavier, cloning-capable end: 17 languages with voice cloning from a 6-second clip by its own model card, ranked best overall in a September 2025 vendor survey read for this guide, and carrying that survey's warning that running it on a laptop is easy while serving thousands of real-time requests is not.

When is local TTS cheaper than an API?

When your daily character volume passes the crossover: hardware cost spread over your amortization window, divided by the gap between the hosted rate and your marginal electricity cost. On this guide's anchors, a used 280 RTX 3060 over 24 months crosses near 26,000 characters a day against a 15-per-million rate, and near 480,000 a day against hosted-open-weights rates near 1.

How much GPU do I need to run Kokoro locally?

Far less than the ranking build logs imply. The weights sit in the hundreds of megabytes, so VRAM is not the constraint; the February 2026 rig article states in its own tip box that a single used RTX 3060 is more than enough for Kokoro alone, its four-3090 build existing to serve language models in the same box. Any 12GB card is beyond adequate, and CPU-only works at lower speed.

Do open-source TTS models have an OpenAI-compatible API?

The two main paths here do. This platform serves the OpenAI /v1/audio/speech shape directly: model, input, and voice in the JSON body, binary audio back. On your own hardware, Kokoro-FastAPI serves the identical route from port 8880, so an OpenAI SDK client moves between local and hosted by changing the base URL and the model string. The demand is old: a 2024 forum thread on open-source voice alternatives treated "has an API" as a first-class requirement.

Can local TTS match ElevenLabs quality?

Not quite at the top end, and the honest statement is directional: premium hosted speech still leads on naturalness, open-weight models have narrowed the gap into the range where information-delivery use cases stop caring, and fixed-voice English narration is where local is strongest. Cloning is separate from quality: several open models clone from seconds of reference audio, and a cloning-capable lane beats any fixed-pack model when you need one specific voice. Test on your own material.

What is the latency difference, local versus API?

Less different than you expect, because synthesis dominates. A card that buffers the whole request before first byte has the same physics in your desk as in a rack: the measured basis on this platform's Kokoro lane is 0.0149 seconds per character, about 52.8 seconds to first byte at the 3,500-character cap, inside a published 55 s budget. Local adds no network hop but your own queueing; hosted adds a round trip and publishes its budgets. For lower first-byte times on long text the lever is chunking, not location.

What happens with very long TTS text: chunking, caps, streaming?

Every lane in this guide caps input length. This platform's measured caps are chatterbox-tts 400, kokoro-tts 3500, pocket-tts 2500, and audio8-tts 250 input characters, enforced with a 400 rejection before synthesis starts, unbilled. Longer text is split on your side: cut at sentence boundaries under the cap, one request per piece, concatenate at playback. Hosted responses are chunked transfer, but synthesis still buffers first, and the local library yields audio chunk by chunk from the same kind of pipeline. The cap numbers are the first inputs your chunking code needs, and the full chunking, session, and limit math is worked end to end in the long audio and long text guide.

Prices and metering units for every lane sit on the pricing page. To run the numbers against a real wallet: sign up, create a key, and put a small balance behind it before you commit a narrator.

Last verified: 2026-09-11