ChatGPT APIの料金計算方法｜gpt-4o・gpt-4o-miniのコスト比較【2026年版】

この方法で何が解決するか

開発者がChatGPT APIを導入するときに直面する課題は「実際にいくら使うと費用になるのか」という予測の難しさです。APIの料金は複雑で、単純な「1回あたり○円」という固定値ではなく、送受信するテキスト量（トークン数）で変動します。

gpt-4o（最新の高性能モデル）とgpt-4o-mini（低コストの軽量版）どちらを選ぶかで、数倍から数十倍のコスト差が生まれることもあります。本記事では、料金体系の仕組みから実際の計算方法、コスト削減のコツ、そして予算超過を自動的に防ぐ仕組みまで、開発者が意思決定に必要な情報をまとめました。

料金体系の基本：トークンとは何か

ChatGPT APIの料金は「トークン」という単位で計算されます。トークンは、テキストを細かく分割した単位で、ざっくり「4文字でトークン1個」という目安です。

料金は以下2つで構成されます：

• 入力トークン: APIに送信するテキスト（ユーザーの質問やシステムプロンプト）の長さ
• 出力トークン: APIから返ってくる回答の長さ

実務的には、出力トークンの方が入力より高い単価に設定されていることが多いです。モデルが「答えを生成する」という処理が、入力を処理するより計算コストがかかるためです。

また、最も頻繁に発生するエラーの1つが『Maximum context length』エラーです。このエラーは、送信するテキストがモデルの最大トークン数を超えたときに発生します。送信前にトークン数をカウントする利点は以下の通りです：

• エラー防止: 『Maximum context length』エラーを事前に検知し、回避できます
• コスト最適化: 実際のAPIコール前に、必要なトークン数を把握して料金計算ができます
• 安定性向上: トークン数が制限を超える場合、テキストを事前に分割や圧縮する対応が可能になります

なお、日本語テキストは英語より多くのトークンを消費します。実行結果の例を見ると、その差は明らかです：

import tiktoken
encoding = tiktoken.encoding_for_model("gpt-4o")

en_tokens = len(encoding.encode("Hello, world!"))
ja_tokens = len(encoding.encode("こんにちは、世界！"))
print(f"英語 'Hello, world!': {en_tokens} tokens")   # 3 tokens
print(f"日本語 'こんにちは、世界！': {ja_tokens} tokens")  # 14 tokens

日本語テキストを扱う場合、文字数の3〜4倍のトークン数を見積もると実態に近くなります。

gpt-4oの料金表

gpt-4oは、OpenAIが2024年以降に公開した最新の高性能モデルです。以下の価格が適用されます。

「1M tokens」は100万トークンという意味です。つまり：

• 入力：100万トークンで5ドル
• 出力：100万トークンで15ドル

実際の計算例を見てみましょう。日本語で200文字の質問をして、500文字の回答が返ってきた場合を想定します。

日本語は1文字がおおよそ1.3トークンになるため：

• 入力：200文字 × 1.3 ≒ 260トークン
• 出力：500文字 × 1.3 ≒ 650トークン
• 合計：910トークン

コスト計算：

入力コスト = 260 / 1,000,000 × $0.005 = $0.0000013
出力コスト = 650 / 1,000,000 × $0.015 = $0.0000098
合計 = $0.0000111（約0.15円）

1回のAPIコールで1円以下というわけです。ただし、アプリケーションが多くのユーザーからアクセスを受けると、これが累積して大きな費用になります。

gpt-4o-miniの料金表

gpt-4o-miniは軽量版で、処理速度と精度を制御したモデルです。料金も大幅に安く設定されています。

gpt-4oと比べると：

• 入力：約33分の1の安さ
• 出力：約25分の1の安さ

同じ例（入力260トークン、出力650トークン）で計算すると：

入力コスト = 260 / 1,000,000 × $0.00015 = $0.000000039
出力コスト = 650 / 1,000,000 × $0.0006 = $0.00000039
合計 = $0.000000429（約0.000006円）

1回でほぼ無視できるコストです。ただし、精度（回答の質）がgpt-4oより落ちる可能性があるため「どのタスクでgpt-4o-miniで十分か」の判断が重要です。

実務的なコスト計算シミュレーション

実際のアプリケーションで月々どの程度費用がかかるか、3つのシナリオで計算してみます。

シナリオ1：チャットボット（月10,000リクエスト、gpt-4o使用）

想定：

• 平均入力：500トークン
• 平均出力：300トークン
• 月リクエスト数：10,000回

計算：

月入力合計 = 10,000 × 500 = 5,000,000トークン
月出力合計 = 10,000 × 300 = 3,000,000トークン

入力コスト = 5,000,000 / 1,000,000 × $0.005 = $25
出力コスト = 3,000,000 / 1,000,000 × $0.015 = $45
月合計 = $70（約9,800円）

シナリオ2：同じチャットボット、gpt-4o-mini使用

同じ条件で、モデルだけgpt-4o-miniに変更：

入力コスト = 5,000,000 / 1,000,000 × $0.00015 = $0.75
出力コスト = 3,000,000 / 1,000,000 × $0.0006 = $1.8
月合計 = $2.55（約360円）

節約効果：$67.45/月（約30倍安い）

ただし、この節約は「gpt-4o-miniの精度で問題ない」という前提での話です。回答の質が落ちて、ユーザー満足度が下がっては本末転倒です。

シナリオ3：大規模な自動処理タスク（月100万リクエスト、gpt-4o-mini使用）

想定：

• 平均入力：100トークン
• 平均出力：200トークン
• 月リクエスト数：1,000,000回

計算：

月入力合計 = 1,000,000 × 100 = 100,000,000トークン
月出力合計 = 1,000,000 × 200 = 200,000,000トークン

入力コスト = 100,000,000 / 1,000,000 × $0.00015 = $15
出力コスト = 200,000,000 / 1,000,000 × $0.0006 = $120
月合計 = $135（約18,900円）

gpt-4oを使った場合：

入力コスト = 100,000,000 / 1,000,000 × $0.005 = $500
出力コスト = 200,000,000 / 1,000,000 × $0.015 = $3,000
月合計 = $3,500（約490,000円）

gpt-4o-miniの節約効果：$3,365/月（約30倍安い）

大規模運用だと、この差は経営判断に直結します。

gpt-4o vs gpt-4o-mini：どっちを使うべき？

選び方の指標を整理します。

gpt-4oを選ぶべき場面

• 高い精度が必須：複雑な推論、専門的な質問への回答、翻訳品質が重要
• ユーザー体験が最優先：エンドユーザー向けのアプリケーション（回答の質が直結する）
• 月のAPIコストが許容範囲：月5万円以上の予算がある、または利用が限定的

実例：

• 医療・法務相談アプリ
• 高度な文章作成支援ツール
• プロダクト向けAIアシスタント機能

gpt-4o-miniを選ぶべき場面

• 定型的なタスク：分類、要約、簡易なコーディング補助
• 大量の自動処理が必要：データ処理、バッチ処理、社内ツール
• コスト最優先：スタートアップやサイドプロジェクト
• 精度の低下が許容できる：間違いがあっても修正可能な業務

実例：

• チャットボット（簡易問答）
• テキスト分類・タグ付けシステム
• 社内ドキュメント要約ツール
• Webスクレイピング後のデータ整形

実際には、ハイブリッド戦略も有効です。複雑なリクエストはgpt-4oで処理し、簡単な質問はgpt-4o-miniで処理するなど、タスクの難度に応じて使い分けることで、コストと品質のバランスを取ることができます。

APIコストの予測と監視の方法

開発段階での予測：tiktokenによるトークン数計算

OpenAIが公開しているPythonライブラリ「tiktoken」を使うと、APIを呼び出す前にローカルでトークン数を即座に計算できます。まずは必要なライブラリをインストールします。

pip install openai tiktoken

動作確認済みバージョン：

• openai: 1.0以上（推奨 1.3以上）
• tiktoken: 0.5以上

基本的なトークン数計算：

import tiktoken

# モデルのエンコーディングを取得
encoding = tiktoken.encoding_for_model("gpt-4o")

# テキストをトークン化
text = "これはテストのテキストです。ChatGPT APIを使用しています。"
tokens = encoding.encode(text)

# トークン数を取得
token_count = len(tokens)
print(f"トークン数: {token_count}")

このコードはローカルで実行でき、計算速度も非常に高速なため、リアルタイムで予算チェックができます。

重要な注意点として、使用するモデルに合わせてエンコーディングを選ぶ必要があります。 モデルによってトークンの分割方法が異なるため、常に同じエンコーディングを使い回すと不正確な計算になります。

# 正しい: 使用するモデルに合わせてエンコーディングを選ぶ
model = "gpt-4o"
encoding = tiktoken.encoding_for_model(model)
tokens = encoding.encode("テキスト")

メッセージリスト全体のトークンカウント

Chat Completionsエンドポイント（複数の会話メッセージを送信する場合）では、メッセージ自体だけでなく、OpenAIが追加するオーバーヘッド（システムプロンプトやメタデータ）も含めてカウントする必要があります。

import tiktoken

def count_messages_tokens(messages, model="gpt-4o"):
    """メッセージリスト全体のトークン数をカウント"""
    encoding = tiktoken.encoding_for_model(model)
    
    # モデルによってオーバーヘッドが異なる
    if model.startswith("gpt-4"):
        tokens_per_message = 3
        tokens_per_name = 1
    else:
        tokens_per_message = 4
        tokens_per_name = -1
    
    num_tokens = 0
    
    for message in messages:
        num_tokens += tokens_per_message
        for key, value in message.items():
            num_tokens += len(encoding.encode(value))
            if key == "name":
                num_tokens += tokens_per_name
    
    num_tokens += 3  # API応答の予約トークン
    return num_tokens

# 使用例
messages = [
    {"role": "system", "content": "あなたは有能なアシスタントです。"},
    {"role": "user", "content": "PythonでAPIを使う方法を教えてください。"}
]

token_count = count_messages_tokens(messages, model="gpt-4o")
print(f"メッセージ全体のトークン数: {token_count}")

各メッセージには4トークンの固定オーバーヘッドがあり、nameフィールドがある場合は+1トークン、最後に2トークンがAPIの応答予約として加算されます。

コスト計算の実装

単にトークン数を知るだけでなく、実際の料金を計算する仕組みも用意しておくと便利です。料金は定期的に更新されるため、アプリケーション内に料金テーブルとして管理します：

import tiktoken
from typing import Dict

# ChatGPT API料金（1M トークンあたりの価格、USD）
# 注: 価格は変動するため、公式ドキュメント（https://openai.com/pricing）で最新情報を確認してください
PRICING = {
    "gpt-4o": {
        "input": 0.005,
        "output": 0.015
    },
    "gpt-4o-mini": {
        "input": 0.00015,
        "output": 0.0006
    }
}

def estimate_cost(
    model: str,
    prompt_text: str,
    estimated_output_tokens: int = 500
) -> Dict[str, float]:
    """
    APIリクエストの予想コストを計算
    """
    encoding = tiktoken.encoding_for_model(model)
    prompt_tokens = len(encoding.encode(prompt_text))

    pricing = PRICING.get(model)
    if not pricing:
        raise ValueError(f"不明なモデル: {model}")

    input_cost = (prompt_tokens / 1_000_000) * pricing["input"]
    output_cost = (estimated_output_tokens / 1_000_000) * pricing["output"]
    total_cost = input_cost + output_cost

    return {
        "model": model,
        "prompt_tokens": prompt_tokens,
        "estimated_output_tokens": estimated_output_tokens,
        "estimated_input_cost": round(input_cost, 6),
        "estimated_output_cost": round(output_cost, 6),
        "estimated_total_cost": round(total_cost, 6),
        "currency": "USD"
    }

# 使用例
prompt = "次のテキストを日本語で要約してください：" + "A" * 5000
cost_estimate = estimate_cost("gpt-4o", prompt, estimated_output_tokens=200)

print(f"モデル: {cost_estimate['model']}")
print(f"入力トークン: {cost_estimate['prompt_tokens']}")
print(f"予想出力トークン: {cost_estimate['estimated_output_tokens']}")
print(f"予想総コスト: ${cost_estimate['estimated_total_cost']}")

なお、出力トークン数は入力の内容によって変動するため完全には予測できません。保守的な見積もりとして、入力トークン数の50%程度・最低200トークンを目安にすると安全です：

def estimate_output_tokens_conservative(prompt_length_tokens: int) -> int:
    """出力トークンを保守的に推定する"""
    return max(200, int(prompt_length_tokens * 0.5))

本番環境での監視

OpenAIダッシュボード（https://platform.openai.com/account/billing/overview）では、リアルタイムの利用状況と費用が表示されます。毎週チェックして「想定より使ってないか、多いか」を確認しましょう。思わぬ大量リクエストや無限ループで月10万円超になっていた、という話も聞きます。

Python SDKを使う場合、以下のような形でAPIコールの結果を記録し、使用量を追跡できます：

from openai import OpenAI

client = OpenAI(api_key="your-api-key")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "こんにちは"}
    ]
)

# トークン数と推定コストを取得
input_tokens = response.usage.prompt_tokens
output_tokens = response.usage.completion_tokens

print(f"入力: {input_tokens}トークン")
print(f"出力: {output_tokens}トークン")

# 推定コスト（gpt-4oの場合）
estimated_cost = (input_tokens / 1_000_000 * 0.005) + (output_tokens / 1_000_000 * 0.015)
print(f"このコール: ${estimated_cost:.6f}")

このログを集計して、週単位・月単位で費用を追跡するのが良い習慣です。

JavaScriptを使う場合：

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "こんにちは" }]
});

const inputTokens = response.usage.prompt_tokens;
const outputTokens = response.usage.completion_tokens;

console.log(`入力: ${inputTokens}トークン`);
console.log(`出力: ${outputTokens}トークン`);

// 推定コスト（gpt-4oの場合）
const estimatedCost = (inputTokens / 1_000_000 * 0.005) + (outputTokens / 1_000_000 * 0.015);
console.log(`このコール: $${estimatedCost.toFixed(6)}`);

自律型予算ゲートの構築

大規模な自動処理では、単なるコスト計算ではなく、予算を超えたらリクエストを自動的に停止する仕組みが有効です。

from datetime import datetime
from typing import Tuple

class BudgetGate:
    """APIコストの予算管理と自動停止機能を提供する"""

    def __init__(self, daily_budget_usd: float, monthly_budget_usd: float):
        self.daily_budget = daily_budget_usd
        self.monthly_budget = monthly_budget_usd
        self.daily_spent = 0.0
        self.monthly_spent = 0.0
        self.day_started = datetime.now().date()
        self.month_started = datetime.now().replace(day=1).date()

    def check_budget(self, cost: float) -> Tuple[bool, str]:
        """リクエストの実行が予算内かどうかをチェック"""
        current_date = datetime.now().date()
        if current_date > self.day_started:
            self.daily_spent = 0.0
            self.day_started = current_date

        current_month_start = datetime.now().replace(day=1).date()
        if current_month_start > self.month_started:
            self.monthly_spent = 0.0
            self.month_started = current_month_start

        if self.daily_spent + cost > self.daily_budget:
            return False, f"日次予算超過: {self.daily_spent:.4f} + {cost:.4f} > {self.daily_budget}"

        if self.monthly_spent + cost > self.monthly_budget:
            return False, f"月次予算超過: {self.monthly_spent:.4f} + {cost:.4f} > {self.monthly_budget}"

        return True, "予算内。実行可能"

    def record_cost(self, cost: float):
        """コスト実績を記録"""
        self.daily_spent += cost
        self.monthly_spent += cost

    def get_status(self) -> Dict:
        """現在の予算状況を取得"""
        return {
            "daily_spent": round(self.daily_spent, 4),
            "daily_budget": self.daily_budget,
            "daily_remaining": round(self.daily_budget - self.daily_spent, 4),
            "monthly_spent": round(self.monthly_spent, 4),
            "monthly_budget": self.monthly_budget,
            "monthly_remaining": round(self.monthly_budget - self.monthly_spent, 4),
        }

# 使用例
budget_gate = BudgetGate(daily_budget_usd=50.0, monthly_budget_usd=1000.0)

cost = 0.15
can_execute, message = budget_gate.check_budget(cost)

if can_execute:
    print(f"リクエスト実行: {message}")
    budget_gate.record_cost(cost)
else:
    print(f"リクエスト中止: {message}")

print(budget_gate.get_status())

この自律型ゲートにより、予算を超えるリスクなく大規模処理を自動実行できます。

コスト削減の実践的なコツ

1. プロンプトの最適化

余計な説明を削ぎ落とし、必要最小限の入力で目的の出力を得る工夫は、トークン数削減に直結します。

悪い例：

あなたはプロの翻訳者です。これからお願いする英文を正確に、かつ自然な日本語に訳してください。
標準的な日本語を使い、ビジネス文書的な雰囲気を保ってください。
意訳ではなく直訳に近い形が理想です。

以下のテキストを訳してください：
Hello, this is a test message.

良い例：

以下の英文を日本語に訳してください：
Hello, this is a test message.

前者はシステムプロンプト的な説明が多く、不要なトークンを浪費しています。後者は簡潔ですが、多くのタスクでは十分です。

2. 回答形式の指定で無駄を削減

APIに「JSON形式で返してください」「100文字以内で」と指定すると、出力トークンを抑制できます。

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "user",
            "content": """
以下のテキストを分類してください。カテゴリーは「ニュース」「Q&A」「商品レビュー」のいずれかです。
JSON形式で、キー「category」に分類結果を返してください。

テキスト：「このスマートウォッチ、バッテリーが3日持つので気に入ってます」
""".strip()
        }
    ]
)

こうすることで、APIは余計な前置きなく、必要なJSON部分だけを返す傾向が強まります。

3. キャッシング（Context Caching）の活用

gpt-4o・gpt-4o-miniでは「Context Caching」という仕組みが利用できます。これは、同じシステムプロンプトや参考資料を何度も送信する場合、一度キャッシュしておいて、2回目以降の費用を削減する機能です。

詳細はOpenAI公式ドキュメント（https://platform.openai.com/docs/api-reference/chat/create）を参照してください。

4. バッチ処理APIの活用

複数のリクエストをまとめて送信する「バッチ処理API」を使うと、通常の半額で実行できます（ただし数時間の遅延が発生）。リアルタイムが必要ないバックグラウンドタスク（ログ分析、定期レポート生成など）はバッチAPIで実行するのが効率的です。

バッチリクエストの準備と予算監視を組み合わせた実装例：

import json
import tiktoken

def prepare_batch_request(requests: list, model: str = "gpt-4o-mini") -> tuple:
    """
    バッチAPIのリクエスト形式にテキストを変換する
    
    Args:
        requests: リクエストの辞書リスト
        model: 使用するモデル
    
    Returns:
        JSONL形式の文字列と総トークン数のタプル
    """
    encoding = tiktoken.encoding_for_model(model)
    total_tokens = 0
    jsonl_lines = []
    
    for i, req in enumerate(requests):
        messages = req.get("messages", [])
        tokens = len(encoding.encode(str(messages)))
        total_tokens += tokens
        
        batch_item = {
            "custom_id": f"request-{i+1}",
            "method": "POST",
            "url": "/v1/chat/completions",
            "body": {
                "model": model,
                "messages": messages,
                "max_tokens": 1000
            }
        }
        jsonl_lines.append(json.dumps(batch_item))
    
    return "\n".join(jsonl_lines), total_tokens

# 使用例
requests = [
    {"messages": [{"role": "user", "content": "Pythonとは何ですか？"}]},
    {"messages": [{"role": "user", "content": "JavaScriptの特徴を教えてください。"}]}
]

jsonl_content, total_tokens = prepare_batch_request(requests)
print(f"バッチのトークン数: {total_tokens}")

予算を監視しながら大量テキストをバッチ処理する実装例：

def batch_process_with_cost_limit(
    texts: list,
    budget_gate: BudgetGate,
    model: str = "gpt-4o-mini",
    max_tokens_per_request: int = 4000
) -> list:
    """複数テキストをバッチで処理し、予算を監視"""
    encoding = tiktoken.encoding_for_model(model)
    batches = []
    current_batch = []
    current_tokens = 0

    for text in texts:
        tokens = len(encoding.encode(text))
        if current_tokens + tokens > max_tokens_per_request:
            batches.append(current_batch)
            current_batch = [text]
            current_tokens = tokens
        else:
            current_batch.append(text)
            current_tokens += tokens

    if current_batch:
        batches.append(current_batch)

    results = []
    for batch_idx, batch in enumerate(batches):
        batch_text = "\n---\n".join(batch)
        tokens = len(encoding.encode(batch_text))
        pricing = PRICING.get(model, {"input": 0.00015, "output": 0.0006})
        estimated_cost = (tokens / 1_000_000) * pricing["input"] + \
                         (tokens * 0.5 / 1_000_000) * pricing["output"]

        can_execute, message = budget_gate.check_budget(estimated_cost)
        if not can_execute:
            print(f"バッチ {batch_idx+1}: スキップ（予算超過）- {message}")
            results.append(None)
            continue

        print(f"バッチ {batch_idx+1}/{len(batches)}: 実行中...")
        budget_gate.record_cost(estimated_cost)
        results.append(batch_text)

    return results

# 使用例
budget_gate = BudgetGate(daily_budget_usd=10.0, monthly_budget_usd=100.0)
texts = ["テキスト1", "テキスト2", "テキスト3"]
results = batch_process_with_cost_limit(texts, budget_gate)
print(f"処理完了: {len([r for r in results if r])} / {len(texts)} バッチ")

ChatGPT API vs Claude API：料金比較（2026年版）

「どちらのAPIを使うべきか」という判断に役立つよう、OpenAI と Anthropic の料金を並べます。

日本語処理での注意点: 日本語はOpenAIより Anthropic のモデルの方がトークン効率が高いケースがあります。同じ日本語文章でも消費トークン数が異なるため、実際にテストして比較することを推奨します。

選択の目安:

• 画像・音声処理が必要 → gpt-4oシリーズ（マルチモーダルが充実）
• 純テキスト・日本語処理が多い → Claude Haikuも有力な選択肢
• コスト最優先の大量処理 → gpt-4o-mini vs Claude Haiku で実測比較

あわせて読みたい

• Claude API月2ドルで使う方法｜curl代理サーバー構築【3ステップ】
• Claude OpusとSonnetを1つのAPIで連携させる方法｜コスト削減＆高速化
• Claude Codeのトークン消費を98%削減する方法【MCP活用＋コンテキスト最適化】