Frequently asked questions
Which is better for Android?
Use the Cloud API for high-quality, consistent voices across devices without managing local engines. Native TTS is better for simple, offline needs. Our API integrates via standard HTTP, allowing indie developers to deliver high-quality voice features without complex infrastructure management or platform-specific code adjustments.
Is the API faster?
Cloud synthesis takes a few seconds for short phrases and processes requests sequentially. Native TTS is near-instant but varies by device. Our API generates audio at roughly real-time speed for long texts, ensuring consistent quality regardless of the user’s hardware capabilities or OS version.
Does it work offline?
No. The API requires an internet connection to send text and receive audio files. Native TTS works offline. Use the Cloud API when connectivity is available to access all 8 voices and 23 languages without downloading large language packs to the device.
Which has better voices?
The API offers 8 distinct presets like aria and atlas, based on licensed recordings. Native TTS voices vary by manufacturer. Our API ensures consistent, high-quality synthetic speech with inaudible watermarks, providing a uniform audio experience across all Android devices regardless of the underlying hardware.
Is the API more expensive?
The API costs $0.01 per 1,000 characters. Native TTS is free but uses device resources. For high-volume apps, the API is cost-effective. Failed requests are free, and you only pay for actual usage, making it predictable for budgeting compared to potential device-specific performance issues.
Can I use both?
Yes. Use Native TTS for basic, offline interactions and the Cloud API for premium features. This hybrid approach reduces data usage while maintaining high audio quality. Implement the API via HTTP requests for complex narratives or multilingual support where native engines lack sufficient voice options.
Which is more reliable?
The API provides consistent quality regardless of device hardware. Native TTS reliability depends on the manufacturer’s implementation. Our API processes requests sequentially with a 60 requests per minute limit, ensuring stable performance. Failed requests do not incur charges, maintaining reliability for billing and service delivery.
Does the API need internet?
Yes. All requests are sent to https://api.ace65.info/v1 and require an active internet connection. The API returns audio files directly. Native TTS works offline. Use the API when your application has reliable connectivity to ensure access to all voices and language support.
Which has more languages?
The API supports 23 languages, including Arabic, Chinese, and Swahili. Native TTS language support varies by device. Our API allows any voice to speak any supported language, providing consistent multilingual capabilities across all Android devices without requiring specific language packs on each user’s phone.
Is the API easy to use?
Yes. It uses a standard JSON POST request compatible with the OpenAI SDK. Send text and receive an audio file. The endpoint is https://api.ace65.info/v1/audio/speech. Integration is straightforward for developers familiar with HTTP clients, requiring only an API key for authentication and simple parameter configuration.
Which is more secure?
The API uses Bearer token authentication and processes input text without storing generated audio. Native TTS data stays on-device. Our API does not use input for training. Request metadata is kept for billing. This ensures privacy for user data while maintaining secure, authenticated API access.
Can I clone voices?
No. The API offers 8 fixed presets. Custom voice cloning is not available. You cannot upload your own voice or design custom voices. Use the existing presets like Felix or Luna for consistent results. This simplifies integration as you do not need to manage voice models.
Does it support SSML?
No. The API accepts plain text input up to 4096 characters. It does not support SSML tags for fine-grained control. Use the speed parameter (0.25–4.0) to adjust pacing. For complex formatting, split text into segments and manage playback timing within your Android application logic.
Which is more scalable?
The API scales with your account limits (60 requests per minute). Native TTS scales with device hardware. For high-volume apps, the API handles concurrent requests sequentially. You can manage load by splitting long texts. The API is designed for integration into scalable Android applications via HTTP.
Core Technology Differences
Cloud TTS processes text on remote servers, returning generated audio files via API responses. Native Android TTS synthesizes speech directly on the device using the OS engine, requiring no network connection. The cloud approach offloads processing power, while native integration keeps data local but limits voice options to the device's installed models.
Cloud synthesis offers consistent audio quality across all devices, as the engine remains identical regardless of the phone model. Native TTS quality varies significantly between Android versions and hardware manufacturers. Cloud outputs are standardized, ensuring predictable results for audiobook or notification applications.
Cloud vs Local Processing
Cloud processing requires sending text to api.ace65.info/v1, where it is converted to audio and returned. This method consumes bandwidth but preserves device battery and CPU. Native TTS runs locally, eliminating latency from network requests but increasing processing time on the device.
- Cloud: Remote server processing, consistent output.
- Native: On-device synthesis, offline capability.
Voice Quality Comparison
Cloud voices like aria or atlas provide clear speech with distinct characteristics. Native Android engines often sound robotic or monotone, especially in older versions. The cloud API delivers uniform clarity across all supported languages, whereas native voices depend on the installed language packs.
- Cloud: 8 distinct, licensed voices.
- Native: Limited to OS-provided voices.
Update Frequency
Cloud voices update instantly on the server, allowing immediate access to new models without app updates. Native TTS engines require Android OS updates or specific library updates to change voice quality. This ensures the cloud API always offers the latest synthesis technology.
Language Support Analysis
The VoxApp API supports 23 languages, including English, Mandarin, and Hindi. Any voice can speak any supported language, providing consistent synthetic quality across all regions. This eliminates the fragmentation often found in mobile OS integrations.
23 Supported Languages
The platform 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. If the language field is omitted, the system guesses the language, defaulting to English for Latin script.
- Arabic, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, Turkish
Native OS Limitations
Native Android TTS engines vary by device manufacturer and OS version, leading to inconsistent voice quality and limited language support. Unsupported languages include Vietnamese, Indonesian, Thai, Ukrainian, Romanian, Czech, Bengali, and others not explicitly listed in the API capabilities.
Voice Diversity
Unlike native systems that offer a few fixed voices per language, our API provides eight distinct presets. These include female voices like Aria and Nova, and male voices like Felix and Atlas, all capable of speaking any of the 23 supported languages.
Cost Efficiency
VoxApp charges $10 per 1 million characters, equating to $0.01 per 1,000 characters. This model eliminates upfront licensing fees and scales directly with usage, making it predictable for indie developers. Failed requests incur no charge, ensuring you pay only for successful synthesis.
Per-Character Pricing
The per-character rate applies to all text, including spaces and punctuation. Since long texts are split into 4,096-character chunks, costs remain linear and transparent. There are no minimum spend requirements or monthly subscriptions, allowing precise budget control for variable user loads.
- $0.01 per 1,000 characters
- No minimum spend
- Failed requests are free
Free Trial Availability
New accounts signing in with Google receive $0.50 in trial credit, sufficient for approximately 50,000 characters. This credit is valid for 7 days, allowing developers to validate integration quality before committing funds. Email-based accounts start without trial credit.
- $0.50 credit for Google sign-ins
- Valid for 7 days
- No trial credit for email accounts
Device Storage Costs
Unlike native TTS engines that consume persistent storage for voice packages, our API returns audio files that are not stored by the service. You manage local caching, reducing the app's installed size footprint compared to bundling multiple voice packs.
- No voice pack downloads required
- Reduced app size footprint
- Client-managed caching
Integration Complexity
Integrating the VoxApp TTS API into Android applications requires minimal code overhead compared to managing local synthesis engines. Developers send a simple POST request to the endpoint with JSON parameters, receiving an audio file directly. This eliminates the need to bundle large voice assets within the APK, reducing initial download size and simplifying version control.
Unlike native libraries that require specific permissions and background service configurations, the API approach relies on standard HTTP clients available in modern Android SDKs. This reduces boilerplate code for audio playback initialization and allows flexible handling of response formats like MP3 or WAV without complex codec management.
API Request Overhead
Each synthesis request incurs a small network latency but eliminates heavy local processing. The JSON body structure mirrors standard TTS endpoints, allowing easy adaptation using existing HTTP libraries like Retrofit or OkHttp. Authentication is handled via a Bearer token, ensuring secure and straightforward access control.
- Standard JSON request body with model, input, voice, and format fields
- Automatic handling of audio file decoding via standard Android media players
- Minimal memory footprint compared to loading multiple local voice models
Native Library Setup
Native TTS engines often require checking for installed voices and handling fallback scenarios, adding complexity to the codebase. With the API, voice availability is consistent across all devices since synthesis occurs server-side. Developers do not need to manage local voice packages or handle device-specific TTS engine variations.
- No need to bundle multiple language voice packs within the APK
- Consistent output quality across all Android versions and device manufacturers
- Simplified testing environment without varying local TTS engine implementations
Network Dependency
Reliable internet connectivity is required for each synthesis request, as audio is generated on the server. For offline use cases, developers must cache the generated audio files locally. The API supports standard HTTP caching headers, allowing efficient storage of repeated text requests to minimize data usage and latency.
Performance Metrics
Cloud synthesis operates at roughly real-time speed, generating approximately 25 characters of text per second of audio. Short phrases may take a few seconds to process, while longer texts scale linearly with duration.
Native Android TTS engines convert text instantly on-device, eliminating network round-trip time. However, they are limited by the device’s processor and available memory, potentially causing UI janks during complex sentence synthesis.
Generation Speed
The API processes requests sequentially, meaning generation time closely mirrors audio length. For a 1000-character input, expect approximately 40 seconds of generation time under normal load conditions, plus potential queue wait time.
Native engines deliver immediate output, ideal for interactive elements like button clicks or short alerts where sub-second response is critical for user experience.
- Real-time ratio: ~25 chars/sec
- Short phrase delay: a few seconds
- Native: instant, <100ms response
Latency Factors
Network latency adds variable overhead to API calls, depending on the user’s connection stability and geographic distance to the server. DNS resolution and TLS handshakes contribute to initial request time.
Device battery level and background processes can significantly impact native TTS performance. Older Android devices may struggle with high-quality voice synthesis, increasing processing time beyond acceptable thresholds.
- Network jitter adds 50-500ms
- TLS handshake overhead included
- Device CPU load varies
Queue Processing
Under high load, API requests may wait in a queue before processing begins. This introduces additional latency beyond the base generation time, especially during peak usage periods.
Native synthesis does not experience queueing since it runs locally on the user’s device. However, concurrent native TTS calls may compete for system resources, leading to unpredictable performance spikes.
- Queue wait time: variable
- Sequential processing model
- No local resource contention
Feature Comparison
Choosing between native and cloud TTS often hinges on specific feature requirements like speed control and audio formats. Our API provides precise configuration options that native Android implementations may lack or handle less efficiently.
Understanding these distinctions helps developers select the right tool for their app’s audio needs without over-engineering the solution.
Speed Adjustment
The API accepts a speed parameter ranging from 0.25 to 4.0, allowing fine-grained control over playback rate. Native Android TTS engines typically offer limited or no adjustable speed options within their standard API calls.
This flexibility ensures audio matches the user’s preferred listening pace without requiring post-processing.
- Adjustable from 0.25x to 4.0x speed
- Applied during synthesis, not playback
- Consistent across all voices
Format Options
We support mp3, wav, opus, flac, and pcm formats via the response_format field. Native Android TTS usually outputs PCM or WAV, requiring additional conversion steps for compressed formats like MP3 or Opus.
Selecting the optimal format reduces bandwidth usage and storage costs for your application.
- mp3, wav, opus, flac, pcm
- No post-processing required
- Direct download via API response
Voice Customization
The API offers eight distinct voice presets (e.g., aria, nova, felix) that can speak any of the 23 supported languages. Native TTS relies on the device’s installed voices, which vary by manufacturer and OS version.
Our voices are based on licensed recordings from LibriTTS-R (CC BY 4.0) and LibriVox public-domain audiobook readings, ensuring consistent quality regardless of the user’s device.
- 8 distinct voice presets
- 23 supported languages
- Consistent voice across devices
Scalability Factors
As your user base expands, the primary scalability constraint shifts from device processing power to API rate limits. Each account key supports 60 requests per minute, scaling linearly with concurrent users. Under heavy load, requests queue sequentially, causing generation delays proportional to queue depth rather than hardware bottlenecks.
User Growth Impact
Native TTS scales infinitely with device count, as processing occurs locally. Cloud API usage scales linearly with request volume. If 10,000 users generate audio simultaneously, you must manage the 60 req/min limit per key, potentially requiring multiple keys or accepting queue latency.
- Linear cost scaling with usage
- Rate limit constraints per key
- Queue-based latency under load
Server Load
Our servers handle synthesis and queue management, removing CPU burden from your Android devices. This preserves battery life and device performance for other app functions. However, sustained high-volume traffic may increase response times as requests wait in the processing queue.
Bandwidth Usage
Audio files are returned directly in the API response, requiring stable internet connectivity. MP3 and Opus formats minimize bandwidth consumption compared to WAV or FLAC. Offline playback is possible by caching generated audio, but initial generation requires data transfer.
- Format-dependent bandwidth (MP3 vs WAV)
- Caching enables offline playback
- Network dependency for generation

Use Case Suitability
This section evaluates specific application scenarios for the VoxApp cloud API, focusing on audiobook distribution, accessibility tools, and notification systems. It highlights the advantages of cloud-based synthesis over native Android TTS for these use cases.
Audiobook Apps
Cloud synthesis supports long-form content by splitting text into 4096-character chunks. This allows indie developers to generate high-quality narrations without consuming significant device storage or processing power.
Accessibility Tools
The API provides 23 languages and eight distinct voice presets. This diversity ensures that accessibility features can be localized effectively, offering clear, synthetic speech for visually impaired users across different linguistic groups.
Notification Systems
For brief alerts, the API delivers audio files quickly. Although short phrases may take a few seconds to generate, the cost remains low at $0.01 per 1,000 characters, making it economical for frequent, short notifications.
Technical Requirements
Reliable internet connectivity is mandatory for all synthesis requests. Since audio generation occurs on our servers, your Android application must maintain an active connection to https://api.ace65.info/v1 during the request lifecycle. Offline playback of generated files is possible, but the initial creation requires data transmission.
The API supports standard HTTP/2 connections. Developers should implement retry logic for transient network errors to ensure smooth user experiences, especially in areas with unstable connectivity.
Internet Connectivity
A stable data connection is required for every synthesis call. The API does not support offline generation; text must be transmitted to our servers for processing. Ensure your Android app handles network interruptions gracefully by queuing requests or notifying the user if the connection drops during the upload or download phase.
- HTTPS/2 connection required
- Minimum bandwidth for MP3/OPUS transfer
- Retry logic recommended for unstable networks
API Key Management
Each account is issued a single active Bearer token (tts-...). This key authenticates all requests to the /v1/audio/speech endpoint. You can rotate the key at any time via the dashboard; the previous key becomes invalid immediately, ensuring that lost or compromised credentials cannot be used for further billing.
- One active key per account
- Immediate invalidation upon rotation
- Passed via
Authorization: Bearerheader
Data Privacy
Input text is processed solely to generate the audio file and is not used for training future models. The generated audio is returned in the response payload and is not stored on our servers after delivery. We retain request metadata (timestamp, character count, status) exclusively for billing purposes.
- No training data usage
- No audio storage after delivery
- Metadata retained only for billing
Maintenance Considerations
Maintenance of a cloud-based TTS integration requires minimal overhead compared to native implementations. Since the synthesis engine resides on our servers, you do not need to manage model updates or language packs for each Android device. Your application logic remains stable, relying on consistent API contracts rather than device-specific OS variations.
However, you must handle network dependencies and API key lifecycle events. If the key is rotated, subsequent requests must use the new token immediately. Proper error handling ensures that temporary network issues do not disrupt the user experience, keeping the app responsive while the API processes the queue.
API Versioning
The API uses a stable v1 endpoint. As long as you target https://api.ace65.info/v1, the request schema remains consistent. You do not need to update your app for new voice models or language additions, as these changes occur server-side and are reflected in the /v1/voices endpoint.
- Use the hardcoded v1 path for stability.
- Fetch voice lists dynamically to support new languages without app updates.
Voice Updates
Voice presets (e.g., Aria, Nova, Atlas) are updated centrally. You do not need to bundle voice data with your APK. Simply query the /v1/voices endpoint to retrieve the current list of available voices and their supported languages for your specific Android build.
- No voice files to bundle.
- Query API for current voice availability.
Error Handling
Implement robust retry logic for transient network errors. The API returns specific error codes for rate limits (429) or authentication failures (401). Handle these gracefully to avoid blocking the UI thread. Failed synthesis requests do not incur charges, so retrying is safe if the input remains valid.
- Handle 429 Rate Limit errors with exponential backoff.
- Retry on 5xx server errors.
- Check 401 for expired or rotated API keys.
Developer Experience
The API relies on standard HTTP protocols, allowing integration with any language capable of making REST calls. Developers can utilize the official OpenAI SDKs by adjusting the base URL, eliminating the need for a proprietary client library. This approach ensures compatibility with existing Android networking stacks without requiring additional dependency management or custom wrappers.
SDK Availability
There is no dedicated mobile SDK or custom wrapper provided by VoxApp. Integration is achieved through standard HTTP requests or by leveraging the OpenAI SDK with a modified base URL. This reduces overhead and allows developers to use familiar tools already present in their build pipelines.
Documentation Quality
Documentation provides clear definitions of request fields, response formats, and error codes. The /docs/ endpoint outlines the exact JSON structure for the speech endpoint, ensuring predictable integration. Developers can verify available voices and formats via the /v1/voices endpoint before implementing synthesis logic.
Support Channels
Support is available exclusively via email. There is no live chat, phone support, or dedicated account manager. Responses are provided based on the volume of inquiries, with no guaranteed SLA or uptime commitment.
Final Recommendations
Choose the API for consistent voice quality across fragmented Android ecosystems and when language diversity or frequent voice updates are critical. It eliminates the need to manage multiple native engine versions and ensures a uniform user experience regardless of device manufacturer or OS version.
Opt for native TTS when offline capability is mandatory or when minimizing latency and data usage is the primary constraint. It is ideal for simple notification sounds or basic text-to-speech in low-connectivity environments where the overhead of an HTTP request is unjustified.
When to Choose API
Select the API when your application requires high-fidelity, consistent audio across diverse Android hardware variants. It is particularly suitable for audiobook apps or accessibility tools where voice personality matters more than absolute offline availability. The per-character pricing model remains cost-effective for apps with moderate daily active users, avoiding the bulk licensing fees of premium native engines.
- Consistent voice quality across all Android devices
- Access to 23 languages without downloading large packs
- No upfront licensing costs for premium voices
When to Choose Native
Use native TTS for offline-first applications or devices with strict data plans. It is the appropriate choice for simple UI read-alouds or notification alerts where the few hundred milliseconds of latency are imperceptible to the user. This approach reduces backend dependency and simplifies the app architecture by removing network error handling.
- Zero latency for immediate UI feedback
- Works without an internet connection
- No API key management required
Hybrid Approaches
A hybrid strategy leverages native TTS for instant, low-stakes responses and the API for high-quality, long-form content. Download premium voice packs for offline use when possible, but fallback to the API for languages not supported by the device. This balances immediate responsiveness with access to superior voice models.
- Use native for short, immediate feedback
- Fallback to API for complex or rare languages
- Cache API-generated audio for offline playback
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Understanding these distinctions helps developers select the right tool for their app’s audio needs without over-engineering the solution.
23 languages
Any voice speaks any of these languages.
