クロードAPI

What does your application need?

0. Are you deploying through Amazon Bedrock, Google Vertex AI, or Microsoft Foundry?
    Yes -> Claude API (+ tool use for agents) - Managed Agents is 1P only.
   No -> continue.

1. Single LLM call (classification, summarization, extraction, Q&A)
    Claude API - one request, one response

2. Do you want Anthropic to run the agent loop and host a per-session
   container where Claude executes tools (bash, file ops, code)?
    Yes -> Managed Agents - server-managed sessions, persisted agent configs,
       SSE event stream, Skills + MCP, file mounts.
       Examples: "stateful coding agent with a workspace per task",
                 "long-running research agent that streams events to a UI",
                 "agent with persisted, versioned config used across many sessions"

3. Workflow (multi-step, code-orchestrated, with your own tools)
    Claude API with tool use - you control the loop

4. Open-ended agent (model decides its own trajectory, your own tools, you host the compute)
    Claude API agentic loop (maximum flexibility)

# Message Batches API — Python

The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.

## Key Facts

- Up to 100,000 requests or 256 MB per batch
- Most batches complete within 1 hour; maximum 24 hours
- Results available for 29 days after creation
- 50% cost reduction on all token usage
- All Messages API features supported (vision, tools, caching, etc.)

---

## Create a Batch

```python
輸入人間
anthropic.types.message_create_params から import MessageCreateParamsNonStreaming
anthropic.types.messages.batch_create_params インポート リクエストから

client = anthropic.Anthropic()

message_batch = client.messages.batches.create(
    リクエスト=[
        リクエスト(
            カスタムid="リクエスト-1",
            params=MessageCreateParamsNonStreaming(
                モデル = "クロード-作品-4-7",
                max_tokens=16000、
                messages=[{"role": "user", "content": "気候変動の影響の概要"}]
            )
        ）、
        リクエスト(
            カスタムid="リクエスト-2",
            params=MessageCreateParamsNonStreaming(
                モデル = "クロード-作品-4-7",
                max_tokens=16000、
                messages=[{"role": "user", "content": "量子コンピューティングの基礎を説明する"}]
            )
        ）、
    】
)

print(f"バッチID:{message_batch.id}")
print(f"ステータス: {message_batch.processing_status}")

インポート時間

True の場合:
    バッチ = client.messages.batches.retrieve(message_batch.id)
    バッチ.processing_status == "終了"の場合:
        休憩
    print(f"ステータス: {batch.processing_status}、処理中: {batch.request_counts.processing}")
    時間.睡眠(60)

print("バッチ完了!")
print(f"成功しました: {batch.request_counts.succeeded}")
print(f"エラー: {batch.request_counts.errored}")

client.messages.batches.results(message_batch.id) の結果:
    一致結果.結果.タイプ:
        ケース「成功」:
            msg = 結果.結果.メッセージ
            text = next((b.type == "text"の場合、msg.contentのbのb.text), "")
            print(f"[{result.custom_id}] {text[:100]}")
        ケース「エラー」:
            if result.result.error.type == "invalid_request":
                print(f"[{result.custom_id}] 検証エラー - リクエストを修正して再試行してください")
            それ以外の場合:
                print(f"[{result.custom_id}] サーバー エラー - 再試行しても安全です")
        ケースが「キャンセルされました」:
            print(f"[{result.custom_id}] キャンセルされました")
        ケース「期限切れ」:
            print(f"[{result.custom_id}] 期限切れ - 再送信")

キャンセルされました = client.messages.batches.cancel(message_batch.id)
print(f"ステータス: {cancelled.processing_status}") # "キャンセル中"

共有システム = [
    {"type": "text", "text": "あなたは文学アナリストです。"},
    {
        "タイプ": "テキスト",
        "text":large_document_text、#すべてのリクエスト間で共有されます
        "cache_control": {"type": "ephemeral"}
    }
】

message_batch = client.messages.batches.create(
    リクエスト=[
        リクエスト(
            Custom_id=f"分析-{i}",
            params=MessageCreateParamsNonStreaming(
                モデル = "クロード-作品-4-7",
                max_tokens=16000、
                システム=共有システム、
                メッセージ=[{"役割": "ユーザー", "コンテンツ": 質問}]
            )
        )
        for i、enumerate(questions) の質問
    】
)

輸入人間
インポート時間
anthropic.types.message_create_params から import MessageCreateParamsNonStreaming
anthropic.types.messages.batch_create_params インポート リクエストから

client = anthropic.Anthropic()

# 1. リクエストの準備
分類する項目 = [
    「製品の品質は素晴らしいです！」、
    「ひどい顧客サービス、二度とありません。」、
    「大丈夫、特に何もないよ。」
】

リクエスト = [
    リクエスト(
        Custom_id=f"classify-{i}",
        params=MessageCreateParamsNonStreaming(
            モデル = "クロード-俳句-4-5",
            max_tokens=50、
            メッセージ=[{
                "ロール": "ユーザー",
                "content": f"ポジティブ/ネガティブ/ニュートラルに分類 (1 単語): {text}"
            }]
        )
    )
    for i、enumerate(items_to_classify) のテキスト
】

# 2. バッチの作成
バッチ = client.messages.batches.create(requests=リクエスト)
print(f"作成されたバッチ: {batch.id}")

# 3. 完了を待ちます
True の場合:
    バッチ = client.messages.batches.retrieve(batch.id)
    バッチ.processing_status == "終了"の場合:
        休憩
    時間.睡眠(10)

# 4. 結果を収集する
結果 = {}
client.messages.batches.results(batch.id) の結果の場合:
    result.result.type == "成功"の場合:
        msg = 結果.結果.メッセージ
        results[result.custom_id] = next((b.type == "text"の場合、msg.contentのbのb.text), "")

Custom_id の場合、sorted(results.items()) での分類:
    print(f"{custom_id}: {classification}")

### python/claude-api/files-api.md

[Python/claude-api/files-api.md をダウンロード](/skills/claude-api/python/claude-api/files-api.md)

```markdown
# Files API — Python

The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.

**Beta:** Pass `betas=["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).

## Key Facts

- Maximum file size: 500 MB
- Total storage: 100 GB per organization
- Files persist until deleted
- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
- Not available on Amazon Bedrock or Google Vertex AI

---

## Upload a File

```python
輸入人間

client = anthropic.Anthropic()

アップロード = client.beta.files.upload(
    file=("レポート.pdf", open("レポート.pdf", "rb"), "アプリケーション/pdf"),
)
print(f"ファイルID:{uploaded.id}")
print(f"サイズ: {uploaded.size_bytes} バイト")

応答 = client.beta.messages.create(
    モデル = "クロード-作品-4-7",
    max_tokens=16000、
    メッセージ=[{
        "ロール": "ユーザー",
        「コンテンツ」: [
            {"type": "text", "text": "このレポートの主な調査結果を要約します。"},
            {
                "タイプ": "ドキュメント",
                "ソース": {"タイプ": "ファイル", "file_id": アップロードされた.id},
                "title": "第 4 四半期レポート"、# オプション
                "citations": {"enabled": True} # オプション、引用を有効にします
            }
        】
    }]、
    betas=["files-api-2025-04-14"],
)
response.content のブロックの場合:
    block.type == "テキスト"の場合:
        print(ブロック.テキスト)

image_file = client.beta.files.upload(
    file=("photo.png", open("photo.png", "rb"), "image/png"),
)

応答 = client.beta.messages.create(
    モデル = "クロード-作品-4-7",
    max_tokens=16000、
    メッセージ=[{
        "ロール": "ユーザー",
        「コンテンツ」: [
            {"type": "text", "text": "この画像には何が入っていますか?"},
            {
                "タイプ": "画像",
                "ソース": {"タイプ": "ファイル", "ファイルID": 画像ファイルID}
            }
        】
    }]、
    betas=["files-api-2025-04-14"],
)

ファイル = client.beta.files.list()
files.data の f の場合:
    print(f"{f.id}: {f.filename} ({f.size_bytes} バイト)")

file_info = client.beta.files.retrieve_metadata("file_011CNha8iCJcU1wXNR6q4V8w")
print(f"ファイル名: {file_info.filename}")
print(f"MIMEタイプ: {file_info.mime_type}")

client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w")

file_content = client.beta.files.download("file_011CNha8iCJcU1wXNR6q4V8w")
file_content.write_to_file("output.txt")

輸入人間

client = anthropic.Anthropic()

# 1.一度アップロードする
アップロード = client.beta.files.upload(
    file=("contract.pdf", open("contract.pdf", "rb"), "application/pdf"),
)
print(f"アップロード済み: {uploaded.id}")

# 2. 同じ file_id を使用して複数の質問をする
質問 = [
    「重要な利用規約は何ですか?」、
    「解約条項とは何ですか?」
    "支払いスケジュールを要約します。",
】

質問中の質問について:
    応答 = client.beta.messages.create(
        モデル = "クロード-作品-4-7",
        max_tokens=16000、
        メッセージ=[{
            "ロール": "ユーザー",
            「コンテンツ」: [
                {"タイプ": "テキスト", "テキスト": 質問},
                {
                    "タイプ": "ドキュメント",
                    "ソース": {"タイプ": "ファイル", "ファイルID": アップロードされた.ID}
                }
            】
        }]、
        betas=["files-api-2025-04-14"],
    )
    print(f"\nQ: {question}")
    text = next((response.contentのbのb.text if b.type == "text"), "")
    print(f"A: {text[:200]}")

# 3. 終わったら片付ける
client.beta.files.delete(uploaded.id)

### python/claude-api/streaming.md

[Python/claude-api/streaming.md をダウンロード](/skills/claude-api/python/claude-api/streaming.md)

```markdown
# Streaming — Python

## Quick Start

```python
client.messages.stream( を使用)
    モデル = "クロード-作品-4-7",
    max_tokens=64000、
    メッセージ=[{"役割": "ユーザー", "コンテンツ": "ストーリーを書く"}]
) ストリームとして:
    stream.text_stream 内のテキストの場合:
        print(text, end="", flash=True)

async_client.messages.stream( との非同期)
    モデル = "クロード-作品-4-7",
    max_tokens=64000、
    メッセージ=[{"役割": "ユーザー", "コンテンツ": "ストーリーを書く"}]
) ストリームとして:
    stream.text_stream 内のテキストの非同期:
        print(text, end="", flash=True)

client.messages.stream( を使用)
    モデル = "クロード-作品-4-7",
    max_tokens=64000、
    Thinking={"タイプ": "アダプティブ"},
    メッセージ=[{"役割": "ユーザー", "コンテンツ": "この問題を分析する"}]
) ストリームとして:
    ストリーム内のイベントの場合:
        イベントタイプ == "content_block_start" の場合:
            ifevent.content_block.type == "思考":
                print("\n[考え中...]")
            elifevent.content_block.type == "テキスト":
                print("\n[応答:]")

        elif イベント.タイプ == "content_block_delta":
            ifevent.delta.type == " Thinking_delta ":
                print(event.delta. Thinking, end="", flash=True)
            elifevent.delta.type == "text_delta":
                print(event.delta.text, end="", flash=True)

client.messages.stream( を使用)
    モデル = "クロード-作品-4-7",
    max_tokens=64000、
    ツール=道具、
    メッセージ=メッセージ
) ストリームとして:
    stream.text_stream 内のテキストの場合:
        print(text, end="", flash=True)

    応答 = stream.get_final_message()
    # response.stop_reason == "tool_use" の場合、ツールの実行を続行します。

client.messages.stream( を使用)
    モデル = "クロード-作品-4-7",
    max_tokens=64000、
    メッセージ=[{"役割": "ユーザー", "コンテンツ": "こんにちは"}]
) ストリームとして:
    stream.text_stream 内のテキストの場合:
        print(text, end="", flash=True)

    # ストリーミング後に完全なメッセージを取得する
    Final_message = stream.get_final_message()
    print(f"\n\n使用されたトークン: {final_message.usage.output_tokens}")

def stream_with_progress(client, **kwargs):
    """進捗状況の更新を含む応答をストリーミングします。"""
    total_tokens = 0
    コンテンツパーツ = []

    client.messages.stream(**kwargs) をストリームとして使用:
        ストリーム内のイベントの場合:
            イベントタイプ == "content_block_delta" の場合:
                イベント.デルタ.タイプ == "テキストデルタ"の場合:
                    テキスト = イベント.デルタ.テキスト
                    content_parts.append(テキスト)
                    print(text, end="", flash=True)

            elif イベント.タイプ == "message_delta":
                event.usage とevent.usage.output_tokens が None でない場合:
                    total_tokens = イベント.使用量.出力トークン

        Final_message = stream.get_final_message()

    print(f"\n\n[使用されたトークン: {total_tokens}]")
    return "".join(content_parts)

試してみてください:
    client.messages.stream( を使用)
        モデル = "クロード-作品-4-7",
        max_tokens=64000、
        メッセージ=[{"役割": "ユーザー", "コンテンツ": "ストーリーを書く"}]
    ) ストリームとして:
        stream.text_stream 内のテキストの場合:
            print(text, end="", flash=True)
anthropic.APIConnectionError を除く:
    print("\n接続が失われました。再試行してください。")
anthropic.RateLimitError を除く:
    print("\nレートが制限されています。待ってから再試行してください。")
e としての anthropic.APIStatusError を除く:
    print(f"\nAPI エラー: {e.status_code}")

### python/claude-api/tool-use.md

[Python/claude-api/tool-use.md をダウンロード](/skills/claude-api/python/claude-api/tool-use.md)

_バイナリリソース_

### python/管理対象エージェント/README.md

[Python/管理対象エージェント/README.md をダウンロード](/skills/claude-api/python/管理対象エージェント/README.md)

_バイナリリソース_

### ルビー/クロード-api.md

[ruby/claude-api.md をダウンロード](/skills/claude-api/ruby/claude-api.md)

```markdown
# Claude API — Ruby

> **Note:** The Ruby SDK supports the Claude API. A tool runner is available in beta via `client.beta.messages.tool_runner()`. Agent SDK is not yet available for Ruby.

## Installation

```bash
gem インストール anthropic

「人間性」が必要

# デフォルト (ANTHROPIC_API_KEY 環境変数を使用)
client = Anthropic::Client.new

# 明示的な API キー
client = Anthropic::Client.new(api_key: "あなたの API キー")

メッセージ = client.messages.create(
  モデル::"クロード-作品-4-7",
  max_tokens: 16000、
  メッセージ: [
    { 役割: "ユーザー"、内容: 「フランスの首都はどこですか?」 }
  】
)
# content は多態性ブロック オブジェクト (TextBlock、ThinkingBlock、
# ツール使用ブロック、...)。.type はシンボルです。「text」ではなく、:text と比較してください。
# .text は、TextBlock 以外のエントリに対して NoMethodError を発生させます。
message.content.each は |block| を実行します。
  block.type ==:text の場合、block.text を配置します
終わり

ストリーム = client.messages.stream(
  モデル::"クロード-作品-4-7",
  max_tokens: 64000、
  メッセージ: [{ 役割: "ユーザー"、コンテンツ: "俳句を書く" }]
)

stream.text.each { |text|印刷(テキスト) }

クラス GetWeatherInput < Anthropic::BaseModel
  必須:location, String, doc: "都市と州、例: カリフォルニア州サンフランシスコ"
終わり

クラス GetWeather < Anthropic::BaseTool
  ドキュメント「場所の現在の天気を取得する」

  input_schema GetWeatherInput

  デフォルト呼び出し(入力)
    「#{input.location}の天気は晴れ、気温は72°Fです。」
  終わり
終わり

client.beta.messages.tool_runner(
  モデル::「クロード作品-4-7」、
  max_tokens: 16000、
  ツール: [GetWeather.new]、
  メッセージ: [{ 役割: "ユーザー"、コンテンツ: "サンフランシスコの天気はどうですか?" }]
).each_message は |message| を実行します。
  message.content を挿入します
終わり

メッセージ = client.messages.create(
  モデル::"クロード-作品-4-7",
  max_tokens: 16000、
  システム_: [
    { タイプ: "テキスト"、テキスト: long_system_prompt、キャッシュ_コントロール: { タイプ: "一時的" } }
  ]、
  メッセージ: [{ 役割: "ユーザー"、コンテンツ: "重要なポイントをまとめます" }]
)

### Ruby/管理対象エージェント/README.md

[ruby/管理対象エージェント/README.md をダウンロード](/skills/claude-api/ruby/管理対象エージェント/README.md)

_バイナリリソース_

### 共有/エージェントデザイン.md

[shared/agent-design.md をダウンロード](/skills/claude-api/shared/agent-design.md)

_バイナリリソース_

### 共有/エラーコード.md

[shared/error-codes.md をダウンロード](/skills/claude-api/shared/error-codes.md)

_バイナリリソース_

### 共有/ライブソース.md

[shared/live-sources.md をダウンロード](/skills/claude-api/shared/live-sources.md)

_バイナリリソース_

### 共有/管理対象エージェント-api-reference.md

[shared/managed-agents-api-reference.md をダウンロード](/skills/claude-api/shared/managed-agents-api-reference.md)

_バイナリリソース_

### 共有/管理対象エージェント-クライアント-パターン.md

[shared/managed-agents-client-patterns.md をダウンロード](/skills/claude-api/shared/managed-agents-client-patterns.md)

_バイナリリソース_

### 共有/管理対象エージェント-core.md

[shared/managed-agents-core.md をダウンロード](/skills/claude-api/shared/managed-agents-core.md)

_バイナリリソース_

### 共有/管理対象エージェント環境.md

[shared/managed-agents-environments.md をダウンロード](/skills/claude-api/shared/managed-agents-environments.md)

_バイナリリソース_

### 共有/管理対象エージェント-イベント.md

[shared/managed-agents-events.md をダウンロード](/skills/claude-api/shared/managed-agents-events.md)

_バイナリリソース_

### 共有/管理対象エージェント-メモリ.md

[shared/managed-agents-memory.md をダウンロード](/skills/claude-api/shared/managed-agents-memory.md)

_バイナリリソース_

### 共有/管理対象エージェント-multiagent.md

[shared/managed-agents-multiagent.md をダウンロード](/skills/claude-api/shared/managed-agents-multiagent.md)

_バイナリリソース_

### 共有/管理対象エージェント-onboarding.md

[shared/managed-agents-onboarding.md をダウンロード](/skills/claude-api/shared/managed-agents-onboarding.md)

_バイナリリソース_

### 共有/管理対象エージェント-結果.md

[shared/managed-agents-outcomes.md をダウンロード](/skills/claude-api/shared/managed-agents-outcomes.md)

_バイナリリソース_

### 共有/管理対象エージェントの概要.md

[shared/managed-agents-overview.md をダウンロード](/skills/claude-api/shared/managed-agents-overview.md)

_バイナリリソース_

### 共有/管理対象エージェント-ツール.md

[shared/managed-agents-tools.md をダウンロード](/skills/claude-api/shared/managed-agents-tools.md)

_バイナリリソース_

### 共有/管理エージェント-webhooks.md

[shared/managed-agents-webhooks.md をダウンロード](/skills/claude-api/shared/managed-agents-webhooks.md)

```markdown
# Managed Agents — Webhooks

Anthropic can POST to your HTTPS endpoint when a Managed Agents resource changes state — an alternative to holding an SSE stream or polling. Payloads are **thin** (event type + resource IDs only); on receipt, fetch the resource for current state. Every delivery is HMAC-signed.

> **Direction matters.** This page covers *Anthropic → you* notifications about session/vault state. It does **not** cover *third-party → you* webhooks that *trigger* a session (e.g. a GitHub push handler that calls `sessions.create()`) — that's ordinary application code on your side with no Anthropic-specific wire format.

---

## Register an endpoint (Console only)

Console → **Manage → Webhooks**. There is no programmatic endpoint-management API yet. Secret rotation is supported from the same page.

| Field | Constraint |
|---|---|
| URL | HTTPS on port 443, publicly resolvable hostname |
| Event types | Subscribe per `data.type` — you only receive subscribed types (plus test events) |
| Signing secret | `whsec_`-prefixed, 32 bytes, **shown once at creation** — store it |

---

## Verify the signature

Every delivery is HMAC-signed. **Use the SDK's `client.beta.webhooks.unwrap()`** — it verifies the signature, rejects payloads more than ~5 minutes old, and returns the parsed event. It reads the `whsec_` secret from `ANTHROPIC_WEBHOOK_SIGNING_KEY`.

```python
輸入人間
フラスコからのインポート Flask、リクエスト

client = anthropic.Anthropic() # 環境から ANTHROPIC_WEBHOOK_SIGNING_KEY を読み取ります
app = Flask(__name__)


@app.route("/webhook",methods=["POST"])
def webhook():
    試してみてください:
        イベント = client.beta.webhooks.unwrap(
            request.get_data(as_text=True),
            headers=dict(request.headers),
        )
    例外を除く:
        「無効な署名」を返します、400

    ifevent.id in seen_event_ids: 重複排除再試行回数 — ID は配信ごとではなくイベントごとです
        ""を返します、204
    seen_event_ids.add(イベント.id)

    一致event.data.type:
        ケース「session.status_idled」:
            session = client.beta.sessions.retrieve(event.data.id)
            通知ユーザー(セッション)
        ケース「vault_credential.refresh_failed」:
            アラート_オンコール(event.data.id)

    ""を返します、204

{
  "タイプ": "イベント",
  "id": "event_01ABC...",
  "created_at": "2026-03-18T14:05:22Z",
  「データ」: {
    "タイプ": "セッション.ステータス_アイドル",
    "id": "session_01XYZ...",
    "組織ID": "8a3d2f1e-...",
    "workspace_id": "c7b0e4d9-..."
  }
}

### 共有/モデル-移行.md

[shared/model-migration.md をダウンロード](/skills/claude-api/shared/model-migration.md)

_バイナリリソース_

### 共有/models.md

[shared/models.md をダウンロード](/skills/claude-api/shared/models.md)

_バイナリリソース_

### 共有/プロンプト-キャッシング.md

[shared/prompt-caching.md をダウンロード](/skills/claude-api/shared/prompt-caching.md)

_バイナリリソース_

### 共有/ツール使用コンセプト.md

[shared/tool-use-concepts.md をダウンロード](/skills/claude-api/shared/tool-use-concepts.md)

_バイナリリソース_

### typescript/claude-api/README.md

[typescript/claude-api/README.md をダウンロード](/skills/claude-api/typescript/claude-api/README.md)

_バイナリリソース_

### typescript/claude-api/batches.md

[typescript/claude-api/batches.md をダウンロード](/skills/claude-api/typescript/claude-api/batches.md)

```markdown
# Message Batches API — TypeScript

The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.

## Key Facts

- Up to 100,000 requests or 256 MB per batch
- Most batches complete within 1 hour; maximum 24 hours
- Results available for 29 days after creation
- 50% cost reduction on all token usage
- All Messages API features supported (vision, tools, caching, etc.)

---

## Create a Batch

```typescript
"@anthropic-ai/sdk" から Anthropic をインポートします。

const client = new Anthropic();

const messageBatch = await client.messages.batches.create({
  リクエスト: [
    {
      カスタムID: "リクエスト-1",
      パラメータ: {
        モデル: "クロード-作品-4-7",
        max_tokens: 16000、
        メッセージ: [
          { 役割: "ユーザー"、コンテンツ: "気候変動の影響の概要" },
        ]、
      }、
    }、
    {
      カスタムID: "リクエスト-2",
      パラメータ: {
        モデル: "クロード-作品-4-7",
        max_tokens: 16000、
        メッセージ: [
          { 役割: "ユーザー"、内容: "量子コンピューティングの基礎を説明する" },
        ]、
      }、
    }、
  ]、
});

コンソール.ログ(`Batch ID: ${messageBatch.id}`);
コンソール.ログ(`Status: ${messageBatch.processing_status}`);

バッチをさせてください。
while (true) {
  バッチ = 待機 client.messages.batches.retrieve(messageBatch.id);
  if (batch.processing_status === "終了") ブレーク;
  コンソール.log(
   `Status: ${batch.processing_status}, processing: ${batch.request_counts.processing}`、
  );
  await new Promise((resolve) => setTimeout(resolve, 60_000));
}

console.log("バッチが完了しました!");
コンソール.ログ(`Succeeded: ${batch.request_counts.succeeded}`);
コンソール.ログ(`Errored: ${batch.request_counts.errored}`);

for await (await の const 結果 client.messages.batches.results(
  messageBatch.id、
)){
  スイッチ (結果.結果.タイプ) {
    ケース「成功」:
      コンソール.log(
       `[${result.custom_id}] ${result.result.message.content[0].text.slice(0, 100)}`、
      );
      壊す;
    ケース「エラー」:
      if (result.result.error.type === "invalid_request") {
        コンソール.ログ(`[${result.custom_id}] Validation error - fix and retry`);
      } それ以外の場合は {
        コンソール.ログ(`[${result.custom_id}] Server error - safe to retry`);
      }
      壊す;
    ケース「期限切れ」:
      コンソール.ログ(`[${result.custom_id}] Expired - resubmit`);
      壊す;
  }
}

const canceled = await client.messages.batches.cancel(messageBatch.id);
コンソール.ログ(`Status: ${cancelled.processing_status}`); // 「キャンセル」

### typescript/claude-api/files-api.md

[typescript/claude-api/files-api.md をダウンロード](/skills/claude-api/typescript/claude-api/files-api.md)

```markdown
# Files API — TypeScript

The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.

**Beta:** Pass `betas: ["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).

## Key Facts

- Maximum file size: 500 MB
- Total storage: 100 GB per organization
- Files persist until deleted
- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
- Not available on Amazon Bedrock or Google Vertex AI

---

## Upload a File

```typescript
import Anthropic, { toFile } from "@anthropic-ai/sdk";
「fs」から fs をインポートします。

const client = new Anthropic();

const updated = await client.beta.files.upload({
  ファイル: await toFile(fs.createReadStream("report.pdf")、未定義、{
    タイプ: "アプリケーション/pdf",
  })、
  ベータ: ["files-api-2025-04-14"]、
});

コンソール.ログ(`File ID: ${uploaded.id}`);
コンソール.ログ(`Size: ${uploaded.size_bytes} bytes`);

const response = await client.beta.messages.create({
  モデル: "クロード-作品-4-7",
  max_tokens: 16000、
  メッセージ: [
    {
      役割: 「ユーザー」、
      内容: [
        { type: "text", text: "このレポートの主な調査結果を要約します。" }、
        {
          タイプ: "ドキュメント",
          ソース: { タイプ: "ファイル"、ファイル ID: アップロードされた.id }、
          タイトル: 「第 4 四半期レポート」、
          引用: { 有効: true }、
        }、
      ]、
    }、
  ]、
  ベータ: ["files-api-2025-04-14"]、
});

console.log(response.content[0].text);

const files = await client.beta.files.list({
  ベータ: ["files-api-2025-04-14"]、
});
for (files.data の const f) {
  コンソール.ログ(`${f.id}: ${f.filename} (${f.size_bytes} bytes)`);
}

await client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w", {
  ベータ: ["files-api-2025-04-14"]、
});

const response = await client.beta.files.download(
  "file_011CNha8iCJcU1wXNR6q4V8w",
  { ベータ版: ["files-api-2025-04-14"] },
);
const content = Buffer.from(応答を待つ.arrayBuffer());
await fs.promises.writeFile("output.txt", content);

### typescript/claude-api/streaming.md

[typescript/claude-api/streaming.md をダウンロード](/skills/claude-api/typescript/claude-api/streaming.md)

```markdown
# Streaming — TypeScript

## Quick Start

```typescript
const stream = client.messages.stream({
  モデル: "クロード-作品-4-7",
  max_tokens: 64000、
  メッセージ: [{ 役割: "ユーザー"、コンテンツ: "ストーリーを書く" }]、
});

for await (ストリームの定数イベント) {
  もし(
    イベント.タイプ === "content_block_delta" &&
    イベント.デルタ.タイプ === "テキストデルタ"
  ) {
    process.stdout.write(event.delta.text);
  }
}

const stream = client.messages.stream({
  モデル: "クロード-作品-4-7",
  max_tokens: 64000、
  思考: { タイプ: "アダプティブ" },
  メッセージ: [{ 役割: "ユーザー"、内容: "この問題を分析します" }]、
});

for await (ストリームの定数イベント) {
  スイッチ (event.type) {
    ケース「content_block_start」:
      スイッチ (event.content_block.type) {
        「思考」の場合：
          console.log("\n[考え中...]");
          壊す;
        「テキスト」の場合:
          console.log("\n[応答:]");
          壊す;
      }
      壊す;
    ケース「content_block_delta」:
      スイッチ (event.delta.type) {
        ケース「思考デルタ」:
          process.stdout.write(event.delta. Thinking);
          壊す;
        ケース「テキストデルタ」:
          process.stdout.write(event.delta.text);
          壊す;
      }
      壊す;
  }
}

"@anthropic-ai/sdk" から Anthropic をインポートします。
import { betaZodTool } から "@anthropic-ai/sdk/helpers/beta/zod";
「zod」から { z } をインポートします。

const client = new Anthropic();

const getWeather = betaZodTool({
  名前: "get_weather",
  説明: "場所の現在の天気を取得する",
  inputSchema: z.object({
    location: z.string().describe("都市と州、例: カリフォルニア州サンフランシスコ"),
  })、
  実行: async ({ location }) =>`72°F and sunny in ${location}`、
});

const ランナー = client.beta.messages.toolRunner({
  モデル: "クロード-作品-4-7",
  max_tokens: 64000、
  ツール: [getWeather]、
  メッセージ: [
    { 役割: "ユーザー"、内容: 「パリとロンドンの天気は?」 }、
  ]、
  ストリーム: true、
});

// 外側のループ: 各ツール ランナーの反復
for await (ランナーの const messageStream) {
  // 内部ループ: この反復のストリーム イベント
  for await (messageStream の const イベント) {
    スイッチ (event.type) {
      ケース「content_block_delta」:
        スイッチ (event.delta.type) {
          ケース「テキストデルタ」:
            process.stdout.write(event.delta.text);
            壊す;
          ケース「input_json_delta」:
            // ストリーミングされるツール入力
            休憩;
        }
        壊す;
    }
  }
}

const stream = client.messages.stream({
  モデル: "クロード-作品-4-7",
  max_tokens: 64000、
  メッセージ: [{ 役割: "ユーザー"、コンテンツ: "こんにちは" }]、
});

for await (ストリームの定数イベント) {
  // イベントを処理します...
}

const FinalMessage = await stream.finalMessage();
コンソール.ログ(`Tokens used: ${finalMessage.usage.output_tokens}`);

イベント: message_start
データ: {"タイプ":"メッセージ開始","メッセージ":{"id":"msg_...","タイプ":"メッセージ",...}}

イベント: content_block_start
データ: {"タイプ":"コンテンツブロック開始","インデックス":0,"コンテンツブロック":{"タイプ":"テキスト","テキスト":""}}

イベント: content_block_delta
データ: {"タイプ":"コンテンツブロックデルタ","インデックス":0,"デルタ":{"タイプ":"テキストデルタ","テキスト":"Hello"}}

イベント: content_block_stop
データ: {"タイプ":"コンテンツブロックストップ","インデックス":0}

イベント: メッセージデルタ
データ: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":12}}

イベント: message_stop
データ: {"タイプ":"メッセージストップ"}

### typescript/claude-api/tool-use.md

[typescript/claude-api/tool-use.md をダウンロード](/skills/claude-api/typescript/claude-api/tool-use.md)

_バイナリリソース_

### typescript/管理対象エージェント/README.md

[タイプスクリプト/管理対象エージェント/README.md をダウンロード](/skills/claude-api/typescript/管理対象エージェント/README.md)

_バイナリリソース_

## GitHub で見る

[GitHub で見る](https://github.com/anthropics/skills/tree/main/claude-api)