Best TTS API for Customer Support Chatbots and Voice Agents
Chatbot and voice-agent integrations are the highest-leverage use case for a TTS API — every customer support interaction that previously needed a human reading from a script can now be synthesized in real time at the cost of an API call. The right TTS API for this use case wins on three axes: low first-byte latency (so the bot doesn't sound laggy), predictable pricing as call volume scales (so finance doesn't freak out at the end of the month), and clean integration points for the platforms developers actually use — Twilio Programmable Voice, Voiceflow, Dialogflow CX, Amazon Connect, Genesys, and the LangChain / OpenAI Agents SDK stack. EasyVoice ships all three: 300-600ms first-byte on Kokoro-82M, $9.99/mo flat unlimited, and reference wiring patterns for every platform in this guide.
5,000 characters per day on the free tier, no credit card. Pro $9.99/mo unlimited. 46 voices, 8 languages.
What makes a TTS API good for chatbots
Chatbot TTS has three constraints generic TTS doesn't have. First, latency — a 1.5-second pause between the user's question and the bot's voice response feels broken; a 400ms pause feels conversational. The first-byte latency of your TTS API plus your LLM round-trip plus your transport overhead must stay under ~1 second total for the perceived UX to feel natural. EasyVoice's 300-600ms warm first-byte (vs OpenAI tts-1 at 800ms-1.5s, ElevenLabs Multilingual v2 at 1.8s) is the right shape for this constraint — see /tts-api/low-latency for the measured numbers.
Second, pricing predictability at scale. A support chatbot that handles 1,000 conversations a day averaging 90 seconds of synthesized speech per conversation generates roughly 4.5M characters per day — over per-character pricing that's ~$2,000/mo on OpenAI tts-1 ($15/1M chars). On EasyVoice Pro at $9.99/mo flat, it's $9.99/mo total. The scaling math is the entire reason flat-rate TTS exists. Third, voice consistency — your support bot needs the same voice across every interaction, not a random voice per request. All TTS APIs in this category satisfy the consistency constraint as long as you pin the voice parameter; the latency and pricing axes are where they actually differentiate.
Twilio Programmable Voice integration
Twilio Programmable Voice has two integration paths for custom TTS. The cleanest is to generate the audio yourself with EasyVoice, host the resulting MP3 on a CDN or your own object store (S3, R2, GCS), and reference it in your TwiML response with <Play>url</Play>. This works for any TTS API but requires you to manage the audio file lifecycle — generate, store, serve, expire. The second path is to stream audio directly from your media server into Twilio's bidirectional Media Streams over WebSocket, which removes the storage step but requires you to operate the WebSocket bridge.
For most support-chatbot use cases, the file-hosting path is sufficient and simpler. Generate the response audio with EasyVoice in the same request handler that decides what the bot should say, write the MP3 to your object store with a UUID-based filename, return a TwiML response pointing to the URL, and expire the file after 24 hours via your storage lifecycle policy. Total round-trip from 'user finishes speaking' to 'bot starts speaking' is dominated by your LLM response time and Twilio's STT — the TTS leg adds 400-1500ms depending on whether you stream the file to storage as it generates or wait for the full file.
Voiceflow integration
Voiceflow's visual conversation designer ships with built-in TTS via several vendors (Amazon Polly, Google, ElevenLabs, custom). The custom-TTS path is the right slot for EasyVoice — Voiceflow's 'API Step' block lets you call any HTTP endpoint mid-conversation, parse the response, and route the result to the audio-out block. The pattern: trigger an API Step at the point in your flow where the bot should speak, POST to /api/tts/generate with the variable holding the bot's response text, write the resulting audio bytes to a Voiceflow variable, then play that variable through the standard audio-out block.
Voiceflow's variables are JSON-typed so audio bytes need to be base64-encoded for transport — your API Step does the encoding inline. For high-volume Voiceflow deployments where the base64-encoding overhead matters, the alternative is to use a Webhook step that posts to a small intermediate service (a Cloudflare Worker, a Vercel Edge Function) which calls EasyVoice, stores the result, and returns a signed URL Voiceflow plays via the standard URL-audio block. Either pattern works; pick based on your team's familiarity with the surrounding infrastructure.
Dialogflow CX integration
Dialogflow CX supports TTS at two layers. The platform's default TTS uses Google Cloud TTS (because Dialogflow is a GCP product). To swap in EasyVoice, the cleanest path is to disable Dialogflow's TTS and use a webhook fulfillment that calls EasyVoice directly, returning an audio response message rather than a text response. The fulfillment receives the bot's intended response text in the webhook payload, calls /api/tts/generate, and returns a Dialogflow response with the audio bytes (or a URL pointing to the audio if you've hosted it).
The integration trades platform-level convenience for vendor flexibility and (often) much better pricing. Dialogflow's bundled TTS billing is opaque — you pay for Dialogflow's bot turns plus the per-character TTS underneath, and the combined bill is hard to model in advance. EasyVoice's $9.99/mo flat on the TTS leg gives you a predictable line item regardless of conversation volume, which finance teams generally prefer. The webhook integration adds ~50-100ms of network latency vs the native path, which is negligible compared to the LLM and STT legs of the same conversation.
OpenAI Agents SDK and LangChain integration
Voice-enabled LLM agents built on the OpenAI Agents SDK, LangChain, or LlamaIndex pass the agent's final-response text to a TTS function as the last step in the chain. EasyVoice plugs in as that TTS function with a 5-line call — same code as the /tts-api/openai-alternative spoke shows. For agents that need streaming output (the bot starts speaking before the LLM finishes generating), pair EasyVoice's chunked streaming with the LLM's streaming output: as each LLM token arrives, accumulate into sentence boundaries (period, question mark, exclamation point), call TTS on the completed sentence, and pipe the audio bytes into the output buffer as they arrive.
This sentence-by-sentence streaming pattern is the standard for sub-second voice-agent UX. The user perceives the bot 'speaking' as soon as the first sentence is generated, even though the full response is still in flight. EasyVoice's 300-600ms first-byte latency is short enough that the first sentence's audio typically finishes generating before the LLM has produced the second sentence — so the audio playback is continuous from the listener's perspective without the bot ever having to pause for the next sentence.
Voice choice for customer support
Support-bot voice selection has more product-design weight than any other TTS use case because the voice is part of your brand. Three rules of thumb: (1) For general English-language support, am_adam (neutral male baritone) or af_heart (warm female mid-range) are the default-safe choices — neither leans too formal nor too casual. (2) For multilingual support, use a native-speaker voice in the customer's language (ef_dora for Spanish, ff_siwis for French, hf_alpha for Hindi, etc.) — English-engine voices reading translated text reliably feel off to native listeners and undermine trust. (3) Match the brand register: enterprise B2B audiences expect authority (am_michael, am_adam), consumer apps benefit from warmth (af_heart, af_aoede), youth brands tolerate energy (af_bella).
Voice consistency across the customer's interaction is more important than voice 'best-in-class' optimization. Pin a single voice per conversation thread; randomization or A/B-testing different voices in the same call session breaks the user's mental model of who they're talking to. If you're A/B testing voice choices for conversion or CSAT, randomize at the conversation-start boundary and keep the voice consistent within the conversation. All 46 EasyVoice voices are free-tier available, so test as many as you need.
Code samples
Drop-in examples for the EasyVoice TTS API. Every request below assumes you've set EASYVOICE_API_KEY as an environment variable.
Twilio TwiML — generate and play
Express route handler returning TwiML with the synthesized audioimport express from "express";
import { writeFileSync } from "fs";
import { randomUUID } from "crypto";
const app = express();
app.post("/twilio/voice", express.urlencoded({ extended: false }), async (req, res) => {
const userText = req.body.SpeechResult ?? "Welcome to support.";
const botResponse = await callYourLLM(userText);
// Call EasyVoice TTS
const ttsRes = await fetch("https://easyvoice.ae/api/tts/generate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.EASYVOICE_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ voice: "af_heart", input: botResponse, response_format: "mp3" }),
});
const audio = Buffer.from(await ttsRes.arrayBuffer());
// Upload to your object store, get a public URL
const fileName = `bot-${randomUUID()}.mp3`;
const audioUrl = await uploadToS3(fileName, audio);
res.type("text/xml").send(`
<Response>
<Play>${audioUrl}</Play>
<Gather input="speech" action="/twilio/voice" />
</Response>
`);
});Voiceflow API Step
POST body for the Voiceflow API block — variable substitution applied{
"method": "POST",
"url": "https://easyvoice.ae/api/tts/generate",
"headers": {
"Authorization": "Bearer {EASYVOICE_API_KEY}",
"Content-Type": "application/json"
},
"body": {
"voice": "af_heart",
"input": "{bot_response_text}",
"response_format": "mp3"
},
"responseMapping": {
"audioBase64": "$.body"
}
}OpenAI Agents SDK — sentence streaming
Stream LLM tokens, synthesize each sentence as it completesimport os, re, requests
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
SENTENCE_END = re.compile(r"[.!?]\s")
def stream_voice_response(user_query: str):
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": user_query}],
stream=True,
)
buffer = ""
for chunk in completion:
delta = chunk.choices[0].delta.content or ""
buffer += delta
# Flush complete sentences to TTS as they form
while m := SENTENCE_END.search(buffer):
sentence, buffer = buffer[: m.end()], buffer[m.end() :]
audio = requests.post(
"https://easyvoice.ae/api/tts/generate",
headers={"Authorization": f"Bearer {os.environ['EASYVOICE_API_KEY']}"},
json={"voice": "am_adam", "input": sentence, "response_format": "mp3"},
stream=True,
)
for byte_chunk in audio.iter_content(4096):
yield byte_chunk
# Flush any final partial sentence
if buffer.strip():
audio = requests.post(
"https://easyvoice.ae/api/tts/generate",
headers={"Authorization": f"Bearer {os.environ['EASYVOICE_API_KEY']}"},
json={"voice": "am_adam", "input": buffer, "response_format": "mp3"},
stream=True,
)
for byte_chunk in audio.iter_content(4096):
yield byte_chunkVoices to try with the API
Every voice below is callable via the same voice parameter — preview samples and read the full character profile.
Frequently asked questions
What's the best TTS API for customer support chatbots?▾
Score candidates on three axes: first-byte latency (under 1s end-to-end perceived response time), pricing predictability at scale (per-character billing punishes high-volume support deployments), and integration cleanness with your platform (Twilio, Voiceflow, Dialogflow, OpenAI Agents SDK). EasyVoice ships 300-600ms first-byte on Kokoro-82M, flat $9.99/mo unlimited regardless of call volume, and reference wiring patterns for all the major platforms. ElevenLabs Turbo v2.5 is the closest competitor on latency but uses tiered + per-character pricing that gets expensive at scale.
How does EasyVoice integrate with Twilio Programmable Voice?▾
Two paths. (1) Generate the audio with EasyVoice in your TwiML response handler, host the MP3 on your object store (S3/R2/GCS), and reference it with <Play>url</Play>. This is the simplest path and works in any language. (2) Stream audio bytes directly into Twilio's bidirectional Media Streams over WebSocket for the lowest possible latency, at the cost of operating the WebSocket bridge yourself. For most support bots, path (1) is sufficient.
Does it work with Voiceflow and Dialogflow CX?▾
Yes. Voiceflow: use an API Step block to call /api/tts/generate, write the audio bytes to a Voiceflow variable, and play it through the audio-out block. Dialogflow CX: use webhook fulfillment to call EasyVoice and return an audio response message instead of text. The Dialogflow integration trades platform-level convenience for vendor flexibility and (usually) better pricing than the bundled Google Cloud TTS underneath.
How do I avoid laggy bot responses?▾
Pair EasyVoice's chunked-streaming response with sentence-level streaming from your LLM. As each LLM token arrives, accumulate into sentence boundaries (period/question mark/exclamation point), call TTS on the completed sentence, and pipe the audio bytes into the output buffer as they generate. The first sentence's audio is typically ready before the LLM finishes the second sentence — the user hears continuous speech from the moment the first sentence completes generating, ~400ms after the LLM emits its first period.
How much will a high-volume support chatbot cost on EasyVoice?▾
Flat $9.99/mo on Pro regardless of volume. For comparison, a support bot handling 1,000 conversations a day at 90 seconds average synthesized speech per conversation generates roughly 4.5M characters per day — that's ~$2,000/mo on OpenAI tts-1 ($15/1M chars), ~$1,300/mo on Google Cloud TTS WaveNet, similar money on Azure Neural. On EasyVoice Pro it's $9.99/mo. The flat-rate model is the entire reason chatbot TTS makes sense on EasyVoice.
What voice should I use for my support bot?▾
For general English-language support, am_adam (neutral male baritone) or af_heart (warm female mid-range) are the default-safe choices. For multilingual support, use native-speaker voices in the customer's language (ef_dora Spanish, ff_siwis French, hf_alpha Hindi, etc.) — English-engine voices reading translated text reliably feel off and undermine trust. Pin one voice per conversation thread; never randomize within a single call session. All 46 voices are free-tier available, so test what fits your brand.
Related TTS API guides
Low Latency TTS API — 300-600ms First-Byte on Kokoro-82M
Low-latency TTS API for real-time chatbots and IVR. EasyVoice Kokoro-82M ships first audio byte in 300-600ms warm. Streaming, cold-start numbers, benchmarks.
Multilingual TTS API — 8 Languages, 46 Voices, Single Endpoint
Multilingual TTS API with native-speaker voices in 8 languages: English, Spanish, French, Italian, Portuguese, Japanese, Hindi, Chinese. Flat $9.99/mo Pro.
Comparing vendors? See EasyVoice vs elevenlabs →
Start building with the EasyVoice TTS API
5,000 characters per day free, no credit card. Pro $9.99/mo unlimited. OpenAI-compatible request shape.