Text-to-Speech APIs

Published September 2, 2026 · Every figure below was read from the vendor’s own API documentation, OpenAPI or discovery specification on September 2, 2026. One note on Resemble AI: it appears throughout because its API is still documented and existing customers still use it, but the company no longer sells voice generation — treat its rows as a record rather than as a buying option. This page compares integration constraints, not output. No listening test has been run, so nothing here says how any of these sound.

The short answer

On this page

Concurrency: the number that decides it

If you are building anything that serves more than one user at a time, concurrency is the constraint that determines your architecture. It is published in wildly different units across these ten, and three vendors do not publish it for speech at all.

Read the units before comparing the numbers. Concurrent requests, transactions per second, requests per minute and streaming sessions are four different things, and a vendor publishing a large number in a generous unit is not necessarily more capable than one publishing a small number in a strict one.

Two vendors document behaviour that changes what the number means. ElevenLabs queues rather than fails when you exceed concurrency, describing queued requests as typically adding about 50ms of latency, and publishes two response headers so you can monitor concurrency in-band. It also meters concurrency differently by transport: HTTP counts each request, the TTS WebSocket counts only generation time, and Text to Dialogue reserves a session per open connection from a separate pool. Cartesia publishes a canonical 429 body with an explicit concurrency_limited error code.

MiniMax’s omission is conspicuous rather than accidental-looking. Its rate-limit tables publish a concurrency column for Music and a max-inflight-tasks figure for Video, but the speech rows have neither — only 60 RPM. The vendor demonstrably publishes concurrency where it chooses to; for speech it does not.

Per-request character caps

The second constraint you hit, usually while building rather than while planning. Every one of these is a hard limit that forces client-side splitting.

Speechify’s SSML note is the one to internalize. If your input carries markup, your usable text budget is smaller than the number suggests — and on a 2,000-character endpoint, a heavily marked-up passage can lose a meaningful fraction of it to tags. Google applies the same principle to billing rather than to limits: it counts all SSML tags except <mark> as billable characters, which our pricing comparison covers.

The 10× gap between OpenAI’s 4,096 and Speechify’s streaming 20,000 is the practical difference between splitting a chapter into dozens of requests and sending it whole. If you are narrating long-form text, check this before you check price.

Streaming means four different things

Every vendor here advertises streaming. They do not mean the same thing by it, and the differences are load-bearing.

Google is the outlier and it matters. Its live v1 discovery document contains exactly seven methods and none of them is a streaming method — streaming exists only as gRPC bidirectional, documented in a guide marked Pre-GA, restricted to one voice family, with only a Python sample invoked through the generated client. If your stack is not gRPC-friendly or your voice is outside that family, Google’s streaming is not available to you regardless of what its marketing says.

Amazon’s constraint is a stack of three. Bidirectional streaming needs the generative engine, an SDK that supports HTTP/2 event streams, and one of a narrower set of SDKs than Polly’s general 10-language list. Each is documented; together they rule out a lot of existing integrations.

OpenAI’s is a version trap. Choosing the cheaper tts-1 or tts-1-hd models means giving up SSE streaming entirely — the parameter exists but those two models do not accept it.

One thing this page deliberately does not compare is latency. Every vendor publishes a figure, they measure different quantities, and most name no metric at all — our real-time comparison sets out why those numbers cannot be ranked, and compares barge-in, turn detection and telephony instead.

Authentication

Three schemes, and knowing which you are dealing with determines how you handle secrets, key rotation and client-side calls.

• Custom API-key header. ElevenLabs uses xi-api-key. Murf uses api-key, and additionally publishes a short-lived bearer token endpoint for client-side use, minted with the api-key header.
• Bearer token. OpenAI, MiniMax (single scheme, HTTP bearer), Resemble AI (Authorization: Bearer <API_KEY>, a single static key with no OAuth, no scoped or rotating tokens and no per-key permission model documented), and Cartesia.
• Cloud IAM. Google requires the single OAuth scope https://www.googleapis.com/auth/cloud-platform, with gcloud CLI credentials or Application Default Credentials for REST. Amazon and Azure authenticate through their platform mechanisms and SDKs.

Cartesia publishes the most interesting enforcement detail on this page. Verbatim: “All endpoints use HTTPS. HTTP is not supported. API keys that call the API over HTTP may be subject to automatic rotation.” The penalty for a plaintext call is not a refused request — it is your key being rotated out from under you. Cartesia also runs three credential types, including an admin key prefixed sk_car_admin_ required for usage and key management, which is a sensible separation few here offer.

Speechify sends a build-date Speechify-Version header by default from its SDKs, and documents that raw HTTP callers can send the same header to pin a dated response shape. That is a genuinely useful thing to publish and nobody else here does it.

Several of these APIs also run your text through a normalizer, a pronunciation layer and a prosody layer before synthesis, each with its own parameters and defaults — and one vendor documents the same normalization parameter with opposite defaults on two of its own endpoints. Our guide to how AI voice generators work covers those stages.

SDK coverage

Whether an official SDK exists in your language is often the whole decision, and the spread here is wide.

ElevenLabs’ count is easy to overstate. The large SDK list belongs to the Agents Platform, not to the REST text-to-speech API, which has two. And the three libraries most likely to appear in a JavaScript or game-engine stack — Vercel AI SDK, .NET and Unity — sit in a table the vendor explicitly marks as not officially supported.

MiniMax’s approach is different in kind rather than merely thinner. Rather than publishing speech SDKs, it publishes compatibility base URLs you point an existing third-party SDK at. That works, and it means no first-party client to file issues against.

Async and batch

For long documents, an async endpoint is usually the right integration, and five vendors publish one.

• ElevenLabs — POST /v1/flows/text-to-speech, positioned as the async alternative to the synchronous endpoint, completed by a polling GET that returns a signed download URL expiring in about an hour, with webhook delivery as an alternative to polling. Its output format enum is restricted to MP3 only — no PCM, WAV, opus, ulaw or alaw. If you need lossless async output, this endpoint cannot give it to you.
• Google Cloud — an async long-audio method in both v1 and v1beta1, polled through dedicated long-running-operations methods, writing output to a Cloud Storage URI you supply. That storage dependency is an architectural requirement, not a convenience.
• Amazon Polly — StartSpeechSynthesisTask, allowing 200,000 total characters against 100,000 billed, with task listing and retrieval capped at 10 tps combined.
• Azure Speech — batch synthesis at 100 requests per 10 seconds on S0, a 2 MB maximum JSON payload, up to 10,000 text inputs per job, no stated limit on concurrent active jobs, and a job time-to-live of up to 31 days.
• MiniMax — /v1/t2a_async_v2 with a separate query endpoint, on both platforms.

Azure’s 10,000 text inputs per job is the largest documented batch unit here, and its 31-day job TTL is the only retention figure any of these vendors publishes for async output.

Documentation defects you will hit

These are not editorial complaints. Each one costs a developer time, and each is verifiable in the vendor’s own published material.

• Murf’s OpenAPI spec declares no security schemes at all. The docs authenticate every curl example with an api-key header, but a generated client built from the spec will not know that. Its AsyncAPI binding, separately, names the credential api_key in both the query and headers objects.
• Resemble AI’s documentation contradicts itself twice on authentication — Bearer against a bare key on the same endpoint, and two different URLs for obtaining an API key. It also publishes no error-code taxonomy, no documented 429 semantics, no Retry-After, no rate-limit response shape and no backoff guidance beyond a single WebSocket line.
• OpenAI’s guide sends parameters its reference does not document. The custom-voice example posts "language": "fr" and "format": "wav" to the speech endpoint, while the reference’s body-parameter list contains only input, model, voice, instructions, response_format, speed and stream_format. A case-insensitive search of that reference for “language” returns nothing.
• Google’s auth documentation and its discovery document disagree. The authentication page presents OAuth bearer tokens as the general REST pattern and shows no API-key header anywhere, while the live v1 discovery document declares an API key as a query parameter named key, described as required unless an OAuth token is supplied.
• ElevenLabs’ regional hosts are published inconsistently. The Servers block listing one default plus four regional data-residency hosts appears on the REST endpoint reference pages but on neither WebSocket reference page, and no statement says which plans may use the regional hosts.
• ElevenLabs’ streaming and non-streaming format enums differ. The non-streaming endpoint accepts 28 output formats; the streaming endpoint accepts 21 and contains no wav_* format at all. Code that works against one endpoint can fail against the other on format alone.
• Murf’s WebSocket hosts differ between its own documents. Its AsyncAPI default server is wss://global.api.murf.ai/v1/speech while the working code sample connects to wss://global.api.murf.ai/v1/speech/stream-input.
• A deprecated parameter still appears in ElevenLabs’ reference. optimize_streaming_latency is documented as deprecated on both the convert and stream endpoints.

Two vendors deserve credit against this list. ElevenLabs exposes character cost, request ID and trace ID as response headers, which makes cost attribution and support escalation straightforward. Cartesia and Speechify both publish a canonical 429 shape — Cartesia with a named concurrency_limited error code, Speechify with a Retry-After header — which is the difference between implementing backoff correctly and guessing at it.

Choosing for your workload

1. Start with concurrency, not price. Work out your peak simultaneous requests and check it against the table above, in the vendor’s own unit. A free tier allowing 1 or 2 concurrent requests will not serve a product regardless of how many characters it includes.
2. Check the per-request cap against your longest input. If you exceed it you are writing a splitter, and splitting introduces prosody seams no vendor document discusses.
3. Confirm the streaming transport matches your stack before assuming streaming exists. gRPC-only, SSE-on-newer-models-only and HTTP/2-event-streams-only are all real constraints here.
4. Check whether an official SDK exists in your language, and whether the SDK you found belongs to the product you are integrating — ElevenLabs’ large SDK list is for a different product.
5. If you are synthesizing long documents, use the async endpoint, and check its format restrictions. ElevenLabs’ async path is MP3-only; Google’s requires Cloud Storage.
6. Read the 429 documentation before you need it. Two vendors publish a canonical shape; one publishes no 429 semantics at all.
7. Then check price — in our pricing comparison, where every rate is normalized to one unit — and language coverage in our multilingual comparison, where no vendor’s advertised count survives a recount.

Frequently asked questions

Sources and what we could not verify

Every figure on this page was read on September 2, 2026 from vendor API documentation, published OpenAPI and AsyncAPI specifications, and live discovery documents. Where a machine-readable specification was available we parsed it directly rather than relying on the rendered documentation. Per-provider detail is in the ten reviews linked throughout, and the method is on the methodology page.

What we could not verify

Honesty about gaps beats a page that looks complete. Genuinely unresolved as of September 2, 2026:

• Whether any of these APIs behaves as documented. We read specifications; we did not create accounts or make API calls. Every limit here is a published figure, not a measured one.
• OpenAI’s per-model rate limits. RPM and TPM for the speech models are not on the public pages and appear to require an account.
• MiniMax’s speech concurrency. Not published, though the vendor publishes concurrency figures for its other media products.
• ElevenLabs’ numeric rate limit. A rate limit distinct from concurrency exists and is signalled by its own error code, but the docs give no numeric threshold; the vendor explicitly deprioritises requests-per-minute in favour of concurrency.
• ElevenLabs’ Enterprise concurrency. That row of the table publishes words rather than numbers.
• Which plans may use ElevenLabs’ regional hosts. The Servers block lists them with no statement of eligibility.
• Per-request character caps for Azure, Google, Cartesia and MiniMax. We did not find a published per-request input limit for these in the documentation we read; absence in what we read is not proof none exists.
• Whether Murf’s OpenAPI omission of security schemes is deliberate. The spec declares none while every documented example uses a header.
• Latency of any kind. This page publishes no latency figures. Vendor latency claims exist and are not measurements; our benchmark does not yet cover them.

Change log

September 2, 2026 — First publication. All figures read from official vendor API documentation and machine-readable specifications on September 2, 2026 and dated accordingly.

Published September 2, 2026 · This page compares documented integration constraints and reports no measurements — we made no API calls and ran no listening test. API limits and specifications change frequently; corrections are recorded with their date on the corrections page. Independence note: this page contains no affiliate links, and no vendor paid for placement or influenced the order — see how we make money and our editorial policy.