Most "add voice to your app" integrations involve more setup than the
feature is worth — SDKs to install, OAuth flows to configure, dashboards to
navigate before you've generated a single second of audio. The VoxCraft API
is deliberately the opposite: one endpoint, one header, one response.
## The whole integration, in one request
```
curl -X POST https://voxcraft.site/api/v1/tts \
-H "Authorization: Bearer vox_live_your_key_here" \
-H "Content-Type: application/json" \
-d '{"text": "Hello world", "voice_id": "en-US-AvaNeural"}' \
--output speech.mp3
```
Send text and a voice ID, get raw `audio/mpeg` bytes back. No SDK to
install, no client library version to track, no webhook to set up. If your
language can make an HTTP POST request, it can use this API.
Need to know which voices exist? `GET /api/v1/voices` (same Bearer auth)
returns every valid `voice_id` across 40+ languages — so you can build a
voice picker in your own app without hardcoding a list or digging through
separate docs.
## How quota works
Every plan includes a fixed number of characters per month — not
pay-per-character metered billing that makes costs unpredictable. You know
what a month costs before you send a single request. Only successful
generations count against quota; a failed or rejected request costs
nothing.
Every response includes your remaining quota in the headers, so you can
track usage without a separate API call:
```
X-Quota-Limit: 200000
X-Quota-Used: 1450
X-Quota-Remaining: 198550
```
If you exceed quota, requests return a 429 with your current usage until
the reset date — no surprise overage invoice.
## Getting a key takes about ten seconds
The Free plan is fully self-serve: enter a name and email on the
[Developer API page](/developers), and a key lands in your inbox
immediately. No sales call, no approval queue, no payment info.
If you need more volume, Starter and Pro plans are a card payment away —
the key is emailed automatically the moment payment goes through, so
there's no gap between paying and being able to make your first request.
## A few things worth knowing before you integrate
- **Per-request limit.** Each request has a maximum character count —
split longer text across multiple calls rather than sending an entire
article in one request.
- **Quota resets monthly**, on a fixed calendar cycle, not a rolling
30-day window from your signup date.
- **Keys are shown once.** For security, the raw key is only ever
displayed at the moment it's created — store it in your secrets
manager immediately, since it can't be retrieved again if lost (a new
key would need to be issued).
- **Commercial use is fine.** Audio generated through the API is yours
to use in whatever you're building, commercial or not.
## Who this is actually for
The API fits anywhere you need programmatic voice generation without
building your own TTS pipeline: automated video narration, IVR/phone
systems, accessibility features reading content aloud, notification
systems, or any workflow where text needs to become audio without a human
clicking "generate" each time.
If that's the shape of what you're building, the whole setup — from zero
to your first MP3 — takes less time than reading this post did.
any provider's word for it, ours included.```
`
Almost every text-to-speech API on the market makes the same three claims:
natural-sounding voices, simple integration, competitive pricing. That
makes the marketing pages nearly useless for actually choosing one. Here's
what to check instead — criteria that reveal real differences, not just
different ways of saying the same thing.
## 1. Pricing model, not just price
The headline price per character/word matters less than the *shape* of the
billing. Two questions to ask before anything else:
- **Fixed quota or metered pay-as-you-go?** A fixed monthly character
allowance means you know your cost in advance. Metered billing means
your cost scales with usage — fine if usage is predictable, risky if a
traffic spike (or a bug that loops a request) can silently run up a
bill.
- **Does a failed request cost you anything?** Some APIs charge for
attempted generations regardless of success. Check whether errors,
rejected content, or timeouts still consume quota.
## 2. Language and voice coverage — for your specific languages
"40+ languages" sounds equivalent across providers until you test the
*specific* language you need. Coverage breadth doesn't guarantee quality in
every language — a provider can support 50 languages while three of them
sound noticeably worse than the rest, often the ones with smaller training
data available (Urdu and Hindi are common examples where quality varies a
lot between providers). Generate a real sample in your actual target
language before committing, not just the English demo on the landing page.
## 3. Integration complexity
Count the steps between "I have an API key" and "I have an MP3 file":
- Does it require an SDK, or does a plain HTTP POST work?
- Is authentication a simple Bearer token, or a multi-step OAuth flow?
- Are quota and usage visible in the response itself, or do you need a
separate dashboard call to check?
Fewer steps isn't just convenience — it's fewer places for an integration
to break in production.
## 4. Self-serve vs. sales-gated access
Some providers require a sales conversation before you can even test the
API. That's a reasonable model for large enterprise deals, but it's a real
cost if you're prototyping or building a side project — you lose days
before you can even evaluate voice quality for your use case. A provider
that lets you get a working key in minutes (even on a limited free tier)
lets you validate fit before you've invested any time in the integration.
## 5. What happens when you exceed quota
A 429 error with a clear "quota exceeded, resets on X date" is a very
different experience from a silent failure or an unexpected overage charge.
Check the documented behavior, not just the happy path.
## 6. Response format flexibility
Do you get raw audio bytes you can pipe directly to a file or a stream? Or
does the API wrap the audio in a JSON envelope requiring an extra decode
step? For real-time or streaming use cases, this difference matters more
than it looks on paper.
## Putting it together
None of these criteria have a universally "right" answer — a fixed-quota,
self-serve API with strong Urdu/Hindi support and a one-header
integration is the right fit for one project and irrelevant to another
that needs enterprise SSO and dedicated infrastructure. The point of this
checklist isn't to declare a winner; it's to ask the six questions that
actually differentiate providers, instead of comparing marketing pages
that all say the same thing.
If you want to see how VoxCraft answers each of these for yourself, the
[Developer API page](/developers) has a live example request and current
plan details — worth testing against your own checklist rather than taking
any provider's word for it, ours included.
```
Voxcraft Studio