Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Bescherm uw API-sleutel: exposeer deze nooit aan de clientzijde

Les 6 van 12 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. Een API-sleutel is een wachtwoord
  2. Veelvoorkomende blootstellingsvectoren
  3. Proxy-architectuur: de oplossing
  4. Veilige opslag van sleutels
  5. Wat te doen als uw sleutel is gecompromitteerd
  6. Belangrijkste punten

Een API-sleutel is een wachtwoord

Uw xAI API-sleutel fungeert als een wachtwoord met volledige toegang tot uw account. Iedereen die deze bezit, kan API-aanroepen doen op uw kosten, toegang krijgen tot uw modellen en mogelijk uw gegevens compromitteren. Hoe verschilt dit van een standaardwachtwoord? Een gestolen sleutel kan stilzwijgend worden gebruikt: u merkt er niets van totdat de factuur arriveert of totdat uw financieel team een alarm slaat. De regel is eenvoudig en absoluut: exposeer nooit een API-sleutel aan de clientzijde.

Veelvoorkomende blootstellingsvectoren

Het meest voorkomende geval is directe opname van de sleutel in frontend JavaScript:

// GEVAAR - Doe dit NOOIT
const response = await fetch("https://api.x.ai/v1/chat/completions", {
  headers: { "Authorization": "Bearer xai-abc123..." }
});

Zodra dit is geïmplementeerd, is deze code zichtbaar voor iedereen die de ontwikkelaarstools van de browser gebruikt. U hoeft alleen het tabblad Netwerk te openen om de sleutel in platte tekst in de aanvraagheaders te lezen.

Een meer verraderlijke vector, omdat deze een vals gevoel van veiligheid geeft: frontend-omgevingsvariabelen. Variabelen die beginnen met NEXT_PUBLIC_, VITE_ of REACT_APP_ worden tijdens het build-proces in de JavaScript gebundeld en zijn dus openbaar. De ontwikkelaar denkt dat hij “de sleutel uit de code heeft gehouden”; in werkelijkheid is deze er gewoon in gecompileerd:

# GEVAAR - deze variabele komt in de bundle
NEXT_PUBLIC_XAI_API_KEY=xai-abc123...

Git-repositories zijn de derde klassieke vector. Zelfs een verwijderde commit blijft in de Git-geschiedenis staan: als u per ongeluk een sleutel heeft gecommit, is het herschrijven van de geschiedenis niet genoeg, omdat clones en forks deze mogelijk hebben behouden. Beschouw deze als gecompromitteerd en trek de sleutel in. Tot slot lekken sleutels ook via indirecte paden, moeilijker voor te stellen maar toch zeer gebruikelijk: applicatielogboeken die volledige headers traceren, foutberichten die aan de gebruiker worden getoond, of monitoringtools die uitgaande aanvragen vastleggen.

Proxy-architectuur: de oplossing

De enige veilige aanpak is om alle aanroepen via uw backend te proxyen:

Client (browser/mobiel)
    ↓ aanvraag zonder API-sleutel
Uw Backend (server)
    ↓ voegt API-sleutel toe (omgevingsvariabele)
xAI API
    ↓ antwoord
Uw Backend
    ↓ stuurt antwoord door (gefilterd indien nodig)
Client

Hier is een minimalistische proxy in Python:

# Python Backend (Flask)
import os
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)
XAI_KEY = os.environ["XAI_API_KEY"]  # Alleen server-side variabele

@app.route("/api/chat", methods=["POST"])
def proxy_chat():
    user_message = request.json.get("message")

    response = requests.post(
        "https://api.x.ai/v1/chat/completions",
        headers={"Authorization": f"Bearer {XAI_KEY}"},
        json={
            "model": "grok-4.3",
            "messages": [{"role": "user", "content": user_message}]
        }
    )

    return jsonify(response.json())

Naast het beschermen van de sleutel – die nooit naar de client wordt verzonden – biedt de proxy u een controlepunt dat bij directe aanroepen onmogelijk is. U kunt aanvragen filteren: rate limiting om te voorkomen dat een client uw quota leegzuigt, inputvalidatie en contentmoderatie. U bepaalt welke modellen toegankelijk zijn, waardoor een gekaapte client geen dure modellen kan aanroepen en onverwachte kosten kan genereren. U kunt aanroepen loggen voor auditing – een centrale behoefte voor een compliance-verantwoordelijke. En u kunt bepaalde antwoorden cachen om kosten bij repetitieve aanvragen te verlagen.

Veilige opslag van sleutels

Aan de serverzijde is de basislijn de omgevingsvariabele, geladen vanuit een .env-bestand dat nooit aan Git wordt gecommit:

# .env-bestand (NOOIT committen naar Git)
XAI_API_KEY=xai-uw-geheime-sleutel

Voeg deze bestanden systematisch toe aan uw .gitignore:

# .gitignore
.env
.env.local
.env.production

Voor productieomgevingen blijft een .env-bestand op een server een kwetsbaar handmatig proces: geef de voorkeur aan een dedicated secrets manager. Bewezen opties zijn onder meer AWS Secrets Manager of SSM Parameter Store, Google Secret Manager, Azure Key Vault, HashiCorp Vault, of Doppler en Infisical voor lichtere structuren. Wat deze tools bieden boven een plat bestand: automatische sleutelrotatie, toegangsauditing – wie las welk geheim en wanneer – en encryptie in rust. Dit zijn elementen die u tijdens een security-audit als zodanig kunt presenteren, terwijl een tekstbestand op een machine niets bewijst.

Wat te doen als uw sleutel is gecompromitteerd

Als u vermoedt dat een sleutel is blootgesteld, is de volgorde van handelingen net zo belangrijk als de handelingen zelf. Trek de sleutel in de xAI-console (console.x.ai) in voordat u iets anders doet: elke minuut dat de gecompromitteerde sleutel actief blijft, is een minuut mogelijke exploitatie, en servicecontinuïteit wordt daarna geregeld, niet ervoor. Genereer vervolgens een nieuwe sleutel en werk uw backends bij om de service te herstellen.

Het incident is hiermee nog niet afgesloten. Audit het gebruik door te zoeken naar verdachte API-aanroepen in uw factuurgeschiedenis – een piek tijdens een ongebruikelijk tijdvenster, gebruik toegeschreven aan een model dat u niet gebruikt. Identificeer de bron van het lek, anders zal de nieuwe sleutel hetzelfde pad volgen als de oude. Sluit af door uw code te scannen met tools zoals gitleaks of truffleHog, die ook de Git-geschiedenis doorlopen en vaak andere lang vergeten geheimen onthullen.

Belangrijkste punten

  • Een API-sleutel is een wachtwoord met volledige toegang tot uw account
  • Proxy API-aanroepen altijd via uw backend
  • Variabelen NEXT_PUBLIC_, VITE_, REACT_APP_ zijn openbaar
  • Gebruik in productie een secrets manager
  • Als een sleutel is gecompromitteerd: trek deze onmiddellijk in en audit het gebruik