Clasificadores de seguridad

Con la llegada de GPT-5, agregamos algunas comprobaciones para detectar y bloquear el acceso a información peligrosa. Es probable que algunos usuarios intenten usar tu aplicación para fines que infrinjan las políticas de OpenAI, especialmente en aplicaciones con una amplia variedad de casos de uso.

El proceso de los clasificadores de seguridad

1. Clasificamos las solicitudes a GPT-5 según umbrales de riesgo.
2. Si tu organización alcanza repetidamente umbrales altos, OpenAI devuelve un error y envía un correo electrónico de advertencia.
3. Si las solicitudes continúan después del plazo indicado (generalmente siete días), suspendemos el acceso de tu organización a GPT-5. Las solicitudes dejarán de funcionar.

Cómo evitar errores, latencia y bloqueos

Si tu organización realiza actividades sospechosas que infringen nuestras políticas de seguridad, podemos devolver un error, limitar el acceso a los modelos o incluso bloquear tu cuenta. Las siguientes medidas de seguridad nos ayudan a identificar de dónde provienen las solicitudes de alto riesgo y a bloquear a usuarios finales específicos, en lugar de bloquear a toda tu organización.

• Implementa identificadores de seguridad en productos donde los usuarios interactúan de forma individual con un modelo. Los identificadores de seguridad son recomendables, pero no obligatorios.
• Si tu caso de uso requiere acceder a una versión de nuestros servicios con menos restricciones para desarrollar aplicaciones beneficiosas en las ciencias de la vida, consulta nuestro programa de acceso especial para saber si cumples con los criterios.

Implementar identificadores de seguridad para usuarios individuales

El parámetro safety_identifier está disponible tanto en la API Responses como en la API para completar chats, que es anterior. La Realtime API admite el mismo concepto mediante el encabezado OpenAI-Safety-Identifier. Para usar identificadores de seguridad, proporciona un ID estable de tu usuario final en cada solicitud. Aplica una función hash al correo electrónico del usuario o a sus ID internos para evitar enviar información personal.

Los identificadores de seguridad no se transfieren entre API ni entre sesiones. Si tu aplicación ya envía safety_identifier en las solicitudes a la API Responses, pasa el mismo valor estable por separado al crear o conectar cada sesión de Realtime.

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

Posibles consecuencias

Si los sistemas de monitoreo de OpenAI identifican un posible abuso, podemos tomar medidas de distintos niveles:

• Demoras en las respuestas en streaming
  • Como intervención inicial de menor impacto ante un usuario que podría estar infringiendo las políticas, OpenAI puede retrasar las respuestas en streaming mientras realiza comprobaciones adicionales antes de devolver la respuesta completa a ese usuario.
  • Si se supera la comprobación, comienza el streaming. Si no se supera, la solicitud se detiene: no aparece ningún token y la respuesta en streaming no comienza.
  • Para mejorar la experiencia del usuario final, considera agregar un indicador de carga giratorio para los casos en que se retrase el streaming.
• Bloqueo del acceso a los modelos para usuarios individuales
  • Cuando se detecta una infracción de las políticas con un alto grado de confianza, se bloquea por completo el acceso a los modelos de OpenAI para el safety_identifier asociado.
  • El identificador de seguridad recibe un error identifier blocked en todas las solicitudes futuras a GPT-5 que usen ese mismo identificador. Actualmente, OpenAI no puede desbloquear un identificador individual.

Para que estos bloqueos sean eficaces, asegúrate de contar con controles que impidan que los usuarios bloqueados abran una cuenta nueva. Recuerda que las infracciones reiteradas de las políticas por parte de tu organización pueden provocar la pérdida de acceso para toda la organización.

Por qué tomamos estas medidas

Los criterios específicos para aplicar estas medidas pueden cambiar según evolucione el uso en el mundo real o se lancen nuevos modelos. Actualmente, OpenAI puede restringir o bloquear el acceso de los identificadores de seguridad asociados con actividades riesgosas o sospechosas en biología o química. Consulta la publicación del blog para obtener más información sobre cómo abordamos las capacidades cada vez mayores de la IA en biología.

Otros tipos de comprobaciones de seguridad

Para conocer las medidas de protección específicas de las herramientas y la personalización de modelos, consulta confirmación y consentimiento para el uso de la computadora y seguridad del ajuste fino. OpenAI también publica resultados en el centro de evaluaciones de modelos.