Moderations-API von OpenAI

Aktualisiert am 3. November 2026 basierend auf dem Moderation-Guide von OpenAI: Hinzugefügt die Kategorie illicit (und illicit/violent), die in der Tabelle fehlte, sowie Kategorien, die auch für Bilder gelten. Quelle: Moderation.

Eine integrierte Moderations-Tool

OpenAI stellt eine kostenlose Moderations-API bereit, die Text analysiert, um potenziell schädliche Inhalte zu erkennen. Dies ist die erste Verteidigungslinie, die in jede Anwendung integriert werden sollte, die OpenAI-Modelle nutzt. Sie sind nicht auf diesen Anwendungsfall beschränkt: Da die API rohen Text als Eingabe akzeptiert, können Sie sie auch dazu verwenden, Eingaben zu filtern, die für andere Modelle bestimmt sind. Die Tatsache, dass sie kostenlos ist, verändert die Betrachtungsweise des Problems. Die üblichen Abwägungen – sollen wir jede Anfrage moderieren oder nur verdächtige? – verlieren an Gewicht, da die einzige verbleibende Kostenfaktor die Latenz ist.

Was die API zurückgibt

Der grundlegende Aufruf passt auf eine Zeile; die Antwort ist es, die Aufmerksamkeit erfordert. Die API gibt drei verschiedene Dinge zurück: einen flagged-Boolean-Wert, der die Entscheidung von OpenAI widerspiegelt, die Liste der tatsächlich ausgelösten Kategorien und, am wichtigsten, kontinuierliche Punktzahlen pro Kategorie. Diese Punktzahlen sind der Unterschied in der Produktion, da sie es Ihnen ermöglichen, selbst zu entscheiden, wo die Grenze gezogen wird, anstatt ein Schwellenwert zu erben, der für den allgemeinen Gebrauch konzipiert wurde.

from openai import OpenAI

client = OpenAI()

def moderate_content(text: str) -> dict:
    """Analyziert Text über die Moderations-API von OpenAI."""
    response = client.moderations.create(input=text)
    result = response.results[0]

    return {
        "blocked": result.flagged,
        "categories": {
            cat: flagged
            for cat, flagged in result.categories.__dict__.items()
            if flagged
        },
        "scores": {
            cat: round(score, 4)
            for cat, score in result.category_scores.__dict__.items()
            if score > 0.01
        },
    }

# Test mit verschiedenen Inhaltstypen
examples = [
    "Wie backe ich einen Schokoladenkuchen?",
    "Ich werde dich töten, wenn du mir nicht antwortest",
    "Erkläre, wie AES-Verschlüsselung funktioniert",
]

for text in examples:
    result = moderate_content(text)
    status = "BLOCKED" if result["blocked"] else "OK"
    print(f"{status} : {text[:50]}...")
    if result["categories"]:
        print(f"  Kategorien : {list(result['categories'].keys())}")

Die drei Testbeispiele sind nicht zufällig: Das erste sollte durchgehen, das zweite sollte blockiert werden, und das dritte – eine völlig legitime technische Frage – zeigt Ihnen, wie Ihr Pipeline-Verhalten reagiert, wenn es mit Sicherheitsvokabular konfrontiert wird. Dies ist genau die Art von Anfrage, die ein Cybersicherheitsteam täglich bearbeitet.

Erkennbare Kategorien

Die API klassifiziert problematische Inhalte entlang mehrerer Achsen, die jeweils einer bestimmten Art von Schaden entsprechen.

Jede Kategorie hat zudem Unterkategorien (z. B. harassment/threatening, illicit/violent, violence/graphic) für eine feinere Filterung. Mit omni-moderation-latest gelten nur self-harm und seine Varianten, sexual und violence (mit violence/graphic) auch für Bilder; die anderen Kategorien gelten nur für Text. Diese Granularität spart Ihnen grobe Abwägungen: Eine Foren-Moderationsplattform könnte harassment/threatening blockieren wollen, während sie einfache harassment toleriert, was viele gewöhnliche Streitigkeiten abdeckt.

Wenn Sie Volumen verarbeiten müssen – beispielsweise eine retrospektive Analyse einer Konversationshistorie – akzeptiert die API eine Liste und gibt für jedes Element ein Ergebnis zurück, wodurch mehrere Netzwerk-Roundtrips vermieden werden.

def moderate_batch(messages: list[str]) -> list[dict]:
    """Moderiert mehrere Nachrichten in einem einzigen Aufruf."""
    response = client.moderations.create(input=messages)
    results = []
    for i, result in enumerate(response.results):
        results.append({
            "index": i,
            "text": messages[i][:50],
            "blocked": result.flagged,
            "max_score": max(
                score
                for score in result.category_scores.__dict__.values()
            ),
        })
    return results

Moderation beider Enden der Pipeline

Ein häufiger Fehler besteht darin, nur Eingaben zu moderieren. Dies basiert auf einer falschen Intuition: Wenn die eingehende Nachricht akzeptabel ist, wird die Antwort auch akzeptabel sein. Doch ein Modell kann problematische Inhalte aus einer neutralen Anfrage erzeugen, insbesondere wenn es auf abgerufene Dokumente verlässt, deren Inhalt niemand überprüft hat. Die Klasse unten wendet daher die gleiche Behandlung in beide Richtungen an und fügt einen benutzerdefinierten Schwellenwert hinzu, der die Standardentscheidung der API verschärft.

class ModerationPipeline:
    """Eingabe- und Ausgabe-Moderations-Pipeline für eine LLM-Anwendung."""

    def __init__(self, custom_threshold: float = 0.7):
        self.client = OpenAI()
        self.threshold = custom_threshold

    def moderate_input(self, message: str) -> tuple[bool, dict]:
        """Moderiert die Nachricht VOR dem Senden an das Modell."""
        result = self.client.moderations.create(input=message).results[0]
        scores = result.category_scores.__dict__
        high_categories = {
            cat: score for cat, score in scores.items() if score > self.threshold
        }
        blocked = result.flagged or bool(high_categories)
        return blocked, {"flagged_api": result.flagged, "custom_categories": high_categories}

    def moderate_output(self, response: str) -> tuple[bool, dict]:
        """Moderiert die Antwort des Modells VOR dem Senden an den Benutzer."""
        return self.moderate_input(response)

    def process_message(self, user_message: str, system_prompt: str) -> str:
        """Vollständige Pipeline: Eingabemoderation, LLM, Ausgabemoderation."""
        # Schritt 1: Eingabemoderation
        input_blocked, details = self.moderate_input(user_message)
        if input_blocked:
            return "Ihre Nachricht kann nicht verarbeitet werden. Bitte formulieren Sie sie anders."

        # Schritt 2: Aufruf des Modells
        response = self.client.chat.completions.create(
            model="gpt-5.6-sol",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_message},
            ],
        )
        model_response = response.choices[0].message.content

        # Schritt 3: Ausgabemoderation
        output_blocked, _ = self.moderate_output(model_response)
        if output_blocked:
            return "Die Antwort wurde aufgrund von Nichteinhaltung gefiltert."

        return model_response

# Nutzung
pipeline = ModerationPipeline(custom_threshold=0.5)
response = pipeline.process_message(
    "Wie schütze ich meine Anwendung vor SQL-Injectionen?",
    "Sie sind ein Experte für defensive Cybersicherheit."
)
print(response)

Was diese API nicht tut

Ihr wichtigster Nachteil ist auch der am häufigsten missverstandene: Sie erkennt Prompt-Injectionen nicht. Eine höfliche Nachricht, die aus Sicht des Inhalts völlig harmlos ist, aber das Modell auffordert, seine Anweisungen zu ignorieren, wird durchgehen, ohne eine Kategorie auszulösen. Zu erwarten, dass sie gegen Manipulation schützt, ist wie die Installation eines Rauchmelders und die Hoffnung, dass dieser Einbrüche verhindert.

Falschpositive Ergebnisse sind der zweite Nachteil, insbesondere in Sicherheits- oder medizinischen Kontexten, in denen die Beschreibung einer Bedrohung Teil des Jobs ist. Für jede Anfrage wird ein zusätzlicher Netzwerkaufbau hinzugefügt, was wichtig ist, wenn Sie Echtzeit-Antworten anstreben. Die Erkennung bleibt in anderen Sprachen weniger zuverlässig als im Englischen, eine Schwachstelle, die Angreifer perfekt kennen. Schließlich entwickeln sich Kategorien und Schwellenwerte mit Updates weiter: Ein Kalibrierungsset von vor sechs Monaten verdient eine Neuüberprüfung.

Diese Grenzen bestimmen, wie das Werkzeug zu verwenden ist. Moderieren Sie in beide Richtungen, passen Sie Schwellenwerte pro Kategorie an, anstatt global, und kombinieren Sie es systematisch mit anderen Ebenen – wie Injektionserkennung und Geschäftslogik-Filterung – die in den folgenden Lektionen detailliert werden. Protokollieren Sie die Ergebnisse, denn das Beobachten Ihrer eigenen Falschpositiven ist der Weg, um zu lernen, wo Sie die Regler verschieben müssen. Und planen Sie für den Fall vor, dass die API nicht verfügbar ist: Entscheiden Sie jetzt, während die Dinge ruhig sind, ob Ihre Anwendung standardmäßig blockieren oder den Verkehr durchlassen soll, anstatt dieses Verhalten während eines Vorfalls zu entdecken.

Kernaussagen

• Die Moderations-API ist kostenlos, schnell und einfach zu integrieren
• Sie erkennt beleidigende Inhalte, aber keine Injektionen oder Jailbreaks
• Die Pipeline von Eingabe über Modell zu Ausgabe muss an beiden Enden moderiert werden
• Standard-Schwellenwerte passen selten – passen Sie sie an Ihren Kontext an
• Es ist eine von mehreren Ebenen, niemals die einzige Verteidigungslinie