OpenAI API 가이드

★ GPT-5.5 시리즈 (최신 플래그십, 2026-04-23 출시):
┌──────────────────┬──────────┬──────────┬─────────────────────────────────────────┐
│ 모델             │ 입력     │ 출력     │ 특징                                    │
├──────────────────┼──────────┼──────────┼─────────────────────────────────────────┤
│ gpt-5.5          │ $5/1M    │ $30/1M   │ 최신 플래그십, 에이전트 코딩 특화       │
│ gpt-5.5-pro      │ $30/1M   │ $180/1M  │ 최고 정확도 (Responses API only)        │
└──────────────────┴──────────┴──────────┴─────────────────────────────────────────┘

GPT-5.5 벤치마크:
• SWE-bench: 88.7%  |  MMLU: 92.4%
• SWE-Bench Pro: 58.6%  |  Terminal-Bench 2.0: 82.7%
• FrontierMath Tier 4 (Pro): 39.6%
• 환각 오류: GPT-5.4 대비 60% 감소
• GPT-4.5 이후 첫 완전 재훈련 기반 모델

GPT-5.4 시리즈 (이전 플래그십, 2026-04-11 가격 기준):
┌──────────────────┬──────────┬──────────┬─────────────────────────┐
│ 모델             │ 입력     │ 출력     │ 특징                    │
├──────────────────┼──────────┼──────────┼─────────────────────────┤
│ gpt-5.4          │ $2.50/1M │ $15.00/1M│ 안정적 추론/코딩        │
│ gpt-5.4-mini     │ $0.75/1M │ $4.50/1M │ 경량, 저비용            │
│ gpt-5.4-nano     │ $0.20/1M │ $1.25/1M │ 초경량                  │
│ gpt-5.4-pro      │ $30/1M   │ $180/1M  │ 최고 성능 (Responses API only) │
└──────────────────┴──────────┴──────────┴─────────────────────────┘

참고:
• 위 표는 Standard short context 가격입니다.
• Batch/Flex는 Standard 대비 50%, Priority는 2.5× 가격입니다.
• gpt-5.5와 gpt-5.5-pro의 컨텍스트 윈도우: 1M tokens

코딩 특화:
┌──────────────────┬──────────┬──────────┬─────────────────────────┐
│ gpt-5.3-codex    │ $1.75/1M│ $14.00/1M │ 코딩 에이전트 특화      │
└──────────────────┴──────────┴──────────┴─────────────────────────┘

추론 모델 (o 시리즈):
┌──────────────────┬──────────┬──────────┬─────────────────────────┐
│ o3               │ 변동/1M │ 변동/1M   │ 최고 추론, 200K context │
│ o4-mini          │ 변동/1M │ 변동/1M   │ 경량 추론, 200K context │
└──────────────────┴──────────┴──────────┴─────────────────────────┘

딥 리서치:
┌──────────────────────────┬──────────┬──────────┬─────────────────┐
│ o3-deep-research         │ 변동/1M │ 변동/1M   │ 심층 조사 특화   │
│ o4-mini-deep-research    │ 변동/1M │ 변동/1M   │ 경량 심층 조사   │
└──────────────────────────┴──────────┴──────────┴─────────────────┘

이전 세대:
┌──────────────────┬──────────┬──────────┬─────────────────────────┐
│ gpt-4.1          │ 변동/1M │ 변동/1M   │ 1M context, 안정적      │
│ gpt-5.2          │ 변동/1M │ 변동/1M   │ Thinking/Instant 변형   │
└──────────────────┴──────────┴──────────┴─────────────────────────┘

레거시/퇴역:
┌──────────────────┬──────────┬──────────┬─────────────────────────┐
│ gpt-4o           │ 변동/1M │ 변동/1M   │ ChatGPT 2026-02-13 퇴역 │
│ o1               │ 변동/1M │ 변동/1M   │ 레거시                  │
│ gpt-3.5-turbo    │ -       │ -         │ 지원 종료               │
└──────────────────┴──────────┴──────────┴─────────────────────────┘

컨텍스트 윈도우:
• GPT-5.5 / GPT-5.5 Pro: 1M tokens
• GPT-5.4: 1M+ (short/long context 가격 구분)
• GPT-5.3-Codex: 400K tokens
• o3 / o4-mini: 200K tokens

// GPT-5.5 에이전트 기능 (2026-04-23 신규)
• 복잡한 다단계 작업 계획 수립 → 도구 사용 → 완료까지 자율 실행
• Terminal-Bench 2.0: 82.7% (복잡한 CLI 워크플로우 자동화)
• SWE-Bench Pro: 58.6% (실제 GitHub 이슈 자동 해결)
• Codex 통합: 구현, 리팩토링, 디버깅, 테스트, 검증 전 과정 처리
• 과학·기술 연구 워크플로우 성능 대폭 향상

// Chat Completions API (대화형 AI)
• 다중 턴 대화
• 시스템 메시지로 행동 제어
• 스트리밍 지원

// Responses API (차세대 API)
• Chat Completions의 후속 API
• 내장 도구 (web search, file search, code interpreter)
• gpt-5.5-pro / gpt-5.4-pro 등 일부 모델은 Responses API 전용
• 기존 Chat Completions API도 계속 지원

// Function Calling
• 외부 API/함수 호출
• 구조화된 데이터 추출
• 병렬 함수 호출 지원

// Vision (이미지 입력)
• 이미지 분석 및 설명
• OCR, 차트 해석
• URL 또는 Base64 지원

// Audio
• 음성 입력 (Whisper API)
• 텍스트→음성 (TTS API)
• 다국어 지원

// JSON Mode
• 항상 유효한 JSON 반환
• 구조화된 데이터 추출

// 배치 API
• 비동기 대량 처리
• 50% 비용 절감
• 24시간 이내 완료

1. OpenAI 플랫폼 접속
   https://platform.openai.com

2. 계정 생성 또는 로그인

3. API Keys 메뉴 (왼쪽 사이드바)

4. "Create new secret key" 클릭

5. 키 이름 입력 (선택사항)

6. 생성된 키 복사 (한 번만 표시)
   sk-proj-...

7. 안전하게 보관

# 설치
$ pip install openai

# 사용
from openai import OpenAI

client = OpenAI(api_key="sk-proj-...")

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "user", "content": "안녕하세요!"}
    ]
)

print(response.choices[0].message.content)

// 설치
$ npm install openai

// 사용
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const response = await client.chat.completions.create({
  model: 'gpt-5.4',
  messages: [
    { role: 'user', content: '안녕하세요!' }
  ],
});

console.log(response.choices[0].message.content);

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {
            "role": "system",
            "content": "당신은 도움이 되는 AI 어시스턴트입니다."
        },
        {
            "role": "user",
            "content": "Python으로 퀵소트를 구현해줘."
        }
    ],
    temperature=0.7,  # 0.0 ~ 2.0
    max_tokens=1000,
    top_p=1.0,
    frequency_penalty=0.0,  # -2.0 ~ 2.0
    presence_penalty=0.0,   # -2.0 ~ 2.0
)

print(response.choices[0].message.content)

# 토큰 사용량 확인
print(f"\n입력: {response.usage.prompt_tokens}")
print(f"출력: {response.usage.completion_tokens}")
print(f"총합: {response.usage.total_tokens}")

from openai import OpenAI

client = OpenAI()

messages = [
    {"role": "system", "content": "당신은 친절한 선생님입니다."},
]

while True:
    user_input = input("You: ")
    if user_input.lower() == "exit":
        break

    messages.append({"role": "user", "content": user_input})

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=messages
    )

    assistant_message = response.choices[0].message.content
    print(f"Assistant: {assistant_message}\n")

    messages.append({"role": "assistant", "content": assistant_message})

import json

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {
            "role": "system",
            "content": "당신은 데이터를 JSON 형식으로 추출하는 도구입니다."
        },
        {
            "role": "user",
            "content": """다음 텍스트에서 이름, 나이, 직업을 JSON으로 추출해주세요:
"철수는 28살이고 소프트웨어 엔지니어입니다."

JSON 형식으로만 답변하세요."""
        }
    ],
    response_format={"type": "json_object"}  # JSON 모드 활성화
)

data = json.loads(response.choices[0].message.content)
print(data)
# {'name': '철수', 'age': 28, 'job': '소프트웨어 엔지니어'}

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "긴 이야기를 들려줘."}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

print()

const stream = await client.chat.completions.create({
  model: 'gpt-5.4',
  messages: [{ role: 'user', content: '긴 이야기를 들려줘.' }],
  stream: true,
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content || '';
  process.stdout.write(content);
}

console.log();

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "특정 위치의 날씨를 가져옵니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "도시 이름 (예: Seoul)"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "서울 날씨 알려줘"}],
    tools=tools,
    tool_choice="auto"  # "auto", "none", {"type": "function", "function": {"name": "..."}}
)

print(json.dumps(response.model_dump(), indent=2, ensure_ascii=False))

import json

def get_weather(location: str, unit: str = "celsius"):
    # 실제 API 호출 대신 더미 데이터
    return json.dumps({
        "location": location,
        "temperature": 22,
        "unit": unit,
        "forecast": "맑음"
    })

messages = [{"role": "user", "content": "서울과 부산의 날씨를 비교해줘"}]

while True:
    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=messages,
        tools=tools
    )

    choice = response.choices[0]

    if choice.finish_reason == "tool_calls":
        messages.append(choice.message)

        for tool_call in choice.message.tool_calls:
            function_name = tool_call.function.name
            arguments = json.loads(tool_call.function.arguments)

            print(f"Calling {function_name} with {arguments}")

            if function_name == "get_weather":
                result = get_weather(**arguments)

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "name": function_name,
                "content": result
            })
    else:
        print(choice.message.content)
        break

# GPT-5.4는 여러 함수를 동시에 호출 가능
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{
        "role": "user",
        "content": "서울, 부산, 제주의 날씨를 알려줘"
    }],
    tools=tools
)

# response.choices[0].message.tool_calls에 3개의 함수 호출이 포함됨
for tool_call in response.choices[0].message.tool_calls:
    print(f"Function: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "이 이미지에 무엇이 있나요?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.jpg",
                        "detail": "high"  # "low", "high", "auto"
                    }
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

import base64

def encode_image(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

image_base64 = encode_image("chart.png")

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "이 차트를 분석해주세요."},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_base64}"
                    }
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

# o 시리즈 추론 모델 사용 방식
response = client.chat.completions.create(
    model="o3",  # 또는 "o4-mini"
    messages=[
        {
            "role": "user",
            "content": """다음 수학 문제를 풀어주세요:

한 농부가 닭과 토끼를 키우고 있습니다.
머리가 총 20개이고, 다리가 총 56개일 때,
닭과 토끼는 각각 몇 마리일까요?"""
        }
    ]
    # 주의: o 시리즈는 temperature, top_p 미지원 (reasoning_effort 사용)
    # 참고: o3, o4-mini는 스트리밍 지원
)

print(response.choices[0].message.content)

import json

# 1. 배치 요청 파일 생성 (JSONL)
batch_requests = [
    {
        "custom_id": "request-1",
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-5.4",
            "messages": [{"role": "user", "content": "안녕하세요"}]
        }
    },
    {
        "custom_id": "request-2",
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-5.4",
            "messages": [{"role": "user", "content": "날씨 어때?"}]
        }
    }
]

with open("batch_input.jsonl", "w") as f:
    for req in batch_requests:
        f.write(json.dumps(req) + "\n")

# 2. 파일 업로드
batch_file = client.files.create(
    file=open("batch_input.jsonl", "rb"),
    purpose="batch"
)

# 3. 배치 생성
batch = client.batches.create(
    input_file_id=batch_file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

print(f"Batch ID: {batch.id}")
print(f"Status: {batch.status}")  # validating, in_progress, completed, failed

# 배치 상태 확인
batch = client.batches.retrieve(batch.id)
print(f"Status: {batch.status}")

if batch.status == "completed":
    # 결과 파일 다운로드
    result_file_id = batch.output_file_id
    result = client.files.content(result_file_id)

    # 결과 파싱
    for line in result.text.strip().split("\n"):
        result_obj = json.loads(line)
        custom_id = result_obj["custom_id"]
        response = result_obj["response"]["body"]["choices"][0]["message"]["content"]

        print(f"{custom_id}: {response}")

┌─────────────────┬──────────────────────────────────────────────────────┐
│ 변형            │ 설명                                                 │
├─────────────────┼──────────────────────────────────────────────────────┤
│ gpt-5.5         │ 표준 플래그십, Chat Completions / Responses API      │
│ gpt-5.5 Thinking│ 동일 모델 ID, reasoning.effort=high → 심층 추론      │
│ gpt-5.5-pro     │ 최고 정확도, Responses API 전용                       │
└─────────────────┴──────────────────────────────────────────────────────┘

이용 가능 채널:
• API: Responses API / Chat Completions API
• ChatGPT: Plus / Pro / Business / Enterprise (gpt-5.5-pro는 Pro·Business·Enterprise)
• Codex: gpt-5.5 기반으로 자율 엔지니어링 작업 처리

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{
        "role": "user",
        "content": "이 파이썬 함수의 버그를 찾고 수정해줘"
    }]
)
print(response.choices[0].message.content)

# Thinking 모드: reasoning.effort를 높여 심층 추론 활성화
response = client.chat.completions.create(
    model="gpt-5.5",
    reasoning_effort="high",
    messages=[{
        "role": "user",
        "content": "복잡한 알고리즘 설계 문제를 단계별로 해결해줘"
    }]
)

# gpt-5.5-pro는 Responses API 전용
response = client.responses.create(
    model="gpt-5.5-pro",
    input="GitHub 이슈를 분석하고 자동으로 PR을 작성해줘",
    tools=[{"type": "code_interpreter"}]
)

실시간 API (2026-04-23 기준):
┌──────────────────┬──────────┬──────────┬──────────────┐
│ 모델             │ 입력     │ 출력     │ 비고         │
├──────────────────┼──────────┼──────────┼──────────────┤
│ gpt-5.5 ★       │ $5.00/1M │ $30.00/1M│ 최신 플래그십│
│ gpt-5.5-pro ★   │ $30.00/1M│ $180.00/1M│ 최고 정확도 │
│ gpt-5.4          │ $2.50/1M │ $15.00/1M│ 이전 플래그십│
│ gpt-5.4-mini     │ $0.75/1M │ $4.50/1M │ Standard     │
│ gpt-4.1          │ 변동/1M  │ 변동/1M  │ 변동         │
│ o3               │ 변동/1M  │ 변동/1M  │ 변동         │
│ o4-mini          │ 변동/1M  │ 변동/1M  │ 변동         │
└──────────────────┴──────────┴──────────┴──────────────┘
예시: 2K input + 500 output

배치 API (50% 할인):
┌──────────────────┬──────────┬──────────┐
│ gpt-5.5          │ $2.50/1M │ $15.00/1M │
│ gpt-5.4          │ $1.25/1M │ $7.50/1M  │
│ gpt-5.4-mini     │ $0.375/1M│ $2.25/1M  │
│ gpt-4.1          │ 변동/1M  │ 변동/1M   │
└──────────────────┴──────────┴──────────┘

class CostTracker:
    PRICING = {
        "gpt-5.5": (5.00, 30.0),
        "gpt-5.5-pro": (30.0, 180.0),
        "gpt-5.4": (2.50, 15.0),
        "gpt-5.4-mini": (0.75, 4.50),
        "gpt-4.1": (2.0, 8.0),
        "o3": (2.0, 8.0),
        "o4-mini": (1.10, 4.40),
    }

    def __init__(self):
        self.total_cost = 0.0

    def track(self, response):
        model = response.model
        input_tokens = response.usage.prompt_tokens
        output_tokens = response.usage.completion_tokens

        input_price, output_price = self.PRICING.get(model, (0, 0))
        cost = (input_tokens * input_price + output_tokens * output_price) / 1_000_000

        self.total_cost += cost

        print(f"Request cost: ${cost:.6f}")
        print(f"Total cost: ${self.total_cost:.6f}")

        return cost

# 사용
tracker = CostTracker()

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "안녕"}]
)

tracker.track(response)

// 1. 올바른 모델 선택
간단한 작업 → gpt-5.4-nano / gpt-4.1-nano
일반 작업 → gpt-5.4-mini / gpt-4.1
복잡한 추론 → o3 / gpt-5.4

// 2. 배치 API 활용
대량 처리 시 50% 절감

// 3. max_tokens 제한
response = client.chat.completions.create(
    model="gpt-5.4",
    max_tokens=500,  # 출력 제한
    ...
)

// 4. 불필요한 컨텍스트 제거
• 오래된 대화 내역 삭제
• 요약 후 긴 컨텍스트 제거

// 5. 사용량 제한 설정
OpenAI 대시보드에서 월간 예산 제한 설정

// 6. Semantic Caching (외부)
동일/유사 쿼리 캐싱 (Redis, Pinecone 등)

// 1. 에러 처리
from openai import OpenAI, APIError, RateLimitError
import time

def call_with_retry(client, **kwargs):
    max_retries = 3
    for i in range(max_retries):
        try:
            return client.chat.completions.create(**kwargs)
        except RateLimitError:
            if i < max_retries - 1:
                time.sleep(2 ** i)  # 지수 백오프
            else:
                raise
        except APIError as e:
            print(f"API Error: {e}")
            raise

// 2. 타임아웃 설정
client = OpenAI(timeout=30.0)  # 30초

// 3. API 키 보안
import os
api_key = os.getenv("OPENAI_API_KEY")

// 4. 프롬프트 최적화
• 명확하고 구체적인 지시
• Few-shot 예시 활용
• 출력 형식 명시

// 5. 모니터링
• 사용량 대시보드 정기 확인
• 비정상 패턴 감지
• 예산 알림 설정