Classificadores de segurança

Com o lançamento do GPT-5, adicionamos verificações para identificar informações perigosas e impedir o acesso a elas. É provável que, em algum momento, alguns usuários tentem usar seu aplicativo para fins que violem as políticas da OpenAI, especialmente se ele atender a muitos casos de uso.

Como funciona a classificação de segurança

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

Como evitar erros, latência e bloqueios

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 restringir o bloqueio aos usuários finais responsáveis, sem bloquear toda a organização.

• Implemente identificadores de segurança em produtos nos quais cada usuário interage com um modelo. Recomendamos o uso desses identificadores, mas eles são opcionais.
• Se seu caso de uso depende de uma versão dos nossos serviços com menos restrições para desenvolver aplicações benéficas na área de ciências da vida, consulte nosso programa de acesso especial e verifique se você atende aos critérios.

Como implementar identificadores de segurança por usuário

Para encaminhar advertências e avisos de desativação associados a um identificador de segurança ao seu fluxo de investigação ou suporte, consulte Notificações sobre medidas de segurança.

O parâmetro safety_identifier está disponível na API Responses, na API chat completions e na API de imagens. A Realtime API também aceita identificadores de segurança por meio do cabeçalho OpenAI-Safety-Identifier. Para usar esse recurso, envie em cada solicitação um ID estável para o usuário final. Use um hash do endereço de e-mail ou do ID interno do usuário para evitar o envio de informações pessoais.

Os identificadores de segurança não são compartilhados automaticamente entre APIs ou sessões. Se seu aplicativo já envia safety_identifier nas solicitações à API Responses, envie o mesmo valor estável separadamente em cada solicitação à API de imagens e sempre que criar uma sessão da Realtime API ou se conectar a ela.

Na API de imagens, inclua safety_identifier em cada solicitação de geração ou edição de imagens. Use no máximo 128 caracteres no identificador. Consulte as orientações sobre identificadores de segurança para imagens para saber como migrar do parâmetro obsoleto user.

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 um possível abuso, poderemos tomar medidas de diferentes níveis de rigor.

• Atraso no início das respostas em streaming
  • Se houver indícios de que um usuário está violando as políticas, a OpenAI poderá, como medida inicial de menor impacto, adiar o início do streaming enquanto realiza verificações adicionais antes de enviar a resposta completa ao usuário.
  • Se a solicitação passar pela verificação, o streaming começará. Se ela falhar na verificação, o processamento será interrompido. Nenhum token será exibido e o streaming da resposta não começará.
  • Para melhorar a experiência do usuário final, considere exibir um indicador de carregamento quando houver atraso no início do streaming.
• Bloqueio do acesso aos modelos para usuários específicos
  • Quando a OpenAI identifica com alto grau de confiança uma violação das políticas, ela bloqueia totalmente o acesso aos seus modelos para o safety_identifier associado.
  • Todas as solicitações futuras ao GPT-5 que usarem esse 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, implemente controles que impeçam usuários bloqueados de abrir uma nova conta. Lembre-se de que violações repetidas das políticas por parte da sua organização podem resultar na perda de acesso para toda a organização.

Por que adotamos essas medidas

Os critérios específicos para aplicar essas medidas podem mudar conforme o uso dos modelos evolui na prática 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 como estamos lidando com o avanço das capacidades da IA na biologia.

Outros tipos de verificação de segurança

Para conhecer as medidas de proteção específicas para ferramentas e personalização de modelos, consulte as orientações sobre 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.