Clasificadores de seguridad

Con el lanzamiento de GPT-5, incorporamos controles para detectar información peligrosa e impedir el acceso a ella. Es probable que, en algún momento, algunos usuarios intenten usar tu aplicación para fines que infrinjan las políticas de OpenAI, sobre todo si la aplicación admite una amplia variedad de casos de uso.

Cómo funcionan los clasificadores de seguridad

1. Clasificamos las solicitudes a GPT-5 según su nivel de riesgo.
2. Si las solicitudes de tu organización alcanzan repetidamente los umbrales de riesgo alto, OpenAI devuelve un error y envía una advertencia por correo electrónico.
3. Si las solicitudes continúan después del plazo indicado (por lo general, siete días), bloqueamos el acceso de tu organización a GPT-5. Las solicitudes dejarán de funcionar.

Cómo evitar errores, demoras 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 los usuarios finales responsables sin bloquear a toda tu organización.

• Implementa identificadores de seguridad en los productos donde los usuarios interactúan individualmente con un modelo. Recomendamos usar estos identificadores, aunque son opcionales.
• Si tu caso de uso requiere una versión de nuestros servicios con menos restricciones para desarrollar aplicaciones beneficiosas en el campo de las ciencias de la vida, consulta nuestro programa de acceso especial para saber si cumples con los requisitos.

Cómo implementar identificadores de seguridad para usuarios individuales

Para dirigir los avisos de advertencia y desactivación asociados a un identificador de seguridad a tu flujo de trabajo de investigación o soporte, consulta las notificaciones sobre la aplicación de las políticas de seguridad.

El parámetro safety_identifier está disponible en la API de respuestas, la API para completar chats y la API de imágenes. La Realtime API admite el mismo mecanismo mediante el encabezado OpenAI-Safety-Identifier. Para usar identificadores de seguridad, incluye en cada solicitud un identificador estable del usuario final. Aplica una función hash a la dirección de correo electrónico o al identificador interno del usuario para evitar enviar datos personales.

Los identificadores de seguridad no se transfieren de una API a otra ni de una sesión a otra. Si tu aplicación ya envía safety_identifier en las solicitudes a la API de respuestas, envía ese mismo valor estable por separado en cada solicitud a la API de imágenes y cada vez que crees una sesión de Realtime o te conectes a ella.

En la API de imágenes, incluye safety_identifier en cada solicitud de generación o edición de imágenes. Usa un identificador de hasta 128 caracteres. Consulta la guía de identificadores de seguridad para imágenes para saber cómo migrar desde el 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"
}
}'

Posibles consecuencias

Si los sistemas de monitoreo de OpenAI detectan un posible uso indebido, podemos tomar medidas de distinta intensidad:

• Demora en la transmisión de respuestas
  • Si hay indicios de que un usuario infringe las políticas, OpenAI puede, como medida inicial de menor impacto, retrasar la transmisión mientras realiza comprobaciones adicionales antes de devolverle la respuesta completa.
  • Si la solicitud supera la comprobación, comienza la transmisión. Si no la supera, la solicitud se detiene. No aparece ningún token ni comienza la transmisión de la respuesta.
  • Para mejorar la experiencia del usuario final, considera mostrar un indicador de carga cuando se retrase la transmisión.
• Bloqueo del acceso a los modelos para usuarios individuales
  • Si OpenAI determina con un alto grado de certeza que se infringieron las políticas, bloquea por completo el acceso a sus modelos para el safety_identifier asociado.
  • Todas las solicitudes posteriores a GPT-5 que usen ese mismo identificador de seguridad recibirán el error identifier blocked. Actualmente, OpenAI no puede desbloquear un identificador individual.

Para que estos bloqueos sean efectivos, asegúrate de contar con controles que impidan que los usuarios bloqueados creen una cuenta nueva. Recuerda que, si tu organización infringe las políticas repetidamente, toda la organización puede perder el acceso.

Por qué tomamos estas medidas

Los criterios específicos para aplicar estas medidas pueden cambiar a medida que evolucione el uso de los modelos en la práctica o se lancen nuevos modelos. Actualmente, OpenAI puede restringir o bloquear el acceso de los identificadores de seguridad asociados a actividades de riesgo o sospechosas en los campos de la biología o la química. Consulta la publicación del blog para obtener más información sobre cómo abordamos los avances en las capacidades de la IA en biología.

Otros tipos de controles de seguridad

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