Audio

Three audio surfaces, all backed by ElevenLabs. The HTTP routes mirror OpenAI's audio.speech and audio.transcriptions APIs — the OpenAI SDKs work as-is with a swapped baseURL. The voice-to-voice route is a WebSocket because the call is bidirectional and long-lived; there is no OpenAI SDK shape for it, so callers either use the Quota SDK or speak the protocol directly. TTS bills per input character; STT bills per second of returned transcript; V2V bills per second of input audio.

Text-to-speech

Request

curl https://api.usequota.ai/v1/audio/speech \
  -H "Authorization: Bearer $QUOTA_API_KEY" \
  -H "Content-Type: application/json" \
  --output speech.mp3 \
  -d '{
    "model": "elevenlabs/eleven_multilingual_v2",
    "input": "The quick brown fox jumps over the lazy dog.",
    "voice": "rachel",
    "response_format": "mp3"
  }'

Request body

Streaming

Set stream: true to receive audio bytes chunk-by-chunk as ElevenLabs renders them, instead of waiting for the full file. First-byte latency drops noticeably for long inputs — useful when you're piping audio straight to a player or speaker. Billing is identical to one-shot (TTS cost is known up-front from input.length), so the only thing that changes is when you start getting bytes.

# Pipe chunks straight to ffplay (or any stdin-reading player)
curl -N https://api.usequota.ai/v1/audio/speech \
  -H "Authorization: Bearer $QUOTA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "elevenlabs/eleven_turbo_v2_5",
    "input": "Streaming is great for long passages — first audio byte arrives in under a second.",
    "voice": "rachel",
    "stream": true
  }' | ffplay -autoexit -nodisp -

Response headers (X-Quota-Credits-Used, X-Quota-Balance, etc.) are sent before the first audio chunk, so they're readable as soon as fetch resolves — no need to wait for response.body to drain.

Response

Binary. The response body is raw audio bytes. The Content-Type header reflects the requested format: audio/mpeg for mp3/opus/aac, audio/wav for wav/flac, audio/pcm for pcm. With stream: true the body uses chunked transfer encoding; otherwise it's a single buffered payload.

Billing metadata comes back in response headers:

Pricing

Billed per character of input. Output audio length does not factor in.

Voices

Pass a curated short name or a raw 20-character ElevenLabs voice ID. Unknown names fall back to rachel. Voice IDs accept anything 20 characters or longer of mixed case alphanumerics — useful for voices you've cloned in your ElevenLabs account.

TTS models

Always pass the full elevenlabs/-prefixed model ID. Bare ElevenLabs IDs (without prefix) return invalid_request.

Speech-to-text

Request

curl https://api.usequota.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $QUOTA_API_KEY" \
  -F file=@meeting.mp3 \
  -F model=elevenlabs/scribe_v1 \
  -F response_format=verbose_json

Form fields

Response

{ "text": "Hello from quota." }

Billing metadata comes back in response headers:

Pricing

Billed per second of audio. Quota pre-reserves a generous upper bound derived from the upload's nominal duration, then reconciles against the exact transcript duration once Scribe returns. Refunded in full on upstream error.

Voice-to-voice (V2V)

Stream audio in, receive audio re-rendered in a target voice out. Billed per second of input audio. Sessions are capped at 30 minutes; callers can declare a shorter cap at handshake.

Lifecycle

1. Client opens the WebSocket. No Authorization header is required on the upgrade — browsers can't set one on new WebSocket(), so auth is the first text frame.
2. Client sends a JSON auth frame (see below). Quota validates the token, looks up pricing, atomically reserves the max-session cost, opens an upstream WebSocket to ElevenLabs, and writes an audio_sessions audit row.
3. Quota replies with a JSON auth_ack frame containing the session ID. From here, binary frames are bidirectional: client PCM in, ElevenLabs-converted audio out.
4. Every 30 seconds Quota does an in-memory insolvency check against your declared max duration. Heartbeat pings run on the same cadence; two missed pongs (~65 s) close the session.
5. On any close — client, upstream, timeout, balance exhaustion, format violation — Quota refunds reservation − actual_used and updates the audit row. The session ID is returned in the close frame so you can correlate to your own telemetry.

Auth frame (client → server)

{
  "type": "auth",
  "token": "sk-quota-...",
  "model": "elevenlabs/voice-conversion-v1",
  "voice": "rachel",
  "format": "pcm_16le_16k_mono",
  "max_duration_seconds": 600
}

Auth ack (server → client)

{
  "type": "auth_ack",
  "session_id": "9f4c…",
  "upstream_ready": true,
  "max_duration_seconds": 600
}

After auth_ack, both directions switch to binary frames. Send raw PCM bytes; receive ElevenLabs-encoded MP3 (44.1 kHz, 128 kbps).

Close codes

Quota uses application-defined close codes (RFC 6455 §7.4.2, ≥ 4000). The Quota SDKs map these to typed errors; native callers should read event.code.

Pricing

elevenlabs/voice-conversion-v1 bills per second of input audio at $9.00 per hour. The reservation at handshake is max_duration_seconds × price; the diff is refunded on close. Output audio length is ≈ 1:1 with input and is not billed separately.

Browser quickstart

import { useVoiceConversion } from "@usequota/nextjs";

export function VoiceClone() {
  const { start, stop, state, error } = useVoiceConversion({
    model: "elevenlabs/voice-conversion-v1",
    voice: "rachel",
    format: "pcm_16le_16k_mono",
    maxDurationSeconds: 600,
  });

  return (
    <button onClick={state === "open" ? stop : start}>
      {state === "open" ? "Stop" : "Speak"}
      {error && <span> — {error.message}</span>}
    </button>
  );
}

User-scoped billing

For end-user-pays flows, pass the user's OAuth access token (quota_token_…) as the bearer instead of your API key. Quota debits the user's wallet rather than yours. Works identically for /v1/audio/speech, /v1/audio/transcriptions, and the V2V WebSocket (pass the OAuth token in the auth frame's token field). See Sign in with Quota or Connect Quota Wallet for the end-to-end OAuth flow.

Errors

Errors use the standard Quota envelope:

{
  "error": {
    "code": "insufficient_credits",
    "message": "Insufficient credits. Balance: 0, Required: 90",
    "hint": "..."
  }
}