Moderação | OpenAI API

Use os modelos de moderação da OpenAI para detectar conteúdo prejudicial em textos e imagens. Você pode classificar entradas de forma independente com o endpoint de moderação ou solicitar pontuações de moderação junto com uma resposta gerada. Use os resultados para aplicar a política do seu aplicativo, por exemplo, filtrando conteúdo, encaminhando uma solicitação para revisão ou tomando medidas em relação a contas que enviam conteúdo sinalizado.

O modelo omni-moderation-latest aceita entradas de texto e imagem. Ele não classifica áudio. O endpoint de moderação é gratuito, e os arquivos de imagem podem ter até 20 MB.

Segurança infantil: Não envie à API de Moderação material identificado como abuso sexual infantil (CSAM) ou suspeito de conter esse tipo de conteúdo. A API não foi projetada para detectar ou lidar com CSAM e não substitui medidas específicas de proteção infantil. Consulte nossas Orientações sobre CSAM para conhecer as etapas de prevenção, detecção, resposta e denúncia de CSAM.

Escolha um fluxo de trabalho de moderação

Fluxo de trabalho	Use quando
Modere conteúdo gerado	Seu aplicativo gera texto com a Responses API ou a API chat completions e precisa de sinais de moderação.
Classifique entradas de forma independente	Seu aplicativo precisa classificar textos ou imagens sem gerar uma resposta do modelo.
Entenda os resultados da moderação	Seu aplicativo precisa interpretar sinalizações, categorias, pontuações ou os tipos de entrada aos quais elas se aplicam.
Consulte as categorias compatíveis	Seu aplicativo precisa saber quais categorias de conteúdo prejudicial se aplicam a textos, imagens ou ambos.

Modere conteúdo gerado

Quando seu aplicativo precisar de texto gerado e pontuações de moderação juntos, passe um objeto moderation no nível superior da solicitação de geração. A API retorna pontuações de moderação para a entrada do modelo e a saída gerada sem uma solicitação de moderação separada.

O modelo continua gerando normalmente. Revise os resultados da moderação antes de mostrar a saída a um usuário ou executar ações subsequentes.

Defina moderation.model ao criar uma resposta:

Gere uma resposta com pontuações de moderação

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)

A Responses API retorna um objeto moderation_result referente à entrada em response.moderation.input e um objeto moderation_result referente à saída em response.moderation.output.

Defina moderation.model ao criar uma conclusão de chat:

Gere uma conclusão de chat com pontuações de moderação

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 retorna contêineres de resultados de moderação em completion.moderation.input e completion.moderation.output. Para uma solicitação com uma única opção gerada, leia o primeiro resultado de entrada e de saída em results[0]. Se você solicitar várias opções, completion.moderation.output.results[i] corresponde a completion.choices[i].

Os resultados de moderação incluídos na resposta usam os mesmos campos de categoria que um resultado de moderação independente. Comece com flagged para uma decisão inicial e, em seguida, examine categories e category_scores para registro em logs, roteamento, trilhas de auditoria ou filas de revisão humana. Uma recusa ou outra resposta que leve a segurança em consideração ainda pode ser sinalizada se abordar conteúdo prejudicial. Trate as pontuações de moderação como sinais para a política do seu aplicativo, não como uma decisão automática de bloqueio.

Verifique o tipo do resultado de moderação antes de ler as pontuações se seu aplicativo precisar lidar com falhas de moderação. Se uma etapa de moderação não puder ser concluída, o campo de moderação correspondente à entrada ou à saída poderá conter um erro em vez de pontuações de moderação.

Para solicitações com chamadas de ferramentas, a moderação abrange os argumentos dessas chamadas e as saídas das ferramentas quando aparecem no conteúdo da conversa. Ela não abrange nomes, descrições ou esquemas de ferramentas, nem esquemas de formato de resposta.

Se você transmitir uma resposta gerada por streaming, as pontuações de moderação chegarão depois que toda a saída gerada estiver disponível. Elas não são incluídas nos deltas parciais da saída.

Classifique entradas de forma independente

Use o endpoint de moderação para classificar entradas de texto ou imagem sem gerar uma resposta do modelo. As abas abaixo mostram como usar as bibliotecas da OpenAI e o modelo omni-moderation-latest:

Obtenha informações de classificação para uma entrada de texto

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..."
  }'

Obtenha informações de classificação para entradas de imagem e texto

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"
        }
      }
    ]
  }'

Entenda os resultados da moderação

Veja um exemplo completo de saída para uma imagem de um único quadro de um filme de guerra. O modelo identifica indícios de violência na imagem, com uma pontuação superior a 0,8 na categoria violence.

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

A resposta JSON inclui campos que descrevem quais categorias estão presentes na entrada e o grau de confiança do modelo em cada categoria.

Categoria de saída	Descrição
`flagged`	Definido como `true` se o modelo classificar o conteúdo como potencialmente prejudicial; caso contrário, `false`.
`categories`	Contém um dicionário de sinalizações de violação por categoria. Para cada categoria, o valor é `true` se o modelo sinalizar uma violação na categoria correspondente; caso contrário, `false`.
`category_scores`	Contém um dicionário de pontuações por categoria. Cada pontuação representa a confiança do modelo de que a entrada contém conteúdo da categoria. O valor fica entre 0 e 1, sendo que valores mais altos indicam maior confiança.
`category_applied_input_types`	Contém os tipos de entrada aos quais a pontuação da categoria se aplica. Por exemplo, se a categoria `violence/graphic` se aplicar tanto a entradas de imagem quanto de texto, a propriedade `violence/graphic` será definida como `["image", "text"]`.

Planejamos aprimorar continuamente o modelo usado pelo endpoint de moderação. Por isso, políticas personalizadas que dependem de category_scores podem precisar de recalibração ao longo do tempo.

Consulte as categorias compatíveis

A tabela abaixo descreve as categorias de conteúdo que o endpoint de moderação pode detectar e os tipos de entrada aceitos por cada categoria.

As categorias marcadas como "Somente texto" não aceitam entradas de imagem. Se você enviar apenas imagens (sem texto) ao modelo omni-moderation-latest, ele retornará uma pontuação de 0 para essas categorias não compatíveis com imagens. Os arquivos de imagem têm um limite de 20 MB.

Categoria	Descrição	Entradas
`harassment`	Conteúdo que expressa, incita ou promove linguagem de assédio contra qualquer alvo.	Somente texto
`harassment/threatening`	Conteúdo de assédio que também inclui violência ou danos graves contra qualquer alvo.	Somente texto
`hate`	Conteúdo que expressa, incita ou promove ódio com base em raça, gênero, etnia, religião, nacionalidade, orientação sexual, deficiência ou casta. Conteúdo de ódio direcionado a grupos não protegidos (por exemplo, jogadores de xadrez) é considerado assédio.	Somente texto
`hate/threatening`	Conteúdo de ódio que também inclui violência ou danos graves contra o grupo visado com base em raça, gênero, etnia, religião, nacionalidade, orientação sexual, deficiência ou casta.	Somente texto
`illicit`	Conteúdo que oferece conselhos ou instruções sobre como cometer atos ilícitos. Uma frase como "como furtar em lojas" se enquadraria nesta categoria.	Somente texto
`illicit/violent`	Os mesmos tipos de conteúdo sinalizados pela categoria `illicit`, mas que também incluem referências à violência ou à obtenção de uma arma.	Somente texto
`self-harm`	Conteúdo que promove, incentiva ou retrata atos de autolesão, como suicídio, cortes autoinfligidos e transtornos alimentares.	Texto e imagens
`self-harm/intent`	Conteúdo em que a pessoa expressa que está praticando ou pretende praticar atos de autolesão, como suicídio, cortes autoinfligidos e transtornos alimentares.	Texto e imagens
`self-harm/instructions`	Conteúdo que incentiva a prática de atos de autolesão, como suicídio, cortes autoinfligidos e transtornos alimentares, ou que fornece instruções ou orientações sobre como praticar esses atos.	Texto e imagens
`sexual`	Conteúdo destinado a provocar excitação sexual, como descrições de atividade sexual, ou que promove serviços sexuais (excluindo educação sexual e bem-estar).	Texto e imagens
`sexual/minors`	Conteúdo sexual que inclui uma pessoa com menos de 18 anos.	Somente texto
`violence`	Conteúdo que retrata morte, violência ou lesões físicas.	Texto e imagens
`violence/graphic`	Conteúdo que retrata morte, violência ou lesões físicas com detalhes explícitos.	Texto e imagens

Sugestões

Primeiros passos

Conceitos fundamentais

SDKs e CLI

Recursos

APIs legadas

Escolha um modelo

Texto e código

Criação de prompts

Raciocínio

Imagens e vídeo

Tempo real e áudio

Modelos especializados

API de Agentes

SDK de Agentes

ChatKit

Pesquisa e recuperação

Conecte ferramentas e dados

Crie fluxos de trabalho com ferramentas

Computador e código

Mídia

GPT-Live

Realtime API

Desenvolva com voz

Conexões

Processamento de áudio

Entre em produção

Desempenho e qualidade

Custo e taxa de processamento

Segurança e governança

Infraestrutura e acesso

Operações

Conceitos fundamentais

Plan

Build

Test and publish

Conversion specs

Guias

Recursos

Primeiros passos

Guias

File Upload

API

Measurement

Advertiser API

Referência da API

Primeiros passos

Fundamentos

Explorar

Disponível em

Versões

Fluxos de trabalho

Capacidades

Referência

Personalização

Arquivo de configuração

Configuração de agentes

Amplie os recursos do ChatGPT e do Codex

Linux

Windows

Fluxos de trabalho de desenvolvimento

Amplie e automatize

Ambientes

Desenvolva com o Codex

Integrações de terceiros

Referência

Permissões

Codex Security

Segurança cibernética

Primeiros passos

ChatGPT Work

Identidade e autenticação

Acesso, política e modelos do workspace

Controles de plug-ins e conectores

Uso, governança e conformidade

Implantação e provedores de modelos

Comunidade

Blog

Comunidade

Blog