Blog

PII-Schwaerzung in Node.js: 4 Ansaetze im Vergleich

So schwaerzt du PII in Node.js, bevor sie ein LLM erreicht: Regex, Transformers.js-NER, Presidio-Sidecar oder Gateway, mit Restore und Streaming.

Engineering6 Min. LesezeitBen @ Grepture

Deine Prompts stecken voller personenbezogener Daten. Dein Stack ist TypeScript.

Wenn du LLM-Features in Node.js baust, kommt frueher oder spaeter die unangenehme Frage: Welche personenbezogenen Daten schicken wir eigentlich an OpenAI? Support-Tickets, CRM-Datensaetze, Chat-Verlaeufe und Tool-Ergebnisse landen in Prompts, und jedes davon enthaelt Namen, E-Mails, Kontonummern und gelegentlich einen API-Key.

Bei der PII-Schwaerzung in Node.js bleiben die meisten Teams dann haengen. Die Python-Welt hat Microsoft Presidio und ein Dutzend NER-Bibliotheken. Die JavaScript-Welt hat eine Handvoll kleiner Regex-Pakete, ein paar Community-Ports und viele Blogposts zu etwas anderem. Ein offizielles Presidio-SDK fuer Node gibt es nicht.

Dieser Guide vergleicht die vier Ansaetze, die 2026 in einer TypeScript-Codebasis tatsaechlich funktionieren, jeweils mit lauffaehigem Code:

  1. Regex-Muster im eigenen Code
  2. Ein lokales NER-Modell mit Transformers.js
  3. Presidio als Sidecar-Service
  4. Ein Gateway im Netzwerkpfad

Fuer jeden Ansatz schauen wir uns an, was er erkennt, wie er die schwierigen Teile loest (Werte in der Antwort wiederherstellen und Streaming) und was der Betrieb kostet.

Was Schwaerzung in einer LLM-App leisten muss

Bevor wir Tools vergleichen, lohnt sich ein genauer Blick auf die Aufgabe. Schwaerzung fuer LLM-Aufrufe ist etwas anderes als Schwaerzung fuer Logdateien.

  • Erkennen von sensiblen Werten im ausgehenden Prompt: strukturierte (E-Mails, IBANs, Kartennummern, Keys) und unstrukturierte (Namen, Adressen, Organisationen).
  • Ersetzen jedes Werts durch einen Platzhalter, mit dem das Modell weiter arbeiten kann. [PERSON_1] laesst den Satz intakt. *** nicht.
  • Wiederherstellen der Originalwerte in der Antwort des Modells, damit deine Nutzer "Sehr geehrte Frau Keller" lesen und nicht "Sehr geehrte [PERSON_1]".
  • Streaming beherrschen, denn die meisten Chat-UIs streamen Tokens, und ein Platzhalter kann auf zwei Chunks verteilt ankommen.

Die meisten Inhalte zu "PII in JavaScript schwaerzen" hoeren nach den ersten beiden Schritten auf. An den letzten beiden scheitern Produktiv-Apps. Warum das Wiederherstellen so wichtig ist, erklaert unser Deep-Dive zu Mask and Restore.

Alle Beispiele unten nutzen denselben Baustein: einen Vault, der Platzhalter fuer die Dauer einer Konversation den Originalwerten zuordnet.

// vault.ts
export type Vault = Map<string, string>; // "[EMAIL_1]" -> "maria.keller@hanse-klinik.de"

export function tokenFor(vault: Vault, type: string, value: string): string {
  for (const [token, original] of vault) {
    if (original === value) return token; // same value, same token
  }
  const n = [...vault.keys()].filter((t) => t.startsWith(`[${type}_`)).length + 1;
  const token = `[${type}_${n}]`;
  vault.set(token, value);
  return token;
}

export function restore(text: string, vault: Vault): string {
  return text.replace(/\[[A-Z_]+_\d+\]/g, (token) => vault.get(token) ?? token);
}

Dass derselbe Wert dasselbe Token bekommt, ist wichtiger, als es aussieht. Wird "Maria Keller" in der ersten Nachricht zu [PERSON_1] und in der zweiten zu [PERSON_3], verliert das Modell den Ueberblick, wer wer ist.

Ansatz 1: Regex im eigenen Code

Am schnellsten startest du mit Mustern, die du selbst kontrollierst. Regex ist hervorragend fuer strukturierte Daten mit fester Form und laeuft in Mikrosekunden.

// regex-redact.ts
import { tokenFor, type Vault } from "./vault";

// Order matters: replace IBANs before generic digit runs, so a card
// pattern never eats part of an IBAN.
const PATTERNS: [type: string, re: RegExp, check?: (v: string) => boolean][] = [
  ["SECRET", /\b(?:sk-[A-Za-z0-9_-]{20,}|AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{36})\b/g],
  ["EMAIL", /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g],
  ["IBAN", /\b[A-Z]{2}\d{2}(?: ?[A-Z0-9]{4}){3,7}(?: ?[A-Z0-9]{1,3})?\b/g],
  ["CARD", /\b(?:\d[ -]?){13,19}\b/g, luhn],
  ["PHONE", /\+\d{1,3}[\s-]?\d{2,4}[\s-]?\d{3,4}[\s-]?\d{2,4}/g],
];

function luhn(value: string): boolean {
  const digits = value.replace(/\D/g, "");
  let sum = 0;
  for (let i = 0; i < digits.length; i++) {
    let d = Number(digits[digits.length - 1 - i]);
    if (i % 2 === 1) d = d * 2 > 9 ? d * 2 - 9 : d * 2;
    sum += d;
  }
  return sum % 10 === 0;
}

export function redactRegex(text: string, vault: Vault): string {
  let out = text;
  for (const [type, re, check] of PATTERNS) {
    out = out.replace(re, (value) => (check && !check(value) ? value : tokenFor(vault, type, value)));
  }
  return out;
}

Die Luhn-Pruefung ist keine Dekoration. Ohne sie trifft das Kartenmuster Bestellnummern, Zeitstempel und die Haelfte deiner Rechnungsnummern.

Wo Regex gewinnt: deterministisch, ohne Abhaengigkeiten, schnell und einem Auditor leicht zu erklaeren. Fuer Secrets und strukturierte Kennungen ist es das richtige Werkzeug, auch innerhalb ausgefeilterer Systeme.

Wo es scheitert: bei Namen, Adressen und Organisationen. Kein Muster findet zuverlaessig "maria" in einer kleingeschriebenen Chat-Nachricht oder "Kastanienallee 12" in einem deutschen Support-Ticket. Wenn deine Prompts Freitext von Menschen enthalten, leakt Regex allein genau die sensibelsten Werte: die, die eine Person identifizieren.

Ansatz 2: Ein lokales NER-Modell mit Transformers.js

Um Namen und Orte zu finden, brauchst du ein Modell. Transformers.js fuehrt Hugging-Face-Modelle ueber ONNX Runtime direkt in Node aus, du bekommst Named Entity Recognition also ohne Python-Service.

npm install @huggingface/transformers
// ner-redact.ts
import { pipeline } from "@huggingface/transformers";
import { tokenFor, type Vault } from "./vault";

const LABELS: Record<string, string> = { PER: "PERSON", ORG: "ORG", LOC: "LOCATION" };

// Load once at startup, not per request.
const ner = await pipeline("token-classification", "Xenova/bert-base-NER");

type TokenResult = { entity: string; word: string; score: number };

/** Merge B-/I- tagged word pieces into whole entities. */
function entities(tokens: TokenResult[]): { type: string; text: string }[] {
  const out: { type: string; text: string }[] = [];
  for (const t of tokens) {
    const [tag, label] = t.entity.split("-");
    const type = LABELS[label];
    if (!type || t.score < 0.8) continue;
    const piece = t.word.startsWith("##") ? t.word.slice(2) : t.word;
    const last = out.at(-1);
    if (tag === "I" && last?.type === type) {
      last.text += t.word.startsWith("##") ? piece : ` ${piece}`;
    } else {
      out.push({ type, text: piece });
    }
  }
  return out;
}

export async function redactNer(text: string, vault: Vault): Promise<string> {
  const found = entities((await ner(text)) as TokenResult[]);
  let out = text;
  // Longest first, so "Maria Keller" is replaced before "Maria".
  for (const e of found.sort((a, b) => b.text.length - a.text.length)) {
    out = out.split(e.text).join(tokenFor(vault, e.type, e.text));
  }
  return out;
}

Lass zuerst Regex und dann NER laufen: Die Muster nehmen die strukturierten Werte, das Modell findet im Rest die Personen und Orte.

Ein paar Dinge solltest du wissen, bevor du das auslieferst:

  • Das Modell bestimmt die Qualitaet. bert-base-NER wurde auf englischen Nachrichtentexten trainiert. Es ist gut bei "Angela Merkel visited Paris" und spuerbar schlechter bei "hey its marta from accounting". Kleingeschriebene Chats, Transkripte und nicht-englischer Text sind genau dort, wo generische NER-Modelle am meisten verpassen. Unser Vergleich der Open-Source-Modelle fuer PII-Schwaerzung geht die Optionen durch, inklusive mehrsprachiger und Zero-Shot-Modelle wie GLiNER.
  • Das Zurueckmappen machst du selbst. Die Pipeline liefert getaggte Wortteile. Sie zusammenzusetzen und im Originaltext wiederzufinden ist dein Code, und genau dort stecken die subtilen Bugs (wiederholte Namen, Tokenizer-Eigenheiten, Satzzeichen).
  • Es kostet Speicher und Startzeit. Das Modell wird beim ersten Lauf heruntergeladen und in jeden Node-Prozess geladen, der es nutzt. Plane das fuer Serverless-Funktionen und Container mit knappen Speichergrenzen ein.
  • Schwellenwerte sind ein Kompromiss. Ein hoeherer Score-Schwellenwert bedeutet weniger Fehlalarme und mehr Leaks. Waehle ihn mit echten Prompts aus deiner App, nicht mit den Beispielen aus einer Model Card.

Ansatz 3: Presidio als Sidecar

Microsoft Presidio ist das am weitesten verbreitete Open-Source-Toolkit fuer PII. Es ist in Python geschrieben, wird aber als zwei HTTP-Services ausgeliefert, und Node kann es wie jede andere API aufrufen.

docker run -d -p 5002:3000 mcr.microsoft.com/presidio-analyzer:latest
docker run -d -p 5001:3000 mcr.microsoft.com/presidio-anonymizer:latest

Der Analyzer liefert Zeichen-Offsets, was das Ersetzen sauberer macht als mit rohen NER-Ergebnissen:

// presidio-redact.ts
import { tokenFor, type Vault } from "./vault";

type Finding = { entity_type: string; start: number; end: number; score: number };

export async function redactPresidio(text: string, vault: Vault): Promise<string> {
  const res = await fetch("http://localhost:5002/analyze", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ text, language: "en", score_threshold: 0.5 }),
  });
  if (!res.ok) throw new Error(`Presidio analyzer returned ${res.status}`);
  const findings = (await res.json()) as Finding[];

  // Replace from the end so earlier offsets stay valid; skip overlaps.
  let out = text;
  let lastStart = Infinity;
  for (const f of findings.sort((a, b) => b.start - a.start)) {
    if (f.end > lastStart) continue;
    const value = text.slice(f.start, f.end);
    out = out.slice(0, f.start) + tokenFor(vault, f.entity_type, value) + out.slice(f.end);
    lastStart = f.start;
  }
  return out;
}

Den Anonymizer-Service lassen wir hier aus und bauen eigene, umkehrbare Tokens aus den Offsets des Analyzers. Presidios Anonymizer kann mit dem encrypt-Operator und dem /deanonymize-Endpunkt zwar umkehrbar verschluesseln, aber verschluesselte Blobs sind lange, undurchsichtige Strings, mit denen Modelle schlechter umgehen als mit kurzen, typisierten Platzhaltern.

Was du bekommst: eine ausgereifte Erkennungs-Engine mit Dutzenden Recognizern, Kontextwoertern, Pruefsummen und einer grossen Community.

Was du dir einhandelst: einen Python-Service, den du neben deiner Node-App deployen, skalieren und ueberwachen musst, einen zusaetzlichen Netzwerk-Hop bei jedem LLM-Aufruf und Sprach-Setup. Der Standard-Analyzer ist auf Englisch konfiguriert; deutscher oder franzoesischer Text braucht zusaetzliche NLP-Modelle und Konfiguration. Wo Presidio aufhoert, haben wir in Warum Presidio fuer PII-Schwaerzung nicht reicht beschrieben.

Der Teil, den alle weglassen: Werte im Stream wiederherstellen

Alle drei Ansaetze enden bisher mit einem maskierten Prompt. Jetzt antwortet das Modell, und seine Antwort enthaelt deine Platzhalter. Fuer einen Aufruf ohne Streaming reicht restore() aus dem Vault:

const reply = restore(completion.choices[0].message.content ?? "", vault);

Streaming ist schwieriger. Das Modell erzeugt Text in kleinen Chunks, und ein Platzhalter kann darauf verteilt sein: Ein Chunk endet mit [EMA, der naechste beginnt mit IL_1]. Stellst du jeden Chunk einzeln wieder her, rutschen beide Haelften unveraendert durch, und dein Nutzer sieht einen kaputten Platzhalter.

Die Loesung: Halte alles zurueck, was der Anfang eines Platzhalters sein koennte, bis klar ist, ob es einer ist.

// stream-restore.ts
import { restore, type Vault } from "./vault";

const MAX_TOKEN_LENGTH = 32;

export function createStreamRestorer(vault: Vault) {
  let buffer = "";
  return {
    push(chunk: string): string {
      buffer += chunk;
      const open = buffer.lastIndexOf("[");
      const pending =
        open !== -1 && !buffer.slice(open).includes("]") && buffer.length - open <= MAX_TOKEN_LENGTH
          ? buffer.slice(open)
          : "";
      const ready = buffer.slice(0, buffer.length - pending.length);
      buffer = pending;
      return restore(ready, vault);
    },
    flush(): string {
      const rest = restore(buffer, vault);
      buffer = "";
      return rest;
    },
  };
}
import OpenAI from "openai";
import { redactRegex } from "./regex-redact";
import { createStreamRestorer } from "./stream-restore";

const openai = new OpenAI();
const vault = new Map<string, string>();

const stream = await openai.chat.completions.create({
  model: process.env.MODEL!,
  stream: true,
  messages: [{ role: "user", content: redactRegex(userMessage, vault) }],
});

const restorer = createStreamRestorer(vault);
for await (const part of stream) {
  process.stdout.write(restorer.push(part.choices[0]?.delta?.content ?? ""));
}
process.stdout.write(restorer.flush());

Zwei weitere Randfaelle solltest du einplanen:

  • Tool-Calls. Gibt das Modell einen Platzhalter in einen Tool-Call weiter, landet der wiederhergestellte Wert in einem JSON-String. Ein Name mit Anfuehrungszeichen oder Backslash zerbricht das JSON, wenn du ihn nicht escapest.
  • Mehrere Ausgabekanaele. Reasoning-Text, mehrere Choices und parallele Tool-Calls streamen jeweils separat. Ein Puffer pro Kanal verhindert, dass das halbe Token eines Kanals an einen anderen geklebt wird.

Ansatz 4: Ein Gateway im Netzwerkpfad

Die vierte Option holt die Schwaerzung ganz aus deiner Anwendung heraus. Ein Gateway sitzt zwischen deiner App und dem Provider, schwaerzt jeden ausgehenden Request und stellt jede Antwort wieder her, Streaming inklusive.

Der Unterschied liegt weniger in der Erkennungsqualitaet als darin, wo die Kontrolle sitzt:

  • Abdeckung. Schwaerzung im Code schuetzt nur die Aufrufe, die daran denken, sie zu nutzen. Ein neuer Service, ein schnelles Skript oder ein Coding-Agent, der die API direkt aufruft, umgeht sie. Ein Gateway schuetzt jeden Request, der hindurchgeht.
  • Eine Richtlinie. Erkennungsregeln, Schwellenwerte und eigene Muster liegen an einem Ort, statt ueber Services und Sprachen hinweg kopiert zu werden.
  • Audit-Trail. Du kannst pro Request zeigen, was erkannt und ersetzt wurde, ohne an jeder Aufrufstelle Logging einzubauen.
  • Keine Modelle pro Prozess. NER laeuft im Gateway, nicht in jedem Node-Prozess.

Der Preis: eine Komponente mehr im Request-Pfad, und du vertraust dem Betreiber deine rohen Prompts an. Deshalb sind Hosting-Standort und Datenaufbewahrung bei der Auswahl so wichtig.

Vergleich

Regex im CodeTransformers.js-NERPresidio-SidecarGateway
Strukturierte Daten (E-Mails, IBANs, Keys)GutMit Regex kombinierenGutGut
Namen, Adressen, OrganisationenSchwachHaengt vom Modell abGut auf EnglischHaengt von den Modellen des Gateways ab
Nicht-englischer TextNur MusterBraucht ein mehrsprachiges ModellBraucht zusaetzliches SetupHaengt vom Gateway ab
Restore in AntwortenBaust du selbstBaust du selbstBaust du selbstEingebaut
Restore im StreamBaust du selbstBaust du selbstBaust du selbstEingebaut
Zusaetzliche LatenzMikrosekundenCPU-Inferenz pro RequestNetzwerk-Hop plus InferenzNetzwerk-Hop plus Inferenz
Laeuft woIn deinem ProzessIn deinem ProzessPython-Service, den du betreibstService, den du oder ein Anbieter betreibt
Deckt vergessene Aufrufe abNeinNeinNeinJa

Ein pragmatischer Weg fuer viele Teams: Starte heute mit Regex, denn das kostet nichts und stoppt die schlimmsten Leaks (Keys, E-Mails, Kartennummern). Entscheide danach, ob du einen NER-Stack selbst betreiben oder in den Netzwerkpfad verlagern willst.

Wie Grepture hilft

Grepture ist ein Open-Source-KI-Gateway, und Ansatz 4 ist genau das, was es tut. Du behaeltst deinen OpenAI- oder Anthropic-Client und aenderst nur, wie er erzeugt wird:

import OpenAI from "openai";
import { Grepture } from "@grepture/sdk";

const grepture = new Grepture({
  apiKey: process.env.GREPTURE_API_KEY!,
  proxyUrl: "https://proxy.grepture.com",
  tokenScope: conversationId, // same value, same token for the whole conversation
});

const openai = new OpenAI(
  grepture.clientOptions({
    apiKey: process.env.OPENAI_API_KEY!,
    baseURL: "https://api.openai.com/v1",
  }),
);

Ab dann wird jeder Request mit Regex-Mustern fuer strukturierte Daten und lokal gehosteten NER-Modellen fuer Namen, Organisationen und Adressen geprueft. Die Erkennung laeuft auf Greptures eigenen Servern in der EU, es geht also kein Prompt-Text an einen anderen KI-Dienst, um die PII zu finden. Werte werden durch Tokens ersetzt, bevor der Request rausgeht, und in der Antwort wiederhergestellt, auch in gestreamten Antworten, in denen ein Token ueber Chunks verteilt ist, und in Tool-Call-Argumenten, in denen der wiederhergestellte Wert JSON-escaped werden muss.

Mit tokenScope auf einer Konversations-ID behaelt derselbe Wert ueber alle Nachrichten hinweg dasselbe Token. So bleiben der Kontext ueber mehrere Turns und das Prompt-Caching beim Provider intakt. Der Zero-Data-Modus haelt Request-Bodies komplett von der Festplatte fern. Fuer Aufrufe, die nicht OpenAI-kompatibel sind, ist grepture.fetch() ein Drop-in-Ersatz fuer fetch. Der Guide zur Schwaerzung bei OpenAI zeigt die Einrichtung Schritt fuer Schritt, und mit 1.000 kostenlosen Requests im Monat kannst du es direkt mit deinen eigenen Prompts ausprobieren.

PII schwärzen, bevor sie das Modell erreicht.

Grepture ist ein Open-Source-AI-Gateway mit Hosting in der EU. Namen, E-Mails und Secrets werden vor dem Versand ersetzt und in der Antwort wiederhergestellt. Kostenlos für 1.000 Anfragen im Monat.

Kostenlos starten