Frequently asked questions
Which voice is best for notifications?
Q: Which voice is recommended for notifications? A: Sage offers a calm, instructional tone ideal for step-by-step guidance. Milo provides a friendly, conversational voice for user-centric messages. Aria’s warm style works well for general updates, while Felix suits promotional alerts. Since every voice supports all 23 languages, choose based on your specific context rather than assuming one is universally superior.
How do I integrate with React?
Use the official OpenAI SDK by setting the base URL to https://api.playpx9.com/v1. Pass your Bearer token in the Authorization header. Send a POST request to /v1/audio/speech with your text, model, and voice. The API returns the audio file directly. You can then play it using standard HTML5 audio elements or Web Audio API in your React components.
Can I use TTS in mobile apps?
Yes, you can call the REST API from any mobile environment that supports HTTP requests. There is no dedicated mobile SDK, but standard HTTP libraries work perfectly. You send text via POST and receive the audio file. Ensure you handle network latency and caching appropriately, as the API processes requests sequentially and may queue under load.
How do I handle long texts?
The API accepts up to 4096 characters per request. For longer texts, split your content into chunks of this size. Generate audio for each chunk individually, then join the resulting audio files on your side. This ensures reliable synthesis without hitting character limits. Failed requests are free, so retry logic works seamlessly for individual parts.
What is the best format for web?
Q: What is the recommended format for web? A: MP3 is the most widely supported format for web playback. WAV offers uncompressed quality but larger file sizes. Opus provides efficient compression suitable for bandwidth-constrained environments. FLAC offers lossless quality. PCM is raw data. Choose MP3 for broad compatibility or Opus for efficiency, depending on your specific web application requirements and player support.
How do I cache audio?
Since generated audio is not stored by the API, you must cache it on your own servers or CDN. Store the audio file using the input text as a key. Cache headers depend on your content’s volatility. For static notifications, long-term caching is effective. For dynamic content, use shorter TTLs. This reduces API calls and speeds up user experiences.
Can I use TTS for alerts?
Yes, the API is well-suited for alert notifications. Use voices like Felix for energetic alerts or Aria for clear warnings. Generate audio on-demand or cache common alert sounds. Note that requests are processed sequentially, so under heavy load, alert generation might queue. Ensure your alert system handles potential delays gracefully without blocking the user interface.
How do I monitor usage?
Check your dashboard at /get-api-key/ to view your balance, characters used, and trial status. The API keeps request metadata for billing purposes. You can also track your own usage by counting characters sent in your application logs. Each request consumes characters based on the input text length, including spaces and punctuation.
What if I exceed rate limits?
The limit is 60 requests per minute per key. If you exceed this, requests may queue or fail. Before your first top-up, the limit is 10 requests per minute. Monitor your usage via the dashboard. If you need higher throughput, consider caching audio for common texts or splitting long texts efficiently to reduce total request counts.
Can I use multiple voices?
Yes, you can use any of the 8 voices in any request. Select the voice that best fits the context of your notification. Each voice has a distinct tone, from warm (Aria) to deep (Orion). You can switch voices dynamically based on the message type or user preference, as all voices support all 23 languages.
How do I change language?
Set the optional language field in your request body to the ISO code of the desired language. If omitted, the system guesses the language, defaulting to English for Latin script. For non-English Latin text, explicitly set the language to ensure accurate synthesis. All 8 voices can speak all 23 supported languages fluently.
Is the API secure?
Use your Bearer token in the Authorization header for authentication. Each account has one active key, which can be rotated instantly. Input text is used only for synthesis and not for training. Audio is returned in the response and not stored by the API. Metadata is kept for billing. There is no specific SLA or uptime guarantee.
Can I use TTS for IVR?
Yes, the API supports WAV, MP3, and other standard formats suitable for IVR systems. Generate audio files for common prompts and cache them for low latency. Note that requests are processed sequentially, so high-volume IVR systems may experience queuing during peak times. Ensure your IVR handles audio file delivery efficiently to maintain call flow.
How do I debug errors?
Check the HTTP status code and response body for error details. Ensure your Bearer token is correct and active. Verify that the model, voice, and format are valid. If a request fails, it is free. Use the dashboard to check your balance and usage. For persistent issues, contact support via email, as there is no live chat.
Why Use TTS in SaaS Notifications
Audio alerts transform passive SaaS notifications into engaging, immediate experiences. By delivering voice updates, you capture attention more effectively than text alone, ensuring users notice critical system events or updates without needing to stare at their screens.
Increase engagement with audio alerts
Voice notifications stand out in crowded inboxes and dashboards. They deliver a personal touch that text cannot match, encouraging users to interact with your platform more frequently and reducing the likelihood of ignored alerts.
Accessibility for visually impaired users
Audio notifications provide essential accessibility for users with visual impairments or screen reader dependencies. Offering TTS ensures your SaaS is inclusive, complying with modern digital standards and widening your potential user base without extra effort.
Modernize user interface experience
Integrating TTS signals a modern, developer-forward approach to your interface. It shows you value user experience beyond basic text, offering a richer, multi-sensory interaction model that keeps your application feeling fresh and technologically current.
Choosing the Right Voice
Selecting the right voice ensures your SaaS notifications resonate with users without feeling robotic. Readly API offers eight distinct presets, each designed for specific tonal contexts. Choosing wisely enhances accessibility and user engagement by matching audio tone to notification intent.
Aria for warm notifications
Aria provides a warm, clear narrator style ideal for general alerts. Her tone is approachable yet professional, making her suitable for reminders, welcome messages, or gentle nudges. This voice helps maintain a friendly connection with users during routine interactions.
- Best for: reminders, welcome messages, gentle nudges
- Tone: warm, clear, approachable
Atlas for neutral news updates
Atlas delivers a neutral, news-style delivery perfect for system updates or status reports. His consistent pacing ensures clarity without emotional bias. Use Atlas when you need to convey factual information efficiently, such as server maintenance notices or data processing completions.
- Best for: system updates, status reports, factual info
- Tone: neutral, consistent, clear
Felix for energetic promos
Felix brings an energetic, promo-style voice to promotional messages. His upbeat tone captures attention effectively for sales, discounts, or feature highlights. This voice adds dynamism to marketing-driven notifications, encouraging user interaction without feeling overly salesy.
- Best for: promotions, discounts, feature highlights
- Tone: energetic, upbeat, dynamic
Setting Up the API
Getting started with Readly API requires minimal setup. First, sign up on the /get-api-key/ page using Google or email to receive your unique API key. This key authenticates your requests and tracks your character usage against your balance.
You can integrate the API using the official OpenAI SDK or plain HTTP. Since the endpoint mimics the OpenAI speech format, you can reuse existing client code by simply adjusting the connection parameters to point to our infrastructure.
Sign up and get API key
Visit /get-api-key/ and register via Google or email. Your account dashboard displays your active API key, current balance, and a ready-to-use cURL example. You start with a $0.50 trial if you use Google sign-in, giving you about 50,000 characters to test immediately.
- Accounts are per-site; keys are active immediately.
- One key per account; issuing a new one invalidates the old.
Install OpenAI SDK or use HTTP
Use the OpenAI SDK for convenience, or send standard POST requests via any HTTP library. The request shape matches the OpenAI speech endpoint exactly, so no custom parsers are needed for JSON bodies or audio responses.
- Supports standard JSON input/output.
- Works with any language that handles HTTP POST.
Configure base_url correctly
Update your SDK’s base URL to https://api.playpx9.com/v1. Ensure your Authorization header includes Bearer tts-... with your specific key. This directs traffic to our TTS engine while keeping your integration familiar if you are migrating from other providers.
- Base URL: https://api.playpx9.com/v1
- Header: Authorization: Bearer tts-<your-key>
Making Your First Request
Sending a TTS request is straightforward: POST a JSON body to the speech endpoint with your text and chosen parameters. The API returns an audio file directly in the response, ready for immediate playback or storage.
Construct JSON body with text
Your request body must include the input field with your notification text (max 4096 characters) and the model (either tts-1 or tts-1-hd). You can also set voice (e.g., aria for warm alerts) and speed if needed. Include your API key in the Authorization header.
Specify voice and format
Choose a voice that matches your notification tone, such as atlas for neutral updates or felix for promos. Select response_format based on your needs: mp3 for broad web compatibility, wav for high quality, or opus for efficiency. If the language isn't clear from the script, explicitly set the language parameter.
Handle response audio file
The API returns the audio file directly in the response body. Save this file or stream it to your user interface. Ensure your code handles the binary data correctly and plays it without delay for a seamless user experience.
Handling Errors
Robust error handling ensures your SaaS notifications remain reliable even when the API encounters issues. Understanding the difference between client-side mistakes and server-side transient failures allows you to build resilient integrations without unnecessary user friction.
Check HTTP status codes
Always inspect the HTTP status code returned by the POST request. A 400 error indicates invalid JSON, missing fields, or an invalid voice ID, while a 401 signals an expired or incorrect API key. A 429 means you have exceeded the 60 requests per minute limit.
Retry on transient failures
Implement exponential backoff for 500 or 503 errors, which indicate temporary server-side issues. Since requests are processed sequentially, brief delays often resolve queue congestion. Do not retry on 4xx errors unless you are correcting the input data, as repeated requests will fail identically.
- Retry
500and503errors with increasing delays. - Do not retry
400or401errors without changing the request.
Log errors for debugging
Log the request payload, timestamp, and error response body to quickly identify issues during development. Since failed requests are free, you can safely retry or adjust parameters without worrying about cost, but logging helps you spot patterns like consistent failures for specific voice models.
Optimizing Costs
Cost efficiency matters for indie SaaS. Readly API charges $0.01 per 1,000 characters, making it predictable for budgeting. Failed requests are free, so you only pay for successful synthesis.
Start by using the free trial credit. Then monitor usage closely to avoid surprise bills. Caching repeated audio saves characters and money.
Use free trial first ['Sign up with Google to receive $0.50 credit (approx. 50,000 characters) valid for 7 days. This lets you test integration without spending real money. Email/password accounts start without this bonus.'] ['$0.50 trial credit', '7-day validity', 'Google sign-up only']
Monitor character usage ['The dashboard shows your balance and characters left. Since spaces and punctuation count as characters, plan your text length carefully. Failed requests do not charge you, but successful ones do.'] ['Track balance in dashboard', 'Count all characters', 'No charge for failures']
Cache audio for repeated texts ['Store generated audio files locally or in your CDN. If a notification text repeats often, reuse the audio file instead of making a new API call. This reduces character consumption and costs.'] ['Store audio in CDN', 'Reuse for repeated texts', 'Reduce API calls']
Managing Rate Limits
Rate limits protect our shared infrastructure while keeping costs predictable. Each API key allows 60 requests per minute, dropping to 10 per minute for new accounts before the first top-up. This ensures fair usage without unexpected throttling during peak development hours.
Queue requests if needed
Implement a simple queue in your backend to handle bursts. If your notification system sends many alerts simultaneously, buffer requests to stay within the 60 req/min limit. This prevents 429 errors and ensures no user alert is lost.
- Buffer outgoing requests in a local queue
- Process requests sequentially to respect the 60 req/min limit
- Handle 429 errors with exponential backoff
Monitor requests per minute
Track your usage via the dashboard. Since requests are processed one after another, high volume may cause slight queuing delays. Monitoring helps you adjust your notification timing to avoid congestion during peak times.
- Check the dashboard for real-time usage stats
- Watch for queue delays on long texts
- Adjust sending frequency based on load
Upgrade limits with top-up
While the base limit is fixed, ensuring your account has funds prevents any interruption. Top-ups via USDT (TRC-20) are credited automatically within minutes. A funded account maintains steady operation without the initial 10 req/min restriction.
- Top-up with USDT on TRON network
- Minimum top-up is $5
- Credits are automatic and immediate
Supporting Multiple Languages
Supporting multiple languages ensures your SaaS notifications reach a global audience without requiring separate voice models for each region. By explicitly setting the language parameter, you guarantee consistent pronunciation and tone, even for Latin-script texts that might otherwise default to English. This explicit control prevents misinterpretation and keeps the user experience predictable across different locales.
You can also rely on automatic detection for simple cases, but testing all supported languages helps catch edge cases where the script might confuse the model. With 23 supported languages, you can cover major markets without extra integration effort, ensuring your audio alerts sound natural whether they are in Spanish, Japanese, or Arabic.
Set language parameter explicitly
Always include the language field in your JSON body, using the ISO code (e.g., "es" for Spanish). This overrides the default detection, which assumes Latin text is English. Explicit settings prevent your German or French notifications from sounding like heavily accented English, ensuring clarity for non-English speakers.
This approach is critical for mixed-script inputs or when your default UI language differs from the notification content. It keeps your integration simple and robust, avoiding the need for complex logic to guess the user's preferred language based on text alone.
- Use ISO codes like
"de","fr", or"ja" - Overrides default Latin-to-English assumption
- Ensures consistent pronunciation for specific locales
Handle auto-detection defaults
If you omit the language field, the API guesses based on the script. Latin script defaults to English, while Cyrillic or CJK scripts trigger their respective models. This works well for simple cases but can fail if you send French text without the "fr" tag, resulting in an English pronunciation.
Detecting the language automatically saves a few lines of code, but it is less reliable than explicit settings. For production SaaS notifications, explicit is better than implicit, as it removes ambiguity and ensures the voice sounds correct regardless of the input text's character set.
- Latin script defaults to English
- Cyrillic/CJK scripts auto-select their model
- Less reliable than explicit settings
Test all 23 supported languages
Our API supports Arabic, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, and Turkish. Test each voice in these languages to ensure the tone matches your brand’s voice. For example, use aria for warm Spanish notifications or atlas for neutral Russian updates.
Verification is simple: send a short test text for each language and verify the output. Since voices are licensed and consistent, once you find the right voice-language combination, you can confidently deploy it across your entire user base without worrying about regional pronunciation quirks.
- Supports 23 languages including Arabic and Hindi
- Test voices like
novafor upbeat English - Verify tone matches brand guidelines
Audio Format Selection
Choosing the right audio format balances file size, compatibility, and quality for your SaaS notifications. Our API supports MP3, WAV, OPUS, FLAC, and PCM via the response_format parameter.
Select formats that align with your delivery channel. Web players handle MP3 universally, while internal systems may prefer uncompressed WAV for editing or efficient OPUS for bandwidth saving.
Use MP3 for web compatibility
MP3 is the safest choice for general web delivery. It offers broad browser support and small file sizes, making it ideal for push notifications or in-app audio players where bandwidth matters.
Use WAV for high quality
WAV provides uncompressed, lossless audio. Use this format when you need maximum fidelity for archival purposes or if your internal processing pipeline requires raw PCM data without encoding artifacts.
Use OPUS for efficiency
OPUS delivers excellent audio quality at very low bitrates. It is perfect for mobile apps or environments where data usage is limited but clear speech remains critical for user comprehension.

Testing Integration
Before going live, verify that your integration handles both success and failure cases correctly. Use the free trial credit to send small batches of text and confirm the audio files are generated as expected.
This step ensures your code correctly parses the response and stores or plays the audio without unexpected errors during real user notifications.
Send test texts
Start by sending short, simple texts using the tts-1 model. Verify that the API returns a 200 status code and that the audio file is attached correctly in the response body.
Ensure you are using the correct base_url and that your API key is valid. Check that the character count matches your expectations.
- Use the free trial credit for initial tests.
- Send texts under 100 characters first.
- Verify the JSON response structure.
Verify audio playback
Download the returned audio file and play it in a standard media player. Check that the voice, speed, and format match your request parameters.
Ensure the audio is clear and free of distortion. Test different voices like Aria or Atlas to confirm they sound as expected.
- Play files in MP3 and WAV formats.
- Check audio clarity and speed.
- Verify voice selection accuracy.
Check error responses
Test invalid inputs, such as exceeding the 4096 character limit or using an invalid voice name. Ensure your code handles 4xx errors gracefully.
Log error messages and status codes to help with debugging. Verify that failed requests do not incur charges.
- Test 400 Bad Request errors.
- Check 401 Unauthorized errors.
- Log error details for debugging.
Deployment Strategies
Deploying TTS in SaaS requires balancing latency with cost. Since synthesis takes time and requests queue under load, you can avoid blocking the user interface by processing audio generation in the background. This ensures your app remains responsive while audio files are prepared.
For a smoother experience, you can implement a polling mechanism. The frontend checks a status endpoint while the backend generates the audio, then plays the file once ready. (Note: The API does not provide a dedicated status endpoint; you must implement your own tracking or use simple polling based on your backend logic.)
Asynchronous processing for long texts
Split input text into chunks of 4096 characters. Send each chunk as a separate request to your API endpoint. Once all parts return, concatenate the audio files client-side or via a server-side script before delivering to the user.
- Limit each request to 4096 characters to avoid truncation.
- Process chunks sequentially or in parallel depending on your rate limits (60 req/min).
- Reassemble files using standard audio libraries like ffmpeg or native JS APIs.
Streaming-like UX with polling
Use a simple status endpoint or webhooks to notify your frontend when synthesis is complete. This approach works well for notifications where immediate playback isn't critical but user experience is.
Implement exponential backoff for polling to avoid hitting rate limits. Display a loading state that indicates audio is being prepared, enhancing perceived performance.
- Send a POST request to generate audio.
- Poll a status endpoint every 2-5 seconds.
- Play the audio URL once status is 'completed'.
Cache results to save costs
Store generated audio files locally or in object storage if the same text is repeated. Since input text determines the output, identical strings will produce identical audio files.
Cache keys can be simple hashes of the input text. This reduces API calls and lowers your monthly character consumption significantly for frequent notifications.
- Hash the input text to create a cache key.
- Store the returned audio file with the key.
- Check cache before making a new API request.
Common Pitfalls
Even a simple TTS integration can stumble on technical details that seem minor but break your user experience. By avoiding a few common traps, you ensure your SaaS notifications remain reliable and cost-effective without unexpected surprises.
Exceeding character limits
The API accepts up to 4096 characters per request. If your notification text is longer, the synthesis will fail. You must split the input into chunks, generate audio for each, and concatenate the files before playback.
- Check text length before sending.
Ignoring rate limits
You are limited to 60 requests per minute (10 before the first top-up). Sending too many concurrent notifications will cause delays or errors. Implement a simple queue in your backend to respect these limits smoothly.
- Implement request queuing.
Misconfiguring base_url
When using the OpenAI SDK, you must update the base_url to https://api.playpx9.com/v1. Using the default OpenAI endpoint will result in authentication failures or incorrect model handling. Always verify your base URL configuration.
- Update base_url for OpenAI SDK.
Monitoring Usage
Keeping track of your TTS usage ensures your SaaS notifications run smoothly without unexpected interruptions. The dashboard provides a clear view of your character consumption, helping you stay within your budget and avoid service disruptions.
Track characters in dashboard
Monitor your character usage in real-time via the dashboard. Since spaces and punctuation count toward the limit, tracking usage helps you optimize text length and manage costs effectively. You can also view your current balance and remaining trial credits.
Set alerts for low balance
Configure notifications to alert you when your balance drops below a certain threshold. This prevents sudden service interruptions for your users, especially if you rely on TTS for critical SaaS notifications. You can top up with USDT (TRC-20) to restore service quickly.
Review billing monthly
Review your billing summary regularly to understand your consumption patterns. Since failed requests are free, you can distinguish between successful and failed usage. This helps you optimize your integration and ensure you are only paying for delivered audio files.
Future Scaling
As your SaaS grows, you can leverage the full range of eight voices to match different notification types. Use Aria for warm updates or Atlas for neutral news, ensuring the tone fits your user base without needing extra engineering effort.
Since the API supports 23 languages, you can easily localize your app globally. Simply pass the correct ISO code in the request to ensure accurate speech synthesis, expanding your reach without building separate voice pipelines.
Add more voices as needed
You can switch between any of the eight presets, such as Felix for energetic promos or Luna for storytelling, by updating the voice parameter. This allows you to A/B test which voice resonates best with your users without changing your infrastructure.
Since voices are generated on the fly, you don't need to manage audio assets. You can introduce new voice styles instantly by just changing the request body, keeping your codebase simple and your UX fresh.
- Switch voices via simple API parameter changes
- A/B test voice tones for notifications
- No asset management required
Expand language support
The API natively supports 23 languages, from Arabic to Turkish. To ensure high-quality synthesis, always set the language parameter explicitly, especially for Latin-script texts that aren't English, as the default guess might be incorrect.
You can scale your user base internationally without hiring voice actors. Each request generates fresh audio, so you can support rare languages or dialects as long as they are in the supported list, with no extra setup cost.
Keep track of the supported languages to avoid auto-detection errors. If a user's language isn't guessed correctly, the language field ensures the output matches their expectation.
- Support 23 languages out of the box
- Set
languageparameter for accuracy - Scale globally without new voice assets
Integrate with notification systems
Combine the TTS API with your existing notification channels, such as email or push services. Generate audio on demand when a user triggers a specific event, then deliver the file via your standard notification pipeline.
Since the API is stateless, you can integrate it into serverless functions or cron jobs. This allows you to process large batches of notifications asynchronously, ensuring your SaaS remains responsive even during high load.
You can cache frequent notifications to save costs. Store the audio file URL or the generated file itself, reducing repeated API calls for common alerts like "Welcome" or "Password Reset."
- Send audio via email or push notifications
- Use serverless functions for async generation
- Cache frequent notifications to reduce costs
Resources
Explore the full reference materials to accelerate your integration. The API documentation details every endpoint, parameter, and response structure for seamless implementation.
Supplement your code with ready-to-use snippets that demonstrate common workflows, ensuring you can start generating audio immediately without guesswork.
API documentation
Access the complete technical reference at /docs/ to understand request shapes, response formats, and error codes.
The documentation includes specific details on the 23 supported languages and 8 voice presets for accurate configuration.
- Endpoint definitions for /v1/audio/speech and /v1/voices
- Parameter descriptions for model, input, and speed
Curl examples
Copy-paste ready commands for quick testing. These examples demonstrate the exact JSON body structure required for successful synthesis.
Use these snippets to verify your setup before integrating into your SaaS notification pipeline.
- Basic speech generation with tts-1
- High-definition audio request with tts-1-hd
SDK guides
Leverage the official OpenAI SDKs by adjusting the base_url to https://api.playpx9.com/v1.
This approach allows you to use familiar libraries while benefiting from our simple, predictable API behavior.
- Python SDK integration steps
- JavaScript/Node.js configuration guide
Conclusion
Readly API gives indie developers a straightforward way to add audio to SaaS notifications without enterprise complexity. By converting text to speech, you improve accessibility for visually impaired users and create a more engaging, modern interface experience that stands out.
The integration is designed for simplicity: use the OpenAI SDK with a simple base URL change, handle errors gracefully, and cache repeated audio to keep costs predictable. This approach lets you focus on building features rather than managing infrastructure.
TTS API enhances SaaS UX
Audio alerts increase engagement by providing an alternative way to consume notifications. This is particularly valuable for accessibility, allowing visually impaired users to interact with your SaaS product more effectively. It also modernizes the user interface by adding a layer of sensory richness that text alone cannot provide.
- Improve accessibility for visually impaired users
- Increase engagement with audio alerts
- Modernize user interface experience
Simple integration for indie devs
Our API is built for developers who value honesty over hype. You can start with the free trial, sign up with Google, and get an API key instantly. The request shape matches the OpenAI speech endpoint, so you can use existing SDKs or plain HTTP requests with minimal code changes.
- No enterprise overhead or complex contracts
- Compatible with OpenAI SDKs
- Predictable pricing based on characters
Start with free trial today
Sign up on our /get-api-key/ page to receive $0.50 of free credit, valid for 7 days. This allows you to test the API with up to 50,000 characters without any financial commitment. Once you are ready, top up with USTRC-20 for automatic credits.
- $0.50 free trial credit
- Valid for 7 days
- No credit card required
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.
