API Documentation

import requests

API_KEY = "sk-tts-your-api-key"
BASE_URL = "https://whatistts.com/api"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

response = requests.post(f"{BASE_URL}/v1/tts/", headers=headers, json={
    "text": "Hello world",
    "model": "openai-tts-1"
})

const API_KEY = "sk-tts-your-api-key";
const BASE_URL = "https://whatistts.com/api";

const response = await fetch(`${BASE_URL}/v1/tts/`, {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${API_KEY}`,
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        text: "Hello world",
        model: "openai-tts-1"
    })
});

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

const (
    apiKey  = "sk-tts-your-api-key"
    baseURL = "https://whatistts.com/api"
)

func main() {
    payload, _ := json.Marshal(map[string]string{
        "text":  "Hello world",
        "model": "openai-tts-1",
    })

    req, _ := http.NewRequest("POST", baseURL+"/v1/tts/", bytes.NewBuffer(payload))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

import requests

session = requests.Session()
# Log in first to get session cookie
session.post("https://whatistts.com/login/", data={
    "email": "user@example.com",
    "password": "your-password"
})

# Then get session token
response = session.post("https://whatistts.com/api/session-token/")
data = response.json()
api_key = data["api_key"]
credits = data["credits"]

// In-browser: session cookie is sent automatically
const response = await fetch("/api/session-token/", {
    method: "POST",
    headers: {
        "X-CSRFToken": window.TTS.csrfToken
    }
});
const data = await response.json();
// data.api_key, data.credits, data.plan

// Session tokens are primarily for browser-based usage.
// For server-to-server integrations, use API key auth instead.

req, _ := http.NewRequest("POST", "https://whatistts.com/api/session-token/", nil)
req.Header.Set("Cookie", "sessionid=your-session-cookie")
req.Header.Set("X-CSRFToken", "your-csrf-token")

client := &http.Client{}
resp, _ := client.Do(req)

response = requests.post(
    "https://whatistts.com/api/generate-key/",
    headers=headers,
    json={"name": "My Production Key"}
)
new_key = response.json()["key"]
print(f"New API key: {new_key}")

const response = await fetch("https://whatistts.com/api/generate-key/", {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${API_KEY}`,
        "Content-Type": "application/json"
    },
    body: JSON.stringify({ name: "My Production Key" })
});
const { key, name, id } = await response.json();

payload, _ := json.Marshal(map[string]string{
    "name": "My Production Key",
})

req, _ := http.NewRequest("POST", baseURL+"/generate-key/", bytes.NewBuffer(payload))
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

import requests

API_KEY = "sk-tts-your-api-key"

response = requests.post(
    "https://whatistts.com/api/v1/tts/",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "text": "Welcome to the future of text to speech.",
        "model": "openai-tts-1",
        "voice": "alloy",
        "format": "mp3",
        "speed": 1.0
    }
)

if response.status_code == 200:
    content_type = response.headers.get("Content-Type", "")
    if "audio/" in content_type:
        # Binary audio response
        with open("speech.mp3", "wb") as f:
            f.write(response.content)
        print("Saved to speech.mp3")
    else:
        # JSON response with URL
        data = response.json()
        print(f"Audio URL: {data.get('url')}")
else:
    print(f"Error {response.status_code}: {response.text}")

const API_KEY = "sk-tts-your-api-key";

const response = await fetch("https://whatistts.com/api/v1/tts/", {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${API_KEY}`,
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        text: "Welcome to the future of text to speech.",
        model: "openai-tts-1",
        voice: "alloy",
        format: "mp3",
        speed: 1.0
    })
});

if (response.ok) {
    const contentType = response.headers.get("Content-Type") || "";
    if (contentType.includes("audio/")) {
        const blob = await response.blob();
        const url = URL.createObjectURL(blob);
        // Play it
        const audio = new Audio(url);
        audio.play();
    } else {
        const data = await response.json();
        console.log("Audio URL:", data.url);
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    payload, _ := json.Marshal(map[string]interface{}{
        "text":   "Welcome to the future of text to speech.",
        "model":  "openai-tts-1",
        "voice":  "alloy",
        "format": "mp3",
        "speed":  1.0,
    })

    req, _ := http.NewRequest("POST", "https://whatistts.com/api/v1/tts/", bytes.NewBuffer(payload))
    req.Header.Set("Authorization", "Bearer sk-tts-your-api-key")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode == 200 {
        file, _ := os.Create("speech.mp3")
        defer file.Close()
        io.Copy(file, resp.Body)
        fmt.Println("Saved to speech.mp3")
    } else {
        body, _ := io.ReadAll(resp.Body)
        fmt.Printf("Error %d: %s\n", resp.StatusCode, string(body))
    }
}

import requests

API_KEY = "sk-tts-your-api-key"

with open("recording.mp3", "rb") as f:
    response = requests.post(
        "https://whatistts.com/api/v1/stt/",
        headers={"Authorization": f"Bearer {API_KEY}"},
        files={"file": ("recording.mp3", f, "audio/mpeg")},
        data={
            "model": "faster-whisper",
            "language": "en"
        }
    )

data = response.json()
print(data["text"])
print(f"Duration: {data['duration']}s")

const API_KEY = "sk-tts-your-api-key";

const formData = new FormData();
formData.append("file", audioFile); // File or Blob object
formData.append("model", "faster-whisper");
formData.append("language", "en");

const response = await fetch("https://whatistts.com/api/v1/stt/", {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${API_KEY}`
        // Do NOT set Content-Type -- browser sets it with boundary
    },
    body: formData
});

const data = await response.json();
console.log(data.text);

package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    file, _ := os.Open("recording.mp3")
    defer file.Close()

    var body bytes.Buffer
    writer := multipart.NewWriter(&body)

    part, _ := writer.CreateFormFile("file", "recording.mp3")
    io.Copy(part, file)

    writer.WriteField("model", "faster-whisper")
    writer.WriteField("language", "en")
    writer.Close()

    req, _ := http.NewRequest("POST", "https://whatistts.com/api/v1/stt/", &body)
    req.Header.Set("Authorization", "Bearer sk-tts-your-api-key")
    req.Header.Set("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    result, _ := io.ReadAll(resp.Body)
    fmt.Println(string(result))
}

import requests

API_KEY = "sk-tts-your-api-key"

with open("my_voice.wav", "rb") as ref:
    response = requests.post(
        "https://whatistts.com/api/v1/voice-clone/",
        headers={"Authorization": f"Bearer {API_KEY}"},
        files={"reference_audio": ("my_voice.wav", ref, "audio/wav")},
        data={
            "text": "This is my cloned voice speaking.",
            "model": "elevenlabs-multilingual-v2",
            "language": "en"
        }
    )

if response.status_code == 200:
    with open("cloned_output.mp3", "wb") as f:
        f.write(response.content)
    print("Saved cloned speech to cloned_output.mp3")

const API_KEY = "sk-tts-your-api-key";

const formData = new FormData();
formData.append("reference_audio", referenceFile); // File object
formData.append("text", "This is my cloned voice speaking.");
formData.append("model", "elevenlabs-multilingual-v2");
formData.append("language", "en");

const response = await fetch("https://whatistts.com/api/v1/voice-clone/", {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${API_KEY}`
    },
    body: formData
});

if (response.ok) {
    const blob = await response.blob();
    const url = URL.createObjectURL(blob);
    const audio = new Audio(url);
    audio.play();
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    file, _ := os.Open("my_voice.wav")
    defer file.Close()

    var body bytes.Buffer
    writer := multipart.NewWriter(&body)

    part, _ := writer.CreateFormFile("reference_audio", "my_voice.wav")
    io.Copy(part, file)

    writer.WriteField("text", "This is my cloned voice speaking.")
    writer.WriteField("model", "elevenlabs-multilingual-v2")
    writer.WriteField("language", "en")
    writer.Close()

    req, _ := http.NewRequest("POST", "https://whatistts.com/api/v1/voice-clone/", &body)
    req.Header.Set("Authorization", "Bearer sk-tts-your-api-key")
    req.Header.Set("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    output, _ := os.Create("cloned_output.mp3")
    defer output.Close()
    io.Copy(output, resp.Body)
    fmt.Println("Saved to cloned_output.mp3")
}

import requests

# Get all voices
response = requests.get("https://whatistts.com/api/v1/voices/")
voices = response.json()["voices"]
print(f"Total voices: {len(voices)}")

# Filter by model
response = requests.get("https://whatistts.com/api/v1/voices/", params={
    "model": "openai-tts-1"
})
openai_voices = response.json()["voices"]
for voice in openai_voices:
    print(f"  {voice['voice_id']} - {voice['name']} ({voice['language']})")

// Get all voices
const response = await fetch("https://whatistts.com/api/v1/voices/");
const { voices } = await response.json();
console.log(`Total voices: ${voices.length}`);

// Filter by model
const filtered = await fetch("https://whatistts.com/api/v1/voices/?model=openai-tts-1");
const { voices: openaiVoices } = await filtered.json();
openaiVoices.forEach(v => {
    console.log(`${v.voice_id} - ${v.name} (${v.language})`);
});

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type VoicesResponse struct {
    Voices []struct {
        ModelName  string `json:"model_name"`
        VoiceID    string `json:"voice_id"`
        Name       string `json:"name"`
        Language   string `json:"language"`
        Gender     string `json:"gender"`
        PreviewURL string `json:"preview_url"`
        IsPremium  bool   `json:"is_premium"`
    } `json:"voices"`
}

func main() {
    resp, _ := http.Get("https://whatistts.com/api/v1/voices/?model=openai-tts-1")
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result VoicesResponse
    json.Unmarshal(body, &result)

    for _, v := range result.Voices {
        fmt.Printf("%s - %s (%s)\n", v.VoiceID, v.Name, v.Language)
    }
}

import requests

response = requests.get("https://whatistts.com/api/v1/models/")
models = response.json()["models"]

for model in models:
    print(f"{model['name']:20s} tier={model['tier']:10s} cost={model['credits_per_1k']} credits/1K chars")

const response = await fetch("https://whatistts.com/api/v1/models/");
const { models } = await response.json();

models.forEach(m => {
    console.log(`${m.name} (${m.tier}) - ${m.credits_per_1k} credits/1K chars`);
});

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type ModelsResponse struct {
    Models []struct {
        Name         string `json:"name"`
        Tier         string `json:"tier"`
        CreditsPer1K int    `json:"credits_per_1k"`
    } `json:"models"`
}

func main() {
    resp, _ := http.Get("https://whatistts.com/api/v1/models/")
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result ModelsResponse
    json.Unmarshal(body, &result)

    for _, m := range result.Models {
        fmt.Printf("%-20s tier=%-10s cost=%d credits/1K\n", m.Name, m.Tier, m.CreditsPer1K)
    }
}

import time
import requests

API_KEY = "sk-tts-your-api-key"

def generate_speech(text, model="openai-tts-1", retries=3):
    for attempt in range(retries):
        response = requests.post(
            "https://whatistts.com/api/v1/tts/",
            headers={
                "Authorization": f"Bearer {API_KEY}",
                "Content-Type": "application/json"
            },
            json={"text": text, "model": model}
        )

        if response.status_code == 200:
            return response.content
        elif response.status_code == 429:
            wait = 2 ** attempt  # Exponential backoff
            print(f"Rate limited. Retrying in {wait}s...")
            time.sleep(wait)
        else:
            response.raise_for_status()

    raise Exception("Max retries exceeded")

async function generateSpeech(text, model = "openai-tts-1", retries = 3) {
    for (let attempt = 0; attempt < retries; attempt++) {
        const response = await fetch("https://whatistts.com/api/v1/tts/", {
            method: "POST",
            headers: {
                "Authorization": `Bearer ${API_KEY}`,
                "Content-Type": "application/json"
            },
            body: JSON.stringify({ text, model })
        });

        if (response.ok) return await response.blob();

        if (response.status === 429) {
            const wait = Math.pow(2, attempt) * 1000;
            console.log(`Rate limited. Retrying in ${wait}ms...`);
            await new Promise(r => setTimeout(r, wait));
            continue;
        }

        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
    }
    throw new Error("Max retries exceeded");
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "math"
    "net/http"
    "time"
)

func generateSpeech(text, model string) (*http.Response, error) {
    maxRetries := 3
    for attempt := 0; attempt < maxRetries; attempt++ {
        payload, _ := json.Marshal(map[string]string{
            "text":  text,
            "model": model,
        })

        req, _ := http.NewRequest("POST", "https://whatistts.com/api/v1/tts/", bytes.NewBuffer(payload))
        req.Header.Set("Authorization", "Bearer sk-tts-your-api-key")
        req.Header.Set("Content-Type", "application/json")

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return nil, err
        }

        if resp.StatusCode == 200 {
            return resp, nil
        }
        resp.Body.Close()

        if resp.StatusCode == 429 {
            wait := time.Duration(math.Pow(2, float64(attempt))) * time.Second
            fmt.Printf("Rate limited. Retrying in %v...\n", wait)
            time.Sleep(wait)
            continue
        }

        return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
    }
    return nil, fmt.Errorf("max retries exceeded")
}

{
    "authorized": false,
    "error": "insufficient_credits",
    "credits_remaining": 1,
    "credits_needed": 5
}

{
    "error": "rate_limit",
    "message": "Free tier limit reached. Sign up for more."
}

{
    "error": "upstream_provider_error",
    "message": "The TTS provider returned an unexpected error. Please try again."
}