Claude API 고급 기능별 가격

들어가며

이전 차시에서 Claude API의 기본 가격 체계를 학습했다. 이번에는 한 단계 더 나아가 고급 기능들의 가격 정책을 알아본다.

프롬프트 캐싱으로 비용을 최대 90% 절감하고, 배치 API로 50% 할인받고, 확장된 사고 기능의 비용 구조를 이해하면 Claude API를 훨씬 효율적으로 사용할 수 있다.

프롬프트 캐싱 (Prompt Caching)

개념

프롬프트 캐싱은 반복적으로 사용되는 프롬프트를 서버에 캐시해두고 재사용하는 기능이다. 동일한 시스템 프롬프트를 100번 호출하는 대신, 한 번 캐시하고 99번 재사용하면 비용을 크게 줄일 수 있다.

캐시 유형

Claude API는 두 가지 캐시 유형을 제공한다.

5분 캐시 (기본)

1시간 캐시

실제 가격 계산 (Sonnet 4.5 기준)

기본 입력 가격: $3/MTok

5분 캐시:
- 캐시 쓰기: $3 × 1.25 = $3.75/MTok
- 캐시 읽기: $3 × 0.1 = $0.30/MTok

1시간 캐시:
- 캐시 쓰기: $3 × 2.5 = $7.50/MTok
- 캐시 읽기: $3 × 0.2 = $0.60/MTok

비용 절감 예시

10,000 토큰 시스템 프롬프트를 100번 호출하는 경우를 계산해보자.

캐싱 없이

비용 = 10,000 × 100 × $3 / 1,000,000 = $3.00

5분 캐싱 사용

캐시 쓰기 (1회): 10,000 × $3.75 / 1,000,000 = $0.0375
캐시 읽기 (99회): 10,000 × 99 × $0.30 / 1,000,000 = $0.297

총 비용: $0.3345
절감율: 약 89%

캐싱 사용 코드

import anthropic

client = anthropic.Anthropic()

# 5분 캐시 사용
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": """당신은 전문 코드 리뷰어입니다.
            다음 기준에 따라 코드를 평가합니다:
            1. 코드 품질
            2. 보안 취약점
            3. 성능 최적화
            4. 가독성
            ... (긴 시스템 프롬프트)""",
            "cache_control": {"type": "ephemeral"}  # 5분 캐시
        }
    ],
    messages=[
        {"role": "user", "content": "다음 코드를 리뷰해주세요: ..."}
    ]
)

1시간 캐시 사용

더 긴 캐시 유지가 필요한 경우:

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "긴 시스템 프롬프트...",
            "cache_control": {"type": "ephemeral", "ttl": "1h"}  # 1시간 캐시
        }
    ],
    messages=[{"role": "user", "content": "질문"}]
)

캐싱 효과 확인

응답에서 캐싱 관련 토큰 정보를 확인할 수 있다.

response = client.messages.create(...)

# 캐시 생성된 토큰 수
cache_creation = getattr(response.usage, 'cache_creation_input_tokens', 0)

# 캐시에서 읽은 토큰 수
cache_read = getattr(response.usage, 'cache_read_input_tokens', 0)

print(f"캐시 생성: {cache_creation} 토큰")
print(f"캐시 읽기: {cache_read} 토큰")

캐싱 적용 시나리오

적합한 경우

• 동일한 시스템 프롬프트로 여러 요청 처리
• 긴 문서를 여러 관점에서 분석
• 대화형 앱에서 컨텍스트 유지
• 코드 리뷰 봇 등 정형화된 지시사항

부적합한 경우

• 매번 다른 프롬프트 사용
• 호출 빈도가 낮은 경우
• 캐시 유지 시간 내 재호출이 없는 경우

배치 API (Batch API)

개념

배치 API는 여러 요청을 한 번에 제출하고 비동기로 처리하는 기능이다. 실시간 응답이 필요 없는 대량 작업에 적합하며, 50% 할인을 받을 수 있다.

배치 API 가격

비용 절감 계산

1,000개 문서 요약 작업을 비교해보자.

입력: 문서당 2,000 토큰 (총 2M 토큰)
출력: 요약당 500 토큰 (총 500K 토큰)
모델: Sonnet 4.5

일반 API:
- 입력: 2M × $3 / 1M = $6.00
- 출력: 0.5M × $15 / 1M = $7.50
- 총 비용: $13.50

배치 API:
- 입력: 2M × $1.50 / 1M = $3.00
- 출력: 0.5M × $7.50 / 1M = $3.75
- 총 비용: $6.75

절감: 50% ($6.75 절약)

배치 API 사용법

배치 요청 생성

import anthropic

client = anthropic.Anthropic()

# 배치 요청 제출
batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": "doc-001",
            "params": {
                "model": "claude-sonnet-4-5-20250929",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "문서 1 요약: ..."}
                ]
            }
        },
        {
            "custom_id": "doc-002",
            "params": {
                "model": "claude-sonnet-4-5-20250929",
                "max_tokens": 1024,
                "messages": [
                    {"role": "user", "content": "문서 2 요약: ..."}
                ]
            }
        },
        # ... 더 많은 요청
    ]
)

print(f"배치 ID: {batch.id}")
print(f"상태: {batch.processing_status}")

배치 상태 확인

# 배치 상태 조회
batch_status = client.messages.batches.retrieve(batch.id)

print(f"상태: {batch_status.processing_status}")
print(f"완료: {batch_status.request_counts.succeeded}")
print(f"실패: {batch_status.request_counts.errored}")

결과 가져오기

# 배치 완료 후 결과 조회
if batch_status.processing_status == "ended":
    results = client.messages.batches.results(batch.id)

    for result in results:
        print(f"요청 ID: {result.custom_id}")
        print(f"응답: {result.result.message.content[0].text}")

배치 API 특징

• 처리 시간: 최대 24시간 내 완료
• 요청 수 제한: 배치당 최대 10,000개 요청
• 만료: 결과는 29일간 보관
• 취소: 진행 중인 배치 취소 가능

배치 적용 시나리오

적합한 경우

• 대량 문서 분류/요약
• 데이터 전처리
• 콘텐츠 생성 (마케팅 문구, 설명 등)
• 일괄 번역
• 감성 분석

부적합한 경우

• 실시간 채팅
• 사용자 대기 중인 요청
• 즉시 결과가 필요한 작업

긴 컨텍스트 (Long Context)

가격 정책

200K 토큰을 초과하는 입력에는 추가 비용이 적용된다.

비용 계산 예시

300K 토큰을 Sonnet 4.5로 처리하는 경우:

처음 200K 토큰: 200,000 × $3 / 1,000,000 = $0.60
추가 100K 토큰: 100,000 × $6 / 1,000,000 = $0.60

총 입력 비용: $1.20

500K 토큰을 처리하는 경우:

처음 200K 토큰: 200,000 × $3 / 1,000,000 = $0.60
추가 300K 토큰: 300,000 × $6 / 1,000,000 = $1.80

총 입력 비용: $2.40

1M 토큰 베타 사용

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    betas=["long-context-1m"],  # 1M 토큰 베타 활성화
    messages=[
        {
            "role": "user",
            "content": very_long_document  # 최대 1M 토큰
        }
    ]
)

긴 컨텍스트 비용 최적화

청킹 전략

긴 문서를 처리할 때 한 번에 모든 내용을 보내는 대신 청크로 나눠 처리하면 비용을 줄일 수 있다.

def chunk_document(text: str, max_tokens: int = 150000) -> list:
    """문서를 청크로 분할"""
    words = text.split()
    chunks = []
    current_chunk = []

    for word in words:
        current_chunk.append(word)
        # 대략적인 토큰 수 추정 (영어 기준)
        if len(current_chunk) * 1.3 > max_tokens:
            chunks.append(" ".join(current_chunk))
            current_chunk = []

    if current_chunk:
        chunks.append(" ".join(current_chunk))

    return chunks

# 사용
chunks = chunk_document(long_document)
summaries = []

for chunk in chunks:
    response = client.messages.create(
        model="claude-sonnet-4-5-20250929",
        max_tokens=2000,
        messages=[{"role": "user", "content": f"요약: {chunk}"}]
    )
    summaries.append(response.content[0].text)

# 최종 요약
final_summary = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2000,
    messages=[{
        "role": "user",
        "content": f"다음 요약들을 종합: {' '.join(summaries)}"
    }]
)

확장된 사고 (Extended Thinking)

개념

확장된 사고는 Claude가 응답하기 전에 더 깊이 생각하는 모드다. 복잡한 추론이 필요한 작업에서 정확도를 높일 수 있다.

가격 정책

Thinking 토큰은 출력 토큰과 동일한 가격이 적용된다.

비용 계산 예시

입력: 1,000 토큰
Thinking: 5,000 토큰
출력: 2,000 토큰
모델: Sonnet 4.5

비용 계산:
- 입력: 1,000 × $3 / 1,000,000 = $0.003
- Thinking: 5,000 × $15 / 1,000,000 = $0.075
- 출력: 2,000 × $15 / 1,000,000 = $0.030

총 비용: $0.108

확장된 사고 사용법

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # thinking에 사용할 최대 토큰
    },
    messages=[
        {
            "role": "user",
            "content": "복잡한 수학 문제를 단계별로 풀어줘..."
        }
    ]
)

# thinking 과정 확인
for block in response.content:
    if block.type == "thinking":
        print(f"사고 과정: {block.thinking}")
    elif block.type == "text":
        print(f"최종 답변: {block.text}")

사용 시나리오

적합한 경우

• 복잡한 수학/논리 문제
• 다단계 추론이 필요한 분석
• 코드 디버깅
• 전략적 의사결정

부적합한 경우

• 단순 질의응답
• 분류 작업
• 빠른 응답이 필요한 경우

웹 검색 (Web Search)

가격

사용법

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    tools=[{"type": "web_search"}],
    messages=[
        {
            "role": "user",
            "content": "2026년 최신 AI 트렌드는?"
        }
    ]
)

비용 고려사항

웹 검색 비용은 토큰 비용과 별도로 청구된다. 한 번의 요청에서 여러 번 검색이 수행될 수 있으므로 비용이 예상보다 높아질 수 있다.

코드 실행 (Code Execution)

가격

기본적인 코드 실행은 토큰 비용에 포함된다. 별도의 추가 비용 없이 샌드박스 환경에서 Python 코드를 실행할 수 있다.

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    tools=[{"type": "code_execution"}],
    messages=[
        {
            "role": "user",
            "content": "피보나치 수열의 처음 20개 항을 계산해줘"
        }
    ]
)

비용 최적화 전략

1. 계층적 모델 선택

작업 복잡도에 따라 모델을 선택한다.

def select_model(task_complexity: str) -> str:
    """작업 복잡도에 따른 모델 선택"""
    if task_complexity == "high":
        return "claude-opus-4-6-20250629"  # 복잡한 추론
    elif task_complexity == "medium":
        return "claude-sonnet-4-5-20250929"  # 일반 작업
    else:
        return "claude-haiku-4-5-20250929"  # 간단한 작업

# 사용 예시
model = select_model("low")  # 분류 작업
response = client.messages.create(
    model=model,
    max_tokens=50,
    messages=[{"role": "user", "content": "긍정/부정 분류: ..."}]
)

2. 캐싱 + 배치 조합

대량 처리 시 캐싱과 배치를 함께 활용한다.

# 시스템 프롬프트 캐싱 + 배치 처리
system_prompt = {
    "type": "text",
    "text": "긴 시스템 프롬프트...",
    "cache_control": {"type": "ephemeral"}
}

batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": f"request-{i}",
            "params": {
                "model": "claude-sonnet-4-5-20250929",
                "max_tokens": 1024,
                "system": [system_prompt],
                "messages": [{"role": "user", "content": f"문서 {i}"}]
            }
        }
        for i in range(1000)
    ]
)

3. 비용 모니터링 대시보드

class CostMonitor:
    """API 비용 모니터링"""

    PRICING = {
        "claude-opus-4-6-20250629": {
            "input": 5, "output": 25,
            "batch_input": 2.5, "batch_output": 12.5,
            "cache_write": 6.25, "cache_read": 0.5
        },
        "claude-sonnet-4-5-20250929": {
            "input": 3, "output": 15,
            "batch_input": 1.5, "batch_output": 7.5,
            "cache_write": 3.75, "cache_read": 0.3
        },
        "claude-haiku-4-5-20250929": {
            "input": 1, "output": 5,
            "batch_input": 0.5, "batch_output": 2.5,
            "cache_write": 1.25, "cache_read": 0.1
        }
    }

    def __init__(self):
        self.total_cost = 0
        self.requests = []

    def log_request(self, model: str, usage: dict, is_batch: bool = False):
        """요청 비용 기록"""
        prices = self.PRICING[model]

        if is_batch:
            input_price = prices["batch_input"]
            output_price = prices["batch_output"]
        else:
            input_price = prices["input"]
            output_price = prices["output"]

        # 기본 비용
        cost = (
            usage.get("input_tokens", 0) * input_price +
            usage.get("output_tokens", 0) * output_price
        ) / 1_000_000

        # 캐싱 비용 조정
        if "cache_creation_input_tokens" in usage:
            cost += usage["cache_creation_input_tokens"] * prices["cache_write"] / 1_000_000
        if "cache_read_input_tokens" in usage:
            cost -= usage["cache_read_input_tokens"] * (input_price - prices["cache_read"]) / 1_000_000

        self.total_cost += cost
        self.requests.append({"model": model, "cost": cost, "usage": usage})

        return cost

    def get_summary(self) -> dict:
        """비용 요약"""
        return {
            "total_requests": len(self.requests),
            "total_cost_usd": self.total_cost,
            "total_cost_krw": self.total_cost * 1340,
            "avg_cost_per_request": self.total_cost / len(self.requests) if self.requests else 0
        }

# 사용 예시
monitor = CostMonitor()

response = client.messages.create(...)
monitor.log_request(
    model="claude-sonnet-4-5-20250929",
    usage={
        "input_tokens": response.usage.input_tokens,
        "output_tokens": response.usage.output_tokens
    }
)

print(monitor.get_summary())

기능별 가격 비교표

전체 비교 (Sonnet 4.5 기준)

최적 조합 예시

시나리오: 1,000개 문서 분류

요구사항:
- 입력: 문서당 1,000 토큰
- 출력: 분류당 50 토큰
- 동일한 시스템 프롬프트 (5,000 토큰)

최적화 전략:
1. Haiku 모델 사용 (간단한 분류)
2. 배치 API 사용 (50% 할인)
3. 시스템 프롬프트 캐싱 (90% 절감)

비용 계산:
일반 Sonnet: $3.75
최적화 Haiku + 배치 + 캐싱: $0.35

절감율: 91%

정리

핵심 요점

1. 프롬프트 캐싱: 반복 프롬프트 비용 최대 90% 절감

   • 5분 캐시: 읽기 0.1× 가격
   • 1시간 캐시: 읽기 0.2× 가격

2. 배치 API: 대량 처리 시 50% 할인

   • 최대 24시간 내 처리
   • 실시간 응답 불필요 시 적합

3. 긴 컨텍스트: 200K 초과 시 2배 가격

   • 청킹으로 비용 최적화 가능
   • 1M 토큰 베타 지원

4. 확장된 사고: Thinking 토큰도 출력 가격 적용

   • 복잡한 추론 작업에 사용
   • budget_tokens로 제한 가능

5. 웹 검색: 검색당 $0.01

   • 토큰 비용과 별도 청구

비용 최적화 체크리스트

• 반복 프롬프트에 캐싱 적용했는가?
• 대량 작업에 배치 API 사용했는가?
• 작업 복잡도에 맞는 모델을 선택했는가?
• 긴 문서는 청킹 전략을 고려했는가?
• 비용 모니터링을 설정했는가?

다음 단계

다음 차시에서는 Claude.ai 구독 플랜을 알아본다. Free, Pro, Max, Team, Enterprise 플랜의 차이점과 자신에게 맞는 플랜 선택 방법을 학습한다.

참고 자료

• Prompt Caching - Anthropic Docs
• Batch API - Anthropic Docs
• Extended Thinking - Anthropic Docs
• Pricing - Anthropic Docs