---
title: TypeScript SDK
url: https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/typescript
description: Node.js、Deno、Bun、およびブラウザ環境向けのAnthropic TypeScript SDKのインストールと設定
---

このライブラリは、TypeScriptまたはJavaScriptからClaude APIへの便利なアクセスを提供します。

<Info>
  コード例を含むAPI機能のドキュメントについては、[APIリファレンス](https://platform.claude.com/docs/ja/api/overview)を参照してください。このページでは、TypeScript固有のSDK機能と設定について説明します。
</Info>

## インストール

```bash
npm install @anthropic-ai/sdk
```

## 要件

TypeScript >= 5.0がサポートされています。

以下のランタイムがサポートされています。

* Node.js 20 LTS以降（[EOLでない](https://endoflife.date/nodejs)）バージョン。
* Deno v1.28.0以上。
* Bun 1.0以降。
* Cloudflare Workers。
* Vercel Edge Runtime。
* `"node"`環境を使用したJest 28以上（`"jsdom"`は現時点ではサポートされていません）。
* Nitro v2.6以上。
* Webブラウザ：秘密のAPI認証情報が露出するのを避けるため、デフォルトでは無効になっています（[APIキーのベストプラクティス](https://support.claude.com/en/articles/9767949-api-key-best-practices-keeping-your-keys-safe-and-secure)を参照）。`dangerouslyAllowBrowser`を明示的に`true`に設定することで、ブラウザサポートを有効にできます。

React Nativeは現時点ではサポートされていないことに注意してください。

他のランタイム環境に関心がある場合は、[GitHubリポジトリ](https://github.com/anthropics/anthropic-sdk-typescript)でissueを作成するか、既存のissueに賛成票を投じてください。

## 使用方法

```typescript
const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});

for (const block of message.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}
```

Workload Identity Federationを含む認証オプションについては、[認証](https://platform.claude.com/docs/ja/manage-claude/authentication)を参照してください。お使いのAPIキーが複数のワークスペースにアクセスできる[個人キーまたはサービスアカウントキー](https://platform.claude.com/docs/ja/manage-claude/authentication#key-types)である場合は、`anthropic-workspace-id`リクエストヘッダーにワークスペースIDを設定してください。[ワークスペースを選択する](https://platform.claude.com/docs/ja/manage-claude/authentication#select-a-workspace)では、このSDKにおけるリクエストごとのオプションを示しています。

## リクエストとレスポンスの型

このライブラリには、すべてのリクエストパラメータとレスポンスフィールドのTypeScript定義が含まれています。次のようにインポートして使用できます。

```typescript
const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const params: Anthropic.MessageCreateParams = {
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
};
const message: Anthropic.Message = await client.messages.create(params);
```

各メソッド、リクエストパラメータ、レスポンスフィールドのドキュメントはdocstringで提供されており、ほとんどのモダンなエディタではホバー時に表示されます。

## トークンのカウント

特定のリクエストの正確な使用量は、`usage`レスポンスプロパティで確認できます。例：

```typescript
const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});
console.log(message.usage);
// { input_tokens: 25, output_tokens: 13 }
```

## ストリーミングレスポンス

SDKは、「Server-Sent Events」（サーバー送信イベント）、すなわちSSEを使用したストリーミングレスポンスをサポートしています。

```typescript
const client = new Anthropic();

const stream = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5",
  stream: true
});
for await (const messageStreamEvent of stream) {
  console.log(messageStreamEvent.type);
}
```

ストリームをキャンセルする必要がある場合は、ループから`break`するか、`stream.controller.abort()`を呼び出すことができます。

## ストリーミングヘルパー

このライブラリは、メッセージのストリーミングのためのいくつかの便利な機能を提供します。例：

```typescript
const anthropic = new Anthropic();

const stream = anthropic.messages
  .stream({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: "Say hello there!"
      }
    ]
  })
  .on("text", (text) => {
    console.log(text);
  });

const message = await stream.finalMessage();
console.log(message);
```

`client.messages.stream(...)`によるストリーミングでは、イベントハンドラや累積など、便利なさまざまなヘルパーが利用できます。

あるいは、`client.messages.create({ ..., stream: true })`を使用することもできます。これはストリーム内のイベントの非同期イテラブルのみを返すため、メモリ使用量が少なくなります（最終的なメッセージオブジェクトを構築しません）。

## ツールヘルパー

このSDKは、Messages APIでツールを簡単に作成・実行するためのヘルパーを提供します。ZodスキーマまたはJSON Schemaを使用してツールへの入力を記述できます。その後、`client.beta.messages.toolRunner()`メソッドを使用してそれらのツールを実行できます。このメソッドは、選択したモデルが生成した入力を適切なツールに渡し、結果をモデルに返す処理を行います。

「tool use」（ツール使用）の詳細については、[Claudeでのツール使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)を参照してください。このSDKでブラウザ使用ツールまたはコンピュータ使用ツールを実行するには、[SDKツールセットによるブラウザ使用とコンピュータ使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/browser-use-sdk)を参照してください。

```typescript
import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
import { z } from "zod";

const anthropic = new Anthropic();

const weatherTool = betaZodTool({
  name: "get_weather",
  inputSchema: z.object({
    location: z.string()
  }),
  description: "Get the current weather in a given location",
  run: (input) => {
    return `The weather in ${input.location} is foggy and 60°F`;
  }
});

const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 1000,
  messages: [{ role: "user", content: "What is the weather in San Francisco?" }],
  tools: [weatherTool]
});

console.log(finalMessage.content);
```

### ツールエラー

ツールからモデルにエラーを報告するには、`run`関数から`ToolError`をスローします。通常の`Error`とは異なり、`ToolError`はコンテンツブロックを受け付けるため、エラーレスポンスに画像やその他の構造化コンテンツを含めることができます。

```typescript
import { ToolError } from "@anthropic-ai/sdk/lib/tools/BetaRunnableTool";

const screenshotTool = betaZodTool({
  name: "take_screenshot",
  inputSchema: z.object({ url: z.string() }),
  run: async (input) => {
    if (!isValidUrl(input.url)) {
      throw new ToolError(`Invalid URL: ${input.url}`);
    }
    const result = await takeScreenshot(input.url);
    if (result.error) {
      // モデルが問題の原因を確認できるよう、エラーのスクリーンショットを含める
      throw new ToolError([
        { type: "text", text: `Failed to load page: ${result.error}` },
        {
          type: "image",
          source: { type: "base64", data: result.screenshot, media_type: "image/png" }
        }
      ]);
    }
    return {
      type: "image",
      source: { type: "base64", data: result.screenshot, media_type: "image/png" }
    };
  }
});
```

通常の`Error`がスローされた場合、メッセージはテキストコンテンツブロックに変換されます。

## ツール使用

このSDKは、関数呼び出しとしても知られるツール使用をサポートしています。詳細については、[Claudeでのツール使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)を参照してください。

## MCPヘルパー

このSDKは、[Model Context Protocol（MCP）](https://modelcontextprotocol.io/)サーバーと統合するためのヘルパーを提供します。これらのヘルパーはMCPの型をClaude APIの型に変換し、MCPのツール、プロンプト、リソースを扱う際のボイラープレートを削減します。

<Tip>
  Claude APIは、Claudeがリモートの MCPサーバーに直接接続できる[`mcp_servers`パラメータ](https://platform.claude.com/docs/ja/agents-and-tools/mcp-connector)もサポートしています。URLでアクセス可能なリモートサーバーがあり、ツールのサポートのみが必要な場合は`mcp_servers`を使用してください。ローカルのMCPサーバー、プロンプト、リソース、またはMCP接続に対するより細かい制御が必要な場合は、MCPヘルパーを使用してください。
</Tip>

```typescript
import {
  mcpTools,
  mcpMessages,
  mcpResourceToContent,
  mcpResourceToFile
} from "@anthropic-ai/sdk/helpers/beta/mcp";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const anthropic = new Anthropic();

// MCPサーバーに接続します
const transport = new StdioClientTransport({ command: "mcp-server", args: [] });
const mcpClient = new Client({ name: "my-client", version: "1.0.0" });
await mcpClient.connect(transport);

// MCPプロンプトを使用します
const { messages } = await mcpClient.getPrompt({ name: "my-prompt" });
const response = await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: mcpMessages(messages)
});
console.log(response.content);

// toolRunnerでMCPツールを使用します
const { tools } = await mcpClient.listTools();
const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Use the available tools" }],
  tools: mcpTools(tools, mcpClient)
});
console.log(finalMessage.content);

// MCPリソースをコンテンツとして使用します
const resource = await mcpClient.readResource({ uri: "file:///path/to/doc.txt" });
await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        mcpResourceToContent(resource),
        { type: "text", text: "Summarize this document" }
      ]
    }
  ]
});

// MCPリソースをファイルとしてアップロードします
const fileResource = await mcpClient.readResource({ uri: "file:///path/to/data.json" });
await anthropic.files.upload({ file: mcpResourceToFile(fileResource) });
```

### MCPのエラー処理

変換関数は、MCPの値がClaude APIでサポートされていない場合（たとえば、サポートされていないコンテンツタイプ、サポートされていないMIMEタイプ、HTTP/HTTPS以外のリソースリンクなど）、`UnsupportedMCPValueError`をスローします。

## メッセージバッチ

このSDKは、`client.messages.batches`名前空間で[バッチ処理](https://platform.claude.com/docs/ja/build-with-claude/batch-processing)をサポートしています。

### バッチの作成

Message Batchesはリクエストの配列を受け取ります。各オブジェクトには`custom_id`識別子と、標準のMessages APIとまったく同じリクエスト`params`が含まれます。

```typescript
const batch = await client.messages.batches.create({
  requests: [
    {
      custom_id: "my-first-request",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hello, world" }]
      }
    },
    {
      custom_id: "my-second-request",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hi again, friend" }]
      }
    }
  ]
});
```

### バッチからの結果の取得

Message Batchの処理が完了すると（`.processing_status === 'ended'`で示されます）、`.batches.results()`で結果にアクセスできます。

```typescript
const results = await client.messages.batches.results(batch.id);
for await (const entry of results) {
  if (entry.result.type === "succeeded") {
    console.log(entry.result.message.content);
  }
}
```

## ファイルのアップロード

ファイルのアップロードに対応するリクエストパラメータは、さまざまな形式で渡すことができます。

* `File`（または同じ構造を持つオブジェクト）
* `fetch`の`Response`（または同じ構造を持つオブジェクト）
* `fs.ReadStream`
* `toFile`ヘルパーの戻り値

Files APIはコンテンツタイプを推測しないため、明示的に設定してください：

```typescript
import fs from "node:fs";
import Anthropic, { toFile } from "@anthropic-ai/sdk";

const client = new Anthropic();

// Node の `fs` にアクセスできる場合は、`fs.createReadStream()` を使用します:
await client.files.upload({
  file: await toFile(fs.createReadStream("/path/to/file"), undefined, {
    type: "application/json"
  })
});

// または、Web の `File` API が利用できる場合は、`File` インスタンスを渡せます:
await client.files.upload({
  file: new File(["my bytes"], "file.txt", { type: "text/plain" })
});
// `fetch` の `Response` を渡すこともできます:
await client.files.upload({
  file: await fetch("https://somesite/file")
});

// または `Buffer` / `Uint8Array` を渡すこともできます
await client.files.upload({
  file: await toFile(Buffer.from("my bytes"), "file", { type: "text/plain" })
});
await client.files.upload({
  file: await toFile(new Uint8Array([0, 1, 2]), "file", { type: "text/plain" })
});
```

## エラーの処理

ライブラリがAPIに接続できない場合、 またはAPIが成功以外のステータスコード（つまり、4xxまたは5xxレスポンス）を返した場合、 `APIError`のサブクラスがスローされます。

```typescript
const message = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .catch(async (err) => {
    if (err instanceof Anthropic.APIError) {
      console.log(err.status); // 400
      console.log(err.name); // BadRequestError
      console.log(err.headers); // {server: 'nginx', ...}
    } else {
      throw err;
    }
  });
```

エラーコードは以下のとおりです。

| ステータスコード | エラータイプ                     |
| -------- | -------------------------- |
| 400      | `BadRequestError`          |
| 401      | `AuthenticationError`      |
| 403      | `PermissionDeniedError`    |
| 404      | `NotFoundError`            |
| 409      | `ConflictError`            |
| 422      | `UnprocessableEntityError` |
| 429      | `RateLimitError`           |
| >=500    | `InternalServerError`      |
| N/A      | `APIConnectionError`       |

## リクエストID

> リクエストのデバッグの詳細については、[リクエストID](https://platform.claude.com/docs/ja/api/errors#request-id)を参照してください。

SDKのすべてのオブジェクトレスポンスは、`request-id`レスポンスヘッダーから追加される`_request_id`プロパティを提供します。これにより、失敗したリクエストをすばやくログに記録し、Anthropicに報告できます。

```typescript
const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});
console.log(message._request_id); // req_018EeWyXxfu5pfWkrYcMdjWG
```

## リトライ

特定のエラーは、デフォルトで短い指数バックオフを伴って2回自動的にリトライされます。 接続エラー（例：ネットワーク接続の問題による）、408 Request Timeout、409 Conflict、 429 Rate Limit、および>=500の内部エラーは、すべてデフォルトでリトライされます。

`maxRetries`オプションを使用して、これを設定または無効化できます。

```typescript
// すべてのリクエストのデフォルトを設定します:
const client = new Anthropic({
  maxRetries: 0 // default is 2
});

// または、リクエストごとに設定します:
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { maxRetries: 5 }
);
```

## タイムアウト

デフォルトでは、リクエストは10分後にタイムアウトします。ただし、大きな`max_tokens`値を指定し、 ストリーミングを使用して*いない*場合、デフォルトのタイムアウトは次の式を使用して動的に計算されます。

```typescript
const minimum = 10 * 60;
const calculated = (60 * 60 * maxTokens) / 128_000;
return calculated < minimum ? minimum * 1000 : calculated * 1000;
```

これにより、リクエストまたはクライアントレベルで上書きされない限り、`max_tokens`パラメータに応じてスケールされた最大60分のタイムアウトになります。

これは`timeout`オプションで設定できます。

```typescript
// すべてのリクエストのデフォルトを設定します:
const client = new Anthropic({
  timeout: 20 * 1000 // 20 seconds (default is 10 minutes)
});

// リクエストごとに上書きします:
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { timeout: 5 * 1000 }
);
```

タイムアウト時には、`APIConnectionTimeoutError`がスローされます。

タイムアウトしたリクエストは[デフォルトで2回リトライされる](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/typescript#retries)ことに注意してください。

## 長時間のリクエスト

<Warning>
  長時間実行されるリクエストには、ストリーミングの[Messages API](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/typescript#streaming-responses)の使用を検討してください。
</Warning>

ストリーミングを使用せずに大きな`max_tokens`値を設定することは避けてください。 一部のネットワークでは、一定時間後にアイドル接続が切断される場合があり、 その結果、Anthropicからレスポンスを受信せずにリクエストが失敗したり[タイムアウト](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/typescript#timeouts)したりする可能性があります。

このSDKは、非ストリーミングリクエストがおよそ10分を超えると予想される場合にもエラーをスローします。 `stream: true`を渡すか、クライアントまたはリクエストレベルで`timeout`オプションを[上書き](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/typescript#timeouts)すると、このエラーは無効になります。

非ストリーミングリクエストで予想されるリクエストの「latency」（レイテンシ）が[タイムアウト](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/typescript#timeouts)より長い場合、 クライアントはレスポンスを受信することなく接続を終了してリトライします。

`fetch`実装でサポートされている場合、SDKは[TCPソケットのkeep-alive](https://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html)オプションを設定し、 一部のネットワークにおけるアイドル接続タイムアウトの影響を軽減します。 これはカスタムプロキシを設定することで[上書き](https://platform.claude.com/docs/ja/cli-sdks-libraries/sdks/typescript#configuring-proxies)できます。

## 自動ページネーション

Claude APIのリストメソッドはページネーションされています。 `for await ... of`構文を使用して、すべてのページにわたってアイテムを反復処理できます。

```typescript
async function fetchAllMessageBatches() {
  const allMessageBatches = [];
  // 必要に応じて追加のページを自動的に取得します。
  for await (const messageBatch of client.messages.batches.list({ limit: 20 })) {
    allMessageBatches.push(messageBatch);
  }
  return allMessageBatches;
}
```

あるいは、一度に1ページずつリクエストすることもできます。

```typescript
let page = await client.messages.batches.list({ limit: 20 });
for (const messageBatch of page.data) {
  console.log(messageBatch);
}

// 手動でページネーションするための便利なメソッドが用意されています:
while (page.hasNextPage()) {
  page = await page.getNextPage();
  // ...
}
```

## デフォルトヘッダー

SDKは、`2023-06-01`に設定された`anthropic-version`ヘッダーを自動的に送信します。

必要に応じて、リクエストごとにデフォルトヘッダーを設定することで上書きできます。

これを行うと、SDKで型が正しくなくなったり、その他の予期しない動作や未定義の動作が発生したりする可能性があることに注意してください。

```typescript
const client = new Anthropic();

const message = await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { headers: { "anthropic-version": "My-Custom-Value" } }
);
```

## 高度な使用方法

### 生のResponseデータへのアクセス（例：ヘッダー）

`fetch()`が返す「生の」`Response`には、すべてのメソッドが返す`APIPromise`型の`.asResponse()`メソッドを通じてアクセスできます。 このメソッドは、成功したレスポンスのヘッダーを受信するとすぐに返り、レスポンスボディを消費しないため、カスタムの解析ロジックやストリーミングロジックを自由に記述できます。

`.withResponse()`メソッドを使用して、解析済みデータとともに生の`Response`を取得することもできます。 `.asResponse()`とは異なり、このメソッドはボディを消費し、解析が完了すると返ります。

```typescript
const client = new Anthropic();

const response = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .asResponse();
console.log(response.headers.get("X-My-Header"));
console.log(response.statusText); // access the underlying Response object

const { data: message, response: raw } = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .withResponse();
console.log(raw.headers.get("X-My-Header"));
console.log(message.content);
```

### ロギング

<Warning>
  すべてのログメッセージはデバッグ専用です。ログメッセージの形式と内容は リリース間で変更される可能性があります。
</Warning>

#### ログレベル

ログレベルは2つの方法で設定できます。

1. `ANTHROPIC_LOG`環境変数を使用する
2. `logLevel`クライアントオプションを使用する（設定されている場合、環境変数を上書きします）

```typescript
const client = new Anthropic({
  logLevel: "debug" // Show all log messages
});
```

利用可能なログレベル（詳細度の高い順）：

* `'debug'` - デバッグメッセージ、情報、警告、エラーを表示
* `'info'` - 情報メッセージ、警告、エラーを表示
* `'warn'` - 警告とエラーを表示（デフォルト）
* `'error'` - エラーのみを表示
* `'off'` - すべてのロギングを無効化

`'debug'`レベルでは、ヘッダーとボディを含むすべてのHTTPリクエストとレスポンスがログに記録されます。 一部の認証関連ヘッダーはマスクされますが、リクエストおよびレスポンスボディ内の機密データは 引き続き表示される可能性があります。

#### カスタムロガー

デフォルトでは、このライブラリは`globalThis.console`にログを出力します。カスタムロガーを提供することもできます。 [pino](https://www.npmjs.com/package/pino)、[winston](https://www.npmjs.com/package/winston)、[bunyan](https://www.npmjs.com/package/bunyan)、[consola](https://www.npmjs.com/package/consola)、[signale](https://www.npmjs.com/package/signale)、[@std/log](https://jsr.io/@std/log)など、ほとんどのロギングライブラリがサポートされています。お使いのロガーが動作しない場合は、issueを作成してください。

カスタムロガーを提供する場合でも、`logLevel`オプションがどのメッセージを出力するかを制御します。 設定されたレベル未満のメッセージはロガーに送信されません。

```typescript
import pino from "pino";

const logger = pino();

const client = new Anthropic({
  logger: logger.child({ name: "Anthropic" }),
  logLevel: "debug" // Send all messages to pino, allowing it to filter
});
```

### カスタム/ドキュメント化されていないリクエストの実行

このライブラリは、ドキュメント化されたAPIに便利にアクセスできるよう型付けされています。ドキュメント化されていない エンドポイント、パラメータ、またはレスポンスプロパティにアクセスする必要がある場合でも、ライブラリを使用できます。

#### ドキュメント化されていないエンドポイント

ドキュメント化されていないエンドポイントにリクエストを行うには、`client.get`、`client.post`、およびその他のHTTP動詞を使用できます。 これらのリクエストを行う際、リトライなどのクライアントのオプションは尊重されます。

```typescript
await client.post("/some/path", {
  body: { some_prop: "foo" },
  query: { some_query_arg: "bar" }
});
```

#### ドキュメント化されていないリクエストパラメータ

ドキュメント化されていないパラメータを使用してリクエストを行うには、ドキュメント化されていない パラメータに`// @ts-expect-error`を使用できます。このライブラリは、リクエストが型と一致することを実行時に検証しないため、 送信した追加の値はそのまま送信されます。

```typescript
client.messages.create({
  // ...
  // @ts-expect-error baz is not yet public
  baz: "undocumented option"
});
```

`GET`動詞を使用するリクエストでは、追加のパラメータはクエリに含まれます。その他のすべてのリクエストでは、 追加のパラメータはボディで送信されます。

追加の引数を明示的に送信したい場合は、`query`、`body`、`headers`リクエスト オプションを使用して送信できます。

#### ドキュメント化されていないレスポンスプロパティ

ドキュメント化されていないレスポンスプロパティにアクセスするには、レスポンスオブジェクトに`// @ts-expect-error`を付けて アクセスするか、レスポンスオブジェクトを必要な型にキャストできます。リクエストパラメータと同様に、SDKは APIからのレスポンスの追加プロパティを検証したり削除したりしません。

### fetchクライアントのカスタマイズ

デフォルトでは、このライブラリはグローバルな`fetch`関数が定義されていることを前提としています。

別の`fetch`関数を使用したい場合は、グローバルをポリフィルするか、

```typescript
import fetch from "my-fetch";

globalThis.fetch = fetch;
```

またはクライアントに渡すことができます。

```typescript
import fetch from "my-fetch";

const client = new Anthropic({ fetch });
```

### fetchオプション

`fetch`関数を上書きせずにカスタムの`fetch`オプションを設定したい場合は、クライアントの作成時またはリクエストの実行時に`fetchOptions`オブジェクトを提供できます。（リクエスト固有のオプションはクライアントオプションを上書きします。）

```typescript
const client = new Anthropic({
  fetchOptions: {
    // `RequestInit` オプション
  }
});
```

### プロキシの設定

プロキシの動作を変更するには、ランタイム固有のプロキシオプションをリクエストに追加する カスタムの`fetchOptions`を提供できます。

<Tabs>
  <Tab title="Node.js">
    ```typescript
    import * as undici from "undici";

    const proxyAgent = new undici.ProxyAgent("http://localhost:8888");
    const client = new Anthropic({
      fetchOptions: {
        dispatcher: proxyAgent
      }
    });
    ```
  </Tab>

  <Tab title="Bun">
    ```typescript
    const client = new Anthropic({
      fetchOptions: {
        proxy: "http://localhost:8888"
      }
    });
    ```
  </Tab>

  <Tab title="Deno">
    ```typescript
    import Anthropic from "npm:@anthropic-ai/sdk";

    const httpClient = Deno.createHttpClient({ proxy: { url: "http://localhost:8888" } });
    const client = new Anthropic({
      fetchOptions: {
        client: httpClient
      }
    });
    ```
  </Tab>
</Tabs>

## ベータ機能

ベータ機能は、早期のフィードバックを得て新しい機能をテストするために、正式リリース前に利用可能になります。Claudeのすべての機能とツールの利用可能状況は、[機能の概要](https://platform.claude.com/docs/ja/build-with-claude/overview)で確認できます。

ほとんどのベータAPI機能には、クライアントの`beta`プロパティを通じてアクセスできます。特定のベータ機能を有効にするには、メッセージの作成時に適切な[ベータヘッダー](https://platform.claude.com/docs/ja/api/beta-headers)を`betas`フィールドに追加する必要があります。

例えば、[コンテキスト編集](https://platform.claude.com/docs/ja/build-with-claude/context-editing)を有効にするには：

```typescript
const client = new Anthropic();
const response = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  betas: ["context-management-2025-06-27"]
});
```

## ランタイムサポート

<Accordion title="ブラウザでの使用">
  `dangerouslyAllowBrowser`オプションを有効にすると、秘密のAPI認証情報がクライアント側のコードで露出するため、危険な場合があります。Webブラウザは本質的にサーバー環境よりも安全性が低くなります。ブラウザにアクセスできるユーザーは誰でも、これらの認証情報を調べたり、抽出したり、悪用したりできる可能性があります。これにより、認証情報を使用した不正アクセスが発生し、機密データや機能が侵害される可能性があります。

  **どのような場合に危険ではないのでしょうか？**

  ブラウザサポートを有効にしても重大なリスクをもたらさない可能性がある特定のシナリオ：

  * **内部ツール：** アプリケーションが、ユーザーが信頼できる管理された内部環境内でのみ使用される場合、認証情報の露出リスクは軽減できます。
  * **開発またはデバッグ目的：** 認証情報が短命である、本番環境でも使用されていない、または頻繁にローテーションされる場合、この機能を一時的に有効にすることは許容される場合があります。
</Accordion>

## プラットフォーム統合

<Note>
  コード例を含む詳細なプラットフォームセットアップガイドについては、以下を参照してください。

  * [Amazon Bedrock](https://platform.claude.com/docs/ja/build-with-claude/claude-in-amazon-bedrock)
  * [Amazon Bedrock（Opus 4.6以前）](https://platform.claude.com/docs/ja/build-with-claude/claude-on-amazon-bedrock-legacy)
  * [Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws)
  * [Google Cloud](https://platform.claude.com/docs/ja/build-with-claude/claude-on-vertex-ai)
  * [Microsoft Foundry](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry)
</Note>

TypeScript SDKは以下のプラットフォームをサポートしています。

* **Agent Platform：** `npm install @anthropic-ai/vertex-sdk`：`AnthropicVertex`クライアントを提供
* **Bedrock：** `npm install @anthropic-ai/bedrock-sdk`：`AnthropicBedrockMantle`クライアント、および`bedrock-runtime`パス用の`AnthropicBedrock`を提供
* **Claude Platform on AWS：** `npm install @anthropic-ai/aws-sdk`：`AnthropicAws`クライアントを提供。コンストラクタに`workspaceId`を渡すか、`ANTHROPIC_AWS_WORKSPACE_ID`環境変数を設定してください。ベータ版で利用可能です。
* **Foundry：** `npm install @anthropic-ai/foundry-sdk`：`AnthropicFoundry`クライアントを提供

新規プロジェクトには`AnthropicBedrockMantle`を使用してください。`AnthropicBedrock`は、Bedrockの`InvokeModel` APIを使用する既存のアプリケーション向けに引き続き提供されます。

## セマンティックバージョニング

このパッケージは概ね[SemVer](https://semver.org/spec/v2.0.0.html)の規約に従っていますが、特定の後方互換性のない変更がマイナーバージョンとしてリリースされる場合があります。

1. 実行時の動作を壊すことなく、静的型のみに影響する変更。
2. 技術的には公開されているが、外部での使用を意図しておらずドキュメント化もされていないライブラリ内部への変更。
3. 実際には大多数のユーザーに影響を与えないと予想される変更。

スムーズなアップグレード体験を確実に提供できるよう、後方互換性は真剣に考慮されています。

## よくある質問

FAQ、issue、コミュニティサポートについては、[GitHubリポジトリ](https://github.com/anthropics/anthropic-sdk-typescript)を参照してください。

## 追加リソース

* [GitHubリポジトリ](https://github.com/anthropics/anthropic-sdk-typescript)
* [APIリファレンス](https://platform.claude.com/docs/ja/api/overview)
* [メッセージのストリーミング](https://platform.claude.com/docs/ja/build-with-claude/streaming)
* [Claudeでのツール使用](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/overview)
