Frequently asked questions
What is our TTS API?
EchoMouth is a cloud text-to-speech API optimized for game developers. Send text via POST to /v1/audio/speech and receive an audio file. It uses a JSON body compatible with the OpenAI speech endpoint, allowing you to use existing OpenAI SDKs by simply changing the base URL to https://api.ao999.info/v1.
Is this API compatible with Unreal Engine?
Yes. Since the API accepts standard JSON requests and returns audio files, it integrates easily with any engine that supports HTTP requests. You can use the official OpenAI SDKs or plain HTTP to send text and receive audio files, making it straightforward to implement in Unreal Engine or Unity.
Can I use the voices in a commercial game?
Yes. The voices are based on licensed recordings from LibriTTS-R (CC BY 4.0) and public-domain audiobook readings. You can use the generated audio in commercial projects without additional licensing fees. Each file includes an inaudible watermark marking it as synthetic speech, but no voice actor attribution is required.
How do I ensure voice consistency for one NPC?
Select a specific voice preset from the eight available options (e.g., aria, nova, felix) and use that same voice parameter for all requests for that NPC. The API does not support custom voice cloning, so consistency relies on choosing the correct preset that matches your character’s profile.
Does the API support multiple languages in one file?
No. Each request generates audio for a single text input. To handle mixed languages, you must send separate requests for each language segment and join the resulting audio files. You can specify the language via an optional ISO code parameter to ensure correct pronunciation.
What is the difference between tts-1 and tts-1-hd?
Both models use the same engine and price ($10 per 1 million characters). The primary difference is the model name; both use the same engine and price. Choose based on your production needs, as both support the same voices, formats, and speed settings.
Do I need to credit the voice actors?
No. The voices are derived from LibriTTS-R (CC BY 4.0) and public-domain sources. While the audio carries an inaudible synthetic watermark, there is no requirement to attribute specific voice actors in your game credits or documentation.
Is the audio royalty-free?
Yes. Once generated, the audio files are yours to use in your game or project without ongoing royalty payments. Failed requests are free, and you only pay for successful synthesis based on the character count of your input text.
Can I speed up the audio for faster NPC lines?
Yes. You can adjust the speed parameter between 0.25 and 4.0. This allows you to make NPC dialogue faster or slower to fit specific animation timings or gameplay pacing requirements without re-synthesizing the text.
What happens if the text is too long?
The API limits input to 4096 characters per request. For longer texts, split the text into parts of up to 4096 characters, generate audio for each part, and join the audio files in your engine. This ensures consistent quality and manageable request sizes.
Do I need a developer account to start?
Yes. Sign up on /get-api-key/ using Google or email to receive an API key. Accounts are per site. You get a free trial credit of $0.50 (valid 7 days) if you sign in with Google. Accounts created with email and password start without trial credit.
Is the API suitable for mobile games?
Yes. The API returns standard audio files (mp3, wav, opus, flac, pcm) that are easy to integrate into mobile game engines. With transparent per-character pricing and no minimum spend, it is cost-effective for mobile projects with variable dialogue volumes.
How do I handle errors in my game engine?
Monitor the HTTP response status. If synthesis fails, the charge is returned in full. Implement retry logic for transient errors. Since requests are processed sequentially, high load may cause delays, so consider queuing requests in your game’s audio manager.
Can I mix TTS with recorded audio?
Yes. The API returns standard audio files that can be mixed with your existing sound assets in any game engine. Use the generated TTS for dynamic NPC dialogue and pre-recorded audio for key events, combining them seamlessly in your audio pipeline.
Is there a limit on the number of NPCs?
No. You can create as many NPCs as needed, each with a unique voice preset. The limit is on your API rate (60 requests per minute per key) and your balance, not on the number of distinct characters you can voice.
Do I get a SLA for production?
No. There is no SLA, uptime guarantee, or enterprise contract. Requests are processed one after another, so under load, generation may wait in a queue. This is suitable for non-real-time NPC dialogue but not for strict real-time voice chat.
Can I download the API SDK?
No. We do not provide an official SDK. However, since the endpoint matches the OpenAI speech format, you can use the official OpenAI SDKs by changing the base URL to https://api.ao999.info/v1. You can also use plain HTTP requests.
Is the base URL change complex?
No. Simply update the base URL in your existing OpenAI SDK configuration to https://api.ao999.info/v1. The request shape is identical, so your existing code for sending text and receiving audio should work with minimal changes, just updating your API key.
Do I need to manage voice licenses manually?
No. The voices are based on LibriTTS-R (CC BY 4.0) and public-domain recordings. You do not need to track individual voice licenses or pay additional royalties.
Voice Consistency
Consistent character voices are critical for NPC dialogue. Our eight preset voices maintain tonal stability across thousands of generated lines, ensuring that a specific character’s audio signature remains uniform regardless of context or duration. This eliminates the jarring shifts common in inconsistent synthesis engines.
For freelance audio engineers, this predictability simplifies asset management. You can assign a voice to a character archetype and rely on it to sound identical in every interaction, from short grunts to long narrative sequences, without needing complex post-processing to fix drift.
Preset Voice Stability
Each voice preset is engineered for specific tonal qualities that do not degrade over time or vary significantly between requests. Whether you are generating dialogue for a news anchor (Atlas) or a documentary narrator (Orion), the core timbre remains consistent.
This stability reduces the need for manual audio leveling or timbre matching when stitching dialogue lines together in your game engine.
- Eight distinct, stable voice profiles
- Consistent timbre across long texts
- No drift between generation sessions
Character Voice Matching
While we do not offer custom cloning, you can match character types by selecting from our eight presets. For example, use Luna for soft storytelling roles or Felix for energetic promo-style NPCs.
You can further refine consistency by locking the speed parameter to a specific value (e.g., 1.0) for all lines belonging to the same character, ensuring rhythmic uniformity across your dialogue tree.
No Custom Cloning
We do not offer voice cloning or custom voice uploads. You cannot clone a specific actor’s voice for your NPCs.
This keeps the API deterministic and simple. You work with the eight available presets, which are based on licensed recordings, rather than managing complex cloning models.
Cost Efficiency
Predictable asset costs are critical for indie game budgets. Our API charges strictly per character processed, ensuring you pay only for what you generate. This transparency eliminates hidden fees and allows precise estimation of dialogue production costs per NPC line.
Bulk generation becomes efficient when splitting longer texts into 4096-character chunks. The deterministic pricing model means you can forecast exact expenses for voice-over pipelines without worrying about tiered volume discounts or unexpected overage charges.
Per-Character Billing
You are charged $0.01 per 1,000 characters, including spaces and punctuation. This rate applies uniformly regardless of the voice model selected, making it easy to calculate the cost of a single NPC line or a full quest dialogue tree.
Failed synthesis requests incur no charge, protecting your budget from wasted credits during debugging or edge-case testing. You only pay for successfully generated audio files.
- $0.01 per 1,000 characters
- Spaces and punctuation count as characters
- Failed requests are free
Bulk Generation Savings
Splitting long narratives into 4096-character segments allows you to process parts independently, but requests are processed sequentially under load. Since requests are processed sequentially under load, batching smaller lines can help manage queue wait times during peak production periods.
The absence of minimum spend requirements means you can generate exactly the audio assets needed for your current build phase without committing to unused capacity.
- No minimum spend
- Split texts into 4096-character parts
- Pay only for generated audio
No Subscription Overhead
There are no monthly plans, seats, or recurring fees. Your balance does not expire, allowing you to top up only when needed. This model suits developers who work on multiple projects with irregular voice-over schedules.
Starting with a $0.50 trial credit lets you validate the integration before committing to larger USDT transfers. You retain full control over your cash flow without locked-in commitments.
- No monthly plans
- No seats or subscriptions
- Balance never expires
Technical Integration
The API mimics the OpenAI speech endpoint structure, allowing you to reuse existing codebases with minimal friction. By setting the base_url to https://api.ao999.info/v1, standard OpenAI SDKs function correctly for both Node.js and Python environments.
This compatibility extends to the request schema, ensuring that developers familiar with OpenAI’s speech models can integrate EchoMouth without rewriting their synthesis logic or learning a new library interface.
OpenAI SDK Compatibility
The API mimics the OpenAI speech endpoint structure, allowing you to reuse existing codebases with minimal friction. By setting the base_url to https://api.ao999.info/v1, standard OpenAI SDKs function correctly for both Node.js and Python environments.
This compatibility extends to the request schema, ensuring that developers familiar with OpenAI’s speech models can integrate EchoMouth without rewriting their synthesis logic or learning a new library interface.
Simple JSON Payload
Requests are sent via POST to /v1/audio/speech with a straightforward JSON body. You specify the model (tts-1 or tts-1-hd), input text (up to 4096 characters), voice preset, and desired output format.
Optional parameters like speed (0.25–4.0) and language allow fine-tuning without complex configuration. The system handles the synthesis synchronously, returning the audio file directly in the response.
For longer NPC dialogues, split your text into chunks under the character limit, generate each part, and concatenate the resulting audio files server-side or in-game.
model: 'tts-1' or 'tts-1-hd'input: Text string, max 4096 charsvoice: One of 8 presets (e.g., 'aria', 'atlas')response_format: mp3, wav, opus, flac, or pcm
Limited Feature Set
The API provides deterministic synthesis without SSML tags or phoneme dictionaries. You cannot inject pauses or stress syllables via markup; control is limited to the global speed parameter.
There is no support for emotion tags or custom pronunciation lexicons. Voice characteristics are fixed per preset, ensuring consistent output but reducing granular expressiveness for nuanced NPC lines.
This constraint simplifies the integration process, reducing the number of parameters you need to manage during bulk generation for large dialogue trees.
Audio Quality
Generated audio files include an inaudible watermark identifying the speech as synthetic, ensuring clear provenance for NPC dialogue assets. This metadata is embedded directly into the audio stream without affecting playback quality or requiring additional processing steps during integration.
Generation typically operates at roughly real-time speed, processing approximately 25 characters per second for long texts. Short phrases may take a few seconds due to queueing under load, ensuring deterministic output times for predictable asset pipelines.
Synthetic Watermark
Every generated file carries an inaudible watermark that marks it as synthetic speech. This allows for easy identification of AI-generated NPC dialogue in final builds without consuming additional file storage or impacting audio fidelity.
Real-Time Generation
Requests are processed sequentially, meaning generation speed is roughly real-time (approx. 25 characters per second) for standard texts. Short phrases may take a few seconds to generate, especially if the queue is active, but latency remains predictable for batch asset creation.
- Sequential processing ensures deterministic output timing.
- Queuing may add slight delays during high load.
Format Versatility
Output supports mp3, wav, opus, flac, and pcm formats. Developers can select the optimal codec for their engine’s audio pipeline, balancing file size and quality without needing external conversion tools.
- mp3: Small file size, broad compatibility.
- wav/flac: Lossless quality for high-fidelity needs.
- opus: Efficient compression.
- pcm: Raw data for custom processing.
Limitations
Our API prioritizes deterministic, character-limited synthesis over granular audio control. Developers should expect a straightforward input-output workflow without intermediate formatting layers or complex markup instructions.
No SSML Control
The API does not support Speech Synthesis Markup Language (SSML). You cannot inject pauses, adjust prosody, or modify pronunciation within the JSON payload.
- Standard JSON text input only
- No <break> or <prosody> tags
- Pronunciation defaults to voice model
No Emotion Tags
Voice output lacks explicit emotion tags such as happiness, anger, or sadness. Each preset voice maintains a consistent tonal profile regardless of input text context.
- Fixed emotional tone per voice
- No dynamic emotion injection
- Consistent narrator style
Fixed Voice Library
You are limited to the eight preset voices. Custom voice cloning or uploading your own voice samples is not available for this API tier.
- 8 preset voices only
- No custom cloning
- No voice upload
Use Case Fit
Our API is engineered for the specific constraints of NPC dialogue generation. By enforcing strict character limits and deterministic pricing, we eliminate the unpredictability of monthly TTS subscriptions, allowing developers to budget audio production per asset rather than per seat.
This approach aligns with the iterative nature of game development, where dialogue lines are frequently rewritten, expanded, or cut. You pay only for the final characters rendered, ensuring that development sprints do not incur hidden overhead costs for discarded lines.
Indie Game Development
Indie teams often lack the budget for dedicated voice actors for every minor NPC. Our preset voices provide consistent, high-quality narration for background characters without the per-minute recording fees. The ability to generate 4096-character chunks allows for long monologues, while shorter requests handle quick interactions efficiently.
The deterministic cost structure means you can calculate the exact audio budget for a game with 500 NPCs. There are no surprise charges from usage spikes during final polish, making it easier to secure funding or manage indie dev budgets.
- No upfront voice actor contracts required
- Predictable costs for large cast games
- Supports 23 languages for localisation
Procedural Dialogue
Procedurally generated text often varies in length and tone. Our API accepts raw text input and returns audio files, enabling voice synthesis in games that generate dialogue on the fly. This is ideal for open-world games where NPC conversations are not pre-scripted.
The ability to switch voices dynamically allows for distinct character identities within procedural systems. Since each request is independent, you can assign different presets to different procedural entities without managing complex voice banks or licensing constraints.
- Real-time synthesis for dynamic worlds
- Dynamic voice assignment per entity
- Handles variable text lengths
Prototype Testing
During prototyping, dialogue lines change constantly. Using a traditional TTS service might incur high costs for frequent regeneration. With our per-character billing and free failed requests, you can test dozens of variations without worrying about budget overruns.
The quick generation time allows for rapid iteration cycles. Developers can plug the API into their engine, generate audio for new script drafts, and listen to the result in seconds, accelerating the feedback loop for narrative design.
- Low risk for high-volume testing
- Free retries on failed requests
- Rapid iteration for narrative design

Comparison to Traditional TTS
Traditional cloud TTS providers often require complex infrastructure management and higher minimum spend floors. Our API simplifies this by offering a single, deterministic endpoint with transparent per-character billing, eliminating the overhead of managing multiple voice ecosystems or subscription tiers for small freelance teams.
While major platforms offer broader language support and SSML controls, they also introduce variability in voice selection and stricter data retention policies. We prioritize deterministic output for NPC dialogue, ensuring that the same input text always yields consistent audio files without unexpected feature bloat.
Vs. Azure Cognitive
Azure Cognitive Services provides extensive SSML support and a wider range of neural voices. However, it requires more complex payload structures and often incurs higher costs for short, frequent NPC dialogue requests. Our API keeps the JSON payload minimal, reducing integration time for indie developers.
- Azure offers SSML; we do not.
- Azure has more voices; we have 8 deterministic presets.
- Azure billing is complex; ours is per-character.
Vs. Amazon Polly
Amazon Polly is a mature service with strong integration into AWS ecosystems. For independent game developers not already deep in AWS, this adds unnecessary infrastructure overhead. Our API works with any HTTP client, using the same request shape as OpenAI, making it easier to drop into Unity or Unreal projects without AWS account dependencies.
- Polly requires AWS account; we require only an API key.
- Polly has more languages; we support 23 core languages.
- Polly charges by character; we charge by character.
Vs. Google Cloud TTS
Google Cloud TTS offers high-quality standard and neural voices but typically requires a Google Cloud account and billing setup. Our USDT TRC-20 payment model allows immediate usage without credit card holds or monthly minimums. This is particularly advantageous for freelancers who need to start generating audio assets instantly without administrative friction.
- Google requires credit card; we accept USDT.
- Google has more voices; we have 8 curated presets.
- Google has complex quotas; we have simple rate limits.
Payment Workflow
Funding your EchoMouth account relies on a single, streamlined method: USDT on the TRON network (TRC-20). There are no credit cards, PayPal options, or complex invoicing systems to manage. You simply transfer the minimum $5 or any higher amount directly to the provided wallet address.
This approach eliminates currency conversion fees and third-party payment processor holds. Your balance updates automatically within minutes of network confirmation, ensuring your development pipeline never stalls waiting for administrative approval or bank clearing periods.
USDT TRC-20 Payments
All top-ups are processed exclusively via TRC-20. The minimum deposit is $5, which covers 500,000 characters of synthesis. This cryptocurrency-focused model keeps transaction overhead low and accessible for freelance audio engineers and indie studios operating globally without banking restrictions.
- Supported network: TRON (TRC-20)
- Minimum top-up: $5
- Supported currency: USDT
- No other payment methods available
Instant Credit
Credits appear in your account balance automatically once the blockchain transaction is confirmed. There is no manual review process or waiting period for standard transfers. You can immediately begin generating NPC dialogue or testing voice presets using your new balance.
No Monthly Bills
There are no recurring subscriptions, seats, or minimum spend requirements. You only pay for the characters you consume. Unused credit does not expire, allowing you to pause production during quiet periods without losing your funds. Billing is strictly usage-based.
Developer Experience
Getting started takes minutes. Use the OpenAI SDK or plain HTTP with a single Bearer token. The endpoint mirrors standard speech APIs, so you can swap the base URL and start generating NPC voices immediately without learning a new protocol.
Easy API Setup
Send a POST request to /v1/audio/speech with JSON body containing model, input, and voice. The response returns the audio file directly. You can generate a new API key instantly from the dashboard, invalidating the old one immediately.
- Standard JSON payload structure
- Bearer token authentication
- Instant key rotation
Clear Documentation
The /docs/ page lists all 8 voices, 23 languages, and supported formats (mp3, wav, opus, flac, pcm). Include the exact character limit (4096) and rate limits (60 req/min) in your integration planning. Ready-to-use cURL examples are provided for immediate testing.
Direct Support
For integration questions or billing discrepancies, contact us via email. There is no phone support or live chat; our team responds to technical inquiries directly. Keep your request metadata handy for faster resolution.
Scalability
Scaling NPC dialogue generation requires understanding the hard limits of the API. With a baseline rate limit of 10 requests per minute, small batches may queue, but higher limits of 60 RPM handle steady production flows. Requests are processed sequentially, meaning each request waits for completion before the next, ensuring deterministic output but introducing latency during high-volume bursts.
For large-scale localization or procedural dialogue trees, developers should implement client-side batching. Since requests are processed sequentially under load, splitting texts into 4096-character chunks and managing the queue locally prevents timeout errors and keeps asset pipelines moving without requiring complex infrastructure.
Rate Limits Impact
The API enforces a strict limit of 60 requests per minute per key, with a lower threshold of 10 RPM for new accounts before the first top-up. This constraint directly affects how quickly you can generate dialogue lines for a scene. If your game generates 100 NPC lines simultaneously, the API will process them sequentially within the allowed window, potentially delaying the initial load time.
To mitigate this, batch your requests. Grouping 4096-character texts into single requests reduces the number of API calls needed, staying within the per-minute limit while maximizing character throughput. This approach is particularly effective for indie developers managing localizations or procedural text generation where predictability matters more than instant feedback.
- 60 requests/minute per key after top-up
- 10 requests/minute for new accounts
- Sequential processing under load
Queue Processing
Requests are processed one after another, so under load, a request may wait in a queue. This linear processing ensures that each audio file is generated completely before the next begins, maintaining consistency in voice and format. For game development, this means you can predict the total time required for a batch of N characters based on the real-time generation speed.
The queue is managed server-side, so you do not need to implement complex retry logic for temporary congestion. However, if you are generating thousands of lines for a dialogue tree, consider staggering your requests or using a background job system to avoid hitting the rate limit too quickly.
Volume Scaling
Scaling beyond the rate limit is straightforward: issue a new API key to double your capacity, as each key has its own limit. Since there are no monthly plans or seats, you can scale up or down based on project needs without contractual obligations. This is ideal for freelance audio engineers who may have peak production periods followed by quieter phases.
For very large volumes, split your text into parts of up to 4096 characters and join the audio files client-side. This method allows you to parallelize the generation process if you manage multiple keys, ensuring that your asset production pipeline remains efficient and cost-predictable, with no hidden fees for high usage.
Licensing and Rights
The API output is clear for commercial game dialogue. You can embed the generated audio directly into your project without extra licensing fees. Text input is not used for training models, keeping your script data private.
Voice data originates from licensed recordings. The system provides deterministic results suitable for NPC lines. You own the resulting audio files for your game's asset library.
Commercial Use Allowed
Generated audio files can be used in commercial games, demos, or prototypes. There are no restrictions on how many times you can synthesize text for your project.
- No per-title licensing fees
- Unlimited commercial usage
Voice Source Licensing
Voices are based on licensed recordings from LibriTTS-R (CC BY 4.0) and public-domain LibriVox readings. This ensures legal clarity for asset production.
- CC BY 4.0 source material
- Public domain audiobook origins
Watermark Usage
Every generated file carries an inaudible synthetic speech watermark. This marks the audio as AI-generated for transparency but does not affect gameplay integration.
- Inaudible synthetic watermark
- Automatic on all outputs
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Unlike our model, Azure requires a monthly Azure subscription and potentially higher minimum spend commitments.
23 languages
Any voice speaks any of these languages.
