Classificateurs de sécurité

Avec le lancement de GPT-5, nous avons ajouté des contrôles pour détecter les informations dangereuses et en bloquer l’accès. Certains utilisateurs tenteront probablement un jour d’utiliser votre application à des fins contraires aux politiques d’OpenAI, surtout si elle couvre un large éventail de cas d’utilisation.

Fonctionnement des classificateurs de sécurité

1. Nous classons les requêtes adressées à GPT-5 selon des seuils de risque.
2. Si votre organisation atteint à plusieurs reprises des seuils de risque élevés, OpenAI renvoie une erreur et envoie un e-mail d’avertissement.
3. Si ces requêtes se poursuivent au-delà du délai indiqué (généralement sept jours), nous supprimons l’accès de votre organisation à GPT-5. Les requêtes ne fonctionneront plus.

Comment éviter les erreurs, la latence et les blocages

Si votre organisation se livre à des activités suspectes qui enfreignent nos politiques de sécurité, nous pouvons renvoyer une erreur, limiter l’accès aux modèles, voire bloquer votre compte. Les mesures de sécurité suivantes nous aident à identifier l’origine des requêtes à haut risque et à bloquer les utilisateurs finaux concernés plutôt que l’ensemble de votre organisation.

• Mettez en place des identifiants de sécurité pour les produits dans lesquels des utilisateurs interagissent individuellement avec un modèle. Les identifiants de sécurité sont recommandés, mais ne sont pas obligatoires.
• Si votre cas d’utilisation nécessite l’accès à une version moins restreinte de nos services pour des applications bénéfiques dans les sciences de la vie, consultez notre programme d’accès spécial pour vérifier si vous remplissez les critères.

Mise en place d’identifiants de sécurité pour chaque utilisateur

Le paramètre safety_identifier est disponible dans l’API Responses et dans l’ancienne API Chat Completions. La Realtime API prend en charge le même principe au moyen de l’en-tête OpenAI-Safety-Identifier. Pour utiliser les identifiants de sécurité, fournissez un identifiant stable pour votre utilisateur final à chaque requête. Hachez les adresses e-mail ou les identifiants internes des utilisateurs pour éviter de transmettre des informations personnelles.

Les identifiants de sécurité ne sont pas transmis automatiquement d’une API ou d’une session à l’autre. Si votre application envoie déjà safety_identifier avec les requêtes à l’API Responses, transmettez séparément la même valeur stable lors de la création de chaque session Realtime ou de la connexion à celle-ci.

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

Conséquences possibles

Si les systèmes de surveillance d’OpenAI détectent un abus potentiel, nous pouvons prendre des mesures à différents niveaux :

• Réponses en streaming retardées
  • Comme première mesure aux conséquences limitées pour un utilisateur susceptible d’enfreindre les politiques, OpenAI peut retarder les réponses en streaming afin d’effectuer des contrôles supplémentaires avant de lui renvoyer la réponse complète.
  • Si le contrôle réussit, le streaming commence. S’il échoue, la requête s’arrête : aucun token ne s’affiche et la réponse en streaming ne démarre pas.
  • Pour améliorer l’expérience des utilisateurs finaux, envisagez d’ajouter un indicateur de chargement animé lorsque le streaming est retardé.
• Accès aux modèles bloqué pour certains utilisateurs
  • Lorsqu’une violation des politiques est détectée avec un degré de confiance élevé, tout accès aux modèles OpenAI est bloqué pour le safety_identifier associé.
  • Toutes les requêtes ultérieures à GPT-5 utilisant le même identifiant de sécurité reçoivent une erreur identifier blocked. OpenAI ne peut actuellement pas débloquer un identifiant individuel.

Pour que ces blocages soient efficaces, assurez-vous d’avoir mis en place des contrôles empêchant les utilisateurs bloqués de créer un nouveau compte. Pour rappel, des violations répétées des politiques au sein de votre organisation peuvent entraîner la perte d’accès pour l’ensemble de celle-ci.

Pourquoi nous prenons ces mesures

Les critères précis d’application de ces mesures peuvent changer en fonction de l’évolution des usages réels ou du lancement de nouveaux modèles. Actuellement, OpenAI peut restreindre ou bloquer l’accès pour les identifiants de sécurité associés à des activités risquées ou suspectes en biologie ou en chimie. Consultez l’article de blog pour en savoir plus sur notre approche face aux capacités croissantes de l’IA en biologie.

Autres types de contrôles de sécurité

Pour les mesures de protection propres aux outils et à la personnalisation des modèles, consultez les sections sur la confirmation et le consentement pour l’utilisation de l’ordinateur et la sécurité de l’affinage. OpenAI publie également des résultats dans le centre d’évaluation des modèles.