Frequently asked questions
What is a TTS API key?
A TTS API key is a unique string starting with 'tts-' used for authentication. Send it in the Authorization header as a Bearer token. Each account has one active key; issuing a new one instantly invalidates the old one. Use this key to access the /v1/audio/speech endpoint and manage your billing and usage limits.
Why replace Google TTS?
Our service offers 8 voice presets and 23 languages, including Arabic and Hindi. You get transparent pricing at $10 per million characters with no monthly plans or subscriptions. Failed requests are free, and you can top up instantly via USDT on TRON. It is a simple, predictable alternative for LMS platforms.
How do I get a key?
Navigate to /get-api-key/ and sign up using Google or an email and password. Google sign-ups receive a $0.50 trial credit valid for 7 days. Once registered, your dashboard displays your active API key, current balance, and a ready-to-use curl example for immediate integration testing.
Is the API compatible with OpenAI SDK?
Yes. The API endpoint matches the OpenAI speech endpoint structure. Simply change the SDK base_url to https://api.shweohh.info/v1 and use your API key. The request shape is identical, supporting models like 'tts-1' and 'tts-1-hd', making migration straightforward for existing OpenAI SDK users.
What voices are available?
We provide 8 presets: Aria, Nova, Luna, Sage (female) and Felix, Milo, Atlas, Orion (male). Each voice supports all 23 languages. Voices are based on licensed recordings from LibriTTS-R and LibriVox. You can adjust speed between 0.25x and 4.0x and choose output formats like mp3, wav, or opus.
How much does it cost?
Pricing is $10 per million characters ($0.01 per 1,000 characters). Spaces and punctuation count. Failed requests are free. Top-ups start at $5 via USDT on TRON. There are no monthly plans, seats, or minimum spends. Balance does not expire, and you only pay for successful synthesis.
Do I need to change my code?
If using the OpenAI SDK, only update the base_url to https://api.shweohh.info/v1. For custom HTTP clients, update the endpoint and headers. The request body structure remains the same. Ensure you send your 'tts-' key in the Authorization header. No other code changes are required for basic usage.
Is the quality comparable?
Voices are based on licensed recordings from LibriTTS-R and LibriVox, providing clear, natural speech. Each file includes an inaudible synthetic watermark. Our 8 presets cover narrator, news, and conversational tones for e-learning content across 23 languages.
Can I use my own voice?
No. We do not offer custom voice cloning or voice uploading. You must choose from the 8 available presets: Aria, Nova, Luna, Sage, Felix, Milo, Atlas, or Orion. These voices are derived from licensed public-domain and CC BY 4.0 audiobook readings.
How long does integration take?
Integration is typically fast due to the OpenAI-compatible endpoint. You can generate a key in seconds and test with a curl command immediately. Splitting long texts into 4096-character chunks is the main logic step.
Is there a learning curve?
Minimal if you know the OpenAI SDK. The API uses standard JSON bodies with fields like 'model', 'input', 'voice', and 'response_format'. If you use raw HTTP, you manage the POST request and Bearer token. The documentation provides clear examples for both approaches.
Can I switch back easily?
Yes. Since we use standard HTTP POST requests and JSON bodies, switching back only requires updating your base_url or API key. No proprietary formats or long-term contracts lock you in. Your generated audio files are standard formats like mp3 or wav, usable anywhere.
What if I have a large LMS?
The API supports 60 requests per minute per key. For larger volumes, split texts into 4096-character chunks and process them sequentially. You can issue new keys if needed, though each key has its own limit. Balance never expires, allowing you to scale usage as your course platform grows.
Do I need a developer?
Yes, a developer is needed to manage API keys, handle authentication headers, and implement text splitting logic for long courses. While the endpoint is simple, integrating it into your LMS requires code changes to handle the POST requests and process the returned audio files.
Identify Current Usage
To switch from Google TTS to CourseVoice, start by auditing your current integration. Identify which voices and formats your LMS currently uses, and note the volume of requests per minute to ensure you stay within our 60 requests per minute limit per key.
Review your existing cost structure against our flat rate of $0.01 per 1,000 characters. Since spaces and punctuation count as characters, precise usage tracking helps predict your monthly spend accurately before migrating your e-learning platform.
Check API calls
Log your current request volume to estimate throughput needs. Our service processes requests sequentially, so long texts may queue under load. Knowing your peak concurrent calls helps prevent throttling during course launches.
- Monitor daily request volume
- Note peak concurrency hours
- Track average text length per call
Note endpoints
Document your current audio generation endpoints. CourseVoice uses a standard POST /v1/audio/speech endpoint, compatible with OpenAI SDKs. Verify if your current LMS plugin requires specific header adjustments or custom base URLs.
- Current TTS endpoint URL
- Required headers (Auth, Content-Type)
- SDK version in use
Review costs
Calculate your current spend per 1,000 characters. Compare this against our $10 per 1 million character rate. Failed requests are free, which may reduce your effective cost if your current provider charges for errors.
- Current cost per character
- Volume discounts or tiers
- Error rate impact on billing
Get New API Key
To begin the migration, navigate to the /get-api-key/ page on shweohh.info. You can create an account using Google for immediate access or standard email and password registration. This step establishes your independent storefront identity distinct from Google Cloud.
Upon successful registration, you receive a unique API key starting with tts-. This key is active immediately, allowing you to start making requests. Note that accounts are per site, so ensure you are registering on the correct domain.
Sign up account
Visit the registration page and choose your preferred authentication method. Google sign-in provides instant access with a $0.50 trial credit valid for 7 days, given when you sign in with Google. Email-based accounts start with zero balance and require a top-up to begin usage.
- Choose Google or Email/Password registration
- Google accounts receive $0.50 trial credit
- Accounts are specific to shweohh.info
Receive key
After registration, your dashboard displays your active API key. Each account holds one active key at a time. You can issue a new key at any moment, which instantly invalidates the previous one, ensuring secure credential management.
- Key starts with 'tts-'
- One active key per account
- Immediate invalidation of old keys
Test connection
Use the provided curl example on your dashboard to verify connectivity. Send a simple text request to the endpoint to confirm the key works. Check the response for a valid audio file URL or blob, confirming your integration is ready.
- Use dashboard curl example
- Verify response format
- Confirm key authentication success
Update Endpoint
Migrate your integration by replacing the Google TTS base URL with https://api.shweohh.info/v1. This single change allows you to use the official OpenAI SDKs directly by changing the base_url, ensuring compatibility with your existing code structure without major refactoring.
Update your authorization header to use the Bearer tts-... key issued for shweohh.info. This key authenticates all subsequent requests to the new endpoint, maintaining secure access to the text-to-speech engine.
Change base URL
Point your API client to https://api.shweohh.info/v1. This endpoint mirrors the OpenAI speech structure, allowing seamless switching for LMS platforms already using compatible libraries.
No changes to request paths are needed; only the base domain changes.
- Base URL: https://api.shweohh.info/v1
Update headers
Set Authorization: Bearer tts-<your-key> in every request header. This key is unique to your account and replaces Google’s credentials.
Ensure no legacy headers interfere with the new authentication method.
- Header: Authorization: Bearer tts-<key>
Verify auth
Send a test request using the new base URL and key. A valid response confirms the endpoint and credentials are correctly configured.
If the response indicates an error, double-check the key format and base URL spelling.
Adjust Parameters
Switching from Google TTS requires mapping their voice names to our eight presets. Our API uses specific identifiers like 'aria' or 'atlas' instead of generic labels. Ensure your code references the correct voice strings from the /v1/voices endpoint to avoid synthesis errors.
Speed adjustments are straightforward. The speed parameter accepts values between 0.25 and 4.0, allowing you to match the pacing of your existing course content. Default is 1.0; adjust slightly to optimize comprehension for your specific audience without distorting the synthetic audio quality.
Map voices
Our eight voices cover diverse tones, from 'nova' for upbeat lessons to 'atlas' for news-style updates. Any voice can speak any of the 23 supported languages. Use the /v1/voices GET endpoint to retrieve the exact voice ID required for your JSON body.
If your previous integration relied on language-specific voices, note that any voice can speak any language here. Explicitly set the language parameter for non-English Latin text to ensure accurate synthesis, as the API guesses language otherwise.
- Aria: Warm, clear narrator
- Nova: Bright, upbeat
- Luna: Soft, storytelling
- Sage: Calm, instructional
- Felix: Energetic, promo
- Milo: Friendly, conversational
- Atlas: Neutral, news
- Orion: Deep, documentary
Set speed
Adjust the speed field in your request body to control playback rate. Values range from 0.25 to 4.0. A setting of 1.0 produces natural pacing. Higher values speed up narration for quick reviews, while lower values aid learners needing slower delivery.
The API processes requests sequentially, so extreme speed settings may slightly affect queue wait times. Stick to moderate adjustments (0.8–1.2) for consistent latency during high-volume course generation.
Choose format
Select response_format from mp3, wav, opus, flac, or pcm. MP3 is a common format for web players. WAV or FLAC provides lossless quality. PCM is raw data for custom processing pipelines.
Failed requests incur no charge regardless of format. Ensure your LMS can handle the selected audio container before deploying to users to avoid playback issues.
Test Integration
After updating your base URL and headers, validate the integration by sending a test request to the speech endpoint. Use a short, representative text snippet to ensure the connection is stable and the authentication header is correctly formatted.
Run sample text
Send a POST request with a simple string to verify the endpoint responds. Ensure the model parameter is set to tts-1 or tts-1-hd and include a valid voice preset from the eight available options.
- Use the
curlexample from /get-api-key/ for immediate testing. - Verify the response returns an audio file.
Check audio quality
Listen to the generated file to confirm natural speech patterns suitable for e-learning content. Check that the voice matches your selected preset and that the audio format (mp3, wav, etc.) plays correctly in your LMS player.
- Verify no clipping or distortion at the default speed setting.
- Ensure the synthetic watermark is present but inaudible.
Verify billing
Confirm that a small amount of your balance is deducted accurately. Since charges are per character, ensure the cost aligns with the text length sent. Failed requests should show a zero charge.
- Check the /get-api-key/ dashboard for updated character count.
- Ensure no duplicate charges occurred during the test phase.
Handle Errors
Handling errors correctly ensures your LMS integration remains stable during high-volume course generation. Understanding the specific constraints of the API prevents unexpected failures when processing student audio requests.
Rate limits
The API enforces a limit of 60 requests per minute per key. If you exceed this, requests will be rejected until the window resets. During the initial trial phase, the limit is stricter at 10 requests per minute.
- Monitor your request count via the dashboard.
- Implement exponential backoff in your client code.
- Respect the 429 Too Many Requests response.
Text length
Each request supports a maximum of 4096 characters in the input field. If your course content exceeds this, split the text into smaller chunks and concatenate the resulting audio files. Spaces and punctuation count toward this limit.
- Pre-process long transcripts before sending.
- Ensure seamless audio joining logic.
Network issues
Network timeouts or transient errors may occur. Since requests are processed sequentially, high load can introduce latency. Retry failed requests with a short delay, but note that failed synthesis requests are free and do not charge your balance.
- Handle HTTP 5xx errors gracefully.
- Verify internet connectivity on the server.

Monitor Usage
Track characters accurately to predict costs before generation. Since pricing is $0.01 per 1,000 characters, monitoring input length helps you estimate expenses for long course modules or exam questions.
Track characters
Count every character, including spaces and punctuation, in your input text. This metric directly correlates with your billing cycle, allowing you to forecast usage for large datasets.
Check balance
Your account dashboard displays your current balance and remaining characters. Top-ups via USDT (TRC-20) are credited automatically, ensuring continuous service without manual intervention.
Review logs
Request metadata, including timestamp, character count, and status, is retained for billing verification. Use these logs to audit usage and identify any failed requests that were refunded.
- Check request timestamps for load analysis
- Verify character counts match input
- Confirm refund status for failed syntheses
Go Live
Once testing confirms stability, enable the API for your LMS users. The synthetic audio will be generated on demand via the endpoint, integrating seamlessly with your course engine without requiring additional infrastructure.
Enable for users
Activate the integration in your application settings. Users will receive audio files directly via the API response, maintaining the same workflow they expect from your platform.
Disable old key
Issue a new API key from the dashboard immediately upon go-live. The previous key stops working instantly.
Support users
Monitor initial requests for any anomalies. Since support is email-only, direct user inquiries to your standard support channel. Ensure your team is prepared for questions about audio quality or speed.
Optimize Costs
Optimizing costs begins with recognizing that your billing is driven strictly by character count. Since the API charges $0.01 per 1,000 characters, redundant audio generation for identical course segments is unnecessary waste. By caching audio files for common phrases or standard introductions, you avoid re-processing the same text repeatedly.
Implementing efficient request limits prevents unnecessary churn and ensures you stay within the 60 requests per minute threshold. This stability is crucial for maintaining consistent delivery speeds during peak learning hours without hitting rate limits that could disrupt user experience.
Cache audio
Store generated MP3s or WAVs in your LMS media library. Reuse these assets for repeated lessons, significantly reducing total character consumption and API calls for recurring content.
This strategy is particularly effective for standardized onboarding modules or frequently accessed definitions where the text remains static over time.
- Store generated MP3s or WAVs in your LMS media library.
- Reuse assets for recurring lessons to reduce API calls.
- Effective for standardized onboarding modules and static definitions.
Limit requests
Enforce a maximum character limit per request to avoid partial failures. Since the API processes requests sequentially, sending overly long texts can delay generation for other users. Keeping requests within the 4096-character limit ensures predictable processing times.
This approach also helps manage the 60 requests per minute limit more effectively, preventing temporary throttling during high-traffic periods.
- Enforce a maximum character limit per request.
- Avoid partial failures by keeping requests under 4096 characters.
- Manage the 60 requests per minute limit effectively.
Batch processing
Group multiple short text segments into single requests where possible. This reduces the overhead of individual API calls and minimizes the number of transactions billed.
By combining related sentences or paragraphs into a single input, you optimize the character-to-audio ratio and streamline the integration workflow for your e-learning platform.
- Group short text segments into single requests.
- Reduce overhead of individual API calls.
- Optimize the character-to-audio ratio.
Troubleshoot
When integrating CourseVoice API into your LMS, you may encounter specific technical hurdles. Understanding the root causes of common failures helps you debug your integration faster without wasting API credits on repeated invalid requests.
This section addresses frequent issues related to request formatting, audio file integrity, and generation delays, ensuring your course delivery remains smooth for students.
Common errors
Ensure the model field is either tts-1 or tts-1-hd. Incorrect model names return a 400 error. Verify that the Authorization header uses the correct Bearer prefix and your active API key.
Check that your input text does not exceed 4096 characters per request. If your course script is longer, split the text into chunks and join the resulting audio files.
- 400 Bad Request: Check voice names and model IDs
- 401 Unauthorized: Verify API key format and expiry
- 413 Payload Too Large: Split text under 4096 chars
Audio issues
If the generated audio is silent or corrupted, verify that the response_format matches your player’s capabilities (mp3, wav, opus, flac, or pcm). Ensure the server can write the file before reading it.
All synthetic files contain an inaudible watermark. This does not affect playback but confirms the file is AI-generated. If audio sounds robotic, try adjusting the speed parameter between 0.25 and 4.0.
- Use mp3 for broad browser compatibility
- Check speed limits (0.25–4.0) for natural pacing
- Verify format matches your LMS media player
Latency problems
Requests are processed sequentially. Under load, a request may wait in a queue, increasing latency. For long texts, generation takes roughly real-time (25 characters per second).
Short phrases may take a few seconds to process. If your LMS expects instant playback, implement a loading state while the API returns the audio file.
- Requests are queued under high load
- Generation speed is ~25 chars/second
- Implement loading states for short queries
Support Resources
We provide comprehensive documentation to guide your integration, covering endpoints, parameters, and code examples. The FAQ section addresses common technical questions about voices, languages, and billing. For issues not covered in the docs, our support team is available via email.
Unlike competitors, we do not offer phone lines, live chat, or SLAs. All support is asynchronous. We prioritize clear, written responses that reference specific request IDs and timestamps to help you resolve integration issues efficiently.
Documentation
Our docs detail the OpenAI-compatible endpoint structure, including request fields like model, voice, and response_format. You will find ready-to-use curl examples and explanations for rate limits and character counting.
Each endpoint is documented with clear parameter descriptions, ensuring you can integrate with your LMS without guessing the required JSON structure.
- Endpoint reference for /v1/audio/speech
- Voice list and language support
- Rate limit details (60 req/min)
- Curl examples and SDK instructions
FAQ section
The FAQ covers practical questions about voice selection, character limits, and audio formats. It explains why failed requests are free and how the TRC-20 top-up process works.
We also clarify that we do not offer SSML, streaming, or custom voice cloning, helping you set accurate expectations for your e-learning platform.
- How to handle text longer than 4096 characters
- Supported audio formats (mp3, wav, opus, flac, pcm)
- Explanation of the $10 per 1M characters pricing
- Why Google OAuth is used for sign-up
Email support
Our primary support channel is email. We do not have a phone number or live chat. All support requests are handled asynchronously by our engineering team.
Include your API key, request ID, and a description of the issue. We aim to respond quickly, but we do not guarantee a specific response time or uptime SLA.
- Asynchronous support via email only
- No phone number or live chat
- Include request ID for faster resolution
- Engineering team handles technical queries
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. You only pay for what you use, with no monthly minimums or seats to manage.
23 languages
Any voice speaks any of these languages.
