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

Ephemera token för WebSocket-anslutningar

Lektion 5 av 12 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Problemet: att autentisera en klient utan att avslöja din nyckel
  2. Så fungerar ephemera token
  3. Att välja rätt varaktighet
  4. Implementering i backend
  5. Viktiga punkter

Problemet: att autentisera en klient utan att avslöja din nyckel

När du bygger en röst- eller realtidsapp med Grok API måste du upprätta en WebSocket-anslutning direkt från webbläsaren eller mobilklienten. Att routa trafiken genom din server lägger till latens som bryter flytet i röstsamtal. Men direkta anslutningar skapar ett autentiseringsproblem: du får aldrig inkludera din API-nyckel i klientsidans kod.

Anledningen är enkel: varje nyckel som bäddas in i frontend-JavaScript, en dekompilerbar mobilapp eller en distribuerad binärfil är komprometterad så fort du publicerar den. Vilken användare som helst kan öppna webbläsarens utvecklarverktyg och läsa den. För att lösa detta erbjuder xAI ephemera token: tillfälliga token som klienter kan använda utan att någonsin se huvudnyckeln.

600s
Standardvaraktighet
3600s
Maximal varaktighet
POST
/v1/realtime/client_secrets
Bearer
Tillfälligt token

Så fungerar ephemera token

Arkitekturen följer en princip: API-nyckeln lämnar aldrig din server, och klienten får endast ett kortlivat token. Flödet är kort. Klienten begär ett token från ditt backend-system, som anropar POST /v1/realtime/client_secrets med din API-nyckel. Detta anrop är den enda platsen där nyckeln förekommer, och det sker helt serverside. xAI returnerar ett ephemeralt token med dess utgångsdatum, vilket ditt backend-system skickar vidare till klienten. Klienten öppnar sedan WebSocket-anslutningen till wss://api.x.ai/v1/realtime och presenterar detta token. Vid ingen tidpunkt ser webbläsaren huvudnyckeln; den hanterar ett token som löper ut automatiskt.

Skapandeanropet från ditt backend-system ser ut så här:

curl -X POST https://api.x.ai/v1/realtime/client_secrets \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"expires_after": {"seconds": 600}}'

Och svaret:

{
  "value": "Bearer eyJhbGciOiJSUzI1NiIs...",
  "expires_at": 1712001200
}

När det gäller varaktighet finns tre riktmärken: det finns ingen dokumenterad nedre gräns (några sekunder är möjligt), standardvärdet är 600 sekunder (10 minuter) och maximum är 3600 sekunder (1 timme).

Att välja rätt varaktighet

Token-varaktigheten måste matcha ditt användningsfall, och detta val är ett verkligt säkerhetsbeslut. För sporadiska röstinteraktioner – en frågestund, ett röstkommando, diktering – räcker ett fönster på 300 till 600 sekunder gott och väl: sessionen avslutas långt innan token löper ut. För långvariga röstsamtal som kundsupport, en intervju eller ett assisterat möte bör du sikta på 600 till 1800 sekunder för att undvika att bli avbruten mitt i samtalet. Långvariga arbetssessioner – realtidstranskribering, kontinuerlig röstövervakning – kan motivera 1800 till 3600 sekunder, men använd maximal varaktighet med försiktighet: det utökar fönstret för exploatering om token stjäls.

Den gyllene regeln kan sammanfattas så här: välj alltid den kortaste varaktighet som är kompatibel med ditt användningsfall. Om ett token fångas upp gör en utgångstid på tio minuter en potentiellt allvarlig incident till ett mindre besvär.

Implementering i backend

Här är ett exempel på en säker proxy i Node.js:

// Backend-rutt - FÅR INTE exponeras på klientsidan
app.post("/api/realtime-token", authenticateUser, async (req, res) => {
  const response = await fetch(
    "https://api.x.ai/v1/realtime/client_secrets",
    {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${process.env.XAI_API_KEY}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        expires_after: { seconds: 600 }
      })
    }
  );

  const token = await response.json();
  res.json({ token: token.value, expires_at: token.expires_at });
});

Tre detaljer i detta exempel bär upp hela säkerheten i uppsättningen. API-nyckeln finns i en servermiljövariabel, aldrig i koden. Mellanprogramvaran authenticateUser verifierar användarens identitet innan ett token utfärdas – utan den skulle vem som helst kunna skaffa token och förbruka din kvot på din bekostnad. Och endast det ephemera token, aldrig nyckeln, returneras till klienten.

Några fallgropar dyker regelbundet upp i kodgranskningar. API-nyckeln smiter in i frontend “bara för prototypen” och hamnar oundvikligen i produktion. Token skapas systematiskt med maximal varaktighet av bekvämlighetsskäl, trots att användningsfallet kräver en fjärdedel av den tiden. Genereringsslutpunkten lämnas utan verifiering av autentisering, öppen för alla. Och bristen på hantering av förnyelse på klientsidan, vilket producerar utgångsfel mitt i sessionen istället för en transparent återanslutning: eftersom svaret ger dig expires_at har din klient allt den behöver för att begära ett nytt token före deadline snarare än efter.

Viktiga punkter

  • Ephemera token möjliggör WebSocket-autentisering utan att avslöja din API-nyckel
  • Slutpunkt: POST /v1/realtime/client_secrets (endast serverside-anrop)
  • Konfigurerbar varaktighet från några sekunder upp till maximalt 3600 sekunder (standard: 600s)
  • Ditt backend-system agerar som en autentiseringsproxy mellan klienten och xAI
  • Välj alltid den kortaste varaktighet som är kompatibel med din användning