Spring til hovedindhold
Dansk— Vælg et sprog
Menu

HTTP-fejl og sikkerhed for API-nøgler

Lektion 13 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Håndtér fejl og beskyt dine legitimationsoplysninger
  2. HTTP-fejlkoder
  3. Afslør aldrig API-nøglen på klienten
  4. Fail-open-moderering
  5. Vigtige pointer

Opdateret 3. november 2026 baseret på xAI-siderne Text to Speech og Rate limits: tekst begrænset til 60.000 tegn, 404-fejlen (ukendt stemme) og hastighedsbegrænsninger pr. niveau. Kilder: Text to Speech · Rate limits.

Håndtér fejl og beskyt dine legitimationsoplysninger

I produktion skal din app håndtere TTS-API-fejl elegant og frem for alt aldrig afsløre din API-nøgle på klienten. Denne lektion dækker fejlkoder, genforsøgsstrategier og backend-proxy-arkitekturen.

HTTP-fejlkoder

TTS-API’en returnerer standard HTTP-fejlkoder. Her er hvordan du reagerer på hver enkelt.

400: Bad Request

Serveren kunne ikke behandle din anmodning. Almindelige årsager:

  • Tom tekst eller tekst på over 60.000 tegn
  • En ugyldig codec (en tastefejl i navnet)
  • En ikke-understøttet sample rate
if response.status_code == 400:
    error = response.json()
    print(f"Invalid request: {error}")
    # Fix the parameters and try again

Genforsøg ikke automatisk en 400-fejl: problemet ligger i din anmodning, ikke på serveren. Ret parametrene først.

401: Unauthorized

API-nøglen er ugyldig, udløbet eller mangler:

if response.status_code == 401:
    raise AuthenticationError("Invalid or expired API key")

Kontrollér at:

  • Authorization-headere er til stede
  • Formatet er Bearer xai-... (med et mellemrum efter Bearer)
  • Nøglen ikke er blevet tilbagekaldt i xAI-konsollen

404: Not Found

Stemme-ID’et er ukendt: kontrollér det med GET /v1/tts/voices for en indbygget stemme eller GET /v1/custom-voices for en brugerdefineret stemme. Ligesom en 400 vil en 404 ikke forsvinde, hvis du genforsøger.

429: Too Many Requests

Du har overskredet en hastighedsbegrænsning: på startniveauet gælder 50 anmodninger pr. sekund og 100 samtidige sessioner for TTS ifølge siden Rate limits, samt 50 samtidige WebSocket-sessioner pr. team ifølge siden Text to Speech. xAI anbefaler at genforsøge med eksponentiel backoff:

if response.status_code == 429:
    retry_after = int(response.headers.get("Retry-After", 5))
    await asyncio.sleep(retry_after)
    # Try again

Implementér eksponentiel backoff for 429-fejl:

async def request_with_backoff(url, payload, headers, max_retries=5):
    for attempt in range(max_retries):
        response = requests.post(url, json=payload, headers=headers)

        if response.status_code == 200:
            return response

        if response.status_code == 429:
            wait = min(2 ** attempt + random.random(), 60)
            print(f"Rate limited. Waiting {wait:.1f}s")
            await asyncio.sleep(wait)
            continue

        if response.status_code >= 500:
            wait = min(2 ** attempt + random.random(), 30)
            await asyncio.sleep(wait)
            continue

        # Client error (400, 401): don't retry
        response.raise_for_status()

    raise Exception("Failed after 5 attempts")

500 / 503: Server Error

Serveren har et midlertidigt problem. Genforsøg med backoff:

if response.status_code in (500, 503):
    # Retry with exponential backoff
    pass

503-fejl skyldes ofte midlertidig overbelastning. De løser sig normalt inden for få sekunder.

Afslør aldrig API-nøglen på klienten

Dette er den vigtigste sikkerhedsregel. Hvis din API-nøgle er synlig i browserens JavaScript, kan alle:

  • Bruge din kvote gratis
  • Påføre dit konto store omkostninger
  • Få adgang til alle xAI-API-endepunkter med din nøgle

Backend-proxy-arkitektur

Løsningen er at proxy’e TTS-opkald gennem din egen backend:

Browser -> Your backend -> xAI API
 (no key)    (API key)      (TTS)

Eksempel med Express.js

const express = require("express");
const app = express();

app.post("/api/tts", async (req, res) => {
  const { text, voice_id, language } = req.body;

  // Server-side validation
  if (!text || text.length > 60000) {
    return res.status(400).json({ error: "Invalid text" });
  }

  const response = await fetch("https://api.x.ai/v1/tts", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.XAI_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ text, voice_id, language })
  });

  if (!response.ok) {
    return res.status(response.status).json({
      error: "TTS error"
    });
  }

  // Pass the audio on to the client
  res.set("Content-Type", response.headers.get("Content-Type"));
  const buffer = await response.arrayBuffer();
  res.send(Buffer.from(buffer));
});

Eksempel med FastAPI (Python)

from fastapi import FastAPI, HTTPException
from fastapi.responses import Response
import httpx

app = FastAPI()

@app.post("/api/tts")
async def proxy_tts(text: str, voice_id: str = "eve", language: str = "en"):
    if len(text) > 60000:
        raise HTTPException(400, "Text too long")

    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.x.ai/v1/tts",
            headers={"Authorization": f"Bearer {os.environ['XAI_API_KEY']}"},
            json={"text": text, "voice_id": voice_id, "language": language}
        )

    if response.status_code != 200:
        raise HTTPException(response.status_code, "TTS error")

    return Response(
        content=response.content,
        media_type=response.headers["content-type"]
    )

WebSocket-proxy

Til TTS-WebSocket skal din backend videresende beskeder mellem klienten og xAI-API’en:

const WebSocket = require("ws");

wss.on("connection", (clientWs) => {
  const xaiWs = new WebSocket(
    "wss://api.x.ai/v1/tts?language=en&voice=eve",
    { headers: { Authorization: `Bearer ${process.env.XAI_API_KEY}` } }
  );

  // Relay client -> xAI
  clientWs.on("message", (msg) => xaiWs.send(msg));

  // Relay xAI -> client
  xaiWs.on("message", (msg) => clientWs.send(msg));

  // Handle closing
  clientWs.on("close", () => xaiWs.close());
  xaiWs.on("close", () => clientWs.close());
});

Fail-open-moderering

TTS-API’en kører indholdsmoderering asynkront. Det betyder, at moderering ikke blokerer anmodningen: lyden genereres og returneres, selv hvis modereringen ikke har afsluttet sin analyse.

Hvis indhold flagges som upassende, kommer rapporten efterfølgende. Derfor bør din app køre sin egen moderering upstream, hvis det er nødvendigt.

Vigtige pointer

  • 400 = en parameterfejl (genforsøg ikke; ret anmodningen)
  • 401 = en ugyldig API-nøgle (kontrollér Authorization-headeren)
  • 429 = hastighedsbegrænset (eksponentiel backoff)
  • 500/503 = en midlertidig serverfejl (genforsøg med backoff)
  • Afslør aldrig API-nøglen i klientkode
  • Proxy alle TTS-opkald gennem din backend
  • Moderering er fail-open: tilføj din egen filtrering, hvis det er nødvendigt