Classifieurs 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. Il est probable que certains utilisateurs finissent par essayer d’utiliser votre application à des fins contraires aux règles d’OpenAI, surtout si elle se prête à de nombreux usages.

Fonctionnement des classifieurs de sécurité

1. Nous classons les requêtes adressées à GPT-5 selon leur niveau de risque.
2. Si les requêtes de votre organisation atteignent à plusieurs reprises un seuil de risque élevé, OpenAI renvoie une erreur et vous 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 bloquons l’accès de votre organisation à GPT-5. Ses requêtes à GPT-5 échoueront alors systématiquement.

Comment éviter les erreurs, les délais de réponse et les blocages

Si votre organisation se livre à des activités suspectes qui enfreignent nos règles de sécurité, nous pouvons renvoyer une erreur, restreindre l’accès aux modèles, voire bloquer votre compte. Les mesures de sécurité suivantes nous aident à déterminer l’origine des requêtes à haut risque et à limiter le blocage aux utilisateurs finaux concernés pour que le reste de votre organisation conserve son accès.

• Mettez en place des identifiants de sécurité dans les produits où les utilisateurs interagissent individuellement avec un modèle. Ces identifiants sont recommandés, mais facultatifs.
• Si vous avez besoin d’une version moins restrictive de nos services pour développer des applications bénéfiques dans le domaine des 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’un identifiant de sécurité pour chaque utilisateur

Pour transmettre les avertissements et les avis de désactivation associés à un identifiant de sécurité à votre workflow d’investigation ou d’assistance, consultez la documentation sur les notifications relatives à l’application des règles de sécurité.

Le paramètre safety_identifier est disponible dans l’API Responses, l’API Chat Completions et l’API Images. La Realtime API prend également en charge les identifiants de sécurité via l’en-tête OpenAI-Safety-Identifier. Pour utiliser ces identifiants, transmettez dans chaque requête un identifiant stable propre à l’utilisateur final. Hachez son adresse e-mail ou son identifiant interne 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 dans ses requêtes à l’API Responses, transmettez cette même valeur stable dans chaque requête à l’API Images, ainsi qu’à chaque création de session Realtime ou connexion à une session Realtime.

Pour l’API Images, incluez safety_identifier dans chaque requête de génération d’images ou de modification d’images. Limitez l’identifiant à 128 caractères. Consultez la documentation sur les identifiants de sécurité pour les images pour savoir comment remplacer le paramètre obsolète 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"
}
}'

Conséquences possibles

Si les systèmes de surveillance d’OpenAI détectent un abus potentiel, nous pouvons prendre des mesures plus ou moins restrictives.

• Retard de la diffusion en continu des réponses
  • Si un utilisateur semble enfreindre les règles, OpenAI peut, dans un premier temps, retarder la diffusion de la réponse. Cette mesure de portée limitée permet d’effectuer des contrôles supplémentaires avant de transmettre la réponse complète à l’utilisateur.
  • Si la requête passe le contrôle, la diffusion commence. Dans le cas contraire, le traitement de la requête s’arrête. Aucun token ne s’affiche et la diffusion ne démarre pas.
  • Pour améliorer l’expérience de l’utilisateur final, envisagez d’afficher un indicateur de chargement animé lorsque la diffusion tarde à démarrer.
• Blocage de l’accès aux modèles pour certains utilisateurs
  • Si OpenAI estime avec un degré de confiance élevé qu’une requête enfreint ses règles, OpenAI bloque tout accès à ses modèles pour le safety_identifier associé.
  • Toute requête ultérieure adressée à GPT-5 avec cet identifiant de sécurité renvoie l’erreur identifier blocked. OpenAI ne peut actuellement pas débloquer un identifiant individuel.

Pour que ces blocages soient efficaces, mettez en place des contrôles qui empêchent les utilisateurs bloqués d’ouvrir un nouveau compte. Pour rappel, des infractions répétées aux règles au sein de votre organisation peuvent entraîner la perte d’accès pour l’ensemble de l’organisation.

Pourquoi nous appliquons ces mesures

Les critères d’application de ces mesures peuvent évoluer avec les usages observés en pratique ou la sortie de nouveaux modèles. Actuellement, OpenAI peut restreindre ou bloquer l’accès pour les identifiants de sécurité associés à des activités à risque ou suspectes en biologie ou en chimie. Consultez notre article de blog pour en savoir plus sur la façon dont nous nous préparons aux progrès de l’IA en biologie.

Autres types de contrôles de sécurité

Pour connaître les mesures de protection propres aux outils et à la personnalisation des modèles, consultez les sections sur la confirmation et le consentement lors de l’utilisation de l’ordinateur et sur la sécurité du fine-tuning. OpenAI publie également des résultats sur son portail d’évaluation des modèles.