Der Ultrafast-Modus ist die schnellste Servicestufe der OpenAI API. Er ist für GPT-6 Astra und GPT-6.1 Sol allgemein verfügbar. Nutze ihn, wenn die kürzere Antwortzeit die höheren Kosten rechtfertigt.
Wir empfehlen ausdrücklich WebSockets, besonders für agentenbasierte Anwendungen, die viele Tool-Aufrufe in kurzer Folge ausführen. Ohne dauerhafte Verbindung kann der zusätzliche Netzwerkaufwand den Latenzvorteil schmälern.
Alle, die die API nutzen, haben Zugriff auf den Ultrafast-Modus für GPT-6 Astra und GPT-6.1 Sol.
Für Ultrafast gelten eigene Ratenlimits, unabhängig vom Standardmodus und vom Schnellmodus.
Prüfe die Limits deiner Organisation, bevor du das Anfragevolumen erhöhst.
Wenn deine Organisation mit einem Account-Team von OpenAI zusammenarbeitet, wende dich an dieses Team, um höhere Ratenlimits zu beantragen.
Setze model auf gpt-6-astra oder gpt-6.1-sol und service_tier auf ultrafast. Gib beide Werte in jedem response.create-Ereignis an.
Installiere das SDK für deine Programmiersprache und die WebSocket-Abhängigkeiten wie im Abschnitt Verbindung herstellen und Antworten erstellen beschrieben. Setze OPENAI_API_KEY in deiner Umgebung, bevor du das Beispiel ausführst.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53// Install: npm install openai ws
// Set OPENAI_API_KEY in your environment.
import OpenAI from "openai";
import { ResponsesWS } from "openai/resources/responses/ws";
const client = new OpenAI();
const ws = new ResponsesWS(client);
let previousResponseId = null;
try {
for (const input of [
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red.",
]) {
let completed = false;
const events = ws.stream();
ws.send({
type: "response.create",
model: "gpt-6-astra",
service_tier: "ultrafast",
previous_response_id: previousResponseId,
input,
});
for await (const event of events) {
if (event.type === "error") throw event.error;
if (event.type !== "message") continue;
const message = event.message;
if (message.type === "response.output_text.delta") {
process.stdout.write(message.delta);
} else if (message.type === "response.completed") {
previousResponseId = message.response.id;
completed = true;
console.log();
break;
} else if (
message.type === "response.failed" ||
message.type === "response.incomplete"
) {
throw new Error(JSON.stringify(message));
}
}
if (!completed) {
throw new Error("Connection closed before the response finished.");
}
}
} finally {
ws.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34# Install: pip install --upgrade "openai[realtime]"
# Set OPENAI_API_KEY in your environment.
from openai import OpenAI
client = OpenAI()
previous_response_id: str | None = None
prompts = [
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red.",
]
with client.responses.connect() as connection:
for prompt in prompts:
connection.response.create(
model="gpt-6-astra",
service_tier="ultrafast",
store=False, # Keep this conversation on the current connection.
previous_response_id=previous_response_id,
input=prompt,
)
for event in connection:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
elif event.type == "response.completed":
previous_response_id = event.response.id
print()
break
elif event.type in {"response.failed", "response.incomplete", "error"}:
raise RuntimeError(event.to_json())
else:
raise RuntimeError("Connection closed before the response finished.")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56package main
import (
"context"
"fmt"
"time"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
client := openai.NewClient()
conn, err := client.Responses.Connect(ctx, responses.ResponseConnectionOptions{})
if err != nil {
panic(err)
}
defer conn.Close()
previousResponseID := ""
for _, prompt := range []string{
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red.",
} {
request := responses.ResponsesClientEventResponseCreateParam{
Model: "gpt-6-astra",
ServiceTier: "ultrafast",
Input: responses.ResponsesClientEventResponseCreateInputUnionParam{
OfString: openai.String(prompt),
},
}
if previousResponseID != "" {
request.PreviousResponseID = openai.String(previousResponseID)
}
if err := conn.Create(ctx, request); err != nil {
panic(err)
}
// FinalResponse reads events until the response finishes.
response, err := conn.FinalResponse(ctx)
if err != nil {
panic(err)
}
if response.Status != responses.ResponseStatusCompleted {
panic(fmt.Sprintf("Response ended with status %s", response.Status))
}
previousResponseID = response.ID
fmt.Println(response.OutputText())
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseStatus;
import com.openai.models.responses.ResponsesClientEvent;
import java.util.List;
var client = OpenAIOkHttpClient.fromEnv();
try (var connection = client.responses().connect()) {
String previousResponseId = null;
for (var prompt :
List.of(
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red.")) {
var request =
ResponsesClientEvent.ResponseCreate.builder()
.model("gpt-6-astra")
.serviceTier(ResponsesClientEvent.ResponseCreate.ServiceTier.ULTRAFAST)
.input(prompt);
if (previousResponseId != null) {
request.previousResponseId(previousResponseId);
}
connection.send(ResponsesClientEvent.ofResponseCreate(request.build()));
var response = connection.finalResponse();
if (response.status().filter(ResponseStatus.COMPLETED::equals).isEmpty()) {
throw new IllegalStateException(
"Response ended with status " + response.status().orElse(null));
}
previousResponseId = response.id();
response.output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(text -> System.out.println(text.text()));
}
} finally {
client.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41# Install: gem install openai async-websocket
# Set OPENAI_API_KEY in your environment.
require "async"
require "openai"
client = OpenAI::Client.new
request = {
model: "gpt-6-astra",
service_tier: :ultrafast
}
prompts = [
"Explain why the sky is blue in one sentence.",
"Now explain why sunsets look red."
]
Sync do |task|
task.with_timeout(120) do
client.responses.connect(request_options: { timeout: 10 }) do |connection|
prompts.each do |prompt|
connection.response.create(**request, input: prompt)
loop do
event = connection.receive
raise "Connection closed before the response finished" unless event
case event
when OpenAI::Responses::ResponseCompletedEvent
request[:previous_response_id] = event.response.id
puts(event.response.output_text)
break
when OpenAI::Responses::ResponseFailedEvent, OpenAI::Responses::ResponseIncompleteEvent,
OpenAI::Responses::ResponsesServerEvent::ResponseWsError
raise "Response failed: #{event.to_json}"
end
end
end
end
end
end
Die Beispiele senden zwei Anfragen über dieselbe Verbindung und geben jede Antwort aus. Die Beispiele für Go, Java und Ruby warten mit der Ausgabe, bis die jeweilige Antwort vollständig vorliegt. Die zweite Anfrage enthält den neuen Prompt und übergibt die ID der ersten Antwort als previous_response_id. Nutze dieselbe Verbindung für weitere Gesprächsrunden und zum Übermitteln von Tool-Ergebnissen. Mehr dazu findest du im Abschnitt Mit inkrementellen Eingaben fortfahren.
Ultrafast unterstützt auch HTTP-Anfragen über das SDK. Verwende für agentenbasierte Anwendungen mit häufigen Tool-Aufrufen eine dauerhafte WebSocket-Verbindung, um den Netzwerkaufwand zwischen Anfragen zu verringern.
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-6-astra",
service_tier: "ultrafast",
input: "Explain why the sky is blue in one sentence.",
});
console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
input="Explain why the sky is blue in one sentence.",
service_tier="ultrafast",
)
print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24package 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-6-astra",
ServiceTier: responses.ResponseNewParamsServiceTierUltrafast,
Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Explain why the sky is blue in one sentence.")},
})
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-6-astra")
.input("Explain why the sky is blue in one sentence.")
.serviceTier(ResponseCreateParams.ServiceTier.ULTRAFAST)
.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
10
11require "openai"
client = OpenAI::Client.new
response = client.responses.create(
model: "gpt-6-astra",
service_tier: :ultrafast,
input: "Explain why the sky is blue in one sentence."
)
puts(response.output_text)
1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6-astra",
"input": "Explain why the sky is blue in one sentence.",
"service_tier": "ultrafast"
}'
Dieses Beispiel wartet, bis die Antwort vollständig vorliegt. Aktiviere Streaming, um die Ausgabe schon während des Empfangs anzuzeigen.
Für GPT-6.1 Sol gelten im Ultrafast-Modus standardmäßig folgende Ratenlimits für Token:
| API-Nutzungsstufe |
Token pro Minute (TPM) |
| Build |
1.000.000 |
| Launch |
4.000.000 |
| Grow |
40.000.000 |
Für GPT-6 Astra gelten im Ultrafast-Modus standardmäßig folgende Ratenlimits für Token:
| API-Nutzungsstufe |
Token pro Minute (TPM) |
| Build |
500.000 |
| Launch |
1.000.000 |
| Grow |
5.000.000 |
In der Preistabelle für Ultrafast findest du die Preise für Eingaben, zwischengespeicherte Eingaben, Schreibvorgänge im Cache und Ausgaben.
GPT-6.1 Sol unterstützt im Ultrafast-Modus Datenresidenz in den USA und in der EU sowie die globale Verarbeitung. Bei GPT-6 Astra unterstützt der Ultrafast-Modus ausschließlich Datenresidenz in den USA und die globale Verarbeitung.