Frequently asked questions
What is the best voice for an RPG protagonist?
Select from eight licensed presets like atlas for neutral news or orion for deep documentary tones. Each voice is based on licensed recordings from LibriVox public-domain audiobook readings. There is no objective 'best' voice; choose the preset that matches your character's narrative style, such as aria for a warm narrator or felix for energetic promo lines.
How do I handle text that exceeds 4096 characters?
Split your input text into parts of up to 4096 characters. Send each part as a separate POST request to the /v1/audio/speech endpoint. Receive the resulting audio files and join them together in your application. This ensures compliance with the single-request character limit while allowing for longer dialogue or narration.
Can I generate audio in real-time during gameplay?
The API does not support streaming, WebSocket, or real-time partial audio. Requests are processed sequentially, so short phrases may take a few seconds to generate. For immediate gameplay needs, cache audio files in advance. Longer texts generate at roughly real-time speed (about 25 characters per second), but latency varies based on queue load.
Does the API support background music mixing?
The API returns raw audio files (mp3, wav, opus, flac, pcm) and does not handle audio mixing. You must mix the generated speech with your background music using your game engine or audio middleware. The API provides only the synthesized voice audio without any embedded sound effects or music tracks.
How do I ensure voice consistency across chapters?
Consistency is achieved by consistently using the same voice preset identifier (e.g., 'atlas' or 'nova') across all API requests. Since voices are based on licensed recordings, the tone remains uniform. Ensure your game logic passes the same voice parameter for the same character regardless of the chapter or scene.
What is the latency like for short phrases?
Short phrases typically take a few seconds to generate. Requests are processed one after another, so under load, a request may wait in a queue. Longer texts generate at roughly real-time speed (about 25 characters per second). Plan your game's audio loading times accordingly to avoid playback delays.
Can I use the API for voice commands in games?
Yes, you can send text to the API to receive an audio file. However, the API does not perform speech-to-text. You must handle voice recognition separately. Send the recognized command text to the POST /v1/audio/speech endpoint to generate the corresponding audio response for the user.
How do I manage API keys in a mobile app?
Each account has one active key issued via the /get-api-key/ page. A new key stops the old one immediately. For mobile apps, embed the key in your client or proxy requests through a backend service to prevent exposure. You can issue a new key at any time via the dashboard.
Is there a limit on the number of voice models?
There are eight voice presets available: aria, nova, luna, sage, felix, milo, atlas, and orion. The API offers two models, 'tts-1' and 'tts-1-hd', which use the same engine and price. You can use any combination of these voices and models without additional model limits.
Can I mix different voices in one audio file?
No, each API request generates a single audio file with one voice. To mix different voices, generate separate audio files for each voice and combine them in your game engine or audio middleware. The API does not support multi-voice synthesis within a single response.
How do I debug audio generation errors?
Check the HTTP status code and response body from the POST request. Failed requests are free, and the charge is returned in full. Ensure your input text is under 4096 characters and your authorization header is correct. Use the official OpenAI SDK or plain HTTP to inspect error details.
What is the recommended speed for narration?
The speed parameter accepts values between 0.25 and 4.0. The default speed is typically suitable for most narration. Adjust the speed parameter in your request to slow down or speed up the voice. Test different speeds to match the pacing of your game's dialogue or instructions.
Do I need to cache audio files to save costs?
Caching is recommended to avoid regenerating identical audio, as you pay per character. Input text is not stored by the API. Generate audio once, save the file, and reuse it in your game. This reduces API calls and costs, especially for static dialogue or repeated phrases.
Can I use the API for non-game projects?
Yes, the API is designed for any text-to-speech need. Send text via POST to receive an audio file. It supports 23 languages and eight voices. Use it for e-learning, audiobooks, or accessibility tools. The pricing is transparent at $10 per 1 million characters, with no monthly plans.
Why Use an API for Game Audio
Lumivoice delivers a reliable text-to-speech API for indie developers seeking consistent audio generation without complex infrastructure. By integrating dynamic voice synthesis, your game can generate unique dialogue on the fly, adapting to player choices in real-time rather than relying on static audio files.
This approach significantly reduces asset storage requirements, allowing smaller teams to manage larger voice catalogs efficiently. With support for 23 languages and eight distinct voice presets, you can localize content or create diverse character rosters without hiring additional voice actors.
Dynamic Voice Generation
Generate unlimited dialogue lines from text inputs up to 4,096 characters. Each request returns an audio file, enabling procedural narration or reactive character responses that scale with your game’s content complexity.
- Audio synthesis via POST requests
- Support for 23 languages with automatic guessing
- 8 licensed voices with distinct tones
Reduced Asset Storage
Store text instead of hundreds of audio files. This reduces bandwidth and disk usage, which is critical for indie games with limited storage budgets. Generated audio is returned in the response and not stored by the API, keeping your server clean.
- Pay only for characters used
- No storage fees for generated audio
- Efficient for large dialogue trees
Multi-language Support
Localize your game effortlessly by switching voices or languages via API parameters. Any voice can speak any supported language, ensuring consistent quality across English, Spanish, Japanese, and 20 other languages without managing separate voice actor contracts.
- 23 supported languages
- Any voice for any language
- ISO code language specification
Choosing the Right Voice
Lumivoice provides eight distinct voice presets, allowing you to assign specific tonal qualities to different game characters. Each voice is derived from licensed recordings, ensuring a consistent and professional baseline for your audio assets without requiring external licensing negotiations.
Matching Character Personalities
Select voices based on narrative function rather than just gender. Use Aria for warm narration or Felix for energetic promotional dialogues. Atlas suits neutral news-style updates, while Orion provides depth for documentary-style exposition within your game world.
- Aria: Warm, clear narrator
- Felix: Energetic, promo style
- Atlas: Neutral, news style
- Orion: Deep, documentary style
Gender and Tone Selection
Choose between female voices (Aria, Nova, Luna, Sage) or male voices (Felix, Milo, Atlas, Orion) to differentiate character roles. Sage offers a calm, instructional tone suitable for tutorials, while Luna provides a soft storytelling experience for cutscenes.
Consistency Across Scenes
Maintain narrative coherence by assigning a single voice preset to a specific character across all scenes. Since the API generates audio dynamically, ensure your game logic passes the correct voice parameter to maintain auditory continuity for the player.
Technical Implementation
Integrating Lumivoice into your game requires sending POST requests to https://api.playr77.com/v1/audio/speech with JSON bodies containing your text, selected voice, and desired format. The API returns the audio file directly, allowing immediate playback or storage within your asset pipeline.
Fetching Audio Files
Use the standard OpenAI SDK or plain HTTP to send your text payload. Specify the model (tts-1 or tts-1-hd), voice preset, and output format (mp3, wav, etc.). The response provides the binary audio data, which you can save locally or play in your game engine.
Caching Strategies
Since voice lines are static, cache generated audio files in your game’s local storage or CDN. This eliminates redundant API calls for repeated dialogue, reducing latency and preserving your character count budget. Re-fetch only when voice settings or text content change.
- Store generated MP3/WAV files in local assets directories.
- Implement a hash-based cache key for unique text-voice combinations.
- Clear cache only when source text or voice preset changes.
Handling API Limits
The API enforces a limit of 60 requests per minute per key. Monitor your usage via the dashboard to avoid throttling. For large dialogue trees, pre-generate audio files during level loading or offline modes to ensure smooth in-game playback without hitting rate limits during active gameplay.
- Limit: 60 requests/minute per key.
- Pre-generate assets during loading screens.
- Monitor usage via the
/get-api-key/dashboard.
Cost Management
Integrating TTS into indie games requires precise budgeting, as costs are strictly tied to character volume. At $0.01 per 1,000 characters, even minor dialogue expansions can impact your total spend. Failed requests incur no charge, providing a safety net during development iterations. Understanding this per-character model helps you allocate funds accurately for voice lines without unexpected overages.
To manage costs effectively, monitor your API usage dashboard regularly. You can start with a free trial credit of $0.50 (valid for 7 days) to test integration without immediate financial commitment. For sustained development, top-ups via USDT on TRON ensure your balance remains available for production builds.
Budgeting for Voice Lines
Calculate the character count for each dialogue script before generation. Since spaces and punctuation count toward the total, precise script estimation prevents budget surprises. Use the API’s rate limits (60 requests/minute) to plan batch generation during off-peak hours, ensuring consistent audio delivery without throttling delays.
- Track character usage per scene via the dashboard.
- Account for punctuation in script word counts.
- Use failed request refunds to offset testing costs.
Optimizing Character Count
Break long dialogues into segments under 4,096 characters to maximize efficiency. Combine shorter lines where context allows, reducing the overhead of multiple API calls. This approach minimizes the number of requests while maintaining audio continuity, ensuring your budget stretches further across large narrative arcs.
- Split texts into <4096 character chunks.
- Combine short lines to reduce API calls.
- Monitor character counts in real-time.
Using Free Trials
Sign in with Google to receive $0.50 in trial credit, valid for 7 days. This allows you to test voice quality and integration speed without immediate payment. Note that email-only accounts start without trial credit, so plan your testing phase accordingly. Use this period to validate audio formats and speed settings.
- Google sign-in grants $0.50 trial credit.
- Credit expires in 7 days.
- Email-only accounts do not receive trial credit.
Quality Control
Quality control ensures generated audio integrates smoothly into the game loop without disrupting immersion. By verifying voice consistency and adjusting parameters, developers can maintain a professional standard across all dialogue and narration assets.
Listening to Samples
Review generated audio files to confirm tone matches character descriptions. Use the eight preset voices to test emotional range before committing to a specific character's voice line.
- Verify voice clarity against background music
- Check for unnatural pauses in long texts
- Ensure consistency across multiple requests
Adjusting Speed Settings
The speed parameter ranges from 0.25 to 4.0, allowing fine-tuning of delivery pace. Adjust this setting to match character traits, such as a slower speed for elderly NPCs or faster speech for excited dialogue.
- Set speed between 0.25 and 4.0
- Match pace to character personality
- Test under varying game loop conditions
Error Handling in Game Loop
Implement fallback mechanisms for API failures. Since requests are processed sequentially, queue management ensures audio plays without blocking the main thread. Failed requests incur no charge, allowing safe retry logic.
- Handle network timeouts gracefully
- Retry failed requests without cost penalty
- Log errors for debugging purposes
Deployment
Deploying Lumivoice requires separating test and production keys to prevent accidental spending during development. Use the email/password or Google sign-up flow to generate distinct credentials for each environment. This separation ensures that experimental voice lines do not consume your primary budget.
Testing in Build Environments
Initialize a dedicated API key for your development builds. This key can be embedded directly into the game client or accessed via a secure backend proxy. Since failed requests are free, you can stress-test voice generation without financial risk.
- Use a separate key for dev builds
- Failed synthesis requests incur no charge
- Embed keys securely in build configurations
Production Key Management
In production, rotate keys periodically using the dashboard to maintain security. The new key becomes active immediately, invalidating the old one. This ensures that compromised keys cannot be used indefinitely for unauthorized audio generation.
- Rotate keys via the dashboard
- Old keys stop immediately upon rotation
- Store production keys in environment variables
Monitoring Usage
Track character consumption against your USDT balance on the dashboard. Since rates are $0.01 per 1,000 characters, monitor usage to avoid unexpected depletion. The dashboard provides real-time visibility into characters left and total usage.
- Monitor character counts on the dashboard
- Track balance against USDT top-ups
- Alert on low balance thresholds
Common Pitfalls
Indie developers often encounter subtle integration errors that break audio playback or inflate costs unexpectedly. These pitfalls are common when moving from prototype to production, particularly regarding language handling and request limits.
Ignoring Language Codes
The API guesses the language from the script, defaulting to English for Latin characters. If you generate German text without setting the language field, the system may pronounce it with an English accent, breaking immersion.
- Always set the
languageparameter for non-English Latin text.
Exceeding Character Limits
Each request supports a maximum of 4096 characters. Sending longer dialogues in a single call will cause synthesis to fail, resulting in missing audio files during gameplay.
Split longer texts into chunks before sending. Join the resulting audio files in your game engine to maintain continuous narration.
- Limit input text to 4096 characters per request.
Rate Limiting Issues
Accounts are limited to 60 requests per minute. If your game triggers many voice lines simultaneously, requests may queue or fail until the window resets.
Pre-generate voice lines during loading screens to avoid real-time generation bottlenecks during critical gameplay moments.
- Monitor your usage dashboard to stay within the 60 RPM limit.

Future Scaling
Lumivoice supports 23 languages, allowing your game to expand globally without new voice recordings. As your player base grows, simply enable additional languages in the API call to reach new markets efficiently.
Adding New Voices
Start with eight curated voices. Since the API handles all synthesis, adding language support requires no new audio assets, only updating the request parameters.
- Use the
GET /v1/voicesendpoint to list available voices and languages. - Select voices that match character archetypes for consistent branding.
Handling Large Text Batches
For long dialogues or narration, split text into chunks under 4096 characters. Generate each part separately and join the audio files in your game engine to ensure stable processing.
- Implement client-side splitting before sending requests to the API.
- Handle potential queue delays by pre-loading audio during menu screens.
Integrating with Game Engines
Use the OpenAI SDK or plain HTTP to send synthesis requests. Integrate the resulting audio files directly into your engine’s audio system for seamless playback during gameplay.
Keep your API key secure within your build environment. Monitor usage via the dashboard to stay within your 60 requests-per-minute limit during intense scenes.
Support and Resources
Access the full API reference at /docs/ to review endpoints, parameters, and authentication details for game integration. The documentation includes ready-to-use cURL examples and SDK configurations compatible with standard HTTP clients.
Support is available exclusively via email. There is no live chat or phone line, ensuring focused, asynchronous assistance for your integration questions.
Documentation Links
Visit the /docs/ page for complete technical specifications. It details request formats, supported voices, and language codes required for non-English text.
- API Endpoint Reference
- Authentication Guide
- Voice Parameters
Community Forums
Community forums are not currently provided by Lumivoice. All support interactions occur directly through our email channel.
Email Support
Send questions to our support email. Responses are provided asynchronously without guaranteed uptime or SLA commitments.
Case Study Example
Lumevoice enables dynamic audio generation for indie projects by converting text scripts into speech files via a simple POST request. This reduces asset storage needs and supports 23 languages without complex infrastructure.
Indie RPG Voiceover
Developers can assign specific voices like 'atlas' for news-style narration or 'nova' for upbeat dialogue. Each request generates a unique audio file, allowing for varied character interactions without recording sessions.
- Supports up to 4096 characters per request
- Voices include aria, nova, luna, sage, felix, milo, atlas, orion
Educational Game Narration
Educational titles benefit from consistent narration across 23 languages. By setting the ISO language code, developers ensure accurate pronunciation for non-English Latin scripts, avoiding default English guessing errors.
- Clear, instructional tones like 'sage' suit educational content
- Automatic language detection works for standard scripts
Accessibility Feature Implementation
Games can offer audio descriptions for visually impaired players by converting UI text or scene descriptions into speech. The API returns audio files that can be played directly in the game loop.
- Generates audio files in mp3, wav, opus, flac, or pcm
- Audio synthesis allows for responsive audio feedback
Tools and Libraries
Lumivoice integrates with existing developer workflows by supporting the standard OpenAI SDK structure. By adjusting the base URL to https://api.playr77.com/v1, you can utilize familiar libraries to generate speech without learning a new protocol.
For lightweight needs, standard HTTP tools handle requests efficiently. Python scripts automate batch processing, while cURL commands allow rapid verification of voice outputs and rate limits during initial setup.
OpenAI SDK Usage
Use the official OpenAI SDK by setting base_url to https://api.playr77.com/v1. This allows you to send POST requests to /v1/audio/speech using the same JSON shape as the OpenAI speech endpoint. Your existing code remains largely compatible, requiring only a key change and base URL update.
Ensure your API key is passed in the Authorization: Bearer header. The SDK handles the JSON serialization for model, input, voice, and response_format fields automatically.
- Set
base_urltohttps://api.playr77.com/v1 - Use standard
tts-1ortts-1-hdmodels - Pass key via
Authorization: Bearerheader
cURL for Quick Tests
Use cURL for immediate verification of voice settings and response formats. A single command can test the aria voice with a short text string, confirming that your key and base URL are configured correctly before full integration.
This method is ideal for debugging specific parameters like speed or response_format without writing a full script.
- Test JSON body structure
- Verify response format (mp3, wav, opus)
- Check authentication headers
Python Scripts for Automation
Python scripts streamline batch audio generation for large dialogue trees. By iterating through a list of text inputs, you can generate multiple audio files sequentially, respecting the 60 requests per minute rate limit.
Scripts can handle the splitting of long texts into 4096-character chunks and join the resulting audio files, ensuring consistent output for game assets.
- Batch process dialogue lines
- Handle 4096-character text splitting
- Manage rate limit delays
Next Steps
To begin, navigate to /get-api-key/ and authenticate via Google or email. Your unique API key appears immediately, accompanied by a ready-to-use cURL example for rapid verification.
Once registered, generate a short sample audio file to validate voice quality and latency. This initial test confirms your integration works before committing to larger production batches.
Sign Up and Get Key
Visit /get-api-key/ to create an account. Google authentication provides an immediate $0.50 trial credit valid for 7 days. Email sign-ups start with zero balance. Your active key is displayed on the dashboard for immediate use.
Test with Sample Text
Send a short text string to the speech endpoint to verify audio format and voice selection. Check that the response returns the expected audio file without errors. This step ensures your game loop handles the response correctly before full deployment.
Plan Your Audio Budget
Calculate costs based on $0.01 per 1,000 characters, including spaces. Estimate total character counts for all voice lines to determine required top-ups. Use the TRON network (TRC-20) for deposits, which are credited automatically within minutes. Balance does not expire.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence.
23 languages
Any voice speaks any of these languages.
