Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

HTTP-fel och säkerhet för API-nycklar

Lektion 13 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Hantera fel och skydda dina uppgifter
  2. HTTP-felkoder
  3. Exponera aldrig API-nyckeln i klienten
  4. Fail-open-moderering
  5. Viktiga punkter

Uppdaterat den 3 november 2026, baserat på xAI:s sidor Text to Speech och Rate limits: text begränsad till 60 000 tecken, felkoden 404 (okänd röst) samt hastighetsbegränsningar per nivå. Källor: Text to Speech · Rate limits.

Hantera fel och skydda dina uppgifter

I produktion måste din app hantera fel från TTS-API:t på ett robust sätt och framför allt aldrig exponera din API-nyckel i klienten. Denna lektion täcker felkoder, strategier för återförsök och arkitekturen för en backend-proxy.

HTTP-felkoder

TTS-API:t returnerar standardiserade HTTP-felkoder. Så här ska du reagera på var och en.

400: Bad Request

Servern kunde inte bearbeta din begäran. Vanliga orsaker:

  • Tom text eller text som överstiger 60 000 tecken
  • En ogiltig codec (ett stavfel i namnet)
  • En ej stödd samplingsfrekvens
if response.status_code == 400:
    error = response.json()
    print(f"Invalid request: {error}")
    # Fix the parameters and try again

Försök inte automatiskt igen vid ett 400-fel: problemet ligger i din begäran, inte på servern. Åtgärda parametrarna först.

401: Unauthorized

API-nyckeln är ogiltig, har löpt ut eller saknas:

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

Kontrollera att:

  • Rubriken Authorization finns med
  • Formatet är Bearer xai-... (med ett mellanslag efter Bearer)
  • Nyckeln inte har återkallats i xAI-konsolen

404: Not Found

Röst-ID:t är okänt: kontrollera det med GET /v1/tts/voices för en inbyggd röst, eller GET /v1/custom-voices för en anpassad röst. Precis som vid ett 400-fel försvinner inte ett 404-fel om du försöker igen.

429: Too Many Requests

Du har överskridit en hastighetsbegränsning: på instegsnivån gäller 50 begäranden per sekund och 100 samtidiga sessioner för TTS enligt sidan Rate limits, samt 50 samtidiga WebSocket-sessioner per team enligt sidan Text to Speech. xAI rekommenderar att du försöker igen med exponentiell backoff:

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

Implementera exponentiell backoff för 429-fel:

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

Servern har ett tillfälligt problem. Försök igen med backoff:

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

503-fel beror ofta på tillfällig överbelastning. De brukar lösa sig inom några sekunder.

Exponera aldrig API-nyckeln i klienten

Detta är den viktigaste säkerhetsregeln. Om din API-nyckel syns i webbläsarens JavaScript kan vem som helst:

  • Använda din kvot gratis
  • Driva upp kostnaderna på ditt konto
  • Komma åt alla xAI-API-slutpunkter med din nyckel

Arkitektur med backend-proxy

Lösningen är att proxya TTS-anrop genom din egen backend:

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

Exempel 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));
});

Exempel 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

För TTS över WebSocket måste din backend vidarebefordra meddelanden mellan klienten och xAI-API:t:

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:t kör innehållsmoderering asynkront. Det innebär att modereringen inte blockerar begäran: ljudet genereras och returneras även om modereringen inte har avslutat sin analys.

Om innehåll flaggas som olämpligt kommer rapporten i efterhand. Därför bör din app köra sin egen moderering i förväg om det behövs.

Viktiga punkter

  • 400 = ett parameterfel (försök inte igen; åtgärda begäran)
  • 401 = en ogiltig API-nyckel (kontrollera rubriken Authorization)
  • 429 = hastighetsbegränsad (exponentiell backoff)
  • 500/503 = ett tillfälligt serverfel (försök igen med backoff)
  • Exponera aldrig API-nyckeln i klientkod
  • Proxya alla TTS-anrop genom din backend
  • Moderering är fail-open: lägg till egen filtrering om det behövs