Moderation | OpenAI API

Nutze die Moderationsmodelle von OpenAI, um schädliche Inhalte in Texten und Bildern zu erkennen. Du kannst eigenständige Eingaben mit dem Moderationsendpunkt klassifizieren oder Moderationsscores zusammen mit einer generierten Antwort anfordern. Nutze die Ergebnisse, um die Richtlinien deiner Anwendung durchzusetzen, etwa indem du Inhalte filterst, Anfragen zur Überprüfung weiterleitest oder Maßnahmen gegen Konten ergreifst, die markierte Inhalte einreichen.

Das Modell omni-moderation-latest akzeptiert Text- und Bildeingaben. Audio klassifiziert es nicht. Der Moderationsendpunkt ist kostenlos nutzbar. Bilddateien dürfen bis zu 20 MB groß sein.

Kinderschutz: Sende keine bekannten oder mutmaßlichen Darstellungen sexuellen Kindesmissbrauchs (CSAM) an die Moderation API. Die API ist weder für die Erkennung noch für den Umgang mit CSAM ausgelegt und ersetzt keine speziellen Schutzmaßnahmen für Kinder. Unsere Hinweise zu CSAM erläutern, wie du CSAM vorbeugen, entsprechendes Material erkennen, darauf reagieren und es melden kannst.

Einen Ablauf für die Moderation wählen

Ablauf	Geeignet, wenn …
Generierte Inhalte moderieren	Deine Anwendung generiert Text mit der Responses API oder der Chat Completions API und benötigt Moderationssignale.
Eigenständige Eingaben klassifizieren	Deine Anwendung muss Texte oder Bilder klassifizieren, ohne eine Modellantwort zu generieren.
Moderationsergebnisse verstehen	Deine Anwendung muss Markierungen, Kategorien, Scores oder die zugehörigen Eingabetypen auswerten.
Unterstützte Kategorien ansehen	Deine Anwendung muss wissen, welche Kategorien schädlicher Inhalte für Texte, Bilder oder beides gelten.

Generierte Inhalte moderieren

Wenn deine Anwendung generierten Text und Moderationsscores zusammen benötigt, übergib in der Generierungsanfrage ein moderation-Objekt auf oberster Ebene. Die API gibt Moderationsscores für die Modelleingabe und die generierte Ausgabe zurück, ohne dass eine separate Moderationsanfrage nötig ist.

Das Modell generiert weiterhin wie gewohnt. Prüfe die Moderationsergebnisse, bevor du die Ausgabe einer Person anzeigst oder nachgelagerte Aktionen ausführst.

Lege moderation.model fest, wenn du eine Antwort erstellst:

Eine Antwort mit Moderationsscores 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
27import 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" },
});

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 OpenAI

client = 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.input
output_moderation = response.moderation.output
if input_moderation.type == "error":
    raise RuntimeError(input_moderation.message)
if output_moderation.type == "error":
    raise RuntimeError(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
44package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative."),
		},
		Moderation: responses.ResponseNewParamsModeration{
			Model: "omni-moderation-latest",
		},
	})
	if err != nil {
		panic(err)
	}

	switch inputModeration := response.Moderation.Input.AsAny().(type) {
	case responses.ResponseModerationInputModerationResult:
		fmt.Println(inputModeration.Flagged)
	case responses.ResponseModerationInputError:
		panic(errors.New(inputModeration.Message))
	default:
		panic("unexpected input moderation result")
	}
	switch outputModeration := response.Moderation.Output.AsAny().(type) {
	case responses.ResponseModerationOutputModerationResult:
		fmt.Println(outputModeration.Flagged)
	case responses.ResponseModerationOutputError:
		panic(errors.New(outputModeration.Message))
	default:
		panic("unexpected output moderation result")
	}
}

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.new

response = 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 gibt unter response.moderation.input ein moderation_result-Objekt für die Eingabe und unter response.moderation.output ein moderation_result-Objekt für die Ausgabe zurück.

Lege moderation.model fest, wenn du eine Chat Completion erstellst:

Eine Chat Completion mit Moderationsscores 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
26import 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" },
});

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 OpenAI

client = 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.input
output_result = completion.moderation.output
if input_result.type == "error":
    raise RuntimeError(input_result.message)
if output_result.type == "error":
    raise RuntimeError(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
45
46
47
48
49package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage("A user asks for instructions to make a harmful weapon. Draft a brief refusal and offer a safer alternative."),
		},
		Moderation: openai.ChatCompletionNewParamsModeration{
			Model: "omni-moderation-latest",
		},
	})
	if err != nil {
		panic(err)
	}

	switch inputResult := completion.Moderation.Input.AsAny().(type) {
	case openai.ChatCompletionModerationInputModerationResults:
		if len(inputResult.Results) == 0 {
			panic("missing input moderation result")
		}
		fmt.Println(inputResult.Results[0].Flagged)
	case openai.ChatCompletionModerationInputError:
		panic(errors.New(inputResult.Message))
	default:
		panic("unexpected input moderation result")
	}
	switch outputResult := completion.Moderation.Output.AsAny().(type) {
	case openai.ChatCompletionModerationOutputModerationResults:
		if len(outputResult.Results) == 0 {
			panic("missing output moderation result")
		}
		fmt.Println(outputResult.Results[0].Flagged)
	case openai.ChatCompletionModerationOutputError:
		panic(errors.New(outputResult.Message))
	default:
		panic("unexpected output moderation result")
	}
}

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.new

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" }
)

puts(completion.moderation)

Chat Completions gibt unter completion.moderation.input und completion.moderation.output Container mit Moderationsergebnissen zurück. Bei einer Anfrage mit einer einzigen generierten Antwortvariante liest du das jeweils erste Ergebnis für Eingabe und Ausgabe unter results[0] aus. Wenn du mehrere Antwortvarianten anforderst, entspricht completion.moderation.output.results[i] der Variante completion.choices[i].

Inline-Moderationsergebnisse verwenden dieselben Kategoriefelder wie ein eigenständiges Moderationsergebnis. Nutze zunächst flagged für eine erste Entscheidung. Prüfe anschließend categories und category_scores, etwa für die Protokollierung, die Weiterleitung, Audit-Trails oder Warteschlangen für die menschliche Überprüfung. Auch eine Ablehnung oder eine andere sicherheitsbewusste Antwort kann eine Markierung auslösen, wenn sie schädliche Inhalte thematisiert. Betrachte Moderationsscores als Signale zur Anwendung deiner Richtlinien, nicht als automatische Entscheidung zum Blockieren.

Prüfe den Typ des Moderationsergebnisses, bevor du Scores ausliest, wenn deine Anwendung Moderationsfehler behandeln muss. Kann ein Moderationsschritt nicht abgeschlossen werden, kann das entsprechende Moderationsfeld für die Eingabe oder Ausgabe einen Fehler anstelle von Moderationsscores enthalten.

Bei Anfragen mit Tool-Aufrufen umfasst die Moderation die Argumente der Tool-Aufrufe und die Tool-Ausgaben, sofern sie im Gesprächsinhalt vorkommen. Tool-Namen, Tool-Beschreibungen, Tool-Schemas und Schemas für das Antwortformat werden nicht erfasst.

Wenn du eine generierte Antwort streamst, treffen die Moderationsscores erst ein, wenn die vollständige generierte Ausgabe vorliegt. In den Deltas der Teilausgaben sind sie nicht enthalten.

Eigenständige Eingaben klassifizieren

Nutze den Moderationsendpunkt, um Text- oder Bildeingaben zu klassifizieren, ohne eine Modellantwort zu generieren. Die folgenden Tabs zeigen, wie du die OpenAI-Bibliotheken und das Modell omni-moderation-latest verwendest:

Klassifizierungsinformationen für eine Texteingabe abrufen

Python

1
2
3
4
5
6
7
8
9import OpenAI from "openai";
const openai = new OpenAI();

const moderation = await openai.moderations.create({
  model: "omni-moderation-latest",
  input: "...text to classify goes here...",
});

console.log(moderation);

1
2
3
4
5
6
7
8
9
10from openai import OpenAI

client = OpenAI()

response = client.moderations.create(
    model="omni-moderation-latest",
    input="...text to classify goes here...",
)

print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	moderation, err := client.Moderations.New(context.Background(), openai.ModerationNewParams{
		Model: openai.ModerationModelOmniModerationLatest,
		Input: openai.ModerationNewParamsInputUnion{
			OfString: openai.String("Text to classify goes here."),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(moderation.Results[0].Flagged)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.moderations.ModerationCreateParams;

var moderation =
    client
        .moderations()
        .create(
            ModerationCreateParams.builder()
                .model("omni-moderation-latest")
                .input("Text to classify goes here.")
                .build());

System.out.println(moderation.results().get(0).flagged());

1
2
3
4
5
6
7
8
9
10
11
12
13
14using OpenAI.Moderations;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "omni-moderation-latest";
ModerationClient client = new(model, key);

ModerationResult result = await client.ClassifyTextAsync(
    "Text to classify goes here."
);

Console.WriteLine($"Flagged: {result.Flagged}");
Console.WriteLine(
    $"Violence: {result.Violence.Flagged}; score: {result.Violence.Score:F3}"
);

1
2
3
4
5
6
7
8
9
10require "openai"

client = OpenAI::Client.new

moderation = client.moderations.create(
  model: OpenAI::Models::ModerationModel::OMNI_MODERATION_LATEST,
  input: "Text to classify goes here."
)

puts(moderation.results.fetch(0).flagged)

1
2
3
4
5
6
7
8curl https://api.openai.com/v1/moderations \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "omni-moderation-latest",
    "input": "...text to classify goes here..."
  }'

Klassifizierungsinformationen für Bild- und Texteingaben abrufen

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import OpenAI from "openai";
const openai = new OpenAI();

const moderation = await openai.moderations.create({
  model: "omni-moderation-latest",
  input: [
    { type: "text", text: "...text to classify goes here..." },
    {
      type: "image_url",
      image_url: {
        url: "https://example.com/image.png",
        // You can also use a Base64 encoded image URL.
        // url: "data:image/jpeg;base64,abcdefg...",
      },
    },
  ],
});

console.log(moderation);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20from openai import OpenAI

client = OpenAI()

response = client.moderations.create(
    model="omni-moderation-latest",
    input=[
        {"type": "text", "text": "...text to classify goes here..."},
        {
            "type": "image_url",
            "image_url": {
                "url": "https://example.com/image.png",
                # You can also use a Base64 encoded image URL.
                # "url": "data:image/jpeg;base64,abcdefg..."
            },
        },
    ],
)

print(response)

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
29package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	moderation, err := client.Moderations.New(context.Background(), openai.ModerationNewParams{
		Model: openai.ModerationModelOmniModerationLatest,
		Input: openai.ModerationNewParamsInputUnion{
			OfModerationMultiModalArray: []openai.ModerationMultiModalInputUnionParam{
				openai.ModerationMultiModalInputParamOfText("Text to classify goes here."),
				openai.ModerationMultiModalInputParamOfImageURL(openai.ModerationImageURLInputImageURLParam{
					URL: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
				}),
			},
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(moderation.Results[0].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
31import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.moderations.ModerationCreateParams;
import com.openai.models.moderations.ModerationImageUrlInput;
import com.openai.models.moderations.ModerationMultiModalInput;
import com.openai.models.moderations.ModerationTextInput;
import java.util.List;

var moderation =
    client
        .moderations()
        .create(
            ModerationCreateParams.builder()
                .model("omni-moderation-latest")
                .inputOfModerationMultiModalArray(
                    List.of(
                        ModerationMultiModalInput.ofText(
                            ModerationTextInput.builder()
                                .text("Text to classify goes here.")
                                .build()),
                        ModerationMultiModalInput.ofImageUrl(
                            ModerationImageUrlInput.builder()
                                .imageUrl(
                                    ModerationImageUrlInput.ImageUrl.builder()
                                        .url(
                                            "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg")
                                        .build())
                                .build())))
                .build());

System.out.println(moderation.results().get(0).flagged());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22using OpenAI.Moderations;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "omni-moderation-latest";
ModerationClient client = new(model, key);

ModerationResult result = await client.ClassifyInputsAsync(
    [
        ModerationInputPart.CreateTextPart("Text to classify goes here."),
        ModerationInputPart.CreateImagePart(
            new Uri(
                "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
            )
        ),
    ]
);

Console.WriteLine($"Flagged: {result.Flagged}");
Console.WriteLine(
    $"Violence: {result.Violence.Flagged}; score: {result.Violence.Score:F3}; inputs: {result.Violence.ApplicableInputKinds}"
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "openai"

client = OpenAI::Client.new

moderation = client.moderations.create(
  model: OpenAI::Models::ModerationModel::OMNI_MODERATION_LATEST,
  input: [
    {
      type: :text,
      text: "Text to classify goes here."
    },
    {
      type: :image_url,
      image_url: {
        url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
      }
    }
  ]
)

puts(moderation.results.fetch(0).flagged)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://api.openai.com/v1/moderations \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "omni-moderation-latest",
    "input": [
      { "type": "text", "text": "...text to classify goes here..." },
      {
        "type": "image_url",
        "image_url": {
          "url": "https://example.com/image.png"
        }
      }
    ]
  }'

Moderationsergebnisse verstehen

Hier siehst du eine vollständige Beispielausgabe für ein Einzelbild aus einem Kriegsfilm. Das Modell erkennt Anzeichen von Gewalt im Bild und vergibt für die Kategorie violence einen Score von über 0,8.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354{
  "id": "modr-970d409ef3bef3b70c73d8232df86e7d",
  "model": "omni-moderation-latest",
  "results": [
    {
      "flagged": true,
      "categories": {
        "sexual": false,
        "sexual/minors": false,
        "harassment": false,
        "harassment/threatening": false,
        "hate": false,
        "hate/threatening": false,
        "illicit": false,
        "illicit/violent": false,
        "self-harm": false,
        "self-harm/intent": false,
        "self-harm/instructions": false,
        "violence": true,
        "violence/graphic": false
      },
      "category_scores": {
        "sexual": 2.34135824776394e-7,
        "sexual/minors": 1.6346470245419304e-7,
        "harassment": 0.0011643905680426018,
        "harassment/threatening": 0.0022121340080906377,
        "hate": 3.1999824407395835e-7,
        "hate/threatening": 2.4923252458203563e-7,
        "illicit": 0.0005227032493135171,
        "illicit/violent": 3.682979260160596e-7,
        "self-harm": 0.0011175734280627694,
        "self-harm/intent": 0.0006264858507989037,
        "self-harm/instructions": 7.368592981140821e-8,
        "violence": 0.8599265510337075,
        "violence/graphic": 0.37701736389561064
      },
      "category_applied_input_types": {
        "sexual": ["image"],
        "sexual/minors": [],
        "harassment": [],
        "harassment/threatening": [],
        "hate": [],
        "hate/threatening": [],
        "illicit": [],
        "illicit/violent": [],
        "self-harm": ["image"],
        "self-harm/intent": ["image"],
        "self-harm/instructions": ["image"],
        "violence": ["image"],
        "violence/graphic": ["image"]
      }
    }
  ]
}

Die JSON-Antwort enthält Felder, die angeben, welche Kategorien in der Eingabe vorkommen und wie sicher sich das Modell bei der jeweiligen Zuordnung ist.

Ausgabekategorie	Beschreibung
`flagged`	Wird auf `true` gesetzt, wenn das Modell den Inhalt als potenziell schädlich einstuft, andernfalls auf `false`.
`categories`	Enthält ein Dictionary mit Markierungen für Verstöße je Kategorie. Für jede Kategorie ist der Wert `true`, wenn das Modell einen Verstoß in der entsprechenden Kategorie markiert, andernfalls `false`.
`category_scores`	Enthält ein Dictionary mit Scores je Kategorie. Jeder Score gibt an, wie sicher sich das Modell ist, dass die Eingabe Inhalte der jeweiligen Kategorie enthält. Der Wert liegt zwischen 0 und 1. Höhere Werte bedeuten eine höhere Konfidenz.
`category_applied_input_types`	Enthält die Eingabetypen, für die der Kategoriescore gilt. Gilt beispielsweise die Kategorie `violence/graphic` sowohl für Bild- als auch für Texteingaben, wird die Eigenschaft `violence/graphic` auf `["image", "text"]` gesetzt.

Wir planen, das zugrunde liegende Modell des Moderationsendpunkts kontinuierlich zu verbessern. Deshalb müssen benutzerdefinierte Richtlinien, die auf category_scores basieren, im Laufe der Zeit möglicherweise neu kalibriert werden.

Unterstützte Kategorien ansehen

Die folgende Tabelle beschreibt die Inhaltskategorien, die der Moderationsendpunkt erkennen kann, und die Eingabetypen, die jede Kategorie unterstützt.

Kategorien mit der Kennzeichnung „Nur Text“ unterstützen keine Bildeingaben. Wenn du ausschließlich Bilder ohne begleitenden Text an das Modell omni-moderation-latest sendest, gibt es für diese nicht unterstützten Kategorien einen Score von 0 zurück. Bilddateien dürfen höchstens 20 MB groß sein.

Kategorie	Beschreibung	Eingaben
`harassment`	Inhalte, die belästigende Äußerungen enthalten, dazu anstiften oder sie fördern, unabhängig davon, gegen wen sie sich richten.	Nur Text
`harassment/threatening`	Belästigende Inhalte, die auch Gewalt oder schwere Schädigungen umfassen, unabhängig davon, gegen wen sie sich richten.	Nur Text
`hate`	Inhalte, die Hass aufgrund von Rasse, Geschlecht, ethnischer Herkunft, Religion, Nationalität, sexueller Orientierung, Behinderung oder Kastenzugehörigkeit ausdrücken, dazu anstiften oder ihn fördern. Hasserfüllte Inhalte, die sich gegen nicht geschützte Gruppen richten (z. B. Schachspielende), gelten als Belästigung.	Nur Text
`hate/threatening`	Hasserfüllte Inhalte, die auch Gewalt oder schwere Schädigungen gegen die betroffene Gruppe aufgrund von Rasse, Geschlecht, ethnischer Herkunft, Religion, Nationalität, sexueller Orientierung, Behinderung oder Kastenzugehörigkeit umfassen.	Nur Text
`illicit`	Inhalte, die Ratschläge oder Anleitungen für rechtswidrige Handlungen geben. Eine Formulierung wie „Wie begeht man Ladendiebstahl?“ würde in diese Kategorie fallen.	Nur Text
`illicit/violent`	Dieselben Arten von Inhalten, die von der Kategorie `illicit` gekennzeichnet werden, jedoch mit zusätzlichen Bezügen zu Gewalt oder zur Beschaffung einer Waffe.	Nur Text
`self-harm`	Inhalte, die selbstschädigendes Verhalten wie Suizid, Ritzen und Essstörungen befürworten, dazu ermutigen oder es darstellen.	Text und Bilder
`self-harm/intent`	Inhalte, in denen eine Person angibt, sich selbst zu schädigen oder dies zu beabsichtigen, etwa durch Suizid, Ritzen oder Essstörungen.	Text und Bilder
`self-harm/instructions`	Inhalte, die zu selbstschädigendem Verhalten wie Suizid, Ritzen und Essstörungen ermutigen oder Anleitungen oder Ratschläge dazu geben.	Text und Bilder
`sexual`	Inhalte, die sexuell erregen sollen, etwa Beschreibungen sexueller Handlungen, oder die sexuelle Dienstleistungen bewerben (ausgenommen sexuelle Aufklärung und sexuelles Wohlbefinden).	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 drastisch und detailliert darstellen.	Text und Bilder

Vorschläge

Erste Schritte

Grundlegende Konzepte

SDKs und CLI

Ressourcen

Ältere APIs

Modell auswählen

Text und Code

Prompts formulieren

Reasoning-Aufwand

Bilder und Video

Echtzeit und Audio

Spezialisierte Modelle

Agents API

Agents SDK

ChatKit

Suche und Informationsabruf

Tools und Daten anbinden

Arbeitsabläufe mit Tools erstellen

Computer und Code

Medien

GPT-Live

Realtime API

Anwendungen mit Sprachfunktionen entwickeln

Verbindungen

Audioverarbeitung

In Produktion gehen

Leistung und Qualität

Kosten und Durchsatz

Sicherheit und Governance

Infrastruktur und Zugriff

Betrieb

Grundlegende Konzepte

Plan

Build

Test and publish

Conversion specs

Leitfäden

Ressourcen

Erste Schritte

Leitfäden

File Upload

API

Measurement

Advertiser API

API-Referenz

Erste Schritte

Grundlagen

Entdecken

Verfügbar auf

Versionen

Arbeitsabläufe

Funktionen

Referenz

Anpassung

Konfigurationsdatei

Agentenkonfiguration

ChatGPT und Codex erweitern

Linux

Windows

Arbeitsabläufe für die Entwicklung

Erweitern und automatisieren

Umgebungen

Mit Codex entwickeln

Integrationen von Drittanbietern

Referenz

Berechtigungen

Codex Security

Cybersicherheit

Erste Schritte

ChatGPT Work

Identität und Authentifizierung

Workspace-Zugriff, Richtlinien und Modelle

Kontrollen für Plug-ins und Konnektoren

Nutzung, Governance und Compliance

Bereitstellung und Modellanbieter

Community

Blog

Community

Blog