Frequently asked questions
How do I authenticate my API requests?
Include your unique API key in the request header using the format Authorization: Bearer tts-.... Each account holds one active key; issuing a new key immediately invalidates the previous one. Ensure the key is sent with every request to the https://api.play76d.com/v1 endpoint to authorize character consumption and speech synthesis.
Can I use the Python OpenAI SDK?
Yes, the official OpenAI SDKs work directly with SynthLogic. Configure the SDK by changing the base_url to https://api.play76d.com/v1 and providing your SynthLogic API key. This allows you to use standard OpenAI client methods for speech generation.
What is the maximum speed multiplier?
The speed parameter accepts values between 0.25 and 4.0. This allows you to slow down narration for clarity or accelerate audio for quick notifications. Adjust this value in your JSON body to control playback rate, keeping in mind that generation time scales with the requested speed multiplier.
How do I handle 429 Too Many Requests?
The API enforces a limit of 60 requests per minute per key (10 per minute before the first top-up). Implement exponential backoff or a queue in your application logic to handle rate limits gracefully. Since requests process sequentially, higher loads may also introduce queuing delays beyond simple rate limiting.
Is the API compatible with cURL?
Yes, the endpoint accepts standard JSON bodies via POST requests, making it fully compatible with cURL. You can send text, select a voice, and specify format using command-line flags. This allows for quick testing and integration into shell scripts or lightweight automation workflows without requiring complex SDK dependencies.
Do I need to install a specific SDK?
No, you do not need a specific SynthLogic SDK. The API follows the standard OpenAI request shape, so you can use the official OpenAI SDKs or plain HTTP libraries. Simply update the base URL to https://api.play76d.com/v1 and use your API key for authentication in any standard HTTP client.
How do I specify the output format?
Include the response_format field in your JSON body with values: mp3, wav, opus, flac, or pcm. This determines the audio encoding of the returned file. Choose based on your storage and bandwidth requirements, keeping in mind that all formats include an inaudible watermark marking the speech as synthetic.
What happens if I send invalid JSON?
The API will reject the request with an appropriate error code if the JSON body is malformed or missing required fields like model or input. Since failed requests are free, you will not be charged for characters processed in invalid submissions. Ensure your client correctly formats the JSON payload before sending.
Can I stream the audio response?
No, the API does not support streaming or WebSocket connections. The entire audio file is generated and returned in the response body or as a file attachment. You must wait for the full synthesis to complete before receiving the audio data, which may take several seconds for longer texts.
How do I list available voices?
Send a GET request to /v1/voices to retrieve a list of available voices, languages, formats, and price. This endpoint provides the eight preset voices (e.g., aria, nova, felix) and their associated metadata. Use this data to dynamically populate your application’s voice selection interface for users.
Is the base URL different for testing?
No, the base URL https://api.play76d.com/v1 is used for both development and production. There is no separate sandbox environment. You can test with your free trial credit or paid balance using the same endpoint. Ensure your API key is valid and has sufficient balance before testing integration workflows.
Do I need to send the model name?
Yes, the model field is required in the request body. You must specify either tts-1 or tts-1-hd, which use the same engine and pricing. This field is mandatory for all synthesis requests to identify the processing pipeline and ensure the correct audio generation parameters are applied to your input text.
How do I handle audio file size limits?
The API does not impose a specific file size limit, but each request is limited to 4096 characters of input text. For longer texts, split the content into chunks of up to 4096 characters, generate audio for each, and join the resulting files. This ensures consistent performance and avoids processing timeouts.
Can I use a custom model name?
No, only tts-1 and tts-1-hd are supported model names. These correspond to the same underlying engine with identical pricing. You cannot upload custom voice models. The system uses eight fixed presets, and the model field simply selects the base processing tier for the request.
First request
curl
curl https://api.play76d.com/v1/audio/speech \
-H "Authorization: Bearer $TTS_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"tts-1","voice":"aria","input":"Hello from the API.","response_format":"mp3"}' \
--output hello.mp3Python (openai)
from openai import OpenAI
client = OpenAI(base_url="https://api.play76d.com/v1", api_key="tts-...")
with client.audio.speech.with_streaming_response.create(
model="tts-1", voice="nova", input="Hello from Python.", response_format="mp3"
) as response:
response.stream_to_file("hello.mp3")Node.js (openai)
import OpenAI from "openai";
import fs from "node:fs";
const client = new OpenAI({ baseURL: "https://api.play76d.com/v1", apiKey: process.env.TTS_API_KEY });
const res = await client.audio.speech.create({ model: "tts-1", voice: "milo", input: "Hello from Node.js." });
fs.writeFileSync("hello.mp3", Buffer.from(await res.arrayBuffer()));| voice | |
|---|---|
aria | female |
nova | female |
luna | female |
sage | female |
felix | male |
milo | male |
atlas | male |
orion | male |
| language | |
|---|---|
ar | العربية |
zh | 中文 |
da | Dansk |
nl | Nederlands |
en | English |
fi | Suomi |
fr | Français |
de | Deutsch |
el | Ελληνικά |
he | עברית |
hi | हिन्दी |
it | Italiano |
ja | 日本語 |
ko | 한국어 |
ms | Bahasa Melayu |
no | Norsk |
pl | Polski |
pt | Português |
ru | Русский |
es | Español |
sw | Kiswahili |
sv | Svenska |
tr | Türkçe |
Authentication
The API uses a single active Bearer token for authentication. Include your key in the request header as Authorization: Bearer tts-.... This token grants access to all endpoints and tracks your usage against your account balance.
Bearer Token Format
Pass the key via the standard Authorization: Bearer header. The token format is tts- followed by your unique identifier. Ensure no extra whitespace is included in the header value to avoid 401 Unauthorized errors.
Key Management
Each account maintains one active key. You can generate a new key at any time via the dashboard. The previous key is immediately invalidated upon issuance of the new one, ensuring secure rotation without downtime.
- Keys are managed via the /get-api-key/ dashboard.
- Only one key is active per account.
Key Revocation
Revocation is instantaneous. When you issue a new key, the old one stops working immediately. There is no grace period, so update your integrations promptly to avoid service interruption.
Endpoint Structure
The API exposes three primary endpoints for speech synthesis and metadata retrieval. The core synthesis endpoint accepts text payloads and returns audio files, while the metadata endpoints provide voice lists and model details.
POST /v1/audio/speech
This endpoint processes text input and returns an audio file. Send a JSON body containing the text, voice, and format preferences. The maximum input length is 4,096 characters per request.
- Endpoint: POST https://api.play76d.com/v1/audio/speech
- Accepts: JSON body with
input,voice,model,response_format - Returns: Audio binary (mp3, wav, opus, flac, pcm)
GET /v1/voices
Retrieve the list of available voice presets and their associated languages. This endpoint confirms supported formats and pricing tiers for each voice configuration without processing audio.
- Endpoint: GET https://api.play76d.com/v1/voices
- Returns: Array of voice IDs, names, and supported languages
GET /v1/models
Fetch available model identifiers. The API supports tts-1 and tts-1-hd, both using the same engine and price.
- Endpoint: GET https://api.play76d.com/v1/models
- Returns: List of model IDs (
tts-1,tts-1-hd)

Request Parameters
The synthesis endpoint accepts plain text input up to 4096 characters per request. Every character, including spaces and punctuation, counts toward your usage quota. For longer content, split the text into valid chunks and concatenate the resulting audio files manually to maintain continuity.
You must select one of eight available voice presets. The API does not support SSML or custom pronunciation lexicons, so voice selection relies on the preset characteristics defined in the model documentation. Ensure the input text matches the selected voice's language capabilities to avoid quality degradation.
Input Text Field
Send the text string in the input field. The maximum length is 4096 characters. Exceeding this limit returns an error. Spaces and punctuation are counted as characters for billing purposes.
- Maximum length: 4096 characters
- All characters (including spaces) count toward usage
- Long texts require manual splitting and concatenation
Voice Selection
Specify the voice ID in the voice field. Choose from eight presets based on your use case: narration, news, or conversational tones. Each voice supports all 23 listed languages. If language is omitted, the system guesses the language, defaulting to English for Latin scripts.
This endpoint confirms supported formats and pricing without processing audio.
- 8 available voice presets
- Supports all 23 languages
- Language guessing defaults to English for Latin text
Response Format Options
Select the audio format using the response_format field. Supported formats include mp3, wav, opus, flac, and pcm. Choose based on your application's playback requirements and storage constraints. The API returns the audio file directly in the response body.
- Supported formats: mp3, wav, opus, flac, pcm
- Audio returned as binary in the response
- No additional processing fees per format
Speed and Language Controls
The API supports a speed multiplier range from 0.25 to 4.0, allowing precise control over audio duration. This feature enables synchronization with interface animations or reduces processing time for high-volume notification queues without altering voice characteristics.
Language handling is handled either through explicit ISO codes or automatic detection. Developers can enforce specific language outputs or rely on the system’s default behavior for Latin-script text, which defaults to English unless specified otherwise.
Speed Multiplier Range
Set the speed parameter to any value between 0.25 and 4.0. Values below 1.0 slow the output, while values above 1.0 accelerate it. This allows fine-tuning for different application contexts, such as slower speeds for accessibility features or faster speeds for bulk audio generation.
ISO Language Code
Pass an ISO 639-1 language code (e.g., en, de, ja) in the request body. While any voice can speak any of the 23 supported languages, explicitly setting the language ensures accurate pronunciation and intonation, especially for non-English languages using Latin script.
- Supported languages include Arabic, Chinese, Danish, Dutch, English, Finnish, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Russian, Spanish, Swahili, Swedish, and Turkish.
Automatic Language Guessing
If the language field is omitted, the system attempts to guess the language from the text script. For Latin-script text without a specified language, the default is English. For non-English Latin-script text, it is recommended to set the language parameter explicitly to avoid incorrect language assignment.
cURL Quick Start
Use cURL to verify connectivity and basic synthesis before integrating into your application. This method provides immediate feedback on token validity and request structure.
Basic Request Example
Send a POST request to the API endpoint with your Bearer token. The JSON body must include the model, input text, and voice selection. Ensure the text length does not exceed 4096 characters.
Response Headers
The API returns standard HTTP headers including content-type and content-length. These headers help your application handle the binary audio response correctly.
Audio Binary Output
The response body contains the raw audio bytes. Redirect the output to a file using the -o flag. Supported formats include mp3, wav, opus, flac, and pcm.

OpenAI SDK Integration
SynthLogic’s TTS API mirrors the OpenAI speech endpoint structure, allowing developers to reuse existing OpenAI SDK clients with minimal configuration. By adjusting the base URL, teams can integrate synthetic speech into SaaS interfaces without rewriting core logic.
Base URL Configuration
Point the SDK client to the SynthLogic API endpoint. Use https://api.play76d.com/v1 as the base URL. This ensures all requests route through the correct synthetic speech infrastructure while maintaining standard SDK compatibility.
Client Initialization
Initialize the OpenAI client using your SynthLogic API key. Pass the key via the Authorization: Bearer header or the SDK’s API key field. The client validates requests against the SynthLogic rate limits and billing system.
Method Compatibility
The POST /v1/audio/speech method is compatible with the official OpenAI SDKs. Send text, voice, and format parameters exactly as defined in the OpenAI schema. The response returns audio binary data directly.
Rate Limits and Quotas
SynthLogic enforces strict rate limits to ensure stable API performance for high-volume SaaS integrations. Each API key is capped at 60 requests per minute during normal operation. This limit applies regardless of the text length or response format requested.
Requests Per Minute
The standard quota allows 60 requests per minute per active key. If your application exceeds this threshold, subsequent requests will receive a 429 Too Many Requests error until the window resets.
- Limit: 60 requests/minute/key
- Applies to all endpoint calls
- Resets on a sliding window
Pre-Topup Limit
New accounts without a top-up are restricted to 10 requests per minute. This lower limit prevents resource exhaustion while you verify integration stability. Once you add USDT (TRC-20) to your balance, the limit automatically increases to the standard 60 requests/minute.
- Standard limit: 60 req/min
- Pre-topup limit: 10 req/min
- Auto-adjusts after funding
Queue Behavior
Requests are processed sequentially. Under heavy load, additional requests may wait in a queue before synthesis begins. This queuing ensures fair resource distribution but may increase latency for long texts. Short phrases typically complete within seconds, while longer texts take roughly real-time duration.
- Sequential processing model
- Latency increases under load
- Real-time generation speed

Error Handling
The API returns standard HTTP status codes to indicate request outcomes. A 200 OK response confirms successful audio generation. Use 400 series codes for client errors and 500 series for server-side issues during synthesis.
HTTP Status Codes
Successful requests return HTTP 200 with the audio binary in the response body. Authentication failures return 401 Unauthorized. Generic server errors return 500 Internal Server Error, indicating a temporary processing issue.
- 200: Success
- 400: Bad Request
- 401: Unauthorized
- 500: Internal Server Error
Character Limit Exceeded
The input text field accepts a maximum of 4096 characters per request. If the text exceeds this limit, the API returns an error. You must split the text into smaller chunks and join the resulting audio files manually.
Invalid Voice ID
Using a voice ID not in the supported list returns a 400 error. Ensure the voice parameter matches one of the eight available presets. Check the /v1/voices endpoint for the current valid voice list.
Listen to the 8 voices
Each sample below was generated by this API from the same sentence. Transform your startup's user experience with seamless notifications and intuitive interfaces that keep teams connected and informed.
23 languages
Any voice speaks any of these languages.
