Ultrafast 모드 | OpenAI API

Ultrafast 모드는 OpenAI API에서 가장 빠른 서비스 등급입니다. 모든 API 사용자가 GPT-6 Astra와 GPT-6.1 Sol에서 사용할 수 있습니다. 추가 비용을 들일 만큼 응답 속도가 중요한 작업에 사용하세요.

WebSocket 사용을 적극 권장합니다. 특히 짧은 시간에 도구를 여러 번 연속으로 호출하는 에이전트 애플리케이션에 적합합니다. 연결을 유지하지 않으면 네트워크 오버헤드로 인해 지연 시간 단축 효과가 줄어들 수 있습니다.

모든 API 사용자가 GPT-6 Astra와 GPT-6.1 Sol에서 Ultrafast 모드를 사용할 수 있습니다. Ultrafast 모드에는 표준 모드 및 패스트 모드와 별도의 요청 한도가 적용됩니다. 트래픽을 늘리기 전에 조직의 요청 한도를 확인하세요. 조직에 OpenAI 계정 담당 팀이 있다면 해당 팀에 연락해 요청 한도를 높여 달라고 요청하세요.

요청 구성

model을 gpt-6-astra 또는 gpt-6.1-sol로, service_tier를 ultrafast로 설정하세요. 이 설정은 각 response.create 이벤트에 포함해야 합니다.

연결 및 응답 생성의 안내에 따라 사용하는 언어에 맞는 SDK와 WebSocket 종속성을 설치하세요. 예제를 실행하기 전에 환경 변수 OPENAI_API_KEY를 설정하세요.

하나의 WebSocket 연결에서 여러 턴에 걸쳐 Ultrafast 사용하기

Python

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

이 예제에서는 같은 연결로 요청 두 개를 보내고 각 응답을 출력합니다. Go, Java, Ruby 예제에서는 응답을 모두 받은 후 출력합니다. 두 번째 요청에서는 새 프롬프트를 보내면서 첫 번째 응답의 ID를 previous_response_id로 전달합니다. 이후 턴의 입력이나 도구 결과를 보낼 때도 같은 연결을 사용하세요. 자세한 내용은 새 입력만 보내 대화 이어가기를 참고하세요.

HTTP로 요청하기

Ultrafast는 SDK를 통한 HTTP 요청도 지원합니다. 도구를 자주 호출하는 에이전트 애플리케이션에서는 WebSocket 연결을 유지해 요청 사이에 발생하는 오버헤드를 줄이세요.

HTTP로 Ultrafast 응답 생성하기

Python

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

이 예제에서는 응답을 모두 받을 때까지 기다립니다. 출력을 받는 즉시 표시하려면 스트리밍을 활성화하세요.

사용 가능 범위

GPT-6.1 Sol의 Ultrafast 모드에는 다음과 같은 기본 분당 토큰 한도가 적용됩니다.

API 사용 등급	분당 토큰 수(TPM)
Build	1,000,000
Launch	4,000,000
Grow	40,000,000

GPT-6 Astra의 Ultrafast 모드에는 다음과 같은 기본 분당 토큰 한도가 적용됩니다.

API 사용 등급	분당 토큰 수(TPM)
Build	500,000
Launch	1,000,000
Grow	5,000,000

입력, 캐시된 입력, 캐시 쓰기, 출력 요금은 Ultrafast 요금표에서 확인하세요.

GPT-6.1 Sol의 Ultrafast 모드는 미국 및 EU 데이터 레지던시와 글로벌 처리를 지원합니다. GPT-6 Astra의 Ultrafast 모드는 미국 데이터 레지던시와 글로벌 처리만 지원합니다.

추천

시작하기

핵심 개념

SDK 및 CLI

클라우드 제공업체

자료

레거시 API

모델 선택하기

텍스트 및 코드

프롬프트 작성

추론

이미지

실시간 처리 및 오디오

특화 모델

Agents API

Agents SDK

ChatKit

검색 및 정보 조회

도구와 데이터 연결하기

도구를 활용한 워크플로우 구축하기

컴퓨터 및 코드

미디어

GPT-Live

Realtime API

음성 기능 개발

연결

오디오 처리

서비스 출시하기

성능 및 품질

평가

비용 및 처리량

안전 및 거버넌스

인프라 및 접근 권한

운영

핵심 개념

기획

개발

테스트 및 게시

전환 명세

가이드

자료

사용자 식별

ChatGPT 요금제 사용량

가이드

파일 업로드

API

성과 측정

광고주 API

API 레퍼런스

시작하기

시작하기

기초

둘러보기

지원 플랫폼

릴리스

워크플로우

주요 기능

Sites

dot

ChatGPT 스페이스

레퍼런스

맞춤 설정

설정 파일

에이전트 설정

ChatGPT와 Codex 확장하기

Linux

Windows

개발 워크플로우

확장 및 자동화

환경

Codex Cloud

Codex로 개발하기

서드 파티 통합

레퍼런스

권한

Codex Security

사이버 안전

시작하기

기능 설정

ID 및 액세스