Google's fast, cost-efficient text-to-speech model for real-time audio generation, accessed via OrcaRouter.
google/gemini-3.1-flash-tts-preview is a text-to-speech model from Google, part of the Gemini Flash family. It accepts text input and generates spoken audio output. The model is optimized for speed…
The primary capability is converting written text into natural-sounding speech. The model is designed for speed, leveraging the Flash architecture to reduce latency. It supports multiple languages and voices? This specific preview's language and voice support is not detailed in provided facts; you should consult Google's documentation for current voice options. The model can handle varied text inputs including punctuation, numbers, and abbreviations, producing spoken output that reflects the intended rhythm and tone.
Best use cases include any application where low-latency speech generation is critical: real-time voice assistants, live translation dubbing, interactive chatbots with voice output, and automated phone systems. It also excels for batch processing when you need to generate many short audio clips quickly. Content producers can use it for dynamic voiceovers in video games or audiobooks. Because output cost is high relative to input, it is most economical when output audio is concise.
If your use case involves extremely long audio generation (e.g., hours of speech) or does not require low latency, consider a batched TTS model with lower per-token output cost. For applications where input volume dominates (e.g., many short prompts), the cheap input cost makes this Flash model attractive. For scenarios requiring very high output quality—such as emotionally expressive characters—you might evaluate premium TTS models from Google or other providers. Always monitor total token volume and latency requirements.
As a Gemini Flash model, this TTS variant is optimized for low latency. Specific latency benchmarks (e.g., time to first audio packet) are not provided in the available facts. In practice, Flash models often respond within hundreds of milliseconds for short inputs. Latency can vary based on output length, network conditions, and concurrent request load. OrcaRouter's routing may add minimal overhead. For real-time applications, test with your expected audio durations under load.
Strengths include low input cost ($1.00/1M tokens), fast generation, and Google's robust infrastructure. The preview status means model quality and availability may change. A limitation is the high output cost ($20.00/1M tokens) relative to text models. Additionally, output audio quality—such as naturalness, accent variety, and prosody—is not benchmarked here. You should evaluate the model's voice quality for your specific domain (e.g., technical jargon, emotional range) before production deployment.
No benchmark scores for google/gemini-3.1-flash-tts-preview are provided in the available facts. TTS models are often evaluated on metrics like Mean Opinion Score (MOS) for naturalness, word error rate (WER) for intelligibility, and latency percentiles. Without specific numbers, you should run your own evaluation using representative prompts to assess quality and speed relative to your requirements. OrcaRouter does not add or modify model performance.
The available facts do not specify supported languages or accent capabilities for this TTS preview. Google's broader TTS models typically support multiple languages, but this specific variant's coverage is unknown. You should test with multilingual text to confirm output quality. For English, performance is likely robust given Google's investment. For less common languages, consider contacting Google directly or testing with sample text via OrcaRouter's API.
Pricing follows Google's official rates with zero markup from OrcaRouter. Input tokens (text) cost $1.00 per 1 million tokens. Output tokens (audio) cost $20.00 per 1 million tokens. Output tokens are generated per unit of audio; the exact token-to-time ratio is not specified. You are billed for both input and output tokens used in each request. There are no additional platform fees or minimum spend requirements. Billing occurs via OrcaRouter's existing payment methods.
Input tokens are 20x cheaper than output tokens. This incentivizes sending longer text prompts (within token limits) to generate proportionally longer audio output, as the input cost remains low. For example, generating a 1-minute audio clip may consume many output tokens at $20/1M, while the text prompt might only cost pennies. Optimize by keeping output concise whenever possible. If your use case generates very long audio, the output cost per request can add up quickly.
The available facts do not mention any caching or discount programs for this model on OrcaRouter. OrcaRouter's pricing is pass-through at provider rates. You may want to check with OrcaRouter for any bulk discount options or reserved capacity that could apply across models. Since output token cost is high, caching generated audio segments for repeated use (e.g., common responses) can reduce total spend significantly.
Comparisons are not directly provided. However, Google's Flash TTS is positioned as cost-effective for real-time use with low input cost. Other TTS models (e.g., OpenAI TTS, ElevenLabs) may have different pricing structures—often charging per character or per second of audio. This model's per-token output pricing may be more expensive for very long audio but cheaper for short, bursty generations. Evaluate your expected token volumes against other offerings on OrcaRouter's catalog.
Use any OpenAI-compatible client. Set the base URL to https://api.orcarouter.ai/v1, API key from your OrcaRouter account, and model ID to "google/gemini-3.1-flash-tts-preview". Send a chat completion request with a user message containing the text to be spoken. The response will include audio content (likely as a base64-encoded chunk or URL). The exact output format depends on Google's model implementation. Refer to OrcaRouter's documentation for streaming support and response parsing.
Standard chat completion parameters apply: model, messages (with role and content), and optionally temperature or top_p for output variability (though less relevant for TTS). For voice selection, Google's model may support an extra parameter (e.g., voice name). The available facts do not list specific TTS parameters. You may need to pass additional fields like "voice" or "language" in the request body. Consult Google's API documentation for the preview model for exact options.
It is common for TTS models to support streaming audio, where audio chunks are sent as they are generated. The provided facts do not confirm streaming support for this preview model. If streaming is enabled, you can use the stream parameter set to true in your API request and process chunks as they arrive. OrcaRouter supports streaming for compatible models. Test with a simple request to see if audio is returned incrementally or as a complete blob.
If you already use an OpenAI-compatible API, change the base URL to https://api.orcarouter.ai/v1 and update the model ID. Update your request parameters to match Google's TTS specifications (e.g., voice name). You may need to adjust audio output handling if the format differs (e.g., MP3 vs WAV). Test with sample prompts to verify quality. Because pricing is zero-markup, your costs may change based on token usage. No special migration tools are required.
OpenAI offers TTS models (tts-1, tts-1-hd) with per-character pricing (~$0.015 per 1k characters). In contrast, Google's model uses token-based pricing, which can be more economical for short inputs but more expensive for long outputs. OpenAI's TTS supports multiple voices and languages; Google's preview specifics are not fully known. Latency: both Flash and OpenAI's models are designed for low latency. Quality is subjective; you should test with your content to compare naturalness and prosody.
Google also provides premium TTS models (e.g., WaveNet, Studio) through its Cloud Text-to-Speech API. Those models typically charge per character of text sent, which can be cheaper for very long audio but have higher per-request costs. The Flash TTS is faster and has simpler input pricing (per token) but may have fewer voice options. For high-fidelity, emotionally rich speech, a premium model may be better. For speed and low cost per input, the Flash variant is advantageous.
If you need real-time response and have short input texts (many small requests), this Flash model's low input cost and fast generation are ideal. For very long audio generation (e.g., full audiobooks), a model that charges per character input (like Google's standard TTS) might be cheaper, as output token cost is avoided. Also consider voice variety and language support: if you require many distinct voices, check if this preview supports that. Test both options with your workload before committing.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1voice| Input / 1M tokens | $1.00 |
| Output / 1M tokens | $20.00 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
GET /api/public/models/google/gemini-3.1-flash-tts-previewOpen @misc{orcarouter_gemini_3_1_flash_tts_preview,
title = {google/gemini-3.1-flash-tts-preview API},
author = {google},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/google/gemini-3.1-flash-tts-preview}
}google. (n.d.). google/gemini-3.1-flash-tts-preview API. OrcaRouter. https://www.orcarouter.ai/models/google/gemini-3.1-flash-tts-preview