HTTP-fejl og sikkerhed for API-nøgler
På denne side
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