【2026年版】Anthropic API料金比較の罠―安さで選ぶと損する理由

import anthropic

client = anthropic.Anthropic(api_key="your-api-key")

# RAGコンテキストを含むメッセージ
message = client.messages.create(
    model="claude-sonnet-4",
    max_tokens=500,
    system="あなたは技術文書の要約専門家です。重要なポイントを簡潔にまとめてください。",
    messages=[
        {
            "role": "user",
            "content": f"以下の文書を500文字で要約してください:\n\n{context}"
        }
    ]
)

# ❌ 悪い例: キャッシュが効かない
message = client.messages.create(
    model="claude-sonnet-4",
    max_tokens=3000,
    system=f"あなたは{topic}の専門家です。",  # topicが毎回変わる
    messages=[
        {"role": "user", "content": f"{long_context}\n\n質問: {question}"}
    ]
)

# ✅ 良い例: キャッシュが効く
message = client.messages.create(
    model="claude-sonnet-4",
    max_tokens=3000,
    system=[
        {
            "type": "text",
            "text": "あなたは技術ライターです。以下のスタイルガイドに従ってください:\n\n[2000トークンのスタイルガイド]",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": f"{long_context}",  # 記事ごとに変わるコンテキスト
                    "cache_control": {"type": "ephemeral"}
                },
                {
                    "type": "text",
                    "text": f"質問: {question}"  # 変動部分は最後に
                }
            ]
        }
    ]
)

import anthropic
from datetime import datetime

client = anthropic.Anthropic(api_key="your-api-key")

# キャッシュ統計を記録
cache_stats = {
    "total_requests": 0,
    "cache_hits": 0,
    "cache_creation": 0,
    "total_input_tokens": 0,
    "cached_input_tokens": 0
}

def create_message_with_cache(system_prompt, user_message):
    message = client.messages.create(
        model="claude-sonnet-4",
        max_tokens=3000,
        system=[
            {
                "type": "text",
                "text": system_prompt,
                "cache_control": {"type": "ephemeral"}
            }
        ],
        messages=[{"role": "user", "content": user_message}]
    )

    # キャッシュ統計を更新
    cache_stats["total_requests"] += 1
    cache_stats["total_input_tokens"] += message.usage.input_tokens

    if hasattr(message.usage, 'cache_read_input_tokens'):
        cache_stats["cache_hits"] += 1
        cache_stats["cached_input_tokens"] += message.usage.cache_read_input_tokens

    if hasattr(message.usage, 'cache_creation_input_tokens'):
        cache_stats["cache_creation"] += 1

    return message

# 使用例
for i in range(100):
    create_message_with_cache(
        "あなたは技術ライターです...",  # 同じシステムプロンプト
        f"記事{i}を書いてください"
    )

# キャッシュヒット率を計算
hit_rate = cache_stats["cache_hits"] / cache_stats["total_requests"] * 100
cost_reduction = cache_stats["cached_input_tokens"] / cache_stats["total_input_tokens"] * 100

print(f"キャッシュヒット率: {hit_rate:.1f}%")
print(f"コスト削減率: {cost_reduction:.1f}%")

def select_model(task_type, input_length, quality_requirement):
    """タスクに応じて最適なモデルを選択"""

    # 複雑なタスクは常にSonnet
    if quality_requirement == "high" or task_type == "code_generation":
        return "claude-sonnet-4"

    # 長文入力は品質重視
    if input_length > 5000:
        return "claude-sonnet-4"

    # シンプルなタスクはHaiku
    if task_type in ["tagging", "classification", "short_summary"]:
        return "claude-haiku-3.5"

    # デフォルトはSonnet
    return "claude-sonnet-4"

# 使用例
model = select_model(
    task_type="blog_generation",
    input_length=3000,
    quality_requirement="medium"
)

# タスク別の推奨max_tokens
MAX_TOKENS_CONFIG = {
    "blog_3000": 3200,  # 3000字 + バッファ200
    "summary_500": 500,
    "json_output": 500,  # 構造化出力は短めに
    "code_100_lines": 1000,
    "qa_short": 300
}

def create_message(task_type, content):
    max_tokens = MAX_TOKENS_CONFIG.get(task_type, 2000)

    message = client.messages.create(
        model="claude-sonnet-4",
        max_tokens=max_tokens,
        messages=[{"role": "user", "content": content}]
    )

    return message

SYSTEM_PROMPT = """
あなたは技術ブログのライターです。

## スタイルガイド
- です/ます調で統一
- 1文は60文字以内
- 専門用語には簡単な説明を付ける
- コード例を積極的に使う

## 記事構造
1. 導入(問題提起)
2. 背景説明
3. 解決策の提示
4. 具体例
5. まとめ

[さらに1500トークン分のガイドライン...]
"""

message = client.messages.create(
    model="claude-sonnet-4",
    max_tokens=3000,
    system=[
        {
            "type": "text",
            "text": SYSTEM_PROMPT,
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": f"テーマ: {topic}"}
    ]
)

print(f"入力トークン: {message.usage.input_tokens}")
print(f"キャッシュ読み込み: {message.usage.cache_read_input_tokens}")
print(f"出力トークン: {message.usage.output_tokens}")

# キャッシュヒット率
cache_hit_rate = message.usage.cache_read_input_tokens / message.usage.input_tokens
print(f"キャッシュヒット率: {cache_hit_rate:.1%}")

import json
from datetime import datetime
from collections import defaultdict

class CostTracker:
    def __init__(self):
        self.costs = defaultdict(lambda: {
            "requests": 0,
            "input_tokens": 0,
            "output_tokens": 0,
            "cached_tokens": 0,
            "total_cost": 0.0
        })

    def track_request(self, model, usage):
        """リクエストのコストを記録"""
        date = datetime.now().strftime("%Y-%m-%d")

        # トークン数を記録
        self.costs[date]["requests"] += 1
        self.costs[date]["input_tokens"] += usage.input_tokens
        self.costs[date]["output_tokens"] += usage.output_tokens

        if hasattr(usage, 'cache_read_input_tokens'):
            self.costs[date]["cached_tokens"] += usage.cache_read_input_tokens

        # コストを計算(Sonnet 4の料金)
        input_cost = (usage.input_tokens - getattr(usage, 'cache_read_input_tokens', 0)) * 3 / 1_000_000
        cache_cost = getattr(usage, 'cache_read_input_tokens', 0) * 0.3 / 1_000_000
        output_cost = usage.output_tokens * 15 / 1_000_000

        total_cost = input_cost + cache_cost + output_cost
        self.costs[date]["total_cost"] += total_cost

    def daily_report(self):
        """日次レポートを生成"""
        today = datetime.now().strftime("%Y-%m-%d")
        data = self.costs[today]

        print(f"\n=== コストレポート {today} ===")
        print(f"リクエスト数: {data['requests']:,}")
        print(f"入力トークン: {data['input_tokens']:,}")
        print(f"出力トークン: {data['output_tokens']:,}")
        print(f"キャッシュトークン: {data['cached_tokens']:,}")
        print(f"合計コスト: ${data['total_cost']:.2f} (約¥{data['total_cost'] * 150:,.0f})")

        if data['input_tokens'] > 0:
            cache_rate = data['cached_tokens'] / data['input_tokens'] * 100
            print(f"キャッシュヒット率: {cache_rate:.1f}%")

# 使用例
tracker = CostTracker()

for i in range(100):
    message = client.messages.create(...)
    tracker.track_request("claude-sonnet-4", message.usage)

tracker.daily_report()

class ModelRouter:
    def __init__(self):
        self.model_costs = {
            "claude-opus-4": {"input": 15, "output": 75},
            "claude-sonnet-4": {"input": 3, "output": 15},
            "claude-haiku-3.5": {"input": 0.8, "output": 4}
        }

    def select_model(self, task_type, input_tokens, quality_requirement="medium"):
        """タスクに応じて最適なモデルを選択"""

        # 高品質が必要な場合
        if quality_requirement == "high":
            return "claude-opus-4"

        # コード生成は品質重視
        if task_type == "code_generation":
            return "claude-sonnet-4"

        # 長文は品質重視
        if input_tokens > 5000:
            return "claude-sonnet-4"

        # シンプルなタスクはHaiku
        simple_tasks = ["tagging", "classification", "short_summary", "json_extraction"]
        if task_type in simple_tasks:
            return "claude-haiku-3.5"

        # デフォルトはSonnet
        return "claude-sonnet-4"

    def estimate_cost(self, model, input_tokens, output_tokens):
        """コストを見積もる"""
        costs = self.model_costs[model]
        input_cost = input_tokens * costs["input"] / 1_000_000
        output_cost = output_tokens * costs["output"] / 1_000_000
        return input_cost + output_cost

# 使用例
router = ModelRouter()

model = router.select_model(
    task_type="blog_generation",
    input_tokens=3000,
    quality_requirement="medium"
)

print(f"選択されたモデル: {model}")

estimated_cost = router.estimate_cost(model, 3000, 2800)
print(f"推定コスト: ${estimated_cost:.4f}")

# タスク別の最適なmax_tokens設定
def get_optimal_max_tokens(task_type):
    """タスクタイプに応じた最適なmax_tokensを返す"""
    config = {
        "blog_short": 1500,      # 1500字程度のブログ
        "blog_medium": 3000,     # 3000字程度のブログ
        "blog_long": 5000,       # 5000字以上のブログ
        "summary_short": 300,    # 短文要約
        "summary_medium": 600,   # 中文要約
        "json_output": 500,      # JSON出力
        "code_snippet": 800,     # コードスニペット
        "code_full": 2000,       # 完全なコード
        "qa_short": 200,         # 短い回答
        "qa_detailed": 800       # 詳細な回答
    }
    return config.get(task_type, 2000)

# 使用例
task = "blog_medium"
max_tokens = get_optimal_max_tokens(task)

message = client.messages.create(
    model="claude-sonnet-4",
    max_tokens=max_tokens,
    messages=[{"role": "user", "content": "記事を書いてください"}]
)

class CostReviewer:
    def __init__(self, tracker):
        self.tracker = tracker

    def weekly_review(self):
        """週次コストレビュー"""
        print("\n=== 週次コストレビュー ===")

        # 最もコストがかかっているタスクを特定
        # (実装は省略)

        # 改善提案を生成
        suggestions = []

        # キャッシュヒット率が低い場合
        if self.get_cache_hit_rate() < 0.7:
            suggestions.append("プロンプトキャッシュの構造を見直してください")

        # 出力トークン数が多い場合
        if self.get_avg_output_tokens() > 3000:
            suggestions.append("max_tokensの設定を見直してください")

        # リトライ率が高い場合
        if self.get_retry_rate() > 0.15:
            suggestions.append("より高性能なモデルへの切り替えを検討してください")

        for suggestion in suggestions:
            print(f"- {suggestion}")

    def get_cache_hit_rate(self):
        # キャッシュヒット率を計算
        pass

    def get_avg_output_tokens(self):
        # 平均出力トークン数を計算
        pass

    def get_retry_rate(self):
        # リトライ率を計算
        pass