使用 OpenAI 内容审核模型检测文本和图像中的有害内容。您可以通过内容审核端点 对独立输入进行分类，也可以在请求生成响应时一并获取内容审核分数。您可以根据结果执行应用的内容政策，例如过滤内容、将请求转交审查，或对提交被标记内容的账户采取干预措施。
omni-moderation-latest 模型接受文本和图像输入，不对音频进行分类。内容审核端点可免费使用，图像文件大小上限为 20 MB。
儿童安全： 请勿向内容审核 API 发送已知或疑似的儿童性虐待材料（CSAM）。该 API 并非为检测或处理 CSAM 而设计，也不能替代专门的儿童安全防护措施。有关预防、检测、应对和举报 CSAM 的步骤，请参阅我们的 CSAM 指南 。
工作流程 适用场景 审核生成的内容 您的应用使用 Responses API 或 Chat Completions API 生成文本，并需要内容审核信号。 对独立输入进行分类 您的应用需要对文本或图像进行分类，而无需生成模型响应。 理解内容审核结果 您的应用需要解读标记、类别、分数或适用的输入类型。 查看支持的类别 您的应用需要了解哪些有害内容类别适用于文本、图像或两者。
审核生成的内容 如果您的应用需要同时获取生成的文本和内容审核分数，请在生成请求中传入顶层 moderation 对象。API 会返回模型输入和生成输出的内容审核分数，无需单独发送内容审核请求。
模型仍会正常生成内容。在向用户展示输出或执行下游操作之前，请先审查内容审核结果。
创建响应时设置 moderation.model：
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 import 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
27 from 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
44 package 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
44 import 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
11 require "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) Responses API 在 response.moderation.input 中返回输入的 moderation_result 对象，在 response.moderation.output 中返回输出的 moderation_result 对象。
创建聊天补全时设置 moderation.model：
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 import 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
30 from 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
49 package 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
45 import 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
16 require "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 在 completion.moderation.input 和 completion.moderation.output 中返回内容审核结果容器。对于仅生成一个候选项的请求，请分别读取输入和输出结果中的首项 results[0]。如果您请求多个候选项，completion.moderation.output.results[i] 对应于 completion.choices[i]。
随生成响应返回的内容审核结果与独立内容审核结果使用相同的类别字段。先根据 flagged 做出初步判断，再查看 categories 和 category_scores，用于日志记录、路由、审计追踪或人工审查队列。拒绝响应或其他考虑了安全因素的响应，如果讨论了有害内容，仍可能触发标记。请将内容审核分数作为应用执行内容政策的参考信号，而非自动拦截的决定。
如果您的应用需要处理内容审核失败的情况，请在读取分数前检查内容审核结果的类型。如果某个内容审核步骤无法完成，相应的输入或输出内容审核字段可能包含错误，而不是内容审核分数。
对于工具调用请求，内容审核涵盖对话内容中出现的工具调用参数和工具输出，但不涵盖工具名称、工具描述、工具模式或响应格式模式。
如果您以流式方式接收生成的响应，内容审核分数会在完整的生成输出可用后返回，不会随部分输出增量一同返回。
使用内容审核端点 对文本或图像输入进行分类，无需生成模型响应。以下选项卡展示了如何使用 OpenAI 库 和 omni-moderation-latest 模型
审核文本输入
1
2
3
4
5
6
7
8
9 import 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
10 from 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
24 package 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
14 import 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
14 using 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
10 require "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
8 curl 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..."
}' 审核图像和文本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 import 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
20 from 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
29 package 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
31 import 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
22 using 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
21 require "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
16 curl 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"
}
}
]
}'
以下是对一张取自战争电影单帧画面的图像进行审核后返回的完整输出示例。模型识别出图像中存在暴力迹象，violence 类别的分数大于 0.8。
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 49 50 51 52 53 54 { "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" ] } } ] } JSON 响应包含一些字段，用于描述输入中存在哪些类别的内容，以及模型对每个类别的置信度。
输出类别
说明 flagged如果模型将内容判定为可能有害，则设为 true，
否则设为 false。
categories包含一个字典，记录各类别的违规标记。对于每个类别，
如果模型将该类别标记为违规，则其值为 true；
否则为 false。
category_scores包含一个字典，记录各类别的分数。每个分数表示模型对输入包含该类别内容的置信度。取值介于 0 和 1 之间，数值越高表示置信度越高。
category_applied_input_types包含类别分数所适用的输入类型。例如，
如果 violence/graphic 类别同时适用于图像和文本输入，
则 violence/graphic 属性设为 ["image", "text"]。
我们计划持续升级内容审核端点的底层模型。
因此，依赖 category_scores 的自定义政策可能需要
随着时间推移重新校准。
下表介绍了内容审核端点可以检测的内容类别，以及每个类别支持的输入类型。
标记为“仅文本”的类别不支持图像输入。如果您仅发送
图像（不附带文本）给 omni-moderation-latest 模型，
模型会为这些不支持的类别返回 0 分。图像文件大小
上限为 20 MB。
类别 说明 输入 harassment包含针对任何对象的骚扰性言语，或煽动、鼓吹使用此类言语的内容。
仅文本 harassment/threatening同时涉及针对任何对象的暴力或严重伤害的骚扰内容。
仅文本 hate基于种族、性别、族裔、宗教、国籍、性取向、残障状况或种姓表达、煽动或宣扬仇恨的内容。针对非受保护群体（例如国际象棋棋手）的仇恨内容归为骚扰。
仅文本 hate/threatening基于种族、性别、族裔、宗教、国籍、性取向、残障状况或种姓，针对特定群体，且同时涉及对该群体的暴力或严重伤害的仇恨内容。
仅文本 illicit提供实施违法行为的建议或指导的内容。例如，“如何在商店行窃”这样的表述就属于此类别。
仅文本 illicit/violent与 illicit 类别所标记的内容类型相同，但还
涉及暴力或获取武器。
仅文本 self-harm宣扬、鼓励或描绘自残行为的内容，例如自杀、割伤自己和饮食失调。
文本和图像 self-harm/intent表达者表示自己正在或打算进行自残行为的内容，例如自杀、割伤自己和饮食失调。
文本和图像 self-harm/instructions鼓励实施自残行为（例如自杀、割伤自己和饮食失调），或提供如何实施此类行为的指导或建议的内容。
文本和图像 sexual旨在引起性兴奋的内容，例如对性行为的描述，或推广性服务的内容（不包括性教育和性健康内容）。
文本和图像 sexual/minors涉及未满 18 岁人士的性内容。
仅文本 violence描绘死亡、暴力或身体伤害的内容。
文本和图像 violence/graphic详细描绘死亡、暴力或身体伤害的血腥细节的内容。
文本和图像
