OpenAI TTS streaming alternative — chunked audio with ReadableStream and iter_content

Does EasyVoice support streaming/chunked TTS responses?

Yes. EasyVoice's TTS API endpoint at https://easyvoice.ae/api/v1/audio/speech returns audio via HTTP chunked transfer encoding by default — the same transport mechanism as OpenAI's audio.speech.create. The response begins as soon as the first audio chunks are synthesized. The HTTP response header Transfer-Encoding: chunked is present on every successful response, confirming that audio bytes are flowing incrementally rather than being buffered server-side until synthesis is complete.

Chunked transfer encoding means: the server does not need to know the total audio file size before sending the first byte. It sends chunks as they are generated. Each chunk is a raw fragment of the audio bytes — not a JSON object, not a base64 string. Your client accumulates chunks until the connection closes (end of synthesis) or pipes them to a media player as they arrive for real-time playback.

Any standard HTTP library handles chunked responses without special configuration. The fetch API in JavaScript exposes the body as a ReadableStream. The requests library in Python supports it with stream=True and iter_content(). Go's net/http.Client streams by default. You do not need WebSockets, Server-Sent Events, or gRPC for streaming TTS. Standard HTTP is the transport.

Consuming the stream in JavaScript — ReadableStream

In JavaScript (Node.js 18+ or browser), the fetch API returns a response object whose body property is a ReadableStream. Call response.body.getReader() to get a reader, then loop: call reader.read(), receive a {value, done} object on each iteration, where value is a Uint8Array chunk of audio bytes and done is true when the stream is complete. Pipe each chunk to your audio context, a writable stream, or a file.

The ReadableStream pattern works identically in Node.js and in modern browsers. In the browser, you can pipe chunks to a MediaSource buffer for real-time playback without waiting for the full file. In Node.js, you can pipe to a Writable stream (fs.createWriteStream) or pass chunks to a WebSocket for real-time distribution to connected clients. The code example below shows the basic reader loop; adapting it to your specific output target is a matter of replacing the audioQueue.push(chunk) call.

One important detail: close the reader when done is true. Leaving a reader open on a completed stream does not cause errors in most environments, but it is good practice. In the example below, the break statement exits the loop when done is true, which allows the garbage collector to release the reader and the underlying connection.

Consuming the stream in Python — iter_content

In Python, the requests library supports streaming responses with stream=True on the requests.post call. This keeps the response connection open and allows you to iterate over the body with res.iter_content(chunk_size=4096). Each iteration yields a bytes object of up to chunk_size bytes. A chunk_size of 4096 bytes is a practical default — it corresponds to roughly 200–400 milliseconds of audio at typical MP3 bitrates.

Pipe chunks to pyaudio for real-time playback, write them to a file incrementally with a file handle opened in binary write mode, or pass them to ffmpeg's stdin for transcoding or processing. The iter_content loop terminates when the server closes the connection (end of synthesis). The with statement on the requests.post call ensures the connection is closed and resources are released after the loop completes, even if an exception is raised mid-stream.

For asynchronous Python (asyncio / httpx), the pattern is equivalent: use httpx.AsyncClient and aiter_bytes() on the response object instead of iter_content. The async pattern integrates with FastAPI, Starlette, or any async framework that needs to forward streaming TTS audio to a client without buffering the full response.

Which response_format works best for streaming?

MP3 is the most broadly compatible format for streaming in general-purpose applications. Most audio players and browser Audio APIs decode chunked MP3 streams correctly without requiring the complete file before playback begins. MP3 frames are self-contained: a decoder can start playback from any chunk boundary without needing the file header from the beginning. This makes mp3 the right default for streaming to a web browser or a mobile app.

Opus is the best choice for WebRTC or latency-sensitive transport. Opus frames are designed for packet-loss resilience and low-latency streaming. If you are building a real-time voice application (voice chatbot, live translation, real-time accessibility read-aloud), response_format: 'opus' delivers lower effective latency per frame than mp3 because Opus frames are smaller and decoded faster. The trade-off is that Opus playback requires a browser or media player with native Opus support (all modern browsers qualify).

WAV (raw PCM) is suitable for audio processing pipelines where you need to manipulate the raw waveform — applying effects, mixing, transcoding — but is not the right format for streaming to end users. WAV files are uncompressed: a 60-second WAV is roughly 10 MB, versus 1 MB for the equivalent MP3. Streaming a large WAV to a browser that plays it inline increases buffering time and bandwidth usage. Use wav when the downstream consumer is an audio processing library, not an end-user media player.

Buffer flushing and chunk handling in practice

When piping streamed audio to a real-time playback system, buffer management determines whether playback is smooth or stuttery. If you push chunks to an audio buffer faster than the playback system can consume them, you accumulate a growing buffer. If you push chunks slower than playback (network delay, slow synthesis), the playback system runs out of audio to play and produces a dropout.

For smooth real-time playback, a common pattern is a double-buffer: maintain a primary buffer (what is currently playing) and a secondary buffer (what is pre-fetched). When the primary buffer is nearly empty, swap in the secondary and fetch the next chunk into a new secondary buffer. This smooths out network jitter and synthesis latency variation without adding significant end-to-end latency.

For file-write applications (generating an audio file, not playing in real-time), buffering is not a concern: write each chunk to the file as it arrives with f.write(chunk) in Python or stream.write(chunk) in Node.js. The file is complete and playable when the loop terminates. No flush() call is needed between chunks — the OS handles write buffering — but a final f.flush() or stream.end() after the loop ensures all bytes are committed to disk.

Switch to EasyVoice streaming if you need an OpenAI-compatible chunked TTS endpoint that works with standard HTTP libraries (ReadableStream in JS, iter_content in Python) without a proprietary SDK, on a $9.99/mo flat-rate plan. Stay on OpenAI streaming if you are already consuming audio.speech.create's chunked response successfully and the cost at your volume is under $9.99/mo (below 666K chars/mo on tts-1, below 333K chars/mo on tts-1-hd).