Frequently asked questions
Which voice is best for storytelling?
Luna is designed for soft, storytelling narration, while Aria offers a warm, clear narrator style. Both voices support all 23 languages. You can select either via the voice parameter in your API request to match your specific narrative tone.
Is MP3 or WAV better for web apps?
MP3 is generally preferred for web apps due to its smaller file size and broad browser compatibility. WAV offers uncompressed quality but results in larger downloads. Choose MP3 for efficient storage and transfer, or WAV if you require lossless audio for post-production workflows. Note that our API returns the complete audio file via POST, not a streaming protocol.
How do I handle text longer than 4096 characters?
Split your input text into chunks of up to 4096 characters. Send each chunk as a separate request to the API. Then, concatenate the returned audio files sequentially to create a single continuous audio track. This ensures compliance with the per-request character limit.
Can I use this API for a mobile app?
Yes. Although we do not offer a dedicated mobile SDK, you can integrate our API into iOS or Android apps using standard HTTP requests or the OpenAI SDK. Send POST requests to our endpoint with your Bearer token. This approach gives you full control over authentication and response parsing without relying on platform-specific wrappers.
What is the best way to store generated audio?
The API returns audio in the response and does not store it. You should store the generated files in your own cloud storage, such as AWS S3 or Google Cloud Storage. This gives you full control over retention, backups, and distribution without relying on the API provider.
Do I need a developer account for this?
Yes, you need an account to obtain an API key. Sign up on the /get-api-key/ page using Google or email. Your account provides a unique key for authentication, tracks your usage, and manages your balance for billing purposes based on characters processed.
How accurate is the language detection?
The API infers language from the script if unspecified, defaulting Latin text to English. For non-English Latin text, explicitly set the language parameter. It supports 23 specific languages; unsupported ones like Vietnamese or Thai may not be processed correctly.
Can I change the voice after generation?
No, the voice is determined at generation time. Once the audio is created, the voice characteristics are fixed within the file. To use a different voice, you must send a new request with the desired voice parameter and receive a new audio file.
Is the API suitable for e-learning?
Yes, Sage offers a calm, instructional voice ideal for e-learning. You can adjust the speed between 0.25 and 4.0 to control pacing. The clear narration supports various languages, making it suitable for educational content delivery where clarity and controlled speed are priorities.
How does the speed parameter affect quality?
The speed parameter (0.25–4.0) adjusts the playback rate without changing pitch significantly. It does not alter the underlying synthesis quality. Faster speeds reduce generation time but may affect perceived clarity. Slower speeds can enhance comprehension for complex content but increase processing time.
What is the difference between tts-1 and tts-1-hd?
Both models use the same engine and price ($10 per 1 million characters). They share identical endpoint structures and capabilities. The distinction lies in the model identifier itself, allowing you to select your preferred preset while maintaining consistent billing and performance characteristics across both options.
Can I use the API for podcasts?
Yes, you can generate podcast episodes using voices like Orion for documentaries or Felix for energetic promos. Split long scripts into 4096-character chunks if needed. The generated audio includes a synthetic watermark. Ensure you handle audio concatenation if splitting the text for generation.
Is the audio watermark noticeable?
The watermark is inaudible to human listeners. It is embedded in the generated audio to mark it as synthetic speech. This allows identification of AI-generated content without affecting the listening experience or audio quality for your audience or end-users.
How do I compare this API to others?
Compare us by our 8 voices, 23 languages, and flat $10/1M character rate. We use LibriVox-based voices without voice cloning or SSML. Unlike some competitors, we keep it simple: no custom cloning, no SSML. Check /docs/ for endpoint details and /pricing/ for rates. We are not affiliated with OpenAI or other brands.
Choosing the Right Voice Presets
Selecting the right voice preset depends on your content type. Use Aria or Luna for warm, clear narration, while Nova or Felix work best for upbeat, energetic promos. For instructional or conversational tones, Sage and Milo offer a friendly, natural delivery.
Matching tone to your brand identity ensures consistency. Each voice is based on licensed recordings from the LibriTTS-R dataset (CC BY 4.0) and LibriVox public-domain audiobook readings, providing a distinct and recognizable audio signature without implying a specific commercial license for the voice itself.
Selecting voices for narration vs conversation
For narrative content, Aria provides a warm, clear narrator voice, while Luna offers a soft, storytelling style. These are ideal for audiobooks or explanatory videos. For conversational interfaces, Milo’s friendly tone or Atlas’s neutral news style ensures clarity without emotional bias.
Use Felix for energetic promotional content or Nova for bright, upbeat updates. These presets handle dynamic scripts well, maintaining engagement without sounding overly robotic. Select based on whether you need emotional warmth or straightforward information delivery.
- Aria: Warm, clear narrator
- Luna: Soft, storytelling
- Milo: Friendly, conversational
- Felix: Energetic, promo
Matching tone to brand identity
Your API key allows instant switching between voices. Use Sage for calm, instructional content or Orion for deep, documentary-style narration. Consistency in voice helps users recognize your brand’s audio identity across different products.
Ensure the voice aligns with your target audience. For example, Orion’s deep tone suits detailed technical explanations, while Nova’s bright voice appeals to younger demographics in casual apps. Test variations to find the best fit.
- Sage: Calm, instructional
- Orion: Deep, documentary
- Atlas: Neutral, news
- Nova: Bright, upbeat
Testing voices with sample texts
Generate short samples using the 4096-character limit to evaluate clarity. Use the POST /v1/audio/speech endpoint with tts-1 or tts-1-hd models. Check for natural pacing and pronunciation in your specific use case.
Review the output for any artifacts. Since voices are based on LibriVox readings, the quality is consistent but may vary slightly depending on the input text’s complexity. Use the free trial credit to test multiple presets before committing.
- Use
tts-1ortts-1-hd - Test within 4096-character limit
- Check for natural pacing
- Review for audio artifacts
Language Support for Global Reach
The API supports 23 languages, including English, Spanish, German, French, Arabic, Chinese, Japanese, and Hindi. Any voice preset can speak any supported language, allowing you to maintain consistent audio branding across different markets. This flexibility ensures that your startup can reach a global audience without needing to manage multiple voice models or separate audio tracks for each region.
Covering major markets with 23 languages
Support spans major global markets, from European languages like Danish, Swedish, and Polish to Asian markets with Korean and Malay. The system also covers Middle Eastern and African languages, including Arabic, Hebrew, and Swahili. This broad coverage allows indie developers to localize products efficiently without integrating multiple third-party TTS services.
- Arabic, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, Turkish
Handling non-Latin scripts correctly
When the language field is omitted, the API guesses the language based on the text script. Latin script defaults to English, while Cyrillic or CJK characters trigger the appropriate language model for accurate pronunciation. This automatic detection simplifies integration, though explicit language codes are recommended for non-English Latin text to avoid misidentification.
Using language codes for precision
Explicitly setting the language ISO code ensures precise pronunciation, especially for Latin-script texts that might otherwise default to English. This is critical for languages like Dutch or Swedish, which share the Latin alphabet but require distinct phonetic processing. Consistent language tagging prevents awkward accents and ensures natural-sounding output across all 23 supported languages.

Cost Efficiency for Budget-Conscious Teams
VoxCraft charges $0.01 per 1,000 characters, including spaces and punctuation. This predictable per-character model simplifies budget forecasting compared to variable per-minute billing. Failed requests incur no charge, protecting your spend during testing phases.
Comparing per-character vs per-minute models
Unlike per-minute pricing, our rate scales directly with input length. Long texts are split into 4,096-character chunks, ensuring consistent cost calculation regardless of audio duration.
This approach eliminates surprise costs from slow-speaking voices or extended pauses, making financial planning straightforward for lean teams.
- - $0.01 per 1,000 characters
- - Spaces and punctuation count
- - Failed requests are free
Estimating costs for typical startup volumes
Generation speed averages 25 characters per second. For a 10,000-character document, expect roughly 400 seconds of audio. Budget accordingly, as requests process sequentially and may queue under load.
Startups can accurately predict monthly API expenses by multiplying estimated character volume by $0.00001.
Leveraging the free trial effectively
Sign in with Google to receive $0.50 in trial credit, valid for 7 days. This allows approximately 50,000 characters of synthesis.
Use this period to test voice quality and integration logic without financial risk. Email-based accounts start without trial credit.
- - $0.50 trial credit
- - 7-day validity
- - ~50,000 characters
Technical Integration Simplicity
The API follows a standard request-response pattern compatible with any HTTP client. You send a POST request with JSON configuration and receive the complete audio file in the response body. This simplicity allows immediate integration without requiring complex WebSocket connections or custom transport layers.
This straightforward approach fits naturally into existing microservices architectures. Whether you are building a Node.js backend or a Python service, standard libraries handle the binary payload efficiently. The consistent endpoint structure reduces boilerplate code and accelerates development cycles for small teams.
Using standard HTTP vs custom libraries
You do not need a proprietary SDK. The API mimics the OpenAI speech endpoint shape, allowing you to use widely adopted HTTP clients. This reduces dependency lock-in and simplifies maintenance across different programming languages and frameworks.
For most indie projects, a simple curl command or a basic HTTP library call is sufficient. This lowers the barrier to entry for developers who prefer minimal overhead over bundled utility functions.
- Uses standard HTTP POST requests
- Compatible with any HTTP client library
- No proprietary SDK required
Integrating with existing microservices
The stateless nature of the API makes it easy to embed within existing service meshes. You can trigger synthesis from any microservice that needs audio output, such as a notification service or a content delivery pipeline.
Since the API returns a complete file, you can store the result in your own infrastructure immediately. This gives you full control over caching, CDN distribution, and long-term storage without relying on the provider's storage tiers.
Managing API keys and security
Security relies on a single active Bearer token per account. You pass this token in the Authorization header for every request. If you suspect a leak or need a fresh start, you can issue a new key instantly, which invalidates the old one immediately.
This single-key model simplifies environment variable management in CI/CD pipelines. You do not need to rotate multiple keys or manage complex permission scopes, keeping your deployment configuration lean and secure.
- Single active Bearer token per account
- Instant key rotation invalidates old keys
- Simple header-based authentication
Audio Quality and Formats
TSelecting the right audio format balances quality, file size, and compatibility. While MP3 remains the standard for web delivery due to its small footprint, WAV offers uncompressed PCM audio, ensuring bit-perfect fidelity for applications requiring raw data integrity or specific legacy player compatibility. Choose MP3 for general playback and WAV when precise audio analysis or lossless playback is critical.
Choosing between MP3 and WAV for quality
MP3 provides efficient compression suitable for most streaming needs, reducing bandwidth usage without significant perceptible quality loss. WAV files are larger but preserve every sample, making them ideal for archival purposes or downstream processing where compression artifacts might interfere with further audio manipulation.
Using Opus for bandwidth efficiency
Opus is a highly efficient codec that delivers superior audio quality at lower bitrates compared to MP3. This makes it an excellent choice for mobile applications or regions with limited bandwidth, ensuring faster load times and reduced data consumption for end-users without sacrificing clarity.
Understanding FLAC for lossless needs
FLAC (Free Lossless Audio Codec) compresses audio without any data loss, offering smaller files than WAV while maintaining perfect fidelity. Use FLAC when you need high-quality archival storage or when the audio will be re-encoded later, avoiding generational loss from lossy formats.
Scalability and Rate Limits
Scalability for indie TTS APIs hinges on understanding that requests are processed sequentially, not in parallel. This linear processing means your system must account for queue delays during high load, as each synthesis waits for the previous one to complete. For typical startup volumes, this usually remains manageable, but traffic spikes can introduce latency.
Planning for traffic spikes
During sudden usage increases, the sequential nature of the engine means requests stack up. You should implement exponential backoff in your client code to handle temporary delays gracefully rather than timing out immediately. Since long texts are split into 4096-character chunks, ensure your logic joins these seamlessly without overwhelming the queue.
- Implement client-side retry logic with jitter.
- Split large texts into 4096-character segments.
- Monitor queue depth via response headers if available.
Managing concurrent requests
Although the backend processes requests one by one, your application can send multiple parallel requests. With a limit of 60 requests per minute per key, you can safely send up to one request per second under normal conditions. Before your first top-up, this limit drops to 10 requests per minute, so throttle your scripts accordingly during the trial phase.
- Respect the 60 RPM limit for paid keys.
- Throttle to 10 RPM during the free trial.
- Use separate API keys for distinct services if needed.
Understanding queue behavior
Requests are processed in the order they arrive. If the server is busy, your request waits in a queue. Short phrases take a few seconds to generate, while longer texts take roughly real-time speed (25 characters per second). Plan your user experience to handle these variable generation times, especially when the queue is long during peak hours.
- Expect delays during high load periods.
- Short phrases may still take a few seconds.
- Long text generation scales with duration.
Data Privacy and Licensing
Understanding the origin of your synthetic voices is critical for indie developers who need clarity on licensing without enterprise-level overhead. Our voices are built from licensed recordings under CC BY 4.0 and public-domain audiobook readings, providing a clear foundation for integration.
We prioritize privacy by using input text solely for audio generation. The raw text is not stored or used for training models. Only request metadata, such as timestamp and character count, is retained for billing purposes, ensuring your data remains secure and minimal.
Understanding voice licensing terms
Our eight voice presets derive from CC BY 4.0 licensed recordings and public-domain sources. This means the underlying voice models carry clear licensing terms that simplify commercial usage rights for your projects.
You do not need to manage individual voice licenses. The API handles the complexity, allowing you to focus on building your product rather than auditing source material rights.
- Voices based on CC BY 4.0 and public-domain readings
Ensuring input data privacy
Input text is processed exclusively to generate the requested audio file. We do not retain the original text for training or secondary analysis, ensuring your proprietary content remains private.
Only necessary metadata—time, character count, and status—is kept for billing accuracy. This minimal data retention policy supports transparency and reduces long-term storage liabilities for your startup.
Commercial use rights for generated audio
Generated audio files are returned directly in the API response and are not stored on our servers. This ephemeral nature supports efficient workflows for high-volume indie applications.
While the source recordings are commercially viable, always review specific project needs. The clear licensing origins reduce legal ambiguity, making it easier to integrate speech into paid products or services.

Developer Experience and Docs
The documentation provides clear, specific guidance for indie developers integrating the TTS API. It explains the standard HTTP request structure and field requirements without unnecessary complexity.
Code examples are readily available, demonstrating how to use the OpenAI SDK by simply changing the base URL. This approach leverages familiar tools for rapid development.
Clarity of API documentation
The docs clearly define the request shape, including required fields like model and voice. It specifies limits, such as 4096 characters per request, and explains rate limits of 60 requests per minute.
Key details like supported formats (mp3, wav, opus, flac, pcm) and speed ranges are explicitly listed, reducing guesswork during implementation.
- Explicit field definitions
- Clear rate limit details
- Supported format list
Availability of code examples
Ready-to-use code snippets demonstrate integration using the official OpenAI SDK. Developers only need to adjust the base_url to https://api.play55kk.com/v1.
Examples cover both basic speech generation and handling responses, ensuring quick onboarding for teams familiar with standard HTTP clients.
- OpenAI SDK compatibility
- Base URL adjustment
- Response handling examples
Ease of getting started
Getting started requires minimal setup. Users sign up via Google or email, receive an API key, and can immediately make requests.
The /get-api-key/ page provides a ready curl example, allowing developers to test the API instantly without complex configuration.
- Quick key issuance
- Curl example provided
- Simple signup process
Support and Community
VoxCraft provides dedicated email support as the single channel for all customer inquiries. There is no phone number, live chat widget, or ticketing portal to navigate. This approach minimizes overhead for indie developers who prefer asynchronous communication that fits into their development workflow without interruption.
Support handles technical queries regarding integration, rate limits, and billing disputes. Since the service is self-serve, support staff focus on resolving specific technical blockers rather than general account management. This ensures that each email receives focused attention from engineers who understand the API architecture.
Access to email support
All support requests are directed to a single email address. There are no multiple departments or tiers to contact. This simplicity means you know exactly where to send your issue, whether it concerns API key regeneration or format compatibility.
Unlike enterprise support models, there is no dedicated account manager or phone line. This structure keeps costs low, allowing the company to offer competitive pricing without subsidizing a large support team.
- Single email channel for all inquiries
- No phone or live chat
- Asynchronous communication model
Responsiveness to technical queries
Support engineers are familiar with the specific API endpoints and error codes. They can quickly identify if an issue stems from incorrect request formatting, rate limit exhaustion, or voice selection. This technical depth reduces the back-and-forth often seen with general customer service.
Queries about character counting, speed adjustments, or language code precision are handled with concrete examples. The team understands the nuances of the 4096-character limit and queue behavior, providing actionable advice rather than generic troubleshooting steps.
- Engineer-led support
- Specific API knowledge
- Actionable technical advice
Transparency in service updates
Service updates are communicated directly via email. There are no complex status pages or social media announcements to monitor. This ensures that developers receive critical information about downtime, rate limit changes, or voice updates without needing to constantly check for news.
The team maintains transparency about known issues and planned maintenance. This straightforward communication style aligns with the no-hype positioning of VoxCraft, providing clear, factual updates when they occur.
- Direct email notifications
- No social media required
- Clear maintenance notices
Future-Proofing Your Integration
Future-proofing your integration ensures your TTS system remains adaptable as your startup scales. By leveraging standard HTTP endpoints and the OpenAI-compatible request shape, you avoid dependency on proprietary protocols. This approach allows easy migration or extension without rewriting core audio generation logic.
Choosing flexible API endpoints
Use the standard POST /v1/audio/speech endpoint for generation and GET /v1/voices for metadata. Since the API follows the OpenAI request shape, you can switch base URLs easily if needed. This compatibility reduces friction when integrating with existing microservices or third-party tools.
- Standard JSON body structure
- Compatible with official OpenAI SDKs
- Simple base URL change for migration
Avoiding vendor lock-in
We do not offer a dedicated SDK, so you rely on standard HTTP libraries you already use. This prevents being tied to a specific vendor’s client library. Your code remains portable across different TTS providers if you abstract the API call layer.
- No proprietary SDK dependency
- Standard HTTP/JSON communication
- Easily swappable backend provider
Planning for voice updates
Voices are static presets, but the GET /v1/voices endpoint allows you to fetch current options dynamically. Hardcoding voice names like 'aria' or 'nova' is safe, but querying the API ensures you always have the latest valid options. This keeps your integration resilient to minor backend changes.
- Dynamic voice list retrieval
- Hardcoded preset names are stable
- Regular API polling for updates
Common Pitfalls to Avoid
New integrators often underestimate how quickly character limits accumulate. Each request is capped at 4,096 characters. Sending a long script in one call causes truncation or errors. Splitting text manually or via script ensures full delivery without losing data.
Ignoring character count limits
The API enforces a strict 4,096-character limit per request. Exceeding this threshold results in immediate failure or truncation of the input text. Developers must implement logic to chunk longer scripts into manageable segments before sending them to the endpoint.
- Limit is 4,096 characters per request
- Spaces and punctuation count toward the limit
- Split long texts into smaller chunks
Misconfiguring language codes
While the API guesses language from script, Latin text defaults to English. Sending non-English text without setting the language field often results in incorrect pronunciation. Explicitly defining the ISO code ensures accurate synthesis for all 23 supported languages.
- Latin script defaults to English
- Set
languagefor non-English Latin text - Unsupported languages like Vietnamese or Thai are not in the list
Overlooking rate limits
New keys start with a 10 requests-per-minute limit. This throttles rapid testing or burst traffic. After the first top-up, the limit increases to 60 requests per minute. Plan your integration to respect these caps to avoid request failures.
- 10 requests/minute before first top-up
- 60 requests/minute after top-up
- Requests process sequentially, causing queue delays

Final Recommendations for Indie Devs
For indie teams balancing limited budgets and tight deadlines, starting with the $0.50 free trial provides immediate, risk-free validation of the API’s quality. This allows you to verify voice suitability without committing capital, ensuring the technology aligns with your product’s specific needs before scaling.
By testing with real-world text samples, you can accurately gauge character counts and latency. This practical approach helps you estimate true costs per request, considering the 60 requests per minute limit and the roughly real-time generation speed, preventing unexpected bottlenecks during peak usage.
Start with the free trial
The $0.50 trial credit, valid for seven days upon Google sign-in, offers approximately 50,000 characters of generation. This is sufficient to test multiple voices and languages without financial commitment, allowing early validation of audio quality and integration ease for your specific use case.
Accounts created via email and password start without this trial credit, so ensure you sign in with Google if you want to leverage this initial testing period effectively before integrating into your production pipeline.
- Valid for 7 days
- Approximately 50,000 characters
- No credit card required
Test with real-world text samples
Generate audio using your actual application data to check for edge cases, such as non-Latin scripts or specific punctuation handling. Since requests are processed sequentially, testing with typical volumes helps you understand queue behavior and latency under load, ensuring smooth user experiences.
Use the language parameter explicitly for non-English Latin text to avoid default English guessing, ensuring accurate pronunciation and tone across your 23 supported languages.
- Use actual app data
- Check punctuation handling
- Test with 4096 char limits
Monitor usage and costs closely
With pricing at $0.01 per 1,000 characters, small errors in character counting can impact costs. Monitor your usage dashboard to track characters generated and ensure you stay within the 60 requests per minute rate limit, which drops to 10 before the first top-up.
Since failed requests are free, tracking status codes helps distinguish between successful generations and wasted efforts, allowing you to optimize your integration logic and reduce unnecessary API calls.
- $0.01 per 1,000 characters
- 60 requests per minute
- Failed requests are free
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. indie developers can build rapid prototypes to validate startup ideas without needing large teams or significant funding.
23 languages
Any voice speaks any of these languages.
