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

Ephemera token och säkerhet

Lektion 13 av 14 Uppdaterad 3 november 2026 Medelnivå
På denna sida
  1. Problemet med en API-nyckel på klienten
  2. Hur det fungerar
  3. Den end-to-end-arkitektur
  4. Regler du aldrig får bryta
  5. Viktiga punkter

Uppdaterat den 3 november 2026, baserat på xAI Voice API-referensen. Källor: Ephemeral Tokens · Voice API reference · Session Resumption.

Problemet med en API-nyckel på klienten

En röstapp som körs i en webbläsare eller på en mobiltelefon kan inte leverera din API-nyckel. Varje besökare kan öppna utvecklarverktygen, läsa nyckeln från JavaScript-bundle:t eller en begäransheader, och sedan använda den på ditt konto tills din kvot är slut. Ingen mängd obfuskering skyddar ett värde som klienten måste ha för att kunna anropa API:t.

xAIs lösning är ephemera token, även kallade klienthemligheter: en kortlivad token, genererad av din server, som auktoriserar en röstsession och inget annat.

600s
standardlivslängd
3600s
maximal livslängd
POST
/v1/realtime/client_secrets
value
token, med expires_at

Hur det fungerar

Flödet reduceras till fem steg:

  1. Din backend (en säker server) anropar POST /v1/realtime/client_secrets med din API-nyckel
  2. API:t returnerar en tillfällig token med begränsad livslängd
  3. Din backend skickar den token till klienten (webbläsare eller mobilapp)
  4. Klienten använder token för att ansluta till Voice Agent WebSocket
  5. Token löper ut efter den livslängd du valde (expires_after.seconds)

Det som kan läcka på klientsidan är nu värt betydligt mindre: en token som löper ut inom några minuter och endast kan öppna en röstsession, inte din API-nyckel. På servern tar genereringen bara några rader kod. Lägg märke till att handlaren börjar med att kontrollera användaren: utan den kontrollen är din backend bara en offentlig tokendispenser.

// Node.js-backend (Express)
app.post("/api/voice-token", async (req, res) => {
  // Kontrollera att användaren är autentiserad
  if (!req.user) return res.status(401).json({ error: "Unauthorized" });

  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 }  // 10 minuter, standardvärdet
      })
    }
  );

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

Klienten känner bara till din egen rutt: den begär en token och öppnar sedan WebSocket med den.

// Frontend (webbläsare)
async function startVoiceSession() {
  // Begär en token från backend
  const tokenRes = await fetch("/api/voice-token", { method: "POST" });
  const { token } = await tokenRes.json();

  // Webbläsarens WebSocket accepterar inte headers:
  // token placeras i ett subprotokoll, prefixat med "xai-client-secret."
  const ws = new WebSocket(
    "wss://api.x.ai/v1/realtime?model=grok-voice-latest",
    [`xai-client-secret.${token}`]
  );

  // ... sessionskonfiguration
}

Den end-to-end-arkitektur

Sammantaget börjar flödet med att användaren loggar in på din app. Deras klient begär sedan en rösttoken från din backend, och backend kontrollerar autentisering och behörigheter innan den genererar den ephemera token via xAI API:t. Token färdas tillbaka till klienten, som använder den för att öppna Voice Agent-sessionen, och den löper ut automatiskt vid slutet av sin livslängd.

Den kontrollen mellan begäran och genereringen gör en enkel relay till en kontrollpunkt, och det är där dina affärsregler lever. Du kan begränsa antalet röstsessioner per användare och dag, så att ett enskilt konto inte kan bränna igenom din månatliga budget över en natt. Du kan reservera token för aktiva prenumerationer och därmed upprätthålla din affärsmodell någon annanstans än i gränssnittet. Du kan hastighetsbegränsa begäranden, så att en buggig eller illvillig klient inte kan begära tusen token i minuten. Och du kan logga varje token du genererar: det är din enda tillförlitliga grund för övervakning, intern fakturering och incidentanalys.

Regler du aldrig får bryta

API-nyckeln får aldrig nå klienten, i någon form. Håll den borta från front-end-JavaScript och från alla miljövariabler som exponeras för webbläsarbygget (variabler med prefix för att injiceras i bundle:t blir offentliga). Håll den borta från URL:er, loggar och felmeddelanden som visas för användare också.

Håll därefter livslängden så kort som är praktiskt möjligt. Enligt API-referensen är standardvärdet för expires_after.seconds 600 sekunder och maximum 3 600; dokumentationen använder 300 i sina exempel. Framför allt måste token vara giltig när klienten öppnar anslutningen. En kort livslängd krymper fönstret under vilket en avlyssnad token kan användas.

Dokumentationen säger inte om en token som löper ut kapar en anslutning som redan är öppen. Om din klient behöver återansluta, efter ett nätverksbortfall eller under en mycket lång session, begär en ny token och använd sessionsåterupptagning: aktivera resumption.enabled i session.update, behåll ID:t du får i conversation.created, och öppna sedan WebSocket igen med ?conversation_id=<id>. De tidigare turerna spelas upp och modellen plockar upp där den slutade.

async function reconnect(conversationId) {
  const { token } = await (await fetch("/api/voice-token", { method: "POST" })).json();
  const url = `wss://api.x.ai/v1/realtime?model=grok-voice-latest&conversation_id=${conversationId}`;
  const ws = new WebSocket(url, [`xai-client-secret.${token}`]);
  ws.onopen = () => ws.send(JSON.stringify({
    type: "session.update",
    session: { resumption: { enabled: true } },  // skicka igen vid varje anslutning
  }));
  return ws;
}

För TTS i HTTP-läge finns det ett ännu enklare alternativ till token: en proxy. Klienten skickar sin text till din backend, och din backend anropar TTS och returnerar ljudet. Nyckeln lämnar aldrig din server, och du får en naturlig plats att filtrera innehåll och mäta användning på vägen.

Viktiga punkter

  • Ephemera token säkrar åtkomsten till Voice Agent från klientsidans appar
  • POST /v1/realtime/client_secrets returnerar value och expires_at; expires_after.seconds har standardvärdet 600 och maximum 3 600
  • I webbläsaren placeras token i subprotokollet xai-client-secret.<token>
  • Din backend måste kontrollera autentisering och behörigheter innan en token genereras
  • Exponera aldrig din API-nyckel på klienten, i URL:er eller i loggar
  • För HTTP-TTS är proxying genom din backend ett giltigt alternativ till ephemera token