Frequently asked questions
What is the best voice for language learning?
No single voice is best; you have eight presets like Aria or Atlas. Each voice speaks all 23 supported languages. Choose based on your content style, such as Luna for storytelling or Sage for instructional lessons. All voices are synthetic with inaudible watermarks.
How do I specify a language in the API?
Include the optional language field with an ISO code in your JSON body. If omitted, the system guesses the language from the script, defaulting Latin text to English. For non-English Latin text, always set the language explicitly to ensure accurate synthesis.
Can I use the API for children's content?
Yes, voices like nova (bright, upbeat) or luna (soft, storytelling) suit children's content. The API generates audio files you can integrate into your platform. Since voices are synthetic with watermarks, they are distinct from real human recordings, avoiding celebrity voice issues.
Does the API support slow speaking speeds?
Yes, you can set the speed parameter between 0.25 and 4.0. This allows you to slow down narration for better comprehension. The default speed is 1.0. Adjusting speed helps learners process text at their preferred pace without changing the voice character.
How do I handle text with special characters?
Send your text directly in the input field of the JSON body. The API handles standard characters within the 4096 character limit. Spaces and punctuation count as characters. No special escaping is required beyond standard JSON formatting for the request payload.
Is the API suitable for real-time conversation?
No, the API does not support streaming or WebSocket connections. Requests are processed sequentially, which may cause delays under load. It returns a complete audio file after synthesis. This makes it ideal for pre-generated lesson audio rather than live interactive dialogue.
Can I generate audio for a whole book?
Yes, but you must split text into parts of up to 4096 characters per request. Generate each part separately and join the resulting audio files. Typical speed is roughly real-time, so long texts will take time proportional to their length.
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 tts-1-hd model uses the same engine but offers higher audio quality. Choose tts-1 for standard needs or tts-1-hd for superior clarity. The endpoint and request format remain identical for both.
How do I cache audio to save costs?
Store the returned audio files locally or in your cloud storage. Since each request costs $0.01 per 1,000 characters, caching prevents re-synthesizing identical text. The API does not store generated audio, so you are responsible for managing your own audio assets.
Is there a limit to how many lessons I can generate?
You are limited by your API key rate limit of 60 requests per minute. There is no limit on total lessons or characters, only on your balance. Failed requests are free. You can top up with USDT (TRC-20) whenever needed.
Can I use the audio commercially?
Yes, the API provides a reliable endpoint for commercial applications. Voices are based on licensed recordings from LibriTTS-R (CC BY 4.0) and LibriVox public-domain readings. Generated files carry an inaudible watermark marking them as synthetic speech, suitable for integration into your platform.
How do I know which language the API detected?
The API does not return the detected language in the response. If you do not set the language field, Latin script defaults to English. To ensure accuracy, explicitly set the language parameter in your request for non-English Latin text.
What happens if my internet drops during request?
If the request fails, the charge is returned in full. You can retry the request. The API processes requests sequentially, so network issues may cause delays but do not incur costs for failed synthesis attempts. Check your balance after retrying.
Do I need a developer to integrate this API?
A developer is needed to implement the JSON POST requests and handle audio files. The endpoint matches the OpenAI speech format, so existing OpenAI SDKs work by changing the base URL. You can use the provided curl example as a starting point.
Why use voice synthesis in education
Voice synthesis transforms static text into audible instruction, allowing learners to hear correct pronunciation and rhythm without requiring native speakers on staff. By providing immediate auditory feedback, applications can reinforce reading skills and help users internalize the natural flow of target languages.
Improving pronunciation accuracy for learners
Consistent exposure to native-level speech helps learners distinguish subtle phonetic differences. Our API supports 23 languages, ensuring that vocabulary and grammar lessons are delivered with clear, standardized pronunciation that reduces confusion for beginners.
Providing auditory feedback for reading
Text-to-speech enables instant playback of any lesson content. Users can listen to paragraphs while reading, reinforcing the connection between written words and their spoken forms. This dual-coding approach supports retention, especially for complex grammatical structures.
Enhancing engagement with interactive audio
Audio elements break the monotony of text-heavy interfaces. By integrating natural-sounding voices like Aria or Felix, apps can create dynamic quizzes and listening exercises that keep users engaged and motivated to continue their daily practice routines.
Selecting the right voice for lessons
Selecting the appropriate voice preset ensures that synthetic speech aligns with the pedagogical goal of each lesson. LinguaVoice provides eight distinct voices, each suited to different learning contexts, from immersive storytelling to structured instruction.
The voices are derived from licensed recordings, ensuring consistent quality without the need for complex voice design. Product teams should match the voice’s tonal characteristics to the content type to maximize learner retention and clarity.
Using Aria for narrative-based learning
Aria offers a warm, clear narrator tone ideal for reading stories or conversational exercises. Her voice supports natural pacing, making it suitable for immersive language exposure where context aids comprehension.
- Best for: Storybooks, dialogue practice, conversational immersion
- Tone: Warm, clear, narrative-focused
Choosing Atlas for clear instructional content
Atlas provides a neutral, news-like delivery that prioritizes articulation over emotional inflection. This makes it optimal for grammar explanations, definition reading, or technical language lessons where clarity trumps character.
- Best for: Grammar rules, definitions, technical terms
- Tone: Neutral, clear, professional
Leveraging Felix for energetic practice drills
Felix brings an energetic, promo-style energy to repetitive drills or vocabulary quizzes. His upbeat tone can help maintain learner engagement during repetitive tasks that might otherwise feel monotonous.
- Best for: Flashcards, quizzes, repetition drills
- Tone: Energetic, upbeat, engaging
Handling multi-language content
Language learning applications require precise audio generation to avoid confusing learners with incorrect accents or pronunciations. The API supports 23 languages, allowing you to generate accurate speech for diverse student bases without needing multiple voice providers.
Correctly specifying the language ensures the synthesis engine applies the right phonetic rules. This is critical for educational accuracy, especially when dealing with languages that share similar scripts but have distinct phonologies.
Setting explicit language codes for accuracy
Always provide the language field in your request body using the ISO code. This overrides automatic detection and ensures the voice generates the correct accent and intonation pattern for the target language.
For example, sending French text with language: fr prevents the engine from defaulting to English, even if the text contains Latin characters.
- Use ISO codes like
en,de,jafor precise control. - Explicit codes override script-based guessing.
- Ensures consistent accent across lessons.
Detecting language from Latin script text
If you omit the language field, the system guesses the language based on the script. Latin script text defaults to English. This can lead to mispronunciation if the text is actually in another Latin-based language like Spanish or Italian.
Relying on auto-detection is risky for mixed-content apps. Explicitly setting the language field eliminates this ambiguity and guarantees the intended pronunciation.
- Latin script defaults to English.
- Risk of mispronunciation without explicit codes.
- Use ISO codes to override defaults.
Mixing languages in single lessons
You can mix languages by sending separate requests for each language segment. For example, generate an English instruction followed by a French practice phrase using distinct language parameters in each request.
Join the resulting audio files on the client side or server side to create a seamless lesson experience. Each segment is synthesized independently, ensuring language-specific accuracy.
- Send separate requests for each language.
- Join audio files client-side or server-side.
- Maintains language-specific accuracy per segment.
Technical integration steps
Integration begins with authentication via the /get-api-key/ page. Signing in with Google triggers the free trial, granting $0.50 credit valid for seven days. The dashboard displays your active API key and current usage limits.
Generating API keys via Google sign-in
Access the API key from your account dashboard after Google authentication. The key starts with "tts-" and authenticates all requests. You can issue a new key at any time, which immediately invalidates the previous one.
- Sign up via /get-api-key/ using Google
- Retrieve the key starting with "tts-"
- Rotate keys instantly via the dashboard
Configuring the request body with text
Send a POST request to https://api.play93k.com/v1/audio/speech. Include the model ("tts-1" or "tts-1-hd"), input text (max 4096 characters), voice preset, and response format. Set the language ISO code explicitly if the script does not indicate the language.
- Endpoint: POST /v1/audio/speech
- Max 4096 characters per request
- Include Authorization: Bearer header
Processing the audio response in your app
The API returns the audio file directly in the response body. Store this file or play it immediately in your application. Failed requests do not consume your character balance, ensuring cost efficiency during testing.
Optimizing for user experience
To ensure a smooth experience, manage loading states by acknowledging that synthesis takes a few seconds for short phrases and longer for complex texts, as requests are processed sequentially. Display a spinner or progress indicator while the API handles the queue, preventing users from thinking the app has frozen during peak usage times.
Optimize caching by storing generated audio files locally for repeat lessons, reducing redundant API calls and costs. This approach is particularly effective for vocabulary drills where the same text is frequently reviewed, ensuring consistent playback without additional character consumption or network latency.
Adjust the speed parameter between 0.25 and 4.0 to match learner proficiency. Beginners benefit from slower speeds for clearer pronunciation, while advanced users can handle faster playback for natural rhythm. This flexibility allows your app to adapt audio delivery to individual learning needs without requiring separate voice models.
Managing loading states during synthesis
Acknowledge that synthesis takes a few seconds for short phrases and longer for complex texts, as requests are processed sequentially. Display a spinner or progress indicator while the API handles the queue, preventing users from thinking the app has frozen during peak usage times.
This transparency reduces user frustration during high-demand periods when requests may wait in line.
- Use visual spinners for pending requests
- Show 'Processing...' states clearly
- Avoid auto-advance until audio is ready
Caching generated audio for repeat lessons
Store generated audio files locally for repeat lessons, reducing redundant API calls and costs. This approach is particularly effective for vocabulary drills where the same text is frequently reviewed, ensuring consistent playback without additional character consumption or network latency.
Implement a local database or cache to map text inputs to audio URLs, ensuring instant playback for known phrases and preserving user data privacy since input text is not used for training.
- Cache audio for repeated phrases
- Map text to audio URLs
- Reduce API calls for reviews
Adjusting speed for different proficiency levels
Adjust the speed parameter between 0.25 and 4.0 to match learner proficiency. Beginners benefit from slower speeds for clearer pronunciation, while advanced users can handle faster playback for natural rhythm. This flexibility allows your app to adapt audio delivery to individual learning needs without requiring separate voice models.
Offer a speed control slider in your UI, allowing users to fine-tune playback speed for better comprehension. This feature enhances accessibility and supports diverse learning styles effectively.
- Set speed for beginners (slow)
- Set speed for advanced users (fast)
- Provide user-controlled speed slider
Cost management for scaling apps
Predictable pricing is essential for scaling language learning applications. With a flat rate of $10 per million characters, you can accurately forecast expenses based on lesson length. This simplicity helps product teams align audio generation costs with user growth without unexpected overages.
Managing usage requires monitoring character consumption and balance through the dashboard. Since requests are processed sequentially, longer texts may queue, but costs remain strictly tied to character count. Failed requests are free, ensuring you only pay for successful audio generation.
Estimating character counts for lessons
Calculate costs by counting all characters, including spaces and punctuation. For example, a 4,000-character lesson costs $0.04. Use this metric to budget effectively for daily user interactions.
bullets
Monitoring usage via the dashboard
Track your balance and character usage in real-time. The dashboard provides clear insights into consumption patterns, helping you identify high-usage areas without manual calculation.
bullets
Topping up with USDT for seamless growth
Top up your account using USDT on the TRON network (TRC-20). Minimum deposits are $5, and credits are applied automatically within minutes. This method avoids traditional payment friction, supporting scalable growth without monthly subscriptions or invoices.
bullets
Common pitfalls and solutions
Integration reliability depends on understanding API constraints. Product teams often overlook rate limits or assume instant audio delivery, leading to poor user experiences during peak lesson times.
Handling rate limits during peak usage
Each key allows 60 requests per minute. If your app sends multiple parallel requests for a lesson, you may hit this cap. Requests are processed sequentially, so under load, synthesis may wait in a queue.
- Implement exponential backoff for 429 errors.
- Pre-generate audio for common phrases during off-peak hours.
- Queue requests if the user is browsing, not actively listening.
Dealing with failed synthesis requests
Synthesis failures occur but are free. If the API returns an error, no charge is applied, and the credit is returned instantly. However, your app must handle these gracefully without confusing the learner.
- Check the
statusfield in the response. - Retry once after a short delay.
- Notify the user if retries fail.
Ensuring consistent audio quality
Quality depends on the response_format chosen. MP3 is efficient, but WAV or FLAC may be needed for high-fidelity language learning. Ensure your player supports the selected format to avoid playback issues.
- Test playback across different devices.
- Use MP3 for general use, WAV for archiving.
- Verify codec compatibility in your media player.

Data privacy considerations
Data handling in your language learning app begins with clear boundaries. Input text is used solely to generate the audio response and is never repurposed for training our models. This ensures that learner content remains private and distinct from model development datasets.
The generated audio files are returned directly in the API response and are not stored on our servers after delivery. Only request metadata—such as timestamp, character count, and status—is retained, strictly for billing and usage verification purposes.
Understanding input text usage policies
We do not use your input text for training. This policy applies to all content sent via the API, ensuring that proprietary lesson materials or user-generated exercises remain exclusive to your application.
Text is processed in real-time to produce the audio file. Once the synthesis is complete and the audio is delivered, the original text input is not retained for future model improvement or analysis.
- Input text is used only for generation.
- Not used for model training.
- Content remains proprietary to your app.
Knowing that audio is not stored
Generated audio is transient. It is transmitted to your client and not archived on our infrastructure. This reduces data retention liabilities and simplifies compliance with storage regulations.
Only the metadata required for billing—time, character count, and status code—is kept. This minimal data set ensures accurate invoicing without storing the actual audio content long-term.
- Audio is not stored on our servers.
- Only billing metadata is retained.
- Reduces long-term storage liabilities.
Compliance with synthetic speech marking
Every audio file generated by our API contains an inaudible watermark. This marks the content as synthetic speech, providing transparency for end-users and helping meet emerging regulatory standards for AI-generated media.
This watermark is embedded automatically during synthesis, requiring no additional configuration from your team. It serves as a clear indicator that the audio is machine-generated, aiding in content authenticity verification.
- Inaudible watermark marks synthetic speech.
- Embedded automatically during synthesis.
- Aids in content authenticity verification.
Support and troubleshooting
Support is limited to email; there is no live chat or phone number available for immediate assistance. For technical issues, the documentation provides specific error codes and request shapes to help you diagnose problems quickly.
Contacting support via email
Our team handles all inquiries through email. While we do not offer phone support or live chat, our engineers respond to technical questions regarding integration and billing.
Checking documentation for errors
Refer to the /docs/ endpoint for precise error responses. The API returns clear status codes when requests fail, such as invalid characters or model errors, allowing you to adjust your payload immediately.
- Use the /v1/models endpoint to verify available models
- Check request format against the /v1/audio/speech schema
Verifying key status and balance
Your account dashboard displays your current balance, character usage, and active key status. If a key is revoked, the old one stops instantly, so ensure you update your app’s configuration in /get-api-key/.
- Check balance for accurate cost forecasting
- Verify key status after issuing a new one
Future-proofing your integration
To ensure long-term stability, structure your integration around the standard OpenAI-compatible request shape. This allows seamless updates to underlying models without requiring major code refactors, as the API contract remains consistent across endpoints like /v1/audio/speech and /v1/voices.
Monitor your usage dashboard regularly to track character consumption against your USDT balance. Since rate limits are fixed at 60 requests per minute per key, anticipate scaling needs by implementing client-side queuing or splitting longer texts into 4096-character chunks before sending them.
Adapting to potential format changes
Rely on the documented request fields (model, input, voice, response_format) rather than hardcoding specific engine behaviors. The API supports standard formats like mp3, wav, opus, flac, and pcm, ensuring compatibility with most educational audio players.
- Use standard OpenAI SDKs with a custom base_url for easy migration.
- Handle
response_formatoptions explicitly to support diverse learner devices.
Monitoring rate limit updates
The current limit is 60 requests per minute per key, with a lower 10 requests per minute threshold before the first top-up. Track your API key status via the dashboard to avoid unexpected throttling during peak lesson times.
- Implement exponential backoff for retry logic when hitting limits.
- Switch keys if you need higher throughput, as old keys stop immediately upon issuing a new one.
Planning for voice library expansions
While current voices are based on licensed recordings, the library may expand. Fetch the available voices dynamically via GET /v1/voices to ensure your UI reflects the latest presets, such as Aria for narrative or Atlas for news-style content.
- Dynamically populate voice dropdowns from the API endpoint.
- Test new voices with sample texts to verify tone suitability for your curriculum.
Case study: Vocabulary app integration
A flashcard application can integrate LinguaVoice to generate pronunciation audio on demand. Users input text up to 4,096 characters, and the API returns audio files in formats like MP3 or WAV. This workflow allows learners to hear correct articulation for each new vocabulary item without pre-downloading large media libraries.
Setup for a simple flashcard app
The integration requires generating an API key via Google sign-in. The app sends a POST request to the speech endpoint with the target word, voice selection (e.g., Aria for narrative context), and language code. The returned audio file is then displayed alongside the card definition.
- Use Google sign-in for immediate API key access
- Set explicit ISO language codes to prevent guessing errors
- Cache audio responses to reduce redundant API calls
User feedback on voice clarity
Luna’s soft tone suits narrative-based learning. The inaudible watermark confirms synthetic origin without affecting listening quality. Users can adjust the speed between 0.25 and 4.0 to match proficiency levels.
Cost analysis of 1,000 daily users
Assuming each user reviews 50 cards daily, each containing 20 characters, the monthly volume reaches approximately 3 million characters. At $10 per million characters, the base cost is $30. With a free trial credit of $0.50, the initial cost is minimal. Top-ups via USDT TRC-20 handle subsequent billing seamlessly without monthly subscriptions.
Next steps for product teams
Product teams can begin by creating an account via Google to receive $0.50 in trial credit, valid for seven days. This allows immediate access to the API without requiring a payment method or credit card on file.
Signing up for a free trial
Visit /get-api-key/ and authenticate with your Google account. You will instantly receive a Bearer key and see your initial balance of approximately 50,000 characters. This trial period lets you validate the integration logic before committing to USDT top-ups.
- Google sign-in required for instant credit.
- Trial expires after 7 days.
- No credit card needed to start.
Testing with sample texts
Send POST requests to https://api.play93k.com/v1/audio/speech using the provided SDK or curl. Test all eight voices across the 23 supported languages, ensuring you set the language parameter for non-English Latin text to avoid incorrect English defaults. Verify that audio generation completes within expected timeframes and that the MP3 or WAV response is playable.
- Set explicit
languagecodes for accuracy. - Test all 8 voice presets.
- Verify MP3/WAV playback.
Deploying to production environments
Once validated, generate a permanent API key via the dashboard. Monitor your balance and usage metrics through the dashboard interface. When credits run low, top up with USDT (TRC-20) for automatic credit within minutes. Ensure your application handles the 60 requests-per-minute rate limit by implementing queuing logic for long texts.
- Generate permanent key via dashboard.
- Top up with USDT (TRC-20).
- Handle 60 req/min rate limit.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. We must design intuitive learning paths that adapt to each user's unique pace and style for maximum engagement.
23 languages
Any voice speaks any of these languages.
