PII aus Google Gemini API-Aufrufen schwaerzen

Senden Sie keine Namen, E-Mails und Geheimnisse mehr an Google Gemini. Erfahren Sie, wie Sie PII aus jedem Gemini API-Aufruf schwaerzen — mit einer Sicherheitsschicht auf Proxy-Ebene, ganz ohne Code-Aenderungen.

Das Problem: PII gelangt ueber Gemini API-Aufrufe nach aussen

Jeder generateContent-Aufruf sendet Ihren Prompt an die Server von Google. Wenn dieser Prompt vom Benutzer eingereichte Texte enthaelt — Support-Tickets, Formulareingaben, CRM-Daten, medizinische Unterlagen — ist die Wahrscheinlichkeit hoch, dass Namen, E-Mail-Adressen, Telefonnummern und andere personenbezogene Daten (PII) enthalten sind.

const result = await model.generateContent(
  `Summarize this patient intake form:

  Name: David Kim
  Email: d.kim@healthcare.org
  Phone: (312) 555-0187
  SSN: 319-42-7756
  DOB: 1975-08-22
  Address: 1200 Lake Shore Dr, Chicago, IL 60610
  Insurance ID: BCBS-449281003
  Notes: Patient reports chronic back pain.
  Internal API key: AIzaSyC-secret-key-here`
);

Diese einzelne Anfrage hat gerade einen Namen, eine E-Mail-Adresse, eine Telefonnummer, eine SSN, ein Geburtsdatum, eine Privatadresse, eine Versicherungs-ID und einen API Key an Google gesendet. Unter DSGVO, CCPA und HIPAA ist das ein Compliance-Vorfall.

So sieht PII in Gemini-Payloads aus

Die Gemini API von Google akzeptiert Freitextfelder im contents-Array. Jedes Feld, in das Ihre Benutzer tippen koennen, ist ein Vektor fuer PII-Leakage:

• Namen und E-Mails in Support- oder Gesundheitskontexten
• Telefonnummern und Adressen aus CRM-Daten
• SSNs und Steuer-IDs in Finanz- oder HR-Workflows
• Krankenaktennummern in Gesundheitsanwendungen
• API Keys und Tokens, die versehentlich von Entwicklern eingefuegt wurden
• Quellcode mit fest eingebauten Zugangsdaten

Der API Key im x-goog-api-key-Header oder Ihre OAuth-Anmeldedaten sind sicher — sie authentifizieren Ihre Anfragen. Das Problem ist, was im Request Body steckt.

Die Loesung: Proxy-basierte Schwaerzung mit Grepture

Grepture ist ein Open-Source-Sicherheitsproxy, der zwischen Ihrer Anwendung und Google Gemini sitzt. Jede Anfrage wird auf PII, Geheimnisse und sensible Muster gescannt, bevor sie Ihre Infrastruktur verlaesst. Sensible Daten werden mit umkehrbaren Token maskiert — und in der Antwort wiederhergestellt, sodass Ihre Anwendung normal funktioniert.

Ihr Code aendert sich nicht. Ihre Prompts bleiben nuetzlich. Gemini sieht niemals echte PII.

Einrichtung in 3 Minuten

1. SDK installieren

npm install @grepture/sdk

2. API Key erhalten

Registrieren Sie sich unter grepture.com/en/pricing — der kostenlose Plan umfasst 1.000 Anfragen/Monat. Kopieren Sie Ihren API Key aus dem Dashboard.

3. Gemini-Client einbinden

Das Google SDK authentifiziert ueber x-goog-api-key statt dem Standard-Authorization-Header. Das erfordert einen eigenen Fetch-Wrapper, der den Traffic ueber den Grepture Proxy leitet und den API Key korrekt weiterleitet:

import { GoogleGenAI } from "@google/genai";

const GREPTURE_API_KEY = process.env.GREPTURE_API_KEY!;
const GEMINI_API_KEY = process.env.GEMINI_API_KEY!;
const PROXY_URL = "https://proxy.grepture.com";

const proxyFetch: typeof fetch = async (input, init) => {
  const url =
    typeof input === "string"
      ? input
      : input instanceof URL
        ? input.toString()
        : input.url;

  const parsed = new URL(url);
  const proxyUrl = `${PROXY_URL}/proxy${parsed.pathname}${parsed.search}`;

  const headers = new Headers(init?.headers);

  // Forward Google's API key via the Grepture auth-forward header
  const googleApiKey = headers.get("x-goog-api-key");
  if (googleApiKey) {
    headers.set("X-Grepture-Auth-Forward", `Bearer ${googleApiKey}`);
  }

  // Authenticate with Grepture and set the target
  headers.set("Authorization", `Bearer ${GREPTURE_API_KEY}`);
  headers.set("X-Grepture-Target", url);

  return globalThis.fetch(proxyUrl, { ...init, headers });
};

const ai = new GoogleGenAI({
  apiKey: GEMINI_API_KEY,
  httpOptions: { fetch: proxyFetch },
});

// Every request is now scanned and protected
const response = await ai.models.generateContent({
  model: "gemini-2.5-flash",
  contents: userInput,
});

Der eigene Fetch faengt jede Anfrage ab, schreibt die URL auf den Grepture Proxy um und leitet Googles x-goog-api-key ueber den X-Grepture-Auth-Forward-Header weiter. Google authentifiziert Ihre Anfragen weiterhin wie gewohnt.

Was erkannt wird

Grepture wird im Free-Tier mit ueber 50 Erkennungsmustern und im Pro-Tier mit ueber 80 ausgeliefert:

Die gesamte Erkennung laeuft auf der Grepture-Infrastruktur — es werden keine Daten an weitere Drittanbieter weitergeleitet.

Maskieren und Wiederherstellen: umkehrbare Schwaerzung

Grepture entfernt PII nicht einfach nur — es ersetzt sensible Werte durch Token, sendet den bereinigten Prompt an Gemini und stellt die Originalwerte in der Antwort wieder her.

Was Gemini sieht:

Summarize this patient intake form:
Name: [PERSON_1]
Email: [EMAIL_1]
Phone: [PHONE_1]
SSN: [SSN_1]
DOB: [DATE_1]
Address: [ADDRESS_1]
...

Was Ihre App zurueckbekommt:

The patient David Kim (d.kim@healthcare.org) reports
chronic back pain. They are located in Chicago, IL
and covered under BCBS insurance.

Gemini verarbeitet saubere Daten. Ihre Anwendung erhaelt die vollstaendige, personalisierte Antwort. Keine PII erreicht jemals Google.

Streaming-Unterstuetzung

Grepture verarbeitet die Streaming-Antworten von Gemini nativ. Wenn Sie generateContentStream verwenden, detokenisiert der Proxy die Chunks in Echtzeit — kein Puffern der gesamten Antwort, kein Latenz-Nachteil.

const stream = await ai.models.generateContentStream({
  model: "gemini-2.5-flash",
  contents: userInput,
});

for await (const chunk of stream) {
  // Tokens are restored in real time
  process.stdout.write(chunk.text ?? "");
}

Naechste Schritte

• Preise ansehen — kostenlos fuer bis zu 1.000 Anfragen/Monat
• Dokumentation lesen — SDK-Referenz, Konfiguration und Dashboard-Anleitung
• So funktioniert es — Architektur, Erkennungsregeln und Zero-Data-Modus