Grok 3 API Rate Limits: 完全ガイド (2026年版)

Grok 3 API レート制限：2026年完全ガイド

xAIの Grok 3 は、フロンティアモデル分野における強力な選択肢であり、その API は OpenAI 互換の形式で全 Grok モデルファミリーへのアクセスを提供します。アプリケーションの構築、バッチ処理の実行、またはワークフローへの Grok の統合のいずれであっても、中断を避け、信頼性の高いシステムを設計するためには、レート制限（Rate Limits）を理解することが不可欠です。

このガイドでは、ティア別の構成、ヘッダー情報、エラーハンドリング、および制限内で運用するための実践的な戦略など、Grok 3 API レート制限のあらゆる側面について解説します。

Grok 3 API モデルの概要

制限の詳細に入る前に、xAI API で利用可能なモデルを確認しておきましょう。

モデル	コンテキストウィンドウ	特徴・強み	ユースケース
grok-3	131,072 トークン	最先端の推論・分析	複雑なタスク、研究
grok-3-fast	131,072 トークン	高速な応答、わずかに低い品質	リアルタイムアプリ、チャット
grok-3-mini	131,072 トークン	効率的、コストパフォーマンス	シンプルなタスク、大量処理
grok-3-mini-fast	131,072 トークン	最速、最も低価格	低遅延が要求されるアプリ

すべてのモデルで 131K のコンテキストウィンドウを共有しており、これは GPT-4o (128K) や Claude (200K) と同等の競争力を持っています。

レート制限ティア（Tier）

xAI は、アカウントの利用実績（支払い額）に基づいた段階的なレート制限システムを採用しています。利用額が増えるにつれて、制限は自動的に引き上げられます。

Free Tier（無料ティア）

API キーを持つ新規アカウントには、API を試用するための月間無料クレジットが付与されます。

制限タイプ	Free Tier
月間クレジット	$25
1分あたりのリクエスト数 (RPM)	5
1時間あたりのリクエスト数 (RPH)	60
1分あたりのトークン数 (TPM - 入力)	15,000
1分あたりのトークン数 (TPM - 出力)	5,000
同時実行リクエスト数	2

Tier 1 ($0以上支払い)

支払い方法を追加し、何らかの購入を行った直後の状態：

制限タイプ	Tier 1
1分あたりのリクエスト数	60
1時間あたりのリクエスト数	1,000
1分あたりのトークン数 (入力)	100,000
1分あたりのトークン数 (出力)	25,000
同時実行リクエスト数	10

Tier 2 ($100以上支払い)

制限タイプ	Tier 2
1分あたりのリクエスト数	200
1時間あたりのリクエスト数	5,000
1分あたりのトークン数 (入力)	500,000
1分あたりのトークン数 (出力)	100,000
同時実行リクエスト数	25

Tier 3 ($500以上支払い)

制限タイプ	Tier 3
1分あたりのリクエスト数	500
1時間あたりのリクエスト数	20,000
1分あたりのトークン数 (入力)	1,000,000
1分あたりのトークン数 (出力)	250,000
同時実行リクエスト数	50

Tier 4 ($1,000以上支払い)

制限タイプ	Tier 4
1分あたりのリクエスト数	1,000
1時間あたりのリクエスト数	50,000
1分あたりのトークン数 (入力)	2,000,000
1分あたりのトークン数 (出力)	500,000
同時実行リクエスト数	100

レート制限ヘッダー

すべての API レスポンスには、現在のレート制限ステータスを示すヘッダーが含まれています。

x-ratelimit-limit-requests: 60
x-ratelimit-limit-tokens: 100000
x-ratelimit-remaining-requests: 58
x-ratelimit-remaining-tokens: 95234
x-ratelimit-reset-requests: 2026-02-06T12:00:32Z
x-ratelimit-reset-tokens: 2026-02-06T12:00:15Z

ヘッダーのリファレンス:

ヘッダー	説明
x-ratelimit-limit-requests	割り当てられたティアの1分あたりの最大リクエスト数
x-ratelimit-limit-tokens	割り当てられたティアの1分あたりの最大トークン数
x-ratelimit-remaining-requests	現在のウィンドウで残っているリクエスト数
x-ratelimit-remaining-tokens	現在のウィンドウで残っているトークン数
x-ratelimit-reset-requests	リクエスト制限がリセットされる時刻
x-ratelimit-reset-tokens	トークン制限がリセットされる時刻

最初のアピコール

Grok API は OpenAI 互換のフォーマットを使用しているため、既存のコードへの統合が容易です。

import openai

client = openai.OpenAI(
    api_key="YOUR_XAI_API_KEY",
    base_url="https://api.x.ai/v1"
)

response = client.chat.completions.create(
    model="grok-3",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain the PageRank algorithm."}
    ],
    temperature=0.7,
    max_tokens=2048
)

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

レート制限エラーの処理

レート制限を超えると、API は 429 Too Many Requests ステータスコードを返します。以下は適切な処理方法です。

import openai
import time
from openai import RateLimitError

client = openai.OpenAI(
    api_key="YOUR_XAI_API_KEY",
    base_url="https://api.x.ai/v1"
)

def call_grok_with_retry(messages, model="grok-3", max_retries=5):
    """レート制限発生時に指数バックオフを用いて Grok API を呼び出す"""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=0.7,
                max_tokens=2048
            )
            return response.choices[0].message.content
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            # 指数バックオフ: 1秒, 2秒, 4秒, 8秒, 16秒
            wait_time = 2 ** attempt
            print(f"レート制限にかかりました。再試行まで {wait_time}秒 待機します...")
            time.sleep(wait_time)
        except Exception as e:
            print(f"予期しないエラー: {e}")
            raise

# 使用例
result = call_grok_with_retry([
    {"role": "user", "content": "Internetの歴史について要約してください。"}
])
print(result)

上級編: レートリミッタークラス

本番環境のアプリケーションでは、使用状況を事前に追跡するレートリミッターを使用することをお勧めします。

import time
import threading
from collections import deque

class GrokRateLimiter:
    """Grok API 用のプロアクティブ・レートリミッター"""

    def __init__(self, max_requests_per_minute=60, max_tokens_per_minute=100000):
        self.max_rpm = max_requests_per_minute
        self.max_tpm = max_tokens_per_minute
        self.request_timestamps = deque()
        self.token_counts = deque()
        self.lock = threading.Lock()

    def wait_if_needed(self, estimated_tokens=1000):
        """レート制限内でリクエストが可能になるまでブロックする"""
        with self.lock:
            now = time.time()
            window_start = now - 60

            # 古いエントリを削除
            while self.request_timestamps and self.request_timestamps[0] < window_start:
                self.request_timestamps.popleft()
                self.token_counts.popleft()

            # リクエスト制限をチェック
            if len(self.request_timestamps) >= self.max_rpm:
                sleep_time = self.request_timestamps[0] - window_start
                time.sleep(max(sleep_time, 0.1))

            # トークン制限をチェック
            current_tokens = sum(self.token_counts)
            if current_tokens + estimated_tokens > self.max_tpm:
                sleep_time = self.token_counts[0] - window_start if self.token_counts else 1
                time.sleep(max(sleep_time, 0.1))

            # このリクエストを記録
            self.request_timestamps.append(time.time())
            self.token_counts.append(estimated_tokens)

# 使用例
limiter = GrokRateLimiter(max_requests_per_minute=60, max_tokens_per_minute=100000)

for prompt in prompts:
    limiter.wait_if_needed(estimated_tokens=500)
    result = call_grok_with_retry([{"role": "user", "content": prompt}])

Grok 3 API の料金

レート制限だけでなく、コストの考慮も重要です。各モデルの料金は以下の通りです。

モデル	入力 (100万トークンあたり)	出力 (100万トークンあたり)
grok-3	$3.00	$15.00
grok-3-fast	$5.00	$25.00
grok-3-mini	$0.30	$0.50
grok-3-mini-fast	$0.10	$0.50

注意点として grok-3-fast は、高速かつわずかに低品質なバリアントであるにもかかわらず、grok-3 よりも高価に設定されています。コスト重視のアプリケーションでは、grok-3-mini や grok-3-mini-fast が大幅な節約になります。

制限内に収めるための戦略

1. タスクに適したモデルを使用する

grok-3-mini-fast で処理可能なタスクに grok-3 を使用しないでください。

def choose_model(task_complexity):
    """タスクの複雑さに基づいて適切なモデルを選択する"""
    if task_complexity == "simple":
        return "grok-3-mini-fast"  # 分類、抽出、フォーマット整形
    elif task_complexity == "medium":
        return "grok-3-mini"       # 要約、Q&A、翻訳
    elif task_complexity == "complex":
        return "grok-3-fast"       # 分析、コーディング、クリエイティブライティング
    else:
        return "grok-3"           # 研究、複雑な推論、マルチステップタスク

2. リクエストのバッチ化

複数の小さなプロンプトを 1 つのリクエストにまとめます。

# 5つの別個のリクエストを送るのではなく:
# 「Xをフランス語に翻訳」、「Yをフランス語に翻訳」...

# 1つのリクエストを使用:
prompt = """以下の各文をフランス語に翻訳してください:
1. Hello, how are you?
2. Where is the nearest train station?
3. I would like to order coffee.
4. What time does the museum close?
5. Thank you very much."""

# 5回ではなく1回のリクエストで済む

3. レスポンスのキャッシュ

同一のクエリを繰り返さないよう、レスポンスをローカルに保存します。

import hashlib
import json
import os

CACHE_DIR = ".grok_cache"
os.makedirs(CACHE_DIR, exist_ok=True)

def cached_grok_call(messages, model="grok-3"):
    """API呼び出しをキャッシュして重複リクエストを避ける"""
    cache_key = hashlib.md5(
        json.dumps({"messages": messages, "model": model}).encode()
    ).hexdigest()
    cache_path = os.path.join(CACHE_DIR, f"{cache_key}.json")

    if os.path.exists(cache_path):
        with open(cache_path, "r") as f:
            return json.load(f)["response"]

    response = call_grok_with_retry(messages, model=model)

    with open(cache_path, "w") as f:
        json.dump({"response": response}, f)

    return response

4. ヘッダーによる使用状況の監視

レート制限ヘッダーを解析し、情報に基づいた判断を行います。

def call_with_monitoring(messages, model="grok-3"):
    """APIを呼び出し、レート制限の状態を報告する"""
    response = client.chat.completions.with_raw_response.create(
        model=model,
        messages=messages,
        max_tokens=2048
    )

    headers = response.headers
    remaining_requests = int(headers.get("x-ratelimit-remaining-requests", 0))
    remaining_tokens = int(headers.get("x-ratelimit-remaining-tokens", 0))

    if remaining_requests < 5:
        print(f"Warning: この1分間の残りリクエスト数はあと {remaining_requests} 回です")
    if remaining_tokens < 5000:
        print(f"Warning: この1分間の残りトークン数はあと {remaining_tokens} です")

    return response.parse().choices[0].message.content

Grok 3 と競合他社の比較

プロバイダー	無料ティア RPM	有料ティア RPM	無料クレジット
xAI (Grok 3)	5	60-1,000+	$25/月
OpenAI (GPT-4o)	3	500-10,000	$5 (初回のみ)
Anthropic (Claude)	5	50-4,000	$5 (初回のみ)
Google (Gemini 2.5 Pro)	5	360-1,000	$0 (無料枠あり)

結論

Grok 3 API は、利用状況に応じてスケールする競争力のあるレート制限、統合が容易な OpenAI 互換インターフェース、そして開始に十分な無料ティアを提供しています。適切なモデルティアの選択、適切なリトライロジックの実装、レスポンスのキャッシュを行うことで、制限内でスムーズに動作する信頼性の高いアプリケーションを構築できます。

もしプロジェクトで Grok によるテキストや推論に加えて、AI アバター、Text-to-Video、音声クローニングなどの AI 生成メディアが必要な場合は、Hypereal AI をご検討ください。既存の AI スタックとシームレスに統合できるプロダクショングレードの生成メディアモデルへ、シンプルな従量課金制 API でアクセス可能です。