Frequently asked questions
What is open source text to speech?
Open source TTS refers to speech synthesis models with publicly available source code and weights, often trained on datasets like LibriTTS. Unlike our hosted API, which provides a simple POST endpoint, open source solutions require you to manage the inference server, handle dependencies, and maintain the software stack yourself to generate audio files.
Is an API better than running a local model?
An API is better if you want to stop managing infrastructure and start shipping voice features immediately. Our hosted API handles scaling, updates, and server maintenance. Running locally gives you full control but requires significant engineering effort to keep the model running, whereas our API offers reliability with a simple API key.
How much does it cost to run TTS locally?
Local costs include hardware, electricity, and engineering time. While our API charges $0.01 per 1,000 characters with no minimum spend, local deployment requires purchasing GPUs or CPUs and paying for server uptime. There is no monthly plan or subscription, but you bear the full infrastructure cost regardless of usage volume.
Do I need a GPU for open source TTS?
Most modern open source TTS models run significantly faster on a GPU. While some can run on CPUs, inference times will be much longer. Our hosted API abstracts this hardware requirement, delivering audio via HTTP without you needing to provision or manage specific GPU instances for your development or production environment.
Can I use open source models with this API?
Our API uses specific licensed voices based on LibriTTS-R and LibriVox recordings. You cannot plug in your own open source model weights directly into our endpoint. However, you can use our standard voices via the API, or if you prefer open source, you can run those models independently on your own infrastructure.
What is the latency of a hosted API?
Typical speed is roughly real time, generating about 25 characters of text per second of audio. Short phrases take a few seconds. Requests are processed sequentially, so under heavy load, a request may wait in a queue. This is generally faster than local CPU inference for most indie developer workloads.
Is data privacy better with local models?
Local models keep your input text entirely on your own hardware, which some prefer for strict data sovereignty. Our API uses input text only to produce audio and does not use it for training. We keep request metadata for billing but do not store the generated audio, offering a strong privacy baseline without local complexity.
How do I scale open source TTS?
Scaling locally requires provisioning more servers, managing load balancers, and handling auto-scaling logic. With our API, scaling is automatic. You can send up to 60 requests per minute per key, and we handle the backend infrastructure. This allows you to focus on your product rather than managing server capacity during traffic spikes.
Do hosted APIs use open source models?
Our voices are based on licensed recordings from LibriTTS-R (CC BY 4.0) and LibriVox public-domain audiobooks. While we use open data, our specific implementation and hosting are proprietary. We are not affiliated with OpenAI or other brands, and we do not resell their models; we provide our own engineered TTS service.
What is the maintenance burden of local TTS?
Running TTS locally requires managing dependencies, updating models, handling server crashes, and ensuring uptime. Our hosted API removes this burden entirely. You simply send a POST request with your API key, and we handle the server maintenance, updates, and infrastructure, allowing your team to focus on building features rather than maintaining servers.
Can I switch between open source and API?
Yes, you can easily switch. Our API uses standard JSON bodies similar to the OpenAI speech endpoint. If you are already using an open source model with a compatible interface, you can often switch by changing the base URL to https://api.suckbetth.com/v1 and updating your API key, requiring minimal code changes.
Which is more reliable for production?
Hosted APIs generally offer higher reliability for production because the provider manages uptime and redundancy. While we do not offer an SLA or uptime guarantee, our infrastructure handles scaling and updates. Local models depend on your own hardware health and your team’s ability to resolve server issues, which can introduce variability.
Do APIs offer better voice quality?
Voice quality is subjective and depends on the specific model. Our voices include options like Aria, Nova, and Atlas, trained on licensed data. Open source models vary widely in quality. We provide 8 distinct presets with consistent quality, whereas local models may require significant tuning to achieve similar results without additional engineering effort.
Is there a hybrid approach possible?
Yes. You can run lightweight models locally for quick prototypes and switch to our API for production scaling. Since our API uses a standard JSON format, you can use the same code structure for both environments. This allows you to leverage local flexibility during development while ensuring reliable, managed performance in production.
Local vs Cloud Processing
Running TTS locally gives you direct control but requires managing GPUs and dependencies. A hosted API abstracts this away, letting you send text and receive audio files via a simple POST request without worrying about server uptime.
Local Model Execution
Local models demand significant hardware, especially GPUs, and consume storage for model weights. You handle the inference pipeline directly, which offers low latency for small batches but scales poorly under variable load.
Cloud-Based Processing
Our API processes requests on our infrastructure. You send a JSON payload, and we return the audio file. This removes the need for your servers to handle heavy computation, allowing your team to focus on application logic instead of model optimization.
Infrastructure Responsibility
With a hosted service, we manage the servers, updates, and scaling. You only manage your API key and usage limits. This reduces operational overhead, letting indie developers ship voice features quickly without hiring dedicated DevOps staff.
Cost Analysis
Running TTS locally requires dedicated GPU hardware and significant electricity, especially for high-quality models. The upfront capital expenditure for servers often exceeds the cost of API calls for most indie teams, and you bear the full risk of hardware depreciation.
Hardware Costs
Local deployment demands powerful GPUs to maintain reasonable generation speeds. You must purchase, house, and maintain this hardware, which sits idle during low-traffic periods, leading to inefficient resource utilization compared to a pay-per-use model.
- GPU acquisition and cooling costs
- Electricity and server rack space
- Hardware depreciation over time
API Usage Costs
SuckBetth charges $0.01 per 1,000 characters, making it highly predictable for variable workloads. There are no minimum monthly fees, so you only pay for the text you actually synthesize, avoiding the waste of reserved infrastructure.
Operational Overhead
Managing local models means handling updates, driver patches, and crash recovery. With a hosted API, these operational tasks are abstracted away, allowing your team to focus on shipping voice features rather than maintaining server uptime.
Complexity and Maintenance
Running a local TTS model means you own the environment. You must handle GPU drivers, CUDA versions, and dependency conflicts. A hosted API abstracts this away; you just send text and receive audio. The infrastructure burden shifts from your server rack to the provider’s dashboard.
With a hosted service, scaling is handled by the API’s backend. You don’t need to provision more GPUs when traffic spikes. You simply manage your API key and monitor your character usage quota, reducing the cognitive load on your engineering team.
Setup Time
Local deployment can take days to configure correctly, especially if you lack dedicated DevOps staff. You need to select the right hardware, install dependencies, and ensure the model loads reliably. With SuckBetth, you get a working API endpoint in minutes. Sign up, grab your key, and start generating audio immediately. No container orchestration required.
For indie developers shipping voice features, time-to-market matters. A hosted API removes the guesswork from environment setup. You focus on building your product’s logic, not debugging why your Python package version is incompatible with your OS.
- No GPU driver management
- Instant API key activation
- Standard HTTP/JSON interface
- Zero container configuration
Scaling Challenges
If you run locally, you must predict your traffic and buy hardware accordingly. Underestimating load means slow responses; overestimating means wasted money on idle GPUs. With a hosted API, the provider handles the heavy lifting. Your code remains simple, regardless of whether you have ten users or ten thousand.
You only pay for what you use. If traffic drops, you don’t pay for idle hardware. This variable cost model suits indie apps with unpredictable usage patterns, unlike the fixed cost of maintaining a dedicated inference server.
- Pay per character, not per GPU hour
- No capacity planning needed
- Automatic load distribution
- No idle hardware costs
Updates and Patches
When a new model version drops or a security patch is needed, local deployments require manual intervention. You pull updates, test compatibility, and restart services. With SuckBetth, updates happen on the server side. You always access the latest engine version without changing your code.
You also avoid the risk of running outdated dependencies that cause subtle bugs. The provider manages the stack, ensuring stability and performance improvements are applied consistently across all users without your direct involvement.
- Automatic engine updates
- No manual restarts needed
- Consistent API behavior
- Provider-managed security patches
Performance and Latency
Understanding latency is critical when integrating speech synthesis into user-facing workflows. Our API processes requests sequentially, meaning generation speed and queue behavior directly impact the perceived responsiveness of your application.
Generation Speed
Long texts are generated at roughly real-time speed, processing about 25 characters of text per second of audio. Short phrases typically take a few seconds to synthesize, which is fast for most non-interactive use cases.
Network Latency
Since we do not offer streaming or WebSocket support, the entire audio file is returned in a single response after processing. This simplifies client-side implementation but means users wait for the full synthesis to complete before playback begins.
Queue Management
Requests are processed one after another, so under high load, a request may wait in a queue before synthesis begins. This linear processing model ensures consistent quality but can increase latency during traffic spikes.
- Standard throughput: ~25 chars/sec for long texts.
- Short phrases: few seconds processing time.
- No parallel processing; requests are sequential.
Flexibility and Control
Hosted APIs trade deep model control for operational simplicity. You don’t manage the underlying neural networks, but you gain immediate access to high-quality outputs without hiring ML engineers. This section clarifies what you can and cannot customize in our service.
We provide specific controls that matter for most indie projects, while keeping the heavy lifting of model maintenance off your plate.
Custom Model Training
We do not offer custom voice cloning or training your own models. Our eight presets are trained on licensed LibriTTS and public-domain audiobook readings. You cannot upload audio to create a unique voice profile, nor can you fine-tune the engine for your specific domain vocabulary.
This means consistent quality across all users, but no personalized voice identity unless you use one of our eight presets.
- No custom voice cloning
- No uploading your own voice samples
- No domain-specific fine-tuning
Parameter Tuning
You control the output through standard parameters. You can adjust the speed between 0.25 and 4.0, choose from five audio formats, and select from eight distinct voice presets. These settings allow you to tailor the audio for different use cases, from fast news updates to slow storytelling.
You cannot tweak internal model hyperparameters or add SSML tags, as the engine is a black box designed for ease of use.
- Speed: 0.25–4.0
- Formats: mp3, wav, opus, flac, pcm
- 8 voice presets
- No SSML support
Data Privacy
Input text is used solely to generate the audio file and is not stored or used for training. The generated audio is returned in the response and is not kept on our servers. This minimizes your data exposure for sensitive content.
Request metadata, such as timestamps and character counts, is retained only for billing purposes. No personal data is sold or shared with third parties.
- Text not used for training
- Audio not stored post-response
- Metadata kept for billing only
Use Case Suitability
Choosing the right deployment model depends heavily on your application’s traffic patterns and latency requirements. Understanding where your use case fits helps avoid over-engineering or under-provisioning.
Low Traffic Apps
For applications with sporadic usage, a hosted API eliminates the need to maintain idle GPU servers. You only pay for what you use, avoiding the fixed costs of dedicated infrastructure that sits dormant between requests.
- No hardware depreciation to manage
- Predictable per-character billing
High Volume Apps
High-volume applications benefit from the simplicity of a unified endpoint. With a rate limit of 60 requests per minute, you can process thousands of characters efficiently without managing complex load balancers or scaling groups.
- Simple rate limit management
- Automatic scaling handled by provider
Real-Time Needs
If your app requires immediate audio feedback, consider that requests are processed sequentially. While typical speed is near real-time, short phrases may take a few seconds, and queue waits can occur during high load.
- Sequential processing model
- Potential queue delays under load

Technical Requirements
For local inference, you need a dedicated GPU with sufficient VRAM, plus ongoing electricity and cooling costs. You also manage storage for model weights and output files, and ensure sufficient bandwidth to serve generated audio to end-users.
GPU Requirements
Running TTS locally demands significant GPU resources. You must provision and maintain the hardware, ensuring it meets the computational needs for real-time synthesis without bottlenecking other services.
- Dedicated GPU with adequate VRAM
- Ongoing power and cooling costs
Storage Needs
You need local storage for model weights and generated audio files. Unlike our hosted API, you bear the full cost of disk space and data retention policies.
Bandwidth Usage
Serving audio files directly from your servers consumes your network bandwidth. High traffic spikes can saturate your connection, requiring careful monitoring and potential CDN integration.
- Direct server serving costs
- Potential need for CDN integration
Ecosystem Integration
Choosing a TTS solution often hinges on how easily it plugs into your existing stack. Open source requires you to manage libraries and dependencies, while a hosted API like ours leverages familiar standards that indie developers already know.
We prioritize seamless integration so you can ship voice features without wrestling with custom drivers or proprietary formats.
SDK Compatibility
Our API mirrors the OpenAI speech endpoint structure. This means you can use the official OpenAI SDKs by simply pointing your base_url to https://api.suckbetth.com/v1. No need to learn a new client library or rewrite your request logic.
This compatibility extends to standard HTTP clients, making it easy to integrate with any language or framework that supports JSON over HTTPS.
- Compatible with official OpenAI SDKs
- Works with any standard HTTP client
- No proprietary client required
Standard Protocols
We use standard RESTful endpoints and JSON bodies, ensuring predictable behavior across different environments. Authentication is handled via standard Bearer tokens, keeping your security model consistent with other cloud services.
Requests follow a simple POST pattern, while voice configurations are accessible via GET endpoints, maintaining a clean and predictable API surface.
- RESTful JSON interface
- Standard Bearer token auth
- Predictable endpoint structure
Developer Experience
Integration is straightforward: send text, receive audio. Our documentation provides ready-to-use curl examples and clear error codes, reducing the time from sign-up to your first synthesized audio file.
By sticking to open standards, we ensure that your developers can troubleshoot issues using familiar tools and methods, minimizing friction during development.
- Ready-to-use curl examples
- Clear error codes
- Familiar troubleshooting tools
Scalability Considerations
Scaling your TTS integration is straightforward because you don't manage the server pool. With a hosted API, the provider handles infrastructure, so you simply send requests and receive audio files without provisioning virtual machines or configuring load balancers yourself.
Auto Scaling
You don't need to predict peak loads or spin up extra instances. The API handles request distribution automatically, allowing your application to scale from ten to ten thousand requests without manual intervention or complex orchestration tools.
Load Balancing
Requests are processed sequentially within your rate limit, but the backend manages the queue. You don't need to implement custom load balancing logic or worry about single points of failure in your own deployment pipeline.
Traffic Spikes
If you exceed the 60 requests per minute limit, requests wait in a queue rather than failing immediately. This prevents your app from crashing during sudden surges, though generation speed may slow to roughly real-time.
- Requests queue naturally under load
Decision Framework
Choosing between local and hosted TTS isn't just about technical specs; it's about matching your team's capacity with your product's needs. For small indie teams, a hosted API removes the burden of managing inference servers, letting you focus on shipping features rather than debugging GPU drivers.
Team Size Impact
With a small team, the operational overhead of maintaining a local TTS pipeline can consume valuable engineering time. A hosted API like SuckBetth lets you start with a simple API key and scale usage without hiring dedicated infrastructure engineers to handle server maintenance or updates.
- Ideal for solo developers or small product teams
- Reduces need for dedicated DevOps roles
- Frees up time for core feature development
Technical Expertise
If your team lacks deep experience with GPU optimization or model quantization, a hosted solution abstracts away the complexity. You get consistent performance and standard SDK compatibility without needing to manage version compatibility or hardware dependencies across different developer environments.
- No GPU driver management required
- Standard HTTP/JSON interfaces
- Works with existing OpenAI SDKs
Long Term Goals
Consider whether voice is a core differentiator or just a utility. If it's a feature among many, a hosted API offers flexibility without locking you into specific hardware. As your usage grows, the per-character pricing scales linearly, avoiding the capital expense of upgrading on-premise hardware.
- Predictable cost scaling with usage
- No hardware depreciation cycles
- Easy to integrate new voice models
Summary of Trade-Offs
Choosing between open source and a hosted API depends on your team’s capacity to manage infrastructure versus their need for immediate deployment. There is no universal winner; the right choice hinges on specific operational constraints and technical expertise.
Speed vs Control
Hosted APIs like SuckBetth offer predictable latency with queued processing, abstracting away the variability of local hardware. You gain instant access to eight voices and 23 languages without worrying about GPU availability or model updates.
- Predictable generation times based on character count
- No hardware bottlenecks during traffic spikes
- Automatic model improvements without downtime
Cost vs Convenience
Running TTS locally requires upfront investment in GPUs and ongoing electricity costs, which scale with usage. A hosted API converts these fixed costs into a variable pay-per-character model, starting with a simple free trial and transparent pricing.
- $0.01 per 1,000 characters with no minimum spend
- No hardware maintenance or upgrade cycles
- Pay only for successful synthesis requests
Complexity vs Simplicity
Open source solutions demand DevOps effort for containerization, scaling, and dependency management. A hosted API provides a simple key-based interface compatible with standard SDKs, allowing indie developers to ship voice features quickly without deep infrastructure expertise.
- Single API key authentication
- Standard JSON request/response format
- Zero infrastructure configuration required
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. It works well for e-learning modules, audiobook snippets, or automated notifications where full real-time interaction isn't critical.
23 languages
Any voice speaks any of these languages.
Sources and further reading
- Wikipedia
- curl documentation
- LibriTTS-R paper (arXiv 2305.18802)
- IETF RFC 7845: Ogg Opus
- Node.js documentation
- FFmpeg documentation
- OpenAI API reference: create speech
- W3C WAI: making audio and video accessible
- Python documentation
- LibriVox public-domain audiobooks
- MDN: Web Speech API
- TRON developer hub: TRC-20
