Frequently asked questions
Why use voice for notifications?
Voice adds a personal touch to SaaS notifications, improving engagement and accessibility. Our API delivers clear, licensed voices that convey tone effectively. Since audio files are returned in the response and not stored, you can cache them as needed for your specific notification workflow without managing large media libraries.
How do I choose the best voice?
Select from eight presets based on your notification’s context. Use aria for warm updates, nova for bright alerts, or atlas for neutral news. Each voice supports all 23 languages. Test different voices with your typical text length to ensure clarity and appropriate tone for your users’ experience.
Can I personalize the voice?
You cannot clone custom voices or upload your own. However, you can adjust the speech speed between 0.25 and 4.0 to change the delivery pace. You can also select from eight distinct voice presets to match your brand’s tone, ensuring consistent audio identity across all notifications.
How do I handle multiple languages?
Send the language parameter with an ISO code to specify the target language explicitly. If omitted, the system guesses the language, defaulting to English for Latin script. This ensures accurate synthesis for all 23 supported languages, preventing mispronunciation in multilingual SaaS applications and global user bases.
What is the best format for notifications?
MP3 is ideal for most web notifications due to its small size and broad compatibility. Use WAV for high-quality local playback. FLAC and PCM are available for specific use cases. Choose the format that best balances quality and bandwidth for your notification delivery method.
How do I cache audio files?
Since generated audio is not stored by our API, you must cache files on your own infrastructure. Store the returned audio files using their unique parameters or a generated ID. Implement cache invalidation based on text changes to avoid regenerating identical notifications, saving costs and reducing latency for users.
What if the API is down?
We do not offer an SLA or uptime guarantee. If the API is unavailable, your request may fail or queue. Implement retry logic with exponential backoff in your notification service. Monitor your API key status and have a fallback mechanism, such as a static audio file or text fallback, ready.
How do I track usage costs?
Monitor your balance and character count on the /get-api-key/ dashboard. Each request charges $0.01 per 1,000 characters. Failed requests are free. Track your API usage via the dashboard to predict costs, ensuring you maintain sufficient balance for continuous notification delivery without unexpected service interruptions due to insufficient funds.
Is voice storage required?
No, our API does not store generated audio. The audio is returned in the response and discarded. You are responsible for storing audio files if you need to replay notifications later. This reduces our storage overhead and gives you full control over your notification media lifecycle and retention policies.
Can I use this for IVR?
Yes, LinguaPulse is suitable for IVR systems. Use WAV or PCM formats for compatibility with most telephony systems. Generate audio files for common prompts and cache them locally to reduce API calls. Ensure your IVR system can handle the audio format and play the files seamlessly for callers.
How do I test the audio quality?
Send short test texts via the API and listen to the returned audio files. Use different voices and speeds to evaluate clarity. Check for artifacts or unnatural pauses. Generation takes a few seconds for short phrases; test latency as well. Adjust parameters until the output meets your quality standards.
What are the rate limits?
You are limited to 60 requests per minute per key. New accounts start with 10 requests per minute until the first top-up. If you exceed the limit, requests may queue or fail. Monitor your usage on the dashboard and implement queuing logic in your application to handle bursts of notifications smoothly.
Do I need to pay per notification?
Yes, you pay per character generated. The rate is $10 per 1 million characters. Failed requests are free. There are no monthly plans or minimum spends. Your balance is deducted automatically upon successful synthesis, ensuring you only pay for the audio notifications that are successfully delivered to your users.
How do I handle errors?
Check the API response status code. If synthesis fails, the charge is returned in full. Implement error handling in your code to retry failed requests or notify users. Common errors include invalid parameters or rate limits. Log error details for debugging and monitor your dashboard for any unusual activity or issues.
Why add voice to notifications?
Voice notifications transform passive SaaS alerts into active, accessible experiences. For visually impaired users, audio provides immediate context without requiring screen reader navigation, ensuring critical updates are received instantly regardless of visual attention.
Urgent system alerts gain higher engagement when delivered as voice, cutting through notification fatigue. This approach reduces cognitive load by allowing users to absorb complex instructions or lengthy text summaries passively, rather than scanning dense UI elements.
Improved accessibility for visually impaired users
Audio notifications allow visually impaired users to receive system updates without interrupting their workflow or relying on visual cues. This ensures equal access to critical SaaS features, such as billing alerts or security warnings, enhancing inclusivity for all users.
- Supports screen readers and audio-only workflows
- Ensures equal access to critical alerts
- Reduces dependency on visual UI elements
Higher engagement rates for urgent alerts
Urgent notifications, such as server outages or payment failures, benefit from voice delivery because audio commands attention more effectively than text badges. Users are more likely to acknowledge and act on voice alerts, reducing response times for critical issues.
- Captures attention in noisy environments
- Reduces time-to-action for urgent alerts
- Increases visibility of critical system status
Reduced cognitive load compared to long text
Complex instructions or detailed error reports can be overwhelming when read as text. Voice notifications allow users to process information passively, freeing mental resources for other tasks. This is particularly useful for multi-step troubleshooting or detailed status updates.
- Allows passive consumption of detailed info
- Simplifies complex instructions and error reports
- Frees mental resources for other tasks
Choosing the right voice
Selecting the appropriate voice profile ensures your SaaS notifications are heard and understood without causing fatigue. The API provides eight distinct presets, each engineered for specific communication styles, allowing you to align audio output with your application’s context.
Neutral voices for system alerts
For critical system status updates, neutral tones prevent unnecessary emotional interpretation. Atlas delivers a clear, news-like delivery suitable for error messages or maintenance warnings, ensuring the information is processed quickly without distraction.
- Atlas: Neutral, news-style delivery ideal for system alerts.
Friendly voices for user updates
- Milo: Friendly, conversational tone for user updates.
Clear narrators for complex instructions
When delivering detailed steps, clarity is paramount. Aria provides a warm, clear narrator voice that excels at articulating complex instructions, while Luna’s soft storytelling style aids in retaining longer informational content.
- Aria: Warm, clear narrator for instructions.
- Luna: Soft, storytelling style for complex content.
Technical integration steps
Implementing TTS in SaaS notifications requires a structured integration path. First, capture each user's voice preference during onboarding or settings. Then, send the notification text to the API endpoint. Finally, handle the returned audio file for delivery or playback.
Capture user preference for voice type
Store the selected voice (e.g., atlas for neutral alerts) in your user database. This ensures consistent delivery of system notifications without requiring real-time selection logic.
Send text to the API endpoint
Construct a JSON body with the text (up to 4096 characters) and the chosen voice. Send a POST request to https://api.play3n3.com/v1/audio/speech using your API key. Include the response_format (mp3 or wav) to match your delivery channel.
- Set
modeltotts-1for standard alerts. - Use
Authorization: Bearer your-keyfor authentication. - Specify
languageif the text is not English to ensure correct pronunciation.
Store or stream the returned audio file
The API returns the audio file directly in the response body. Save this file to a temporary storage bucket with a short TTL, or play it in the client. For email or push notifications, upload the file to a CDN and link the URL.
Handling different languages
Integrating multilingual SaaS notifications requires precise language handling to ensure clarity and accessibility. LinguaPulse supports 23 languages, including Arabic, Chinese, French, and Spanish, allowing your system to serve global users effectively. Proper language detection prevents mispronunciation and maintains the intended tone of your alerts.
By explicitly setting the language parameter, you avoid reliance on heuristic guessing, which defaults to English for Latin scripts. This ensures that non-English Latin text, such as German or Dutch, is synthesized correctly without ambiguity, providing a consistent user experience across different regions.
Detecting user preference
Capture the user’s preferred language during onboarding or in their profile settings. Store this locale code (e.g., 'fr' for French) in your user database. When triggering a notification, retrieve this value to determine the correct voice synthesis parameters.
Ensure your frontend sends this language code alongside the notification payload. This explicit handoff allows your backend to configure the TTS request accurately before sending it to the API.
- Store locale in user profile
- Send locale with payload
- Avoid runtime guessing
Setting the language parameter
Always pass the language field in your JSON body. Although the API guesses language from script, explicit setting guarantees accuracy for languages sharing the same script, like Dutch and English. This eliminates ambiguity and ensures correct phonetics.
LinguaPulse supports 23 languages. If a user’s profile specifies 'de' for German, the API will synthesize the text using the appropriate German voice presets, regardless of the voice model selected.
- Pass
languagein JSON - Supports 23 languages
- Ensures correct phonetics
Fallback to English
If the language field is omitted, the API defaults to English for Latin-script text. For non-Latin scripts, it attempts detection. If detection fails or the language is unsupported (e.g., Vietnamese), the output may sound unnatural.
Implement a fallback strategy in your code. If synthesis fails or returns unexpected audio, retry with language: 'en' or fall back to sending the text notification directly. This ensures the user receives communication even if voice synthesis encounters an edge case.
- Default to English for Latin
- Unsupported languages may fail
- Retry with 'en' or text
Managing audio delivery
Once the API returns the audio file, you must decide how to deliver it to the user. The choice depends on whether you are sending asynchronous alerts or providing real-time playback within your interface.
Storing audio files temporarily
Store generated MP3 or WAV files in your object storage for up to 24 hours. This allows users to retry playback if they missed the initial push notification without re-synthesizing the text.
- Use ephemeral storage to manage costs
- Set a 24-hour expiration policy
- Cache common notification texts to avoid redundant API calls
Sending audio via email or push
Attach the audio file directly to email notifications or include the URL in push notification payloads. Ensure your email provider supports audio attachments and that your push service can handle large payloads.
- Embed audio links in HTML emails
- Include direct URLs in push notifications
- Verify file size limits with your provider
Playing audio directly in the app
Play the returned audio file directly in your app’s media player. This provides a low-latency experience for users receiving urgent system alerts or IVR-style updates.
- Implement native media players for iOS/Android
- Use HTML5 audio tags for web apps
- Ensure seamless playback for voice interfaces
Cost optimization strategies
Optimizing costs in SaaS voice notifications begins with avoiding redundant synthesis. Since the API charges $0.01 per 1,000 characters, re-generating identical alerts wastes credits. Store synthesized MP3s and serve them directly from your storage, ensuring you only pay for unique text variations.
Shorten notification payloads to stay within the 4,096-character limit without unnecessary padding. Choose the standard 'tts-1' model for routine alerts. Both 'tts-1' and 'tts-1-hd' have the same price, so you can choose based on your preference for audio quality.
Caching common notifications
Cache the resulting audio files for recurring notifications like 'password reset' or 'order confirmed.' This eliminates repeated API calls for identical text strings, significantly reducing monthly character consumption.
Implement a simple key-value store mapping notification templates to their generated audio URLs. Serve these static assets directly to users, bypassing the TTS endpoint entirely for known messages.
- Map template IDs to cached MP3 URLs
- Invalidate cache only when template text changes
- Serve cached files via CDN for lower latency
Limiting audio length
Keep notification text concise to minimize character counts. The API charges per character, so trimming fluff directly reduces costs. Aim for clear, direct sentences under 4,096 characters to avoid splitting logic overhead.
Avoid generating audio for every minor system event. Prioritize high-urgency alerts where voice adds value, and use text-only fallbacks for low-priority updates to conserve your balance.
- Trim redundant words before sending to API
- Use concise phrasing to stay under limits
- Avoid audio generation for low-priority events
Using lower cost models for non-urgent alerts
The API offers 'tts-1' and 'tts-1-hd' at the same price. Both models share the same $0.01/1k char rate. Reserve 'tts-1-hd' for complex instructions or critical alerts where audio fidelity impacts user understanding.
Monitor usage to ensure you aren't over-provisioning quality. If a notification is merely informational, the standard model provides clear speech without the need for premium processing, keeping your per-character cost efficient.
- Use 'tts-1' for routine alerts
- Reserve 'tts-1-hd' for critical UX moments
- Both models share the same $0.01/1k char rate
Monitoring usage
Track character consumption in your dashboard to identify spikes in usage. Set alerts for unusual activity to prevent budget overruns before they occur.
Review the billing metadata to see which notification types consume the most characters. Optimize those specific templates to reduce long-term costs.
- Set budget alerts in dashboard
- Review monthly character consumption reports
- Identify high-cost notification templates
Rate limit management
With a limit of 60 requests per minute, batch non-urgent notifications if possible. This prevents queuing delays and ensures urgent alerts are processed immediately.
Implement exponential backoff in your client library to handle rate limits gracefully. This avoids wasted requests that still count toward your limit if they fail due to throttling.
- Implement exponential backoff for retries
- Batch non-urgent notifications to save requests
- Monitor rate limit headers in responses
Error handling for cost efficiency
Failed requests are free, but ensure your error handling distinguishes between transient network issues and permanent failures. Retry only when appropriate to avoid unnecessary API calls.
Log synthesis errors to identify patterns. If a specific voice or format consistently fails, switch to a more reliable configuration to avoid repeated attempts and potential waste.
- Distinguish transient vs. permanent failures
- Log synthesis errors for pattern analysis
- Retry only when appropriate
Best practices for UX
Best practices for UX
Allow users to mute voice notifications
Give users explicit control over audio playback. Since TTS adds an audio layer to your SaaS interface, respecting user preference prevents annoyance. Allow them to toggle voice notifications on or off per notification type or globally in settings.
Provide visual cues alongside audio
Always pair audio with visual indicators. Show a text summary or icon while the audio plays, ensuring accessibility for users with hearing impairments or those in quiet environments. This reduces cognitive load and ensures the message is received regardless of audio context.
Keep notification text concise
Optimize input text for speech synthesis. Shorter texts generate faster and consume less of the 4096-character limit per request. Clear, concise phrasing improves audio clarity, making it easier for users to understand urgent alerts or complex instructions without re-listening.

Error handling in notifications
When synthesis fails, the API returns no charge, so retries are safe. Implement exponential backoff for transient errors like rate limits (60 req/min).
If audio generation fails completely, fall back to displaying the text notification. Ensure your UI degrades gracefully without breaking the user experience.
Retrying failed synthesis requests
Since failed requests are free, you can retry them without cost risk. Use exponential backoff to handle transient network issues or temporary server load. Avoid immediate aggressive retries to prevent hitting the 60 requests per minute limit per key.
- Retry on 5xx errors or timeouts.
- Double the wait time between attempts.
- Stop after 3–4 attempts to avoid queue saturation.
Fallback to text if audio fails
If the audio file cannot be retrieved or is corrupted, display the original text notification. This ensures the user still receives the critical information. Store the fallback text in your notification history for consistency.
Logging synthesis errors for debugging
Log request metadata including timestamp, character count, voice used, and error code. This data helps identify patterns, such as specific voices failing under load or language-specific issues. Use these logs to monitor API health and optimize your integration.
Testing your implementation
Testing your implementation ensures your SaaS notification system delivers clear, reliable audio without unexpected costs or latency issues. By leveraging the free trial credit and systematically evaluating voice outputs, you can validate both technical performance and user experience before full deployment.
Start by using the $0.50 free trial credit to generate test audio files. This allows you to verify API connectivity and response times without financial risk. Use the provided curl example to send sample notification texts and confirm the audio files are generated correctly.
Using the free trial credit
Sign in with Google to receive $0.50 in trial credit, valid for 7 days. This covers approximately 50,000 characters, enough to test various notification scenarios. Use this balance to validate your integration workflow, including API key authentication and request formatting, before committing to paid usage.
- - Sign in with Google to activate trial credit
- - Validate API connectivity and authentication
- - Test up to 50,000 characters of notification text
- - Confirm audio file generation and download
Testing with different voices
Experiment with all eight available voices to determine the best fit for your notification types. Use neutral voices like Atlas for system alerts, friendly voices like Milo for user updates, and clear narrators like Aria for complex instructions. Ensure the selected voice aligns with your brand tone and user expectations.
- - Test neutral voices for system alerts
- - Use friendly voices for user updates
- - Choose clear narrators for complex instructions
- - Evaluate voice clarity across different languages
Verifying audio quality and clarity
Play back generated audio files to assess clarity, pronunciation, and naturalness. Check for consistent audio quality across different notification lengths and languages. Ensure the audio files are playable in your target environments, whether via email, push notifications, or in-app players. Verify that the audio is not distorted and that the speed settings are appropriate.
- - Play back audio files for clarity
- - Check pronunciation and naturalness
- - Verify audio quality across languages
- - Test playback in target environments
Scaling for high volume
Scaling TTS for SaaS notifications requires monitoring API usage and handling rate limits gracefully. LinguaPulse allows 60 requests per minute per key, with a lower limit of 10 per minute before the first top-up. Implementing exponential backoff ensures your application respects these limits without failing abruptly.
Batching requests for efficiency involves splitting longer texts into parts of up to 4096 characters. Since requests are processed sequentially, queueing under load may cause delays. Joining the resulting audio files maintains continuity for notifications like IVR updates or in-app voice messages.
Monitoring API usage
Track your character consumption and request frequency via the dashboard. Each request counts toward your 60-per-minute limit, so monitoring helps prevent throttling during peak notification bursts.
- Check balance and character usage in the dashboard
- Monitor request count per minute per key
Handling rate limits gracefully
Implement exponential backoff in your client code. If you receive a rate limit error, wait and retry. This prevents overwhelming the API, especially when sending urgent alerts to multiple users simultaneously.
- Use exponential backoff for retries
- Respect the 60 requests per minute limit
Batching requests for efficiency
Split texts longer than 4096 characters into smaller segments. Generate audio for each segment and join the files. This ensures long notifications are delivered completely without hitting character limits.
- Split text into 4096-character chunks
- Join generated audio files for final output
Legal and data considerations
LinguaPulse processes input text solely to generate the requested audio file, ensuring it is not used for model training. Generated audio is returned directly in the API response and is not stored on our servers, minimizing data persistence. Only request metadata—such as timestamp, character count, and status—is retained specifically for billing accuracy.
User consent for voice data
Since synthesized voices may sound realistic, obtain explicit user consent before delivering voice notifications. Clearly disclose that the audio is AI-generated to maintain transparency, especially if users might confuse it with human recording.
- Disclose synthetic nature in notification settings
- Allow users to opt out of voice notifications
- Provide visual text fallback for transparency
Data retention policies
We retain request metadata (time, characters, status) strictly for billing purposes. Input text is used only during synthesis and is not archived. Generated audio is not stored after delivery, reducing your storage liability.
- Metadata kept for billing only
- Input text not archived
- Audio not stored post-delivery
Compliance with privacy regulations
Our minimal data retention model aligns with privacy-by-design principles. By storing no audio and limited metadata, you reduce the scope of data processing for compliance audits.
- No audio storage reduces data scope
- Minimal metadata simplifies audits
- No third-party training data usage
Future enhancements
LinguaPulse focuses on delivering a reliable core API for immediate SaaS integration, so future feature development depends on user demand and technical feasibility. We do not promise custom voice cloning or SSML support.
Adding more voice options
We currently offer eight licensed presets based on LibriTTS-R recordings. While we do not offer custom voice cloning, we may introduce additional preset voices if user feedback indicates a need for specific tonal qualities in notification contexts.
Supporting more languages
Our API supports 23 languages. We evaluate new language support based on demand and the availability of high-quality source recordings. Languages like Vietnamese or Thai are not currently supported, as they are not in our licensed dataset.
Integrating with other SaaS tools
We provide a standard REST API compatible with OpenAI SDKs, making integration with tools like Twilio, SendGrid, or custom CRM systems straightforward. We do not offer proprietary plugins or pre-built connectors; you build the integration using our documented endpoints.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Accurate language detection prevents unnatural accents and improves user experience.
23 languages
Any voice speaks any of these languages.
Sources and further reading
- Wikipedia
- curl documentation
- Tether (USDT)
- W3C WAI: making audio and video accessible
- OpenAI API reference: create speech
- ISO 639 language codes
- LibriTTS-R corpus (OpenSLR 141)
- MDN: Web Speech API
- LibriTTS-R paper (arXiv 2305.18802)
- openai-python on GitHub
- Creative Commons Attribution 4.0
- TRON developer hub: TRC-20
