Classificadores de segurança

Com a introdução do GPT-5, adicionamos verificações para identificar informações perigosas e impedir o acesso a elas. É provável que alguns usuários acabem tentando usar seu aplicativo para fins que não estão de acordo com as políticas da OpenAI, especialmente em aplicativos com uma ampla variedade de casos de uso.

Como funciona o processo de classificação de segurança

1. Classificamos as solicitações ao GPT-5 de acordo com limiares de risco.
2. Se sua organização atingir limiares elevados repetidamente, a OpenAI retornará um erro e enviará um e-mail de aviso.
3. Se as solicitações continuarem após o prazo informado (geralmente sete dias), interromperemos o acesso da sua organização ao GPT-5. As solicitações deixarão de funcionar.

Como evitar erros, latência e banimentos

Se sua organização realizar atividades suspeitas que violem nossas políticas de segurança, poderemos retornar um erro, limitar o acesso aos modelos ou até bloquear sua conta. As medidas de segurança a seguir nos ajudam a identificar a origem das solicitações de alto risco e a bloquear usuários finais individualmente, em vez de bloquear toda a sua organização.

• Implemente identificadores de segurança em produtos nos quais usuários individuais interagem com um modelo. Os identificadores de segurança são recomendados, mas não obrigatórios.
• Se o seu caso de uso depender do acesso a uma versão menos restrita dos nossos serviços para desenvolver aplicações benéficas nas ciências da vida, leia sobre nosso programa de acesso especial para verificar se você atende aos critérios.

Como implementar identificadores de segurança para usuários individuais

O parâmetro safety_identifier está disponível tanto na Responses API quanto na API chat completions, mais antiga. A Realtime API oferece suporte ao mesmo conceito por meio do cabeçalho OpenAI-Safety-Identifier. Para usar identificadores de segurança, forneça um ID estável para seu usuário final em cada solicitação. Aplique uma função de hash ao e-mail ou aos IDs internos dos usuários para evitar o envio de informações pessoais.

Os identificadores de segurança não são transferidos entre APIs ou sessões. Se seu aplicativo já envia safety_identifier nas solicitações à Responses API, envie o mesmo valor estável separadamente ao criar cada sessão Realtime ou se conectar a ela.

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

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6-terra",
  input: "This is a test",
  safety_identifier: "user_123456",
});

console.log(response.output_text);

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

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="This is a test",
    safety_identifier="user_123456",
)

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

import (
	"context"
	"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-5.6-terra",
		Input:            responses.ResponseNewParamsInputUnion{OfString: openai.String("This is a test")},
		SafetyIdentifier: openai.String("user_123456"),
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

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

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.6-terra")
        .input("Help me plan a study schedule.")
        .safetyIdentifier("user_1234")
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

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

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.6-terra",
  input: "Help me plan a study schedule.",
  safety_identifier: "user_1234"
)

puts(response.output_text)

1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-5.6-terra",
"input": "This is a test",
"safety_identifier": "user_123456"
}'

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

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-5.6-terra",
  messages: [{ role: "user", content: "This is a test" }],
  safety_identifier: "user_123456",
});

console.log(response.choices[0].message.content);

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

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-5.6-terra",
    messages=[{"role": "user", "content": "This is a test"}],
    safety_identifier="user_123456",
)

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

import (
	"context"
	"fmt"

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

func main() {
	client := openai.NewClient()
	response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model:            "gpt-5.6-terra",
		Messages:         []openai.ChatCompletionMessageParamUnion{openai.UserMessage("This is a test")},
		SafetyIdentifier: openai.String("user_123456"),
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Choices[0].Message.Content)
}

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.chat.completions.ChatCompletionCreateParams;

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-5.6-terra")
        .addUserMessage("Help me plan a study schedule.")
        .safetyIdentifier("user_1234")
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15require "openai"

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-5.6-terra",
  messages: [
    {
      role: :user,
      content: "Help me plan a study schedule."
    }
  ],
  safety_identifier: "user_1234"
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10curl https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-5.6-terra",
"messages": [
{"role": "user", "content": "This is a test"}
],
"safety_identifier": "user_123456"
}'

1
2
3
4
5
6
7
8
9
10curl https://api.openai.com/v1/realtime/client_secrets \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "OpenAI-Safety-Identifier: user_123456" \
-d '{
"session": {
"type": "realtime",
"model": "gpt-realtime-2.1"
}
}'

Possíveis consequências

Se os sistemas de monitoramento da OpenAI identificarem possíveis abusos, poderemos tomar medidas em diferentes níveis:

• Atraso nas respostas em streaming
  • Como intervenção inicial de menor impacto para um usuário que possa estar violando as políticas, a OpenAI pode atrasar as respostas em streaming enquanto realiza verificações adicionais antes de retornar a resposta completa a esse usuário.
  • Se a verificação for bem-sucedida, o streaming será iniciado. Se a verificação falhar, a solicitação será interrompida: nenhum token será exibido e a resposta em streaming não será iniciada.
  • Para melhorar a experiência do usuário final, considere adicionar um indicador de carregamento para os casos em que houver atraso no streaming.
• Bloqueio de acesso aos modelos para usuários individuais
  • Quando uma violação de política é identificada com alto grau de confiança, o safety_identifier associado tem seu acesso aos modelos da OpenAI completamente bloqueado.
  • Todas as solicitações futuras ao GPT-5 que usarem o mesmo identificador de segurança receberão o erro identifier blocked. Atualmente, a OpenAI não pode desbloquear um identificador individual.

Para que esses bloqueios sejam eficazes, garanta que existam controles para impedir que usuários bloqueados criem uma nova conta. Lembre-se de que violações repetidas das políticas por parte da sua organização podem levar à perda de acesso para toda a organização.

Por que estamos fazendo isso

Os critérios específicos para aplicação dessas medidas podem mudar conforme o uso real evolui ou novos modelos são lançados. Atualmente, a OpenAI pode restringir ou bloquear o acesso de identificadores de segurança associados a atividades de risco ou suspeitas nas áreas de biologia ou química. Consulte a publicação no blog para saber mais sobre como estamos lidando com o avanço das capacidades da IA em biologia.

Outros tipos de verificações de segurança

Para conhecer as medidas de proteção específicas para ferramentas e personalização de modelos, consulte confirmação e consentimento no uso do computador e segurança no ajuste fino. A OpenAI também publica resultados na central de avaliações de modelos.