Sicherheitsklassifikatoren

Mit der Einführung von GPT-5 haben wir Prüfungen hinzugefügt, um Zugriffe auf gefährliche Informationen zu erkennen und zu unterbinden. Wahrscheinlich werden einige Nutzende irgendwann versuchen, deine Anwendung für Zwecke einzusetzen, die gegen die Richtlinien von OpenAI verstoßen. Das gilt besonders für Anwendungen mit vielfältigen Einsatzmöglichkeiten.

So funktioniert die Sicherheitsklassifizierung

1. Wir stufen Anfragen an GPT-5 anhand von Risikoschwellenwerten ein.
2. Wenn deine Organisation wiederholt hohe Schwellenwerte erreicht, gibt OpenAI einen Fehler zurück und sendet eine Warnung per E-Mail.
3. Wenn solche Anfragen nach Ablauf der angegebenen Frist (in der Regel sieben Tage) fortgesetzt werden, sperren wir den Zugriff deiner Organisation auf GPT-5. Anfragen funktionieren dann nicht mehr.

So vermeidest du Fehler, Latenz und Sperren

Wenn deine Organisation durch verdächtige Aktivitäten gegen unsere Sicherheitsrichtlinien verstößt, können wir einen Fehler zurückgeben, den Modellzugriff einschränken oder sogar dein Konto sperren. Die folgenden Sicherheitsmaßnahmen helfen uns, die Herkunft von Anfragen mit hohem Risiko zu ermitteln und einzelne Nutzende zu sperren, statt deine gesamte Organisation zu blockieren.

• Implementiere Sicherheitskennungen für Produkte, in denen einzelne Nutzende mit einem Modell interagieren. Sicherheitskennungen werden empfohlen, sind aber nicht vorgeschrieben.
• Wenn du für nützliche Anwendungen in den Biowissenschaften auf eine weniger eingeschränkte Version unserer Dienste angewiesen bist, informiere dich über unser Programm für Sonderzugang, um zu prüfen, ob du die Kriterien erfüllst.

Sicherheitskennungen für einzelne Nutzende implementieren

Der Parameter safety_identifier ist sowohl in der Responses API als auch in der älteren Chat Completions API verfügbar. Die Realtime API unterstützt dasselbe Konzept über den Header OpenAI-Safety-Identifier. Um Sicherheitskennungen zu verwenden, übergib bei jeder Anfrage eine gleichbleibende ID für die jeweilige Person. Verwende Hashwerte von E-Mail-Adressen oder internen Nutzer-IDs, um keine personenbezogenen Daten zu übermitteln.

Sicherheitskennungen werden nicht zwischen APIs oder Sitzungen übernommen. Wenn deine Anwendung bereits safety_identifier bei Anfragen an die Responses API sendet, übergib denselben gleichbleibenden Wert separat beim Erstellen jeder Realtime-Sitzung oder beim Verbindungsaufbau mit ihr.

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

Mögliche Konsequenzen

Wenn die Überwachungssysteme von OpenAI möglichen Missbrauch erkennen, können wir unterschiedlich weitreichende Maßnahmen ergreifen:

• Verzögerte Streaming-Antworten
  • Wenn eine Person möglicherweise gegen Richtlinien verstößt, kann OpenAI als erste Maßnahme mit geringeren Auswirkungen Streaming-Antworten verzögern. Dabei führen wir zusätzliche Prüfungen durch, bevor wir die vollständige Antwort an diese Person zurückgeben.
  • Wenn die Prüfung bestanden wird, beginnt das Streaming. Andernfalls wird die Anfrage abgebrochen: Es erscheinen keine Token, und die Streaming-Antwort beginnt nicht.
  • Für eine bessere Nutzungserfahrung kannst du eine Ladeanimation für Fälle hinzufügen, in denen sich das Streaming verzögert.
• Gesperrter Modellzugriff für einzelne Nutzende
  • Wenn ein Richtlinienverstoß mit hoher Sicherheit festgestellt wird, wird der Zugriff auf OpenAI-Modelle für den zugehörigen safety_identifier vollständig gesperrt.
  • Bei allen zukünftigen GPT-5-Anfragen mit derselben Sicherheitskennung wird der Fehler identifier blocked zurückgegeben. OpenAI kann derzeit keine einzelnen Kennungen entsperren.

Damit diese Sperren wirksam sind, stelle sicher, dass du Maßnahmen implementiert hast, die gesperrte Personen daran hindern, ein neues Konto zu eröffnen. Zur Erinnerung: Wiederholte Richtlinienverstöße aus deiner Organisation können dazu führen, dass die gesamte Organisation ihren Zugriff verliert.

Warum wir das tun

Die konkreten Kriterien für diese Maßnahmen können sich ändern, wenn sich die tatsächliche Nutzung weiterentwickelt oder neue Modelle veröffentlicht werden. Derzeit kann OpenAI den Zugriff für Sicherheitskennungen einschränken oder sperren, die mit riskanten oder verdächtigen Aktivitäten im Bereich Biologie oder Chemie verbunden sind. Im Blogbeitrag erfährst du mehr darüber, wie wir mit den zunehmenden Fähigkeiten von KI in der Biologie umgehen.

Weitere Arten von Sicherheitsprüfungen

Schutzmaßnahmen speziell für Tools und Modellanpassungen findest du unter Bestätigung und Einwilligung bei der Computernutzung und Sicherheit beim Fine-Tuning. OpenAI veröffentlicht außerdem Ergebnisse im Hub für Modellevaluierungen.