Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du
.md an die URL der Seite anhängst.
Mit den Moderationsmodellen von OpenAI kannst du schädliche Inhalte in Texten und Bildern erkennen. Über den Moderationsendpunkt kannst du Eingaben separat klassifizieren. Du kannst Moderationswerte auch zusammen mit einer generierten Antwort anfordern. Nutze die Ergebnisse, um die Richtlinien deiner Anwendung durchzusetzen. Du kannst beispielsweise Inhalte filtern, eine Anfrage zur Prüfung weiterleiten oder Maßnahmen gegen Konten ergreifen, über die markierte Inhalte eingereicht wurden.
Das Modell omni-moderation-latest akzeptiert Text und Bilder als Eingabe. Audioinhalte kann es nicht klassifizieren. Die Nutzung des Moderationsendpunkts ist kostenlos. Bilddateien dürfen bis zu 20 MB groß sein.
Kinderschutz: Sende keine Inhalte an die Moderation API, von denen du weißt oder vermutest, dass sie sexuellen Missbrauch von Kindern darstellen (CSAM). Die API ist weder für die Erkennung von CSAM noch für den Umgang damit ausgelegt. Sie ersetzt keine speziellen Maßnahmen zum Kinderschutz. In unserem Leitfaden zu CSAM erfährst du, wie du CSAM vorbeugen, solche Inhalte erkennen, darauf reagieren und sie melden kannst.
Für deine Anwendung musst du wissen, welche Kategorien schädlicher Inhalte für Text, Bilder oder beides gelten.
Generierte Inhalte moderieren
Wenn deine Anwendung sowohl generierten Text als auch Moderationswerte benötigt, übergib in der Anfrage zur Textgenerierung ein moderation-Objekt auf oberster Ebene. Die API liefert Moderationswerte für die Modelleingabe und die generierte Ausgabe, ohne dass du eine separate Moderationsanfrage stellen musst.
Das Modell generiert den Text wie gewohnt. Prüfe die Moderationsergebnisse, bevor du jemandem die Ausgabe anzeigst oder weitere Aktionen ausführst.
Lege moderation.model fest, wenn du eine Antwort erstellst.
Eine Antwort mit Moderationswerten generieren
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31import OpenAI from "openai";const client = new OpenAI();const response = await client.responses.create({ model: "gpt-6-astra", input: [ { role: "user", content: "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.", }, ], moderation: { model: "omni-moderation-latest" },});if (!response.moderation) { throw new Error("The API did not return the requested moderation results.");}const inputModeration = response.moderation.input;const outputModeration = response.moderation.output;if (inputModeration.type === "error") { throw new Error(inputModeration.message);}if (outputModeration.type === "error") { throw new Error(outputModeration.message);}console.log(inputModeration.flagged);console.log(outputModeration.flagged);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27from openai import OpenAIclient = OpenAI()response = client.responses.create(model="gpt-6-astra",input=[ {"role": "user","content": ("A user asks for instructions to make a harmful weapon. ""Draft a brief refusal and offer a safer alternative." ), } ],moderation={"model": "omni-moderation-latest"},)input_moderation = response.moderation.inputoutput_moderation = response.moderation.outputif input_moderation.type =="error":raiseRuntimeError(input_moderation.message)if output_moderation.type =="error":raiseRuntimeError(output_moderation.message)print(input_moderation.flagged)print(output_moderation.flagged)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.core.JsonValue;import com.openai.models.responses.ResponseCreateParams;import java.util.ArrayList;import java.util.List;import java.util.Map;ResponseCreateParams params = ResponseCreateParams.builder() .model("gpt-6-astra") .input( "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.") .putAdditionalBodyProperty( "moderation", JsonValue.from(Map.of("model", "omni-moderation-latest"))) .build();var response = client.responses().create(params);var moderation = response .moderation() .orElseThrow( () -> new IllegalStateException("The response did not include moderation results"));List<Boolean> flags = new ArrayList<>();var input = moderation.input();if (input.isError()) { throw new IllegalStateException(input.asError().message());}if (!input.isModerationResult()) { throw new IllegalStateException("Missing input moderation flag");}flags.add(input.asModerationResult().flagged());var output = moderation.output();if (output.isError()) { throw new IllegalStateException(output.asError().message());}if (!output.isModerationResult()) { throw new IllegalStateException("Missing output moderation flag");}flags.add(output.asModerationResult().flagged());flags.forEach(System.out::println);
1
2
3
4
5
6
7
8
9
10
11require "openai"client = OpenAI::Client.newresponse = client.responses.create( model: "gpt-6-astra", input: "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.", moderation: { model: "omni-moderation-latest" })puts(response.moderation)
Die Responses API liefert das moderation_result-Objekt für die Eingabe unter response.moderation.input und das moderation_result-Objekt für die Ausgabe unter response.moderation.output.
Lege moderation.model fest, wenn du eine Chat Completion erstellst.
Eine Chat Completion mit Moderationswerten generieren
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import OpenAI from "openai";const client = new OpenAI();const completion = await client.chat.completions.create({ model: "gpt-6-astra", messages: [ { role: "user", content: "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.", }, ], moderation: { model: "omni-moderation-latest" },});if (!completion.moderation) { throw new Error("The API did not return the requested moderation results.");}const inputResult = completion.moderation.input;const outputResult = completion.moderation.output;if (inputResult.type === "error") throw new Error(inputResult.message);if (outputResult.type === "error") throw new Error(outputResult.message);const inputModeration = inputResult.results[0];const outputModeration = outputResult.results[0];console.log(inputModeration.flagged);console.log(outputModeration.flagged);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30from openai import OpenAIclient = OpenAI()completion = client.chat.completions.create(model="gpt-6-astra",messages=[ {"role": "user","content": ("A user asks for instructions to make a harmful weapon. ""Draft a brief refusal and offer a safer alternative." ), } ],moderation={"model": "omni-moderation-latest"},)input_result = completion.moderation.inputoutput_result = completion.moderation.outputif input_result.type =="error":raiseRuntimeError(input_result.message)if output_result.type =="error":raiseRuntimeError(output_result.message)input_moderation = input_result.results[0]output_moderation = output_result.results[0]print(input_moderation.flagged)print(output_moderation.flagged)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.core.JsonValue;import com.openai.models.chat.completions.ChatCompletionCreateParams;import java.util.ArrayList;import java.util.List;import java.util.Map;ChatCompletionCreateParams params = ChatCompletionCreateParams.builder() .model("gpt-6-astra") .addUserMessage( "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative.") .putAdditionalBodyProperty( "moderation", JsonValue.from(Map.of("model", "omni-moderation-latest"))) .build();var completion = client.chat().completions().create(params);var moderation = completion .moderation() .orElseThrow( () -> new IllegalStateException("The completion did not include moderation results"));List<Boolean> flags = new ArrayList<>();var input = moderation.input();if (input.isError()) { throw new IllegalStateException(input.asError().message());}if (!input.isModerationResults() || input.asModerationResults().results().isEmpty()) { throw new IllegalStateException("Missing input moderation flag");}flags.add(input.asModerationResults().results().get(0).flagged());var output = moderation.output();if (output.isError()) { throw new IllegalStateException(output.asError().message());}if (!output.isModerationResults() || output.asModerationResults().results().isEmpty()) { throw new IllegalStateException("Missing output moderation flag");}flags.add(output.asModerationResults().results().get(0).flagged());flags.forEach(System.out::println);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"client = OpenAI::Client.newcompletion = client.chat.completions.create( model: "gpt-6-astra", messages: [ { role: :user, content: "A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative." } ], moderation: { model: "omni-moderation-latest" })puts(completion.moderation)
Die Chat Completions API liefert unter completion.moderation.input und completion.moderation.output jeweils einen Container mit Moderationsergebnissen. Wenn deine Anfrage eine einzelne Antwortvariante erzeugt, lies das erste Ergebnis für die Eingabe und die Ausgabe jeweils unter results[0] aus. Wenn du mehrere Varianten anforderst, gehört completion.moderation.output.results[i] zu completion.choices[i].
Moderationsergebnisse, die du zusammen mit der Antwort erhältst, verwenden dieselben Kategoriefelder wie das Ergebnis einer separaten Moderationsanfrage. Prüfe für eine erste Entscheidung flagged. Werte anschließend categories und category_scores aus, um Ergebnisse zu protokollieren, Anfragen weiterzuleiten, Entscheidungen für Audits zu dokumentieren oder Fälle zur manuellen Prüfung in eine Warteschlange aufzunehmen. Das Modell kann auch eine Ablehnung oder eine andere Antwort, die Sicherheitsaspekte berücksichtigt, markieren, wenn darin schädliche Inhalte zur Sprache kommen. Nutze Moderationswerte als Anhaltspunkte für die Anwendung deiner Richtlinien. Ein solcher Wert allein sollte keine automatische Sperre auslösen.
Wenn deine Anwendung Moderationsfehler behandeln muss, prüfe den Typ des Moderationsergebnisses, bevor du die Werte ausliest. Lässt sich ein Moderationsschritt nicht abschließen, kann das zugehörige Moderationsfeld für die Eingabe oder Ausgabe anstelle der Moderationswerte einen Fehler enthalten.
Bei Anfragen mit Tool-Aufrufen erfasst die Moderation die Argumente der Aufrufe und die Ausgaben der Tools, sofern sie im Gesprächsinhalt vorkommen. Tool-Namen, Tool-Beschreibungen, Tool-Schemas und Schemas für das Antwortformat sind davon ausgenommen.
Wenn du eine generierte Antwort streamst, erhältst du die Moderationswerte erst, sobald die vollständige Ausgabe vorliegt. Die einzelnen Ausgabeabschnitte im Stream enthalten keine Moderationswerte.
Das folgende Beispiel zeigt die vollständige Ausgabe für ein Einzelbild aus einem Kriegsfilm. Das Modell erkennt im Bild Hinweise auf Gewalt. Der Wert für die Kategorie violence liegt über 0,8.
Die Felder der JSON-Antwort zeigen, welche Kategorien das Modell in der Eingabe erkennt und wie sicher es sich bei der jeweiligen Einstufung ist.
Ausgabefeld
Beschreibung
flagged
Hat den Wert true, wenn das Modell den Inhalt als potenziell schädlich einstuft,
andernfalls false.
categories
Enthält für jede Kategorie einen Eintrag, der angibt, ob das Modell einen Verstoß erkannt hat.
Der Wert ist true, wenn das Modell einen Verstoß in dieser Kategorie markiert,
andernfalls false.
category_scores
Enthält für jede Kategorie einen Moderationswert. Er gibt an, wie sicher sich das Modell ist,
dass die Eingabe Inhalte dieser Kategorie enthält. Der Wert liegt zwischen 0 und 1.
Je höher der Wert, desto sicherer ist sich das Modell.
category_applied_input_types
Enthält die Eingabetypen, für die der jeweilige Moderationswert gilt. Gilt die Kategorie
violence/graphic beispielsweise sowohl für Bild- als auch für Texteingaben,
hat die Eigenschaft violence/graphic den Wert ["image", "text"].
Wir planen, das Modell hinter dem Moderationsendpunkt laufend zu verbessern.
Wenn deine eigenen Richtlinien auf category_scores beruhen, musst du sie daher
möglicherweise im Laufe der Zeit neu kalibrieren.
Unterstützte Kategorien prüfen
Die folgende Tabelle beschreibt die Inhaltskategorien, die der Moderationsendpunkt erkennen kann, und die Eingabetypen, die er für jede Kategorie unterstützt.
Kategorien mit der Angabe „Nur Text“ unterstützen keine Bildeingaben. Wenn du ausschließlich
Bilder ohne Begleittext an das Modell omni-moderation-latest sendest, liefert es für
diese Kategorien den Wert 0. Bilddateien dürfen höchstens 20 MB groß sein.
Kategorie
Beschreibung
Eingaben
harassment
Inhalte, die jemanden mit Worten belästigen, zu solchen Äußerungen anstiften oder sie fördern.
Nur Text
harassment/threatening
Belästigende Inhalte, in denen es zusätzlich um Gewalt gegen die Betroffenen oder um deren schwere Schädigung geht.
Nur Text
hate
Inhalte, die Hass aufgrund rassistischer Zuschreibungen, des Geschlechts, der ethnischen Herkunft,
der Religion, der Nationalität, der sexuellen Orientierung, einer Behinderung oder der Kastenzugehörigkeit
ausdrücken, schüren oder fördern. Hassinhalte, die sich gegen nicht geschützte Gruppen richten
(etwa gegen Menschen, die Schach spielen), fallen unter Belästigung.
Nur Text
hate/threatening
Hassinhalte, in denen es zusätzlich um Gewalt gegen die betroffene Gruppe oder um deren schwere Schädigung geht.
Sie richten sich aufgrund rassistischer Zuschreibungen, des Geschlechts, der ethnischen Herkunft, der Religion,
der Nationalität, der sexuellen Orientierung, einer Behinderung oder der Kastenzugehörigkeit gegen die Gruppe.
Nur Text
illicit
Inhalte mit Ratschlägen oder Anleitungen zu rechtswidrigen Handlungen. Eine Formulierung wie
„Wie begeht man einen Ladendiebstahl?“ fällt in diese Kategorie.
Nur Text
illicit/violent
Inhalte wie in der Kategorie illicit, die zusätzlich auf Gewalt oder die Beschaffung einer Waffe Bezug nehmen.
Nur Text
self-harm
Inhalte, die selbstschädigendes Verhalten fördern, dazu ermutigen oder es darstellen.
Dazu zählen etwa Suizid, das Zufügen von Schnittverletzungen am eigenen Körper und Essstörungen.
Text und Bilder
self-harm/intent
Inhalte, in denen jemand äußert, sich selbst zu schädigen oder dies zu beabsichtigen.
Beispiele betreffen Suizid, das Zufügen von Schnittverletzungen am eigenen Körper und Essstörungen.
Text und Bilder
self-harm/instructions
Inhalte, die zu selbstschädigendem Verhalten ermutigen oder dazu Anleitungen oder Ratschläge geben.
Dazu zählen etwa Inhalte zu Suizid, zum Zufügen von Schnittverletzungen am eigenen Körper und zu Essstörungen.
Text und Bilder
sexual
Inhalte, die sexuell erregen sollen, etwa Beschreibungen sexueller Handlungen, oder die sexuelle Dienstleistungen
bewerben. Sexualaufklärung und Inhalte zum sexuellen Wohlbefinden sind ausgenommen.
Text und Bilder
sexual/minors
Sexuelle Inhalte, in denen eine Person unter 18 Jahren vorkommt.
Nur Text
violence
Inhalte, die Tod, Gewalt oder körperliche Verletzungen darstellen.
Text und Bilder
violence/graphic
Inhalte, die Tod, Gewalt oder körperliche Verletzungen in drastischen Einzelheiten darstellen.