Giggy Speech API

Text-to-speech billing

Batch is free. Fast: $5.00 per 1,000,000 input characters; Streaming: $10.00 per 1,000,000 input characters with Pro, Studio or Scale credits. Starter and Creator cost more per credit.

TTS counts Unicode code points in the full submitted text, including spaces and punctuation, not UTF-8 bytes or generated audio duration. The same character rates apply across supported languages. Each paid request rounds up to a pricing block with a minimum charge. REST and MCP use the app's selected-mode rates; free homepage and authenticated Playground previews retain their preview exemption.

Fast: 10 credits per started 20-character block, minimum 10 credits. Streaming: 10 credits per started 10-character block, minimum 10 credits. See pricing and credit-pack estimates.

API base URL

Use https://api.giggy.ai/v1 for text-to-speech and speech-to-text. Existing integrations can continue using https://giggy.ai/v1 with the same API keys, request formats, billing and generation history. Keep each operation on the origin where it was admitted.

Core developer endpoints

• POST /v1/text-to-speech — native Giggy text-to-speech with Batch, Fast, and Streaming modes. Batch uses zero credits.
• POST /v1/audio/speech — OpenAI-compatible text-to-speech adapter for voice-product integrations.
• POST /v1/audio/transcriptions — WAV PCM16, mono, 16 kHz. Batch: 0.5 seconds–25 minutes; Fast and uploaded-recording Streaming: 0.5 seconds–12 hours. Fast costs 4,000 credits per audio hour; Streaming costs 8,000, rounded up per request. Batch/Fast return HTTP 202 generation JSON; Streaming returns cumulative transcript SSE.
• Request privacy (TTS/STT) — Put privacy: {content_retention_12h: true, compute_eea_adequate_only: true} last in the JSON body or WebSocket start message. Raw WAV STT uses trailing content_retention_12h=true&compute_eea_adequate_only=true query parameters. Optional booleans; omission or false preserves the existing policy. See request shapes and fields.
• WebSocket wss://api.giggy.ai/v1/audio/transcriptions — production default for live STT. Authenticate with Authorization: Bearer or xi-api-key in the upgrade headers. Send start, wait for generation_created and ready, then send binary LINEAR16 mono audio and stop on the same socket. Transcription and input_complete events return there. HTTPS/SSE live input remains an explicit legacy transport.
• GET /v1/voices — list public Giggy voices.
• GET /v1/my-voices — list custom voices owned by the API-key scope.
• GET /v1/generations/{generationUuid} — read durable generation state and completed results.
• GET /v1/generations/{generationUuid}/stream — stream generation events and ordered PCM chunks using server-sent events.
• GET /v1/integrations/voices — public connector voice catalog.
• POST /v1/integrations/vapi/text-to-speech/{voiceId} — Vapi custom TTS webhook.

Partner integrations: LiveKit, Pipecat and Jambonz

Use these compatibility integrations with your existing voice stack. They do not establish upstream provider listings or commercial partnerships. Keep Giggy API keys server-side. Existing integrations can retain the legacy origin and installed transport until their adapter is updated and qualified.

LiveKit

Configure the LiveKit OpenAI TTS plugin with base_url=https://api.giggy.ai/v1, model=giggyspeech, your Giggy voice UUID and response_format=pcm. Supply STT, LLM, VAD and room transport separately; a base URL change does not supply a native STT adapter. Disable automatic synthesis replay after partial streaming. The native Giggy TTS contribution remains an open contribution, not a released provider.

LiveKit runnable TTS example · Native TTS and streaming STT contribution status. Older example checkouts may still use giggy.ai; explicitly configure api.giggy.ai for the API path.

Pipecat

pipecat-giggy 0.3.1 is the released Giggy-maintained TTS/live STT adapter. Install with python -m pip install pipecat-giggy==0.3.1; the tested Pipecat dependency is 1.12.0. It uses V25 one-socket live STT with binary PCM, explicit stop, canonical decode preparation, fenced final events and saved-result verification. Applications own transport and upstream turn timing. Drain the lifecycle and surface verification errors after final text. Version 0.2.0 retains its earlier transport. Native LiveKit streaming STT remains available from its unreleased source PR.

Jambonz

Configure a custom STT provider with wss://api.giggy.ai/v1/audio/transcriptions and your Giggy API key. Jambonz sends Authorization: Bearer on the upgrade, then start, binary 8 kHz mono LINEAR16 and stop on one socket; transcription messages return there. Giggy converts 8 kHz continuously to canonical 16 kHz. Do not use the HTTPS recording endpoint for live recognition. Without external endpointing, the existing energy threshold and 650 ms silence rule delimit utterances; test quiet speech and noise. Unsupported hints reject explicitly.

Jambonz custom STT specification · Giggy live STT guide. The Jambonz-style wire protocol is tested; native media-server calls require separate end-to-end qualification. STT compatibility does not establish support for Jambonz streaming TTS.

Speech-to-text quickstart: Python and JavaScript

Keep GIGGY_API_KEY on your server. Use https://api.giggy.ai/v1 for recording STT and wss://api.giggy.ai/v1/audio/transcriptions for live STT. Install the published Python SDK with python -m pip install giggy==0.2.0 (Python 3.10+) or JavaScript/TypeScript SDK with npm install @giggy-ai/[email protected] (Node.js 22+). Prepare signed PCM16 mono 16 kHz WAV, for example with ffmpeg -i input.mp3 -ac 1 -ar 16000 -c:a pcm_s16le recording.wav. Free Batch accepts 0.5 seconds–25 minutes. Use paid Fast for recordings up to 12 hours.

Python: retrieve the final transcript

import os
from giggy import Giggy

giggy = Giggy(api_key=os.environ["GIGGY_API_KEY"], base_url="https://api.giggy.ai/v1")
result = giggy.transcriptions.transcribe("recording.wav", mode="batch")
print(result["text"])

JavaScript: retrieve the final transcript

import { Giggy } from '@giggy-ai/sdk';

const giggy = new Giggy({ apiKey: process.env.GIGGY_API_KEY, baseURL: 'https://api.giggy.ai/v1' });
const result = await giggy.transcriptions.transcribe({ audioPath: 'recording.wav', mode: 'batch' });
console.log(result.text);

These existing SDK methods submit once, wait for durable completion and fetch the signed transcript without forwarding your API key to the artifact host. The default SDK mode is Batch; direct REST requests default to paid Fast. For raw REST, POST the WAV body with Content-Type: audio/wav and xi-api-key. Batch/Fast admission returns HTTP 202 with generation.generation_uuid, not transcript text. Retain that UUID, read GET /v1/generations/{generationUuid} until completed, then fetch generation.result.url for the final transcript JSON. A timeout is not permission to upload the same recording again.

Choose the spoken language (optional)

For uploaded recordings in Batch, Fast, or Streaming, set language to a supported code or name, such as en or English, to skip automatic language detection. With a raw WAV body, use POST /v1/audio/transcriptions?mode=fast&language=en. With a JSON data URL, include "language": "en". Omit language, or use null in JSON, for automatic detection. Live WebSocket start also accepts an optional supported language; omit it for automatic detection.

Choose the correct transcription workflow

Application capture, resampling, VAD and turn boundaries are your responsibility. Closing unfinished live input cancels it; closing uploaded-recording SSE does not cancel the admitted recording. Paid API live admission reserves 96,000 credits and settles against accepted audio duration. Do not append cumulative revisions or treat them as verified final text.

Complete examples: Python uploaded-WAV Streaming · JavaScript uploaded-WAV Streaming · Python live microphone · Node live PCM replay. A replay example tests the live protocol; it does not capture microphone hardware.

Live STT: one WebSocket for audio and transcripts

Connect your server to wss://api.giggy.ai/v1/audio/transcriptions with Authorization: Bearer or xi-api-key in the upgrade headers. Keep credentials off browser clients. Send {"type":"start","format":"raw","encoding":"LINEAR16","sampleRateHz":16000,"interimResults":true,"options":{"endpointing":"external"}}; optionally set language. Wait for generation_created and ready before sending headerless binary PCM16 LE mono audio. Send {"type":"stop"} after the real tail. Do not open an HTTPS request every 20 ms.

Replace cumulative transcription text. Validate generation UUID, attempt, increasing sequence and is_final; require input_complete before publishing final text. Continue to canonical completion and verify saved text and duration. Jambonz can use the same endpoint with8 kHz LINEAR16 start/audio/stop;8 kHz is converted continuously to canonical 16 kHz. Without external endpointing, the existing energy threshold and 650ms silence rule delimit turns. Quiet speech and background noise require testing.

Paid API input supports 0.5 seconds to 12 hours and reserves 96,000 credits, settling against accepted duration. Previews and the reference replay are capped at 30 seconds. Start promptly, bound capture queues, and honor input/idle watchdogs. A disconnect cancels unfinished work; do not reconnect or replay ambiguous PCM. Existing HTTPS/SSE clients remain supported explicitly. Sockets remain pinned to the admitting controller while deployments drain.

Download the locked Node WebSocket reference client. Extract, run npm ci, set GIGGY_API_KEY and GIGGY_STT_ORIGIN=https://api.giggy.ai, then run npm start -- --input recording.wav --allow-billable. The example replays 0.5–30 seconds of PCM16 mono 16 kHz WAV at capture cadence; applications own microphone capture and endpointing. Published SDK transports do not automatically change when this guide changes.

Migrate an OpenAI or AssemblyAI application

OpenAI-compatible text-to-speech uses https://api.giggy.ai/v1/audio/speech: keep the OpenAI speech client, set its base URL to https://api.giggy.ai/v1, authenticate with your Giggy key, set model=giggyspeech and use a Giggy voice UUID. Choose a supported response format and disable automatic synthesis retries. See the existing OpenAI-client TTS example.

Speech-to-text is a separate contract. Changing an OpenAI client base URL alone does not migrate audio.transcriptions.create: Giggy accepts raw WAV rather than an OpenAI multipart upload, uses xi-api-key and returns asynchronous admission or cumulative SSE. Replace the transcription call with the Giggy Python or JavaScript quickstart above, convert the recording locally and consume the verified final text. For AssemblyAI, replace transcriber.transcribe(audio) with transcriptions.transcribe and transcript.text with the result text.

Speaker labels, word timestamps, confidence, chapters, sentiment and redaction options have no equivalent in this API. Remove unsupported options; do not invent fields. For explicit lifecycle control use submit/get/result. After interruption with a known UUID, reconcile that operation rather than automatically resubmitting it.

AI coding agents and MCP

Giggy exposes a Streamable HTTP MCP server at https://giggy.ai/mcp. MCP supports public voice discovery, owned custom-voice discovery, speech generation, recorded-audio transcription, and durable generation reads. It is not a live microphone transport.

Voice-agent compatibility

LiveKit, Pipecat and Vapi can use the existing TTS compatibility integrations. The Giggy-maintained Pipecat adapter 0.3.0 supplies one-socket WebSocket STT and decode preparation with upstream Pipecat VAD. Native LiveKit streaming STT is available in its open source PR; the Vapi custom TTS webhook does not make Giggy a native Vapi transcriber. See the framework capability guide. These integrations do not establish an upstream provider listing. Use the published OpenAPI contract for supported formats and rates. Compatibility synthesis uses paid modes.

Developer tools and integrations

• Transcribe recordings with the Python SDK (giggy 0.2.0, Python 3.10+) or JavaScript/TypeScript SDK (@giggy-ai/sdk 0.2.0, Node.js 22+).
• Stream speech with the Node TTS example.
• Build voice agents with Pipecat TTS/live STT (adapter 0.2.0, Python 3.11+, Pipecat 1.12.0) or the existing LiveKit/Vapi TTS examples. Applications own transport, VAD and turn boundaries.
• Automate Batch/Fast voiceovers with n8n-nodes-giggy 0.1.0 in self-hosted n8n. Cloud verification is not established.
• Connect coding assistants through the remote MCP server and agent skill. Each user supplies their own API key; plugin directory approvals are separate.
• Explore TTS Postman requests, Voice AI Essentials and AI-readable documentation.