Frequently asked questions
What is synthetic speech?
Synthetic speech is audio generated by converting text into sound using a text-to-speech API. You send text to our endpoint and receive an audio file. This method allows teams to generate consistent, watermark-marked audio datasets efficiently without recording human voice actors for every variation.
Are the voices realistic?
Our voices are based on licensed recordings from LibriTTS-R and LibriVox public-domain audiobook readings. They offer natural intonation and clarity. Every generated file carries an inaudible watermark marking it as synthetic speech, ensuring transparency while maintaining high audio quality suitable for machine learning training data.
Can I use the audio commercially?
Yes, you can use the generated audio commercially. The voices are based on CC BY 4.0 licensed recordings from LibriTTS-R. Since the base audio is public domain or openly licensed, you do not need to pay additional royalties for the synthetic output generated via our API.
How do I choose between tts-1 and tts-1-hd?
Both models use the same engine and have the same price. Choose based on your preference for audio quality or compatibility. Since the cost per character is identical, you can test both with our free trial to see which output best fits your specific dataset requirements.
What is the difference between MP3 and WAV?
MP3 is a compressed format that reduces file size, while WAV is uncompressed and preserves original audio quality. Both are supported alongside Opus, FLAC, and PCM. Choose MP3 for storage efficiency or WAV/FLAC if your ML pipeline requires lossless audio data for precise feature extraction.
Do I need to credit the voice actors?
The voices are based on LibriTTS-R (CC BY 4.0) and LibriVox public-domain readings. While attribution is good practice, the synthetic nature and watermark mean you are not directly redistributing the original recordings, but you should check the specific license of the source material if you have strict compliance needs. Check the specific license of the source material if you have strict compliance needs.
Can I combine multiple voices?
Yes, you can generate audio for different voices in separate requests and combine them. Since each request produces a single audio file, you can concatenate these files using standard audio tools. This allows you to create diverse datasets with varied vocal styles and tones.
Is the API reliable?
We do not offer an SLA or uptime guarantee. Requests are processed sequentially, so under load, a request may wait in a queue. Typical speed is roughly real time. Failed requests are free, ensuring you only pay for successful synthesis, but availability is not guaranteed.
How do I handle accents?
Each voice has a specific style, such as Felix for energetic promo or Atlas for neutral news. You can set the language parameter to guide the synthesis. If not set, Latin text defaults to English. For non-English Latin text, explicitly set the language to avoid misinterpretation.
Can I use this for voice assistants?
Yes, the audio files are suitable for voice assistant training. You can generate consistent speech patterns using specific voices like Sage for instructional content. The synthetic watermark helps identify training data origins, and the consistent quality aids in building robust speech recognition models for assistant applications.
Do you support mixed-language text?
You can generate audio in 23 languages. If you mix languages, set the language parameter to the primary language or script to ensure correct pronunciation. The API guesses the language from the script if not specified, but explicit setting ensures accuracy for mixed-script inputs.
How do I archive my generated audio?
Generated audio is returned in the response and not stored by us. You must download and archive the audio files yourself after each request. Request metadata is kept for billing, but the actual audio data is transient, so you are responsible for your dataset storage.
Can I customize the speed?
Yes, you can adjust the speed between 0.25 and 4.0. This allows you to speed up or slow down the speech to match your dataset’s requirements. Adjusting speed helps in creating varied audio samples for training models that need to handle different speech rates.
Is there a limit on file size?
There is no specific file size limit, but each request is limited to 4096 characters. Longer texts must be split into parts and joined. File size depends on the format and duration. MP3 files will be smaller than WAV files for the same audio content.
Understanding Synthetic Speech
Synthetic speech APIs generate audio from text, allowing teams to create consistent datasets for machine learning without recording studios. By sending text via POST requests, you receive standardized audio files ready for model training.
This approach simplifies infrastructure, letting you focus on data quality rather than hardware management. It is ideal for building robust speech recognition systems across multiple languages and styles.
Definition and use cases
Synthetic speech converts written text into audio using cloud APIs. You input text, and the system returns an audio file in formats like MP3, WAV, or FLAC. This method supports diverse use cases, from training speech-to-text models to generating voiceovers for e-learning content.
Teams use this data to improve model accuracy across various accents and speaking styles. The ability to generate thousands of variations ensures your dataset covers edge cases effectively.
- Training speech recognition models
- Generating voiceovers for e-learning
- Creating diverse acoustic datasets
- Testing voice assistant responses
Benefits for ML models
Consistency is key for ML training. Our voices are based on licensed recordings, ensuring stable acoustic properties across generated files. Each audio file carries an inaudible watermark, marking it as synthetic for transparent dataset management.
Supporting 23 languages allows you to train multilingual models without sourcing native speakers for each language. This scalability reduces time-to-market for global products significantly.
- Inaudible watermarking for traceability
- Consistent acoustic properties
- 23 language support
- Rapid dataset scaling
Limitations to know
Text input is limited to 4096 characters per request. For longer texts, you must split them into parts and join the resulting audio files manually. This requires careful handling in your data pipeline.
Requests are processed sequentially, so high volume may lead to queuing delays. The API does not support streaming or real-time partial audio, which suits batch processing but not live interaction.
- 4096 character limit per request
- Sequential processing may cause queues
- No streaming support
- Manual audio joining for long texts
Choosing the Right Voice
Selecting the right voice ensures your synthetic dataset aligns with target model performance. Linguicore offers eight distinct presets, each trained on licensed LibriTTS-R data, providing consistent acoustic characteristics across 23 languages.
Female voice options
Aria delivers a warm, clear narrator style ideal for instructional content. Nova offers a bright, upbeat tone suitable for energetic promos. Luna provides a soft, storytelling voice for narrative datasets, while Sage ensures calm, instructional clarity.
Male voice options
Felix brings an energetic, promo-ready tone. Milo offers a friendly, conversational style for dialogue training. Atlas provides a neutral, news-like delivery for structured data, and Orion adds a deep, documentary voice for rich audio textures.
Matching tone to content
Match voice personality to your dataset’s semantic intent. Use Felix or Nova for high-energy ad training, and Atlas or Sage for news or technical corpora. Consistency in voice selection improves model generalization across similar audio patterns.
Selecting Audio Formats
Choosing the right audio format balances quality, storage, and processing speed for your ML datasets. Our API supports MP3, WAV, OPUS, FLAC, and PCM, letting you tailor output to specific model requirements.
MP3 offers high compression for smaller files, ideal for large-scale training sets. WAV provides uncompressed, lossless quality, preferred for high-fidelity acoustic feature extraction. Select based on whether you prioritize storage efficiency or raw audio integrity.
MP3 vs WAV
MP3 files are significantly smaller, reducing storage costs and transfer times. WAV files retain full audio fidelity, ensuring no data loss during encoding. Choose MP3 for general text-to-speech datasets and WAV when precise spectral analysis is needed.
- MP3: Lossy compression, smaller file size.
- WAV: Uncompressed, highest quality, larger size.
- Both are widely supported by ML frameworks.
Compression trade-offs
Compression reduces file size but may introduce artifacts. MP3 uses perceptual coding, discarding less audible data. This is usually sufficient for most NLP and ASR training tasks. For critical acoustic modeling, uncompressed formats preserve subtle voice characteristics.
- Higher compression = smaller files, potential quality loss.
- Lower compression = larger files, better fidelity.
- Test formats with a sample dataset before scaling.
Storage considerations
Large ML datasets can consume terabytes of storage. Using MP3 can significantly reduce storage needs compared to WAV. Plan your storage infrastructure accordingly, ensuring easy access for training pipelines. Consider cloud storage solutions for scalability.
- Estimate storage needs based on format choice.
- Use cloud storage for scalable access.
- Regularly audit storage usage to optimize costs.
Managing Volume and Scale
Synthetic speech generation is linear by design, meaning requests process sequentially rather than in parallel. This architecture ensures consistency but creates a bottleneck during high-volume dataset creation, where thousands of short phrases can quickly exhaust your per-minute allowance.
Understanding these limits helps you plan your infrastructure. By anticipating queue delays and adjusting your request frequency, you avoid unnecessary waiting times while maintaining steady throughput for your ML training pipelines.
Rate limits impact
Our API allows 60 requests per minute per key, which drops to 10 per minute before your first top-up. Since requests are processed sequentially, longer texts may wait in a queue, extending total generation time. Plan your batch sizes to stay within these boundaries without overwhelming the system.
Batch processing tips
Split large texts into parts of up to 4096 characters and join the resulting audio files. This approach keeps individual requests small and manageable, reducing the risk of timeouts or partial failures. Group similar voices together to minimize switching overhead during bulk generation runs.
Cost estimation
Cost is straightforward: $10 per 1 million characters, including spaces and punctuation. Failed requests are free, so you only pay for successful synthesis. Calculate your budget by multiplying the total character count of your dataset by $0.00001 to estimate expenses accurately.
Data Privacy and Licensing
Synthetic speech data is critical for training robust models, but understanding where your input text goes and how the underlying voices are licensed is essential for compliance. Linguicore’s API is designed with clear data boundaries and transparent licensing structures to help ML teams avoid legal pitfalls.
We use licensed recordings from the LibriTTS-R dataset (CC BY 4.0) and public-domain readings from LibriVox. This combination ensures high-quality, commercially usable voices while keeping your specific input text private and unused for training.
Input text privacy
Your input text is used solely to generate the requested audio file. It is not stored permanently nor used to train our base models. We retain only request metadata—timestamp, character count, and status—for billing and audit purposes.
Generated audio is returned in the response and not retained on our servers unless you choose to store it. This ensures that your proprietary datasets remain under your control.
- Input text is not used for training
- Metadata kept only for billing
- Audio returned in response, not stored
Voice licensing (LibriTTS-R)
Our voices are based on the LibriTTS-R dataset, licensed under CC BY 4.0, and readings from LibriVox public-domain audiobooks. This allows commercial use without complex royalty structures.
Every generated audio file contains an inaudible watermark, clearly marking it as synthetic speech. This aids in dataset transparency and helps downstream models distinguish synthetic from human-recorded audio.
- LibriTTS-R (CC BY 4.0)
- LibriVox public-domain readings
- Inaudible synthetic watermark included
Commercial usage rights
The CC BY 4.0 license permits commercial use, including integration into ML training pipelines and end-product audio generation. You may use the generated audio in proprietary models without additional fees.
No voice cloning or custom voice design is offered, so you rely on the eight preset voices. These are sufficient for most synthetic speech dataset requirements without attribution complexity.
- Commercial use permitted
- No voice cloning included
- No attribution required for CC BY 4.0
Integration Strategies
Integrating Linguicore into your ML pipeline is straightforward because the API mirrors the OpenAI speech endpoint shape. You can use official OpenAI SDKs by simply pointing the base_url to https://api.playzbzb.com/v1 and providing your API key. Alternatively, use any standard HTTP client to send JSON payloads to the POST /v1/audio/speech endpoint. This flexibility lets you stick with your existing infrastructure without learning a new proprietary SDK or managing custom client libraries, as you can use the official OpenAI SDKs or standard HTTP.
The single active API key per account simplifies authentication across your team’s services. Since the request structure matches industry standards, you can quickly swap in Linguicore as an alternative to other providers without rewriting your core synthesis logic.
API vs SDK
The API’s compatibility with OpenAI SDKs means you likely already have the necessary client libraries in your stack. You only need to adjust the base_url and inject your tts-... key into the authorization header. This approach avoids vendor lock-in and keeps your codebase lightweight, relying on well-documented HTTP interactions or the official OpenAI SDKs.
For teams preferring minimal dependencies, standard HTTP POST requests with JSON bodies work perfectly. This is especially useful for batch processing scripts or non-Python environments where maintaining an SDK might add unnecessary complexity.
- Use OpenAI SDKs with modified
base_url - Supports standard HTTP POST requests
- No proprietary client library required
- Simple JSON payload structure
Error handling patterns
Since requests are processed sequentially, you may encounter queueing delays during high load. Implement exponential backoff for 429 (rate limit) or 503 (service unavailable) responses. Failed synthesis returns a full refund, so ensure your error handling logic distinguishes between transient network issues and actual synthesis failures to avoid double-charging or losing data.
Always validate the input length before sending. The API accepts up to 4096 characters per request. Sending larger texts without splitting will result in an error, wasting a request cycle. Check response codes immediately to determine if you need to retry or split the text.
- Implement exponential backoff for 429/503 errors
- Validate input length (<4096 chars) before sending
- Distinguish between network errors and synthesis failures
- Check response codes for immediate retry logic
Queue management
Requests are processed one after another, so under load, a request may wait in a queue. For large dataset generation, split long texts into parts of up to 4096 characters and join the audio files afterward. This ensures consistent character counts and prevents timeout issues during peak usage times.
Monitor your rate limits (60 requests per minute per key). If your team exceeds this, consider using multiple keys or staggering requests. Since there is no streaming, you must wait for the full audio file before proceeding, which impacts throughput. Plan your batch jobs during off-peak hours to minimize queue wait times.
- Split texts into <4096 char chunks
- Stagger requests to respect 60 RPM limit
- Wait for full audio before proceeding
- Use off-peak hours for large batches
Quality Assurance
Ensuring synthetic audio meets ML training standards requires verifying both signal integrity and generation consistency. Since every file carries an inaudible watermark, you can programmatically confirm that the output is genuinely synthetic and not a leak of proprietary human recordings.
Watermark detection
Include a verification step in your pipeline to detect the synthetic watermark. This ensures data provenance and prevents accidental mixing of human and synthetic samples during model training.
- Verify watermark presence post-generation
- Distinguish synthetic from human audio
- Maintain clean dataset boundaries
Audio quality checks
Monitor audio clarity across the supported languages. Use automated scripts to flag artifacts, ensuring consistent voice quality whether using aria for narration or atlas for news-style data.
- Check for clipping or distortion
- Validate language-specific articulation
- Ensure consistent volume levels
Latency monitoring
Track request processing times, noting that short phrases take a few seconds while longer texts process at roughly real-time speed. Monitor queue wait times to optimize your batch throughput.
- Measure end-to-end generation time
- Track queue wait duration
- Identify latency spikes under load

Cost Management
Controlling your TTS spend is straightforward because billing is transparent and immediate. Every request consumes characters from your balance, with failed requests refunded in full. You can monitor your exact usage, remaining balance, and character count directly on the /get-api-key/ dashboard, ensuring you always know your financial position before generating audio for your ML datasets.
Since character count drives cost, optimizing your input text directly impacts your budget. Spaces and punctuation count as characters, so trimming unnecessary whitespace or consolidating instructions can reduce expenses. For large datasets, splitting long texts into 4096-character chunks ensures consistent processing and avoids unexpected queue delays during peak loads.
Tracking usage
The API provides clear metrics on your account page. You can see your current balance, trial status, and total characters processed. This real-time visibility helps you predict costs for upcoming training runs without guessing.
Failed requests are free, so you don’t pay for errors. This is crucial when testing voice parameters or processing noisy input data where some segments might fail synthesis.
- Check balance on /get-api-key/ page
- Monitor characters processed per request
- View failed request refunds instantly
Optimizing character count
Every space and punctuation mark counts toward the 4096-character limit and the final bill. Simplifying your input text—removing redundant words or formatting tags—can significantly lower your per-hour audio cost. Aim for concise, clean text inputs to maximize the utility of each character.
Use the input field efficiently. Since the API processes requests sequentially under load, batching your text into optimal 4096-character segments helps maintain steady generation speeds without wasting credits on oversized payloads.
- Count spaces as characters
- Trim redundant punctuation
- Use 4096-char chunks for efficiency
Top-up strategies
Top-ups are done via USDT on the TRON network (TRC-20), with a minimum of $5. Credits are added automatically within minutes, ensuring your pipeline stays active. There are no subscriptions or monthly plans, so you only pay for what you use.
Balance does not expire, making it ideal for long-term ML projects. You can top up once and let your team generate datasets over weeks or months without worrying about credit decay. No invoices or VAT complexities simplify accounting for distributed teams.
- Pay with USDT (TRC-20)
- Minimum top-up: $5
- Credits never expire
- No monthly plans
Language Expansion
Linguicore supports 23 languages, from Arabic to Turkish, allowing teams to scale synthetic datasets globally. Since every voice can speak any supported language, you do not need to manage distinct voice pools for each region, simplifying your infrastructure.
Adding new languages
Expanding your dataset is as simple as passing the language parameter in your API request. While the system guesses the language from the script, explicitly setting the ISO code ensures accuracy for Latin-script text that isn't English, preventing mispronunciation in your training data.
Consistency across languages
Maintaining consistent audio quality across diverse languages is critical for model performance. The engine generates clear synthetic speech for languages such as Hindi, Korean, or Swedish.
Voice mapping
You can map specific voices to specific languages to maintain tonal consistency. For instance, using 'aria' for English narration and 'luna' for storytelling in German ensures your dataset has a coherent style, even when switching between the eight available presets.
- Use explicit
languagecodes for non-English Latin text to avoid default English guessing.
Team Collaboration
Team collaboration is straightforward with our single-key model. Share one active API key across your entire engineering team to simplify access for all developers building synthetic speech datasets. The system handles concurrency efficiently, ensuring consistent performance regardless of team size.
Since only one key is active at a time, issuing a new key instantly revokes the old one. This provides a simple, effective security mechanism for rotating credentials without complex permission hierarchies.
Shared API keys
Maintain a single point of control. When you generate a new key from your dashboard, the previous one stops immediately. This eliminates the need to manage multiple credentials or track which engineer is using which token.
This simplicity reduces overhead for large teams. You do not need to configure complex RBAC systems; just share the current key via your secure vault or CI/CD environment variables.
- One active key per account
- Instant revocation upon new key generation
- No per-seat licensing fees
Role management
Role management is minimal by design. All API keys have identical permissions to read voices, generate audio, and check balances. There are no granular roles like 'read-only' or 'admin' to configure.
This uniformity means any developer can trigger synthesis or check usage stats without waiting for permission changes. It keeps the focus on building models rather than managing access policies.
- Uniform key permissions
- No granular role tiers
- Simplified access for all engineers
Usage monitoring
Track consumption directly from the dashboard. The interface displays your current balance, characters remaining, and recent request status. This visibility helps teams anticipate costs and detect anomalies early.
Since failed requests are free, monitoring request status helps distinguish between billing events and technical errors. Use this data to optimize your batch processing pipelines without worrying about unexpected charges.
- Real-time balance display
- Character count tracking
- Request status visibility
Troubleshooting Common Issues
Even with robust infrastructure, generating synthetic speech datasets can encounter friction. Understanding common API errors, audio artifacts, and billing nuances helps ML teams maintain steady data pipelines without significant downtime or unexpected costs.
API errors
Most failures are instantaneous. If a request fails, no charge is applied, and the audio is not generated. Check your Authorization header for the correct tts-... key format. Ensure the input text does not exceed 4096 characters, as longer texts must be split by your client code before sending.
- Verify the
modelfield is either "tts-1" or "tts-1-hd". - Ensure
voicematches one of the 8 available presets. - Confirm
response_formatis one of mp3, wav, opus, flac, or pcm.
Audio glitches
Since requests are processed sequentially, high load may introduce queue delays. Short phrases might take a few seconds, while longer texts generate at roughly real-time speed. If audio cuts off, check if your input text exceeded the character limit or if the voice preset is incompatible with the specified language.
- Split texts into chunks of 4096 characters max.
- Set the
languagecode explicitly for non-English Latin text. - Listen for the inaudible watermark to verify synthetic origin.
Billing discrepancies
Charges are based on character count, including spaces and punctuation. Failed requests are free, so verify status codes before assuming a charge. If you issue a new API key, the old one stops immediately. USDT top-ups on TRON (TRC-20) are credited automatically within minutes.
Future-Proofing Your Data
Synthetic speech datasets must evolve alongside your ML models. By maintaining flexible audio formats and consistent voice mappings, you ensure your training data remains usable as model architectures change. This approach minimizes re-generation costs when new requirements emerge.
Proactive planning prevents technical debt. Regularly reviewing format standards and voice presets keeps your pipeline efficient, ensuring long-term compatibility without needing complex infrastructure upgrades or extensive data reprocessing efforts.
Scalability
Our API handles increasing request volumes by processing requests sequentially. As your dataset grows, simply increase your key’s throughput by topping up your balance. The system queues requests naturally, ensuring no data is lost even during peak generation periods.
Plan for character limits by splitting long texts into 4096-character chunks. This ensures consistent audio quality and prevents timeouts, allowing you to scale from thousands to millions of audio files seamlessly.
- Sequential processing ensures no data loss under load
- Simple top-up process scales with your volume needs
- No complex infrastructure changes required for growth
Format evolution
Support for MP3, WAV, OPUS, FLAC, and PCM allows you to adapt to future model requirements. If your training pipeline shifts from lossy to lossless compression, you can regenerate assets without changing your voice presets.
Generated audio is returned in the response and not stored, so you control the archival format. Choose the format that best balances storage costs and model performance today, knowing you can switch formats easily in future batches.
Voice updates
Voices are based on licensed recordings from LibriTTS-R. You can generate new samples using updated voices without reprocessing your entire dataset.
Maintain consistency by locking your voice IDs in your generation scripts. If a voice profile changes subtly, you can continue using the same ID, ensuring your historical data remains comparable with new generations.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. This ensures data provenance and prevents accidental mixing of human and synthetic samples during model training.
23 languages
Any voice speaks any of these languages.
