Google's preview text-to-speech model via OrcaRouter — low-cost audio generation from text input.
google/gemini-2.5-flash-preview-tts is a text-to-speech model developed by Google, currently in preview. It converts text input into speech audio, leveraging the Gemini 2.5 Flash architecture for…
The model converts text into speech, handling typical text-to-speech tasks: reading paragraphs, generating voiceovers, and creating audio for accessibility. It supports punctuation and numeric expressions naturally. Because it is a Flash model, it is optimized for throughput and can process large volumes of text quickly. It does not support transcription (speech-to-text), language translation, or multimodal inputs. The audio output is suitable for playback in applications. No specific voice personalities or accents are confirmed for this preview. Users should test with their own text to assess audio quality and naturalness.
This model excels in scenarios where low cost and low latency are more important than studio-quality audio. Best use cases include: generating narration for short videos, podcasts, and social media content; providing audio for chatbots and virtual assistants; creating audio versions of news articles or blog posts; prototyping TTS features before investing in higher-end models; and serving multilingual audiences if the model supports the needed languages. Because the output token price is $10 per million, it is economical for generating non-critical audio where occasional artifacts are acceptable.
If your use case involves extremely high volumes (e.g., millions of tokens per day) and audio quality can be very basic, you might consider a cheaper alternative like Google's TTS Lite or another provider's low-cost TTS model. However, no cheaper model is explicitly provided in the facts. Alternatively, if you need real-time streaming with the lowest possible cost per character, you could evaluate models that charge per character rather than per token. This model's output token cost is relatively high compared to input cost, so text-to-speech scenarios that generate long audio from short text may be cost-effective, while generating short audio from long text could be less so. Always benchmark your specific workload to compare pricing.
If your application requires studio-grade audio, expressive emotional tones, or multi-voice dialogue, you may need a more expensive TTS model such as Google Cloud Text-to-Speech (WaveNet) or Amazon Polly with neural voices. These models offer multiple voice options, SSML support, and higher naturalness but at higher per-character or per-second pricing. google/gemini-2.5-flash-preview-tts is a preview optimized for speed and cost, so it may not match the nuance of dedicated enterprise TTS solutions. Evaluate a small sample of your text with this model versus alternatives to determine if quality meets your requirements.
No specific latency benchmarks are published for this preview model. As a Gemini 2.5 Flash variant, it is architected for low-latency inference. In practice, response time depends on text length, network latency to Google's servers via OrcaRouter, and current load. Users should expect moderately fast generation for short texts (e.g., a few sentences), with longer texts taking proportionally longer. Because it uses a Flash model, it should outperform slower, high-quality TTS models but may not be as fast as ultra-lightweight models. For precise latency measurement, run load tests with typical input sizes using OrcaRouter's API.
Based on public information about Gemini 2.5 Flash, strengths include fast inference, cost efficiency (low input token price), and natural-sounding speech for a lightweight model. The preview status means early access to Google's latest TTS technology. The zero-markup pricing via OrcaRouter ensures you pay only the provider rate. Input token pricing ($0.50 per million) is among the lowest for TTS models. The Flash architecture also implies lower carbon footprint per request compared to larger models.
This model is in preview, so reliability and availability are not guaranteed. No benchmark scores (e.g., MOS, CER) are provided. It lacks features found in mature TTS services: no SSML support, limited voice options, no emotion control, no custom voice training. Output quality may be inconsistent across different languages or accents. Due to token-based pricing, long silences or non-speech tokens could increase cost unpredictably. There is no information on audio format (e.g., WAV, MP3), sample rate, or bit depth. Users should verify compatibility with their audio processing pipeline.
Google's Gemini 2.5 Flash is a general-purpose family; the TTS variant is specialized for speech generation. Compared to a generic Gemini Flash model (which outputs text), the TTS version adds a decoder for audio tokens, making it more appropriate for audio but potentially slower due to the decoding step. It is not directly comparable to text-only Flash models. For TTS specifically, it competes with models like OpenAI TTS-1, Microsoft Edge TTS, and open-source alternatives. No cross-model benchmarks are available for this preview, so direct comparisons are speculative.
Pricing is per token: $0.50 per 1 million input tokens and $10.00 per 1 million output tokens. Input tokens are the text you send to the model. Output tokens are the audio tokens generated. OrcaRouter bills at the provider rate with zero markup. There are no additional fees for using the API beyond token consumption. Charges are incurred for both successful and failed requests if tokens are processed. Unused tokens are not charged. Billing is typically monthly, but check your OrcaRouter account for details. Tokens are counted by Google's tokenizer, which may vary from other models.
Output tokens are 20x more expensive than input tokens ($10 vs $0.50 per million). This is typical for TTS models because generating audio is computationally intensive. Therefore, long silences or extended pauses in the input can increase output token count without carrying information. Optimizing input text to be concise can reduce cost. Conversely, input token cost is negligible; you could provide detailed context without much penalty. If your use case requires generating very short audio from very long text (e.g., a brief response from a long document), the cost ratio may be favorable.
No specific caching or discount programs are mentioned in the provided facts. OrcaRouter does not offer built-in caching for model outputs. Each request is processed fresh by Google's servers. Some platforms offer caching of identical requests, but this is not confirmed for OrcaRouter. For high-volume users, contact OrcaRouter to inquire about potential volume-based discounts or reserved capacity. Until then, assume per-token pricing applies to every request.
Comparing to common TTS services: Google Cloud Text-to-Speech charges per character (e.g., $0.000004 per character for Standard, $0.000016 for WaveNet). OpenAI TTS-1 charges $0.015 per 1000 characters. Convert to per-token: this model's $10 per million output tokens may be competitive for short texts but expensive for long audio. Since no character-to-token ratio is given, users should test with their content. The zero-markup from OrcaRouter is an advantage over provider APIs that add overhead.
You use OrcaRouter's OpenAI-compatible API at base URL https://api.orcarouter.ai/v1. Send a POST request to the chat/completions or audio endpoint (if available) with the model ID 'google/gemini-2.5-flash-preview-tts'. For standard TTS, you may need to use a dedicated audio generation endpoint; consult OrcaRouter's documentation for the correct route. Include your API key in the Authorization header. The request body typically contains the text to convert, and optionally parameters like voice or speed (if supported). Audio is returned as base64-encoded tokens or a download URL, depending on the endpoint.
Common parameters supported by OpenAI-compatible APIs include: 'model' (required: 'google/gemini-2.5-flash-preview-tts'), 'messages' or 'prompt' with the text, 'temperature' and 'top_p' (may affect audio variation if supported), 'max_tokens' (limits output length). However, for TTS, many of these may not apply. The model might support 'voice' or 'speed' parameters. No specific parameters are documented in the provided facts. Check OrcaRouter's API reference for this model. If the model does not support a parameter, it will be ignored or return an error.
If you are migrating from another provider (e.g., Google Cloud TTS, AWS Polly, OpenAI TTS), you need to change your endpoint to https://api.orcarouter.ai/v1 and update your authentication to use OrcaRouter API key. Update the model identifier to 'google/gemini-2.5-flash-preview-tts'. Then, adapt your request format to OpenAI-compatible schema. For example, if you previously sent text in a specific field, you'll now use the 'messages' array or 'prompt' parameter. Audio output format may differ; you may need to parse base64 responses. Test with a small request before migrating production traffic.
OrcaRouter provides an OpenAI-compatible API with likely endpoints: /v1/chat/completions for text-to-text, and possibly /v1/audio/speech for TTS. For this model, the appropriate endpoint is likely the audio speech endpoint. If that is not available, you may need to use the completions endpoint with special parameters. The facts state the model is accessed through OrcaRouter's OpenAI-compatible API at base_url https://api.orcarouter.ai/v1 with model id 'google/gemini-2.5-flash-preview-tts'. Confirm with OrcaRouter documentation which endpoint to use for generating audio.
Google Cloud TTS offers multiple voice types (Standard, WaveNet, Studio) with SSML support, custom voice creation, and a wide range of languages. pricing is per character. This preview model (gemini-2.5-flash-preview-tts) uses token-based billing and is a Flash variant optimized for speed and low cost. It is likely less feature-rich than Cloud TTS but may be more cost-effective for simple, high-volume TTS. google/gemini-2.5-flash-preview-tts is a preview, whereas Cloud TTS is generally available with SLAs. If you need reliability and advanced features, Cloud TTS is safer; if you want low latency and low cost, try this model.
OpenAI TTS-1 charges $0.015 per 1000 characters. Both models generate audio from text. OpenAI's model is known for expressive voices and wide adoption, but it has a different pricing model (per character). google/gemini-2.5-flash-preview-tts uses per-token pricing, which may be cheaper for very short text but more expensive for long text (since one character may equal multiple tokens). OpenAI TTS-1 is stable and production-ready, while Google's model is a preview. You can use both via OrcaRouter by switching model IDs. Test your specific use case to compare cost and audio quality.
Open-source TTS models like Coqui TTS, Piper, or Bark are free but require hosting, maintenance, and GPU resources. They offer customization but lack the speed and simplicity of an API call. google/gemini-2.5-flash-preview-tts via OrcaRouter eliminates infrastructure overhead and provides a pay-per-use model. For hobby projects, open-source may be cheaper; for production with minimal latency and management, the API is easier. The preview model's speed and cost may be competitive with some open-source models when factoring in hosting costs.
Amazon Polly offers a variety of voices, SSML support, and a Free Tier (5 million characters per month). Pricing is per character (Standard $0.000004, Neural $0.000016). google/gemini-2.5-flash-preview-tts is token-based, and its preview status means no SLAs or free tier. For low-volume use, Polly's free tier is attractive. For high-volume, the token pricing of this model may be cheaper or more expensive depending on compression. Polly supports many languages and features like pronunciation lexicons. This model is simpler but faster and lower-cost depending on usage.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1voice| Input / 1M tokens | $0.500 |
|---|---|
| Output / 1M tokens | $10.00 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
What developers are saying this week
GET /api/public/models/google/gemini-2.5-flash-preview-ttsOpen @misc{orcarouter_gemini_2_5_flash_preview_tts,
title = {google/gemini-2.5-flash-preview-tts API},
author = {google},
year = {n.d.},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/google/gemini-2.5-flash-preview-tts}
}google. (n.d.). google/gemini-2.5-flash-preview-tts API. OrcaRouter. https://www.orcarouter.ai/models/google/gemini-2.5-flash-preview-tts