토큰 사용량 이해하기: 개발자를 위한 AI API 과금 가이드

"100만 토큰당 $0.25"라는 가격은 저렴하게 들립니다 — 여러분의 챗봇이 한 달에 2억 토큰을 소모하고 있고, 이를 예상하지 못했다는 사실을 깨닫기 전까지는 말이죠.

토큰 기반 과금은 AI API의 보편적인 가격 모델이지만, 여러 가지 놀라움이 숨어 있습니다: 동일한 영어 문장이 일본어로는 3배 더 많은 비용이 들고, 코딩 작업에서 단순한 "yes" 한 마디가 400 토큰을 소비할 수 있으며, 추론 모델은 여러분이 볼 수도 없는 수천 개의 토큰을 조용히 소모합니다.

이 가이드는 토큰 사용량을 이해하고, 비용을 정확하게 추정하며, 과금 서프라이즈를 피하는 데 필요한 모든 것을 다룹니다.

---

토큰이란 정확히 무엇인가?

토큰은 LLM이 처리하는 텍스트의 최소 단위로, 대략 단어 조각에 해당합니다. "unbelievable"이라는 단어는 ["un", "believe", "able"]로 토큰화될 수 있습니다 — 세 개의 토큰입니다. "cat"은 일반적으로 하나의 토큰입니다.

토큰 vs 문자 vs 단어

| 텍스트 | 문자 수 | 단어 수 | 토큰 수 (GPT 토크나이저) | |------|-----------|-------|----------------------| | "Hello" | 5 | 1 | 1 | | "unbelievable" | 12 | 1 | 3 | | "The quick brown fox" | 19 | 4 | 4 | | "こんにちは" (일본어) | 5 | 1 | 5 | | "print('hello')" | 14 | 1 | 7 |

경험칙: 1 토큰 ≈ 0.75 영어 단어 ≈ 4 문자. 그러나 이는 언어와 콘텐츠 유형에 따라 크게 달라집니다.

토큰화가 비용 청구서에 중요한 이유

서로 다른 모델은 서로 다른 토크나이저를 사용합니다. GPT-4o와 DeepSeek은 BPE(Byte-Pair Encoding) 토크나이저의 변형을 사용하지만, 그 어휘집은 다릅니다. GPT-4o에서 100 토큰인 프롬프트가 DeepSeek V4 Flash에서는 120 토큰이 될 수 있습니다 — 수백만 건의 요청에서 20% 차이가 누적됩니다.

---

AI API의 토큰 계산 및 과금 방식

모든 API 호출은 두 가지 숫자를 기준으로 과금됩니다:

1. 입력 토큰: 전송하는 모든 것 — 시스템 프롬프트, 대화 이력, 사용자 메시지
2. 출력 토큰: 모델이 생성하는 모든 것 — 중단 시퀀스 같은 보이지 않는 토큰 포함

과금 공식

비용 = (입력 토큰 × 입력 요율) + (출력 토큰 × 출력 요율)

Global API를 통한 DeepSeek V4 Flash 예시 (정액제 $0.25/M):

프롬프트: 800 토큰
응답: 500 토큰
합계: 1,300 토큰

비용 = 1,300 × ($0.25 / 1,000,000) = $0.000325

작아 보이시나요? 이제 확장해 봅시다: 하루 100,000건의 API 호출 = $32.50/일 = $975/월. 시스템 프롬프트, 대화 이력, 추론 토큰 없이도 이렇습니다.

Global API가 정액 요금제를 사용하는 이유

기존 AI 제공업체는 입력 토큰과 출력 토큰에 서로 다른 요율을 부과합니다(출력에 3-5배 더 비싼 경우가 많음). 이는 비용 추정을 예측 불가능하게 만듭니다 — 호출이 끝나기 전까지 출력 길이를 알 수 없기 때문입니다.

Global API는 모델별 정액 요금제를 사용합니다: 입력과 출력 토큰에 동일한 요율 적용. 이로 인해 비용 추정이 단순해집니다:

| 모델 | 정액 요율 / 1M 토큰 | 1K 토큰 호출 비용 | |-------|----------------------|-------------------| | GA-Economy | $0.125 | $0.000125 | | Qwen3-8B | $0.01 | $0.00001 | | DeepSeek V4 Flash | $0.25 | $0.00025 | | GLM-5 | $1.92 | $0.00192 | | MiniMax M2.5 | $1.15 | $0.00115 | | Kimi K2.5 | $3.00 | $0.003 |

모든 가격 보기

---

토큰 계산: 도구와 코드

옵션 1: tiktoken (Python)

전송 전 토큰을 계산하는 가장 정확한 방법:

import tiktoken

# GPT 계열 토크나이저 (대부분의 OpenAI 호환 모델에서 작동)
encoding = tiktoken.get_encoding("cl100k_base")

def count_tokens(text: str) -> int:
    return len(encoding.encode(text))

# 시스템 프롬프트
system = "You are a helpful assistant. Answer concisely."
print(f"System prompt: {count_tokens(system)} tokens")

# 사용자 메시지
user = "Explain quantum entanglement in simple terms."
print(f"User message: {count_tokens(user)} tokens")

# 대화 이력
history = [
    {"role": "system", "content": system},
    {"role": "user", "content": user},
    {"role": "assistant", "content": "Imagine two coins that always land the same way..."},
    {"role": "user", "content": "Can we use this for communication?"},
]
total = sum(count_tokens(m["content"]) for m in history)
print(f"Full conversation: {total} tokens")

옵션 2: JavaScript (js-tiktoken)

import { encodingForModel } from "js-tiktoken";

const enc = encodingForModel("gpt-4");

function countTokens(text) {
  return enc.encode(text).length;
}

const messages = [
  { role: "system", content: "You are a helpful assistant." },
  { role: "user", content: "What is a token in LLM APIs?" },
];

let total = 0;
for (const msg of messages) {
  // OpenAI는 메시지당 포맷팅을 위해 약 4 토큰을 추가합니다
  total += countTokens(msg.content) + 4;
}
total += 2; // 프라이머 토큰

console.log(`Estimated tokens: ${total}`);

옵션 3: 내장 사용량 데이터 (가장 신뢰할 수 있음)

모든 API 응답에는 실제 토큰 수가 포함됩니다:

import openai

client = openai.OpenAI(
    api_key="a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6",
    base_url="https://global-apis.com/v1",
)

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "Hello"}],
)

usage = response.usage
print(f"Prompt tokens: {usage.prompt_tokens}")
print(f"Completion tokens: {usage.completion_tokens}")
print(f"Total tokens: {usage.total_tokens}")

---

개발자들을 놀라게 하는 숨은 토큰 비용

1. 시스템 프롬프트 세금

매 요청마다 전송되는 500 토큰의 시스템 프롬프트는 빠르게 누적됩니다:

500 토큰 × 100,000 요청/일 × 30일 = 월 15억 토큰
$0.25/M 토큰 기준: $375/월 — 시스템 프롬프트만으로.

해결책: 시스템 프롬프트를 100 토큰 미만으로 유지하세요. 간결한 지시문을 사용하세요. 필요할 때만 확장되는 템플릿 기반 시스템 프롬프트를 고려하세요.

2. 대화 이력 누적

대화의 각 턴은 전체 이력을 다음 요청에 추가합니다:

턴 1: 100 토큰 (사용자) + 200 토큰 (어시스턴트) = 300 토큰
턴 2: 300 (이력) + 100 (새 사용자) + 300 (어시스턴트) = 700 토큰
턴 3: 700 + 100 + 300 = 1,100 토큰
턴 10: 3,100 + 100 + 300 = 3,500 토큰

10턴 후, 각 요청 비용은 첫 번째보다 10배 더 비쌉니다.

해결책: 이력을 마지막 N턴으로 제한하세요. 저렴한 모델로 이전 메시지를 요약하세요:

def trim_history(messages: list[dict], max_turns: int = 6) -> list[dict]:
    """마지막 N개의 사용자-어시스턴트 쌍만 유지합니다."""
    # 시스템 메시지는 항상 보존
    system = [m for m in messages if m["role"] == "system"]

    # 마지막 N개의 비시스템 메시지 유지
    non_system = [m for m in messages if m["role"] != "system"]
    recent = non_system[-(max_turns * 2):]

    return system + recent

3. 추론 토큰 오버헤드 (DeepSeek R1, o1, QwQ)

추론 모델은 최종 답변을 생성하기 전에 내부 "생각" 토큰을 생성합니다. 이는 사용량에 포함되지만 API 응답에서 종종 숨겨집니다:

# Global API를 통한 DeepSeek R1
response = client.chat.completions.create(
    model="deepseek-r1",
    messages=[{"role": "user", "content": "Solve this: 345 × 678"}],
)

# 응답은 50 토큰의 가시적 출력처럼 보일 수 있지만,
# 모델은 내부적으로 2,000개 이상의 추론 토큰을 소비했습니다
print(f"Billed tokens: {response.usage.total_tokens}")
# 과금된 토큰: 2,312 — 50이 아닙니다!

규칙: 작업이 실제로 추론을 필요로 할 때만 추론 모델을 사용하세요. 간단한 수학에는 표준 모델을 사용하세요. R1은 다단계 논리와 어려운 문제를 위해 남겨두세요.

4. 비영어 언어

LLM은 비영어 텍스트를 덜 효율적으로 토큰화합니다:

| 텍스트 | 언어 | 토큰 | |------|----------|--------| | "Hello, how are you today?" | 영어 | 7 | | "こんにちは、今日はお元気ですか？" | 일본어 | 15 | | "你好，你今天好吗？" | 중국어 | 13 | | "Привет, как дела сегодня?" | 러시아어 | 18 |

중국어 챗봇은 영어보다 메시지당 약 2배의 비용이 듭니다. 다국어 사용자를 서비스한다면 그에 맞게 예산을 책정하세요.

---

토큰 비용 추정기 구축

다음은 배포 전에 사용할 수 있는 완전한 비용 추정 도구입니다:

# cost_estimator.py
import tiktoken

MODEL_PRICING = {
    # 정액 요금제 (Global API) — $/1M 토큰
    "deepseek-v4-flash": 0.25,
    "deepseek-v3.2": 0.378,
    "deepseek-r1": 2.50,
    "qwen3-235b-a22b": 1.82,
    "qwen3-8b": 0.01,
    "glm-5": 1.92,
    "glm-4-9b": 0.01,
    "kimi-k2.5": 3.00,
    "minimax-m2.5": 1.15,
    "ga-economy": 0.125,
    "ga-standard": 0.20,
    "ga-express": 0.25,
}

def estimate_monthly_cost(
    model: str,
    daily_requests: int,
    avg_prompt_tokens: int,
    avg_completion_tokens: int,
) -> dict:
    """예상 사용량을 기반으로 월간 API 비용을 추정합니다."""
    rate = MODEL_PRICING.get(model, 0.50)
    total_tokens_per_call = avg_prompt_tokens + avg_completion_tokens
    daily_tokens = daily_requests * total_tokens_per_call
    monthly_tokens = daily_tokens * 30

    cost_per_call = (total_tokens_per_call / 1_000_000) * rate
    monthly_cost = (monthly_tokens / 1_000_000) * rate

    return {
        "model": model,
        "rate_per_million": rate,
        "daily_requests": daily_requests,
        "avg_tokens_per_call": total_tokens_per_call,
        "cost_per_call": round(cost_per_call, 6),
        "daily_tokens": daily_tokens,
        "monthly_tokens": monthly_tokens,
        "monthly_cost": round(monthly_cost, 2),
    }

# 예시: 고객 지원 챗봇
result = estimate_monthly_cost(
    model="deepseek-v4-flash",
    daily_requests=5000,
    avg_prompt_tokens=600,
    avg_completion_tokens=300,
)

print(f"Model: {result['model']}")
print(f"Cost per call: ${result['cost_per_call']}")
print(f"Monthly cost: ${result['monthly_cost']}")
# Model: deepseek-v4-flash
# Cost per call: $0.000225
# Monthly cost: $33.75

모델별 나란히 비교

def compare_models(daily_requests: int, prompt_tokens: int, completion_tokens: int):
    """모델 간 월간 비용을 비교합니다."""
    print(f"{'Model':<25} {'Rate/M':>8} {'$/Call':>8} {'$/Month':>10}")
    print("-" * 55)

    for model, rate in sorted(MODEL_PRICING.items(), key=lambda x: x[1]):
        result = estimate_monthly_cost(model, daily_requests, prompt_tokens, completion_tokens)
        print(
            f"{model:<25} ${rate:>6.3f} "
            f"${result['cost_per_call']:>7.5f} "
            f"${result['monthly_cost']:>9.2f}"
        )

# 하루 10,000 요청, 500 프롬프트 + 300 출력
compare_models(10000, 500, 300)

샘플 출력:

Model                     Rate/M   $/Call    $/Month
-------------------------------------------------------
qwen3-8b                  $0.010  $0.00001     $2.40
glm-4-9b                  $0.010  $0.00001     $2.40
ga-economy                $0.125  $0.00010    $30.00
ga-standard               $0.200  $0.00016    $48.00
deepseek-v4-flash         $0.250  $0.00020    $60.00
ga-express                $0.250  $0.00020    $60.00
deepseek-v3.2             $0.378  $0.00030    $90.72
minimax-m2.5              $1.150  $0.00092   $276.00
qwen3-235b-a22b           $1.820  $0.00146   $436.80
glm-5                     $1.920  $0.00154   $460.80
deepseek-r1               $2.500  $0.00200   $600.00
kimi-k2.5                 $3.000  $0.00240   $720.00

가장 저렴한 모델($2.40/월)과 가장 비싼 모델($720/월)의 차이는 300배입니다. 작업에 적합한 모델을 선택하는 것이 AI 비용 청구서에서 가장 큰 지렛대입니다.

---

세 가지 일반적인 과금 시나리오 (그리고 실제 비용)

시나리오 1: 주말 프로젝트 챗봇

모델: DeepSeek V4 Flash ($0.25/M)
사용량: 하루 50회 대화, 평균 8턴
턴당: 시스템(200) + 사용자(100) + 어시스턴트(300) = 평균 600
총계: 50 × 8 × 600 = 240,000 토큰/일 = 7.2M/월
비용: 7.2 × $0.25 = $1.80/월

평결: 신용카드 명세서에서 눈치채지 못할 것입니다.

시나리오 2: SaaS 제품 (일일 활성 사용자 1만 명)

모델: GA-Standard ($0.20/M)
사용량: 10,000 사용자, 평균 5개 쿼리
턴당: 시스템(300) + 이력(500) + 사용자(200) + 어시스턴트(400) = 평균 1,400
총계: 50,000 × 1,400 = 7,000만 토큰/일 = 21억/월
비용: 2,100 × $0.20 = $420/월

평결: 합리적입니다. 캐싱을 추가하면 약 $250까지 절감 가능합니다.

시나리오 3: AI 코딩 어시스턴트 (개발자 1만 명)

모델: MiniMax M2.5 ($1.15/M) + Kimi K2.5 ($3.00/M)
사용량: 10,000 개발자, 각 20건 요청
혼합: 70% M2.5 (단순), 30% K2.5 (복잡)
턴당: 평균 1,200 (컨텍스트가 많은 코드)
총계: 200,000 × 1,200 = 2.4억 토큰/일 = 72억/월
비용 (M2.5): 5,040 × $1.15 = $5,796
비용 (K2.5): 2,160 × $3.00 = $6,480
총계: $12,276/월

평결: 상당한 금액입니다. 계층형 라우팅 + 시맨틱 캐싱을 고려하세요.

---

오늘 바로 토큰 사용량을 줄이는 빠른 성과

1. 시스템 프롬프트 줄이기 — 절약한 100 토큰마다 100 × 요청 수 × 30일만큼 과금 토큰 감소
2. 대화 이력 제한 — 전체 채팅을 보내지 말고 마지막 6턴만 유지하세요
3. max_tokens 사용 — 출력 토큰을 제한하여 폭주 응답이 예산을 초과하지 않도록 하세요
4. 엔드포인트별 사용량 추적 — API 호출에 메타데이터를 태깅하여 어떤 기능이 토큰을 소모하는지 파악하세요
5. 적절한 모델 크기 선택 — "hello world"에 Kimi K2.5는 필요하지 않습니다

캐싱, 프롬프트 압축, 계층형 라우팅을 포함한 완전한 비용 최적화 전략은 다중 모델 비용 최적화 가이드를 참조하세요.

---

토큰 사용량 추적 시작하기

Global API는 실시간 토큰 사용량 대시보드, 모델별 비용 추적, 비용 추정을 예측 가능하게 만드는 정액 요금제를 제공합니다. 서프라이즈는 없습니다.

• 가입하기 — 무료 크레딧 100개 — 신용카드 불필요
• 전체 가격 페이지
• API 문서