---
title: Files API
url: https://platform.claude.com/docs/ja/build-with-claude/files
description: ファイルを一度アップロードし、Messagesリクエストでfile_idによって参照し、スキルやコード実行ツールによって作成された出力をダウンロードします。
featureMetadata:
  status: stable
  zdr:
    eligibility: not-eligible
    note: ファイルは明示的に削除されるか、設定された有効期限に達するまで保持されます。
  supportedModels:
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: stable
    Claude Platform on AWS: stable
    Claude Models on Google Cloud (Anthropic managed): stable
    Microsoft Foundry (hosted on Anthropic): stable
---

**APIサポート**：使用方法は製品によって異なります。

* **Messages API**：アップロードしたファイルを、`document`、`image`、または`container_upload`ブロックで`file_id`により参照します。
* **Managed Agents**：セッションのサンドボックスにファイルをマウントするか、`user.message`イベントで`file_id`を参照します。

Files APIを使用すると、リクエストごとにコンテンツを再アップロードすることなく、Claude APIで使用するファイルをアップロードおよび管理できます。これは、[コード実行ツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool)を使用して入力（たとえば、データセットやドキュメント）を提供し、その後出力（たとえば、チャート）をダウンロードする場合に特に便利です。このガイドに加えて、[APIリファレンスを直接参照](https://platform.claude.com/docs/ja/api/files/upload)することもできます。

## ファイルタイプのサポート

Messagesリクエストでの`file_id`の参照は、該当するファイルタイプをサポートするすべてのモデルでサポートされています。[画像](https://platform.claude.com/docs/ja/build-with-claude/vision)は現在のすべてのClaudeモデルでサポートされています。[PDF](https://platform.claude.com/docs/ja/build-with-claude/pdf-support)および[コード実行ツールでのその他のファイルタイプ](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool#availability-feature-support)については、リンク先のページでモデルのサポート状況を確認してください。

## Files APIの仕組み

Files APIは、ファイルを扱うための「一度作成すれば何度でも使用できる」アプローチを提供します：

* Anthropicの安全なストレージに**ファイルをアップロード**し、一意の`file_id`を受け取ります
* スキルやコード実行ツールによって作成された**ファイルをダウンロード**します
* コンテンツを再アップロードする代わりに、`file_id`を使用して[Messages](https://platform.claude.com/docs/ja/api/messages/create)リクエストで**ファイルを参照**します
* 一覧表示、取得、削除の操作で**ファイルを管理**します

<Warning id="workspace-scoped-access" title="アップロードされたファイルはワークスペース全体からアクセス可能です">
  ファイルはエンドユーザー、会話、またはセッションにスコープされていません。ワークスペースへのアクセス権を持つAPIキーであれば、そのワークスペースにアップロードされたすべてのファイルにアクセスできます。すべてのサービスアカウント、および組織ロールでAPIアクセスが許可されているすべてのユーザーは、追加されたワークスペースに加えてデフォルトワークスペースも使用できます。そのため、分離しておく必要があるファイルは専用のワークスペースに保管し、[そのワークスペースにスコープされたキー](https://platform.claude.com/docs/ja/manage-claude/workspaces#api-keys-and-resource-scoping)でのみアクセスしてください。エンドユーザーやその他の信頼できないソースから`file_id`の値を受け入れないでください。ユーザーが指定したファイルIDにより、アプリケーションのあるユーザーが別のユーザーがアップロードしたコンテンツを読み取れてしまう可能性があります。ファイルIDはサーバー側の参照として扱い、ユーザーとそのファイルの対応関係はアプリケーション内で管理してください。

  Files API上でマルチテナントアプリケーションを構築する場合は、テナントごとに個別の[ワークスペース](https://platform.claude.com/docs/ja/manage-claude/workspaces)を作成してください。ワークスペースはファイルの分離境界であるため、テナントごとにワークスペースを用意することで、そのテナントのデータを他のすべてのテナントから厳密に分離できます。各組織は最大100個のワークスペースを持つことができます。それ以上が必要な場合は、アカウントチームにお問い合わせください。
</Warning>

## Files APIの使い方

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

今後のAPI呼び出しで参照するファイルをアップロードします：

<CodeGroup>
  ```bash cURL
  curl -X POST https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -F "file=@/path/to/document.pdf"
  ```

  ```bash CLI
  ant files upload --file /path/to/document.pdf
  ```

  ```python Python
  uploaded = client.files.upload(
      file=("document.pdf", open("/path/to/document.pdf", "rb"), "application/pdf"),
  )
  file_id = uploaded.id
  print(file_id)
  ```

  ```typescript TypeScript
  const uploaded = await client.files.upload({
    file: await toFile(fs.createReadStream("/path/to/document.pdf"), undefined, {
      type: "application/pdf"
    })
  });
  console.log(uploaded.id);
  ```

  ```csharp C#
  var uploaded = await client.Files.Upload(
      new FileUploadParams
      {
          File = new BinaryContent
          {
              Stream = File.OpenRead("/path/to/document.pdf"),
              FileName = "document.pdf",
              ContentType = new("application/pdf")
          }
      });

  var fileId = uploaded.ID;
  Console.WriteLine(fileId);
  ```

  ```go Go
  f, err := os.Open("/path/to/document.pdf")
  if err != nil {
  	log.Fatal(err)
  }
  defer f.Close()

  response, err := client.Files.Upload(context.Background(),
  	anthropic.FileUploadParams{
  		File: anthropic.File(f, "document.pdf", "application/pdf"),
  	})
  if err != nil {
  	log.Fatal(err)
  }

  fileID := response.ID
  fmt.Println(fileID)
  ```

  ```java Java
  FileMetadata file = client.files().upload(
      FileUploadParams.builder()
          .file(MultipartField.<InputStream>builder()
              .value(Files.newInputStream(Path.of("/path/to/document.pdf")))
              .filename("document.pdf")
              .contentType("application/pdf")
              .build())
          .build()
  );

  String fileId = file.id();
  System.out.println(fileId);
  ```

  ```php PHP
  $file = $client->files->upload(
      file: FileParam::fromResource(fopen('/path/to/document.pdf', 'rb'), contentType: 'application/pdf'),
  );

  $fileId = $file->id;
  echo $fileId;
  ```

  ```ruby Ruby
  file = client.files.upload(
    file: Anthropic::FilePart.new(
      Pathname("/path/to/document.pdf"),
      content_type: "application/pdf"
    )
  )

  file_id = file.id
  puts file_id
  ```
</CodeGroup>

ファイルのアップロードに対するレスポンスには以下が含まれます：

```json Response
{
  "id": "file_011CNha8iCJcU1wXNR6q4V8w",
  "type": "file",
  "filename": "document.pdf",
  "mime_type": "application/pdf",
  "size_bytes": 1024000,
  "created_at": "2025-01-01T00:00:00Z",
  "downloadable": false,
  "expires_at": null
}
```

アップロードしたファイルの[`downloadable`](https://platform.claude.com/docs/ja/api/files#file_metadata.downloadable)は`false`です。ダウンロードできるのは、[スキル](https://platform.claude.com/docs/ja/build-with-claude/skills-guide)または[コード実行ツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool)によって作成されたファイルのみです。[ファイルのダウンロード](https://platform.claude.com/docs/ja/build-with-claude/files#downloading-a-file)を参照してください。

APIリファレンスには、ファイルオブジェクトのすべてのフィールドが記載されています。

(See `file_metadata` on `files` in [the API reference](https://platform.claude.com/docs/ja/api/files#file_metadata).)

### メッセージでのファイルの使用

アップロード後、アップロードレスポンスの`id`を`file_id`として渡すことでファイルを参照します：

<CodeGroup>
  ```bash cURL
  curl -X POST https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "text",
              "text": "Please summarize this document for me."
            },
            {
              "type": "document",
              "source": {
                "type": "file",
                "file_id": "'"$FILE_ID"'"
              }
            }
          ]
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<YAML
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: text
          text: Please summarize this document for me.
        - type: document
          source:
            type: file
            file_id: $FILE_ID
  YAML
  ```

  ```python Python
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {"type": "text", "text": "Please summarize this document for me."},
                  {
                      "type": "document",
                      "source": {
                          "type": "file",
                          "file_id": file_id,
                      },
                  },
              ],
          }
      ],
  )
  print(response)
  ```

  ```typescript TypeScript
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Please summarize this document for me."
          },
          {
            type: "document",
            source: {
              type: "file",
              file_id: uploaded.id
            }
          }
        ]
      }
    ]
  });

  console.log(response);
  ```

  ```csharp C#
  var response = await client.Messages.Create(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 1024,
          Messages =
          [
              new UserMessageParam
              {
                  Content = new List<ContentBlockParam>
                  {
                      new TextBlockParam { Text = "Please summarize this document for me." },
                      new DocumentBlockParam
                      {
                          Source = new FileDocumentSource { FileID = fileId }
                      }
                  }
              }
          ]
      });

  Console.WriteLine(response);
  ```

  ```go Go
  msg, err := client.Messages.New(context.Background(),
  	anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(
  				anthropic.NewTextBlock("Please summarize this document for me."),
  				anthropic.NewDocumentBlock(anthropic.FileDocumentSourceParam{
  					FileID: fileID,
  				}),
  			),
  		},
  	})
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(msg)
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(1024)
      .addUserMessageOfContentBlockParams(List.of(
          ContentBlockParam.ofText(TextBlockParam.builder()
              .text("Please summarize this document for me.")
              .build()),
          ContentBlockParam.ofDocument(DocumentBlockParam.builder()
              .fileSource(fileId)
              .build())
      ))
      .build();

  Message message = client.messages().create(params);
  System.out.println(message);
  ```

  ```php PHP
  $response = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  ['type' => 'text', 'text' => 'Please summarize this document for me.'],
                  [
                      'type' => 'document',
                      'source' => [
                          'type' => 'file',
                          'fileID' => $fileId,
                      ],
                  ],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo $response;
  ```

  ```ruby Ruby
  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "Please summarize this document for me." },
          {
            type: "document",
            source: {
              type: "file",
              file_id: file_id
            }
          }
        ]
      }
    ]
  )

  puts response
  ```
</CodeGroup>

### ファイルタイプとコンテンツブロック

Files APIは、さまざまなコンテンツブロックタイプに対応するさまざまなファイルタイプをサポートしています：

| ファイルタイプ                                                                                                                                                 | MIMEタイプ                                              | コンテンツブロックタイプ       | ユースケース          |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- | ------------------ | --------------- |
| PDF                                                                                                                                                     | `application/pdf`                                    | `document`         | テキスト分析、ドキュメント処理 |
| プレーンテキスト                                                                                                                                                | `text/plain`                                         | `document`         | テキスト分析、処理       |
| 画像                                                                                                                                                      | `image/jpeg`, `image/png`, `image/gif`, `image/webp` | `image`            | 画像分析、視覚的タスク     |
| データセット、その他（[独自のファイルのアップロードと分析](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool#upload-and-analyze-your-own-files)を参照） | 各種                                                   | `container_upload` | データ分析、可視化       |

#### ドキュメントブロック

PDFおよびテキストファイルには、`document`コンテンツブロックを使用します：

```json
{
  "type": "document",
  "source": {
    "type": "file",
    "file_id": "file_011CNha8iCJcU1wXNR6q4V8w"
  },
  "title": "Document Title", // Optional
  "context": "Context about the document", // Optional
  "citations": { "enabled": true } // Optional, enables citations
}
```

#### 画像ブロック

画像には、`image`コンテンツブロックを使用します：

```json
{
  "type": "image",
  "source": {
    "type": "file",
    "file_id": "file_011CPMxVD3fHLUhvTqtsQA5w"
  }
}
```

#### コンテナアップロードブロック

[コード実行ツールにファイルを送信する](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool#upload-and-analyze-your-own-files)には、`container_upload`コンテンツブロックを使用します：

```json
{
  "type": "container_upload",
  "file_id": "file_011CNha8iCJcU1wXNR6q4V8w"
}
```

### その他のファイル形式の扱い

`document`ブロックがサポートしていないファイルタイプ（たとえば、.docxや.xlsx）の場合は、ファイルをプレーンテキストに変換し、その内容をメッセージに直接含めてください。.csvや.mdファイルなど、すでにプレーンテキストであるファイルは、この方法で読み込むことも、明示的な`text/plain`コンテンツタイプを指定してFiles API経由でアップロードすることもできます。データセットをテキストとして読み込むのではなく分析するには、`container_upload`ブロックを使用してコード実行ツール用にアップロードしてください（[独自のファイルのアップロードと分析](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool#upload-and-analyze-your-own-files)を参照）。

以下の例では、テキストファイルを読み込み、その内容をプレーンテキストとして送信します：

<CodeGroup>
  ```bash cURL
  # テキストファイルを読み込みます
  # 注: 特殊文字を含むファイルの場合は、base64 エンコードを検討してください
  TEXT_CONTENT=$(cat document.txt)

  curl https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -d @- <<EOF
  {
    "model": "claude-opus-5-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "Here's the document content:\n\n${TEXT_CONTENT}\n\nPlease summarize this document."
          }
        ]
      }
    ]
  }
  EOF
  ```

  ```bash CLI
  # "@./path" 参照は、ファイルの内容をフィールドに直接インライン展開します。
  ant messages create --model claude-opus-5-5 --max-tokens 1024 <<'YAML'
  messages:
    - role: user
      content:
        - type: text
          text: "Here's the document content:"
        - type: text
          text: "@./document.txt"
        - type: text
          text: "Please summarize this document."
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  # テキストファイルを読み込みます
  with open("document.txt") as f:
      text_content = f.read()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "text",
                      "text": f"Here's the document content:\n\n{text_content}\n\nPlease summarize this document.",
                  }
              ],
          }
      ],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  import fs from "node:fs/promises";
  // ...
  const client = new Anthropic();

  // テキストファイルを読み込みます
  const textContent = await fs.readFile("document.txt", "utf-8");

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: `Here's the document content:\n\n${textContent}\n\nPlease summarize this document.`
          }
        ]
      }
    ]
  });

  const textBlock = response.content.find((block) => block.type === "text");
  console.log(textBlock?.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  // テキストファイルを読み込みます
  string textContent = await File.ReadAllTextAsync("document.txt");

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages = [new UserMessageParam
      {
          Content = $"Here's the document content:\n\n{textContent}\n\nPlease summarize this document."
      }]
  };

  var message = await client.Messages.Create(parameters);
  foreach (var block in message.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  // テキストファイルを読み込みます
  textContent, err := os.ReadFile("document.txt")
  if err != nil {
  	log.Fatal(err)
  }

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock(
  			fmt.Sprintf("Here's the document content:\n\n%s\n\nPlease summarize this document.", string(textContent)),
  		)),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // テキストファイルを読み込みます
  String textContent = Files.readString(Path.of("document.txt"));

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(1024L)
      .addUserMessage("Here's the document content:\n\n" + textContent + "\n\nPlease summarize this document.")
      .build();

  Message response = client.messages().create(params);
  response.content().stream()
      .flatMap(block -> block.text().stream())
      .forEach(textBlock -> System.out.println(textBlock.text()));
  ```

  ```php PHP
  $client = new Client();

  // テキストファイルを読み込みます
  $textContent = file_get_contents('document.txt');

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'text',
                      'text' => "Here's the document content:\n\n{$textContent}\n\nPlease summarize this document."
                  ]
              ]
          ]
      ],
      model: 'claude-opus-5-5',
  );

  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  # テキストファイルを読み込みます
  text_content = File.read("document.txt")

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Here's the document content:\n\n#{text_content}\n\nPlease summarize this document."
          }
        ]
      }
    ]
  )

  message.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

<Note>
  画像を含む.docxファイルの場合は、まずPDF形式に変換してから[PDFサポート](https://platform.claude.com/docs/ja/build-with-claude/pdf-support)を使用して、組み込みの画像解析を活用してください。これにより、PDFドキュメントからの引用を使用できます。
</Note>

### ファイルの管理

#### ファイルの一覧表示

アップロードしたファイルの一覧を取得します。このエンドポイントはページネーションされています。各リクエストは最大[`limit`](https://platform.claude.com/docs/ja/api/files/list#list.limit)件のファイル（デフォルトは20件、最大1,000件）を返し、レスポンスの[`next_page`](https://platform.claude.com/docs/ja/api/files/list#list.response.next_page)カーソルを[`page`](https://platform.claude.com/docs/ja/api/files/list#list.page)パラメータとして渡すと次のページを取得できます。ファイルは新しい順に並べられます。[ファイルの一覧APIリファレンス](https://platform.claude.com/docs/ja/api/files/list)を参照してください。SDKは最初のページを返し、[自動ページネーション](https://platform.claude.com/docs/ja/api/overview#pagination)ヘルパーを提供します。

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21"
  ```

  ```bash CLI
  # list コマンドは自動でページ送りされるため、--max-items は合計件数を制限します
  ant files list --max-items 10
  ```

  ```python Python
  client = anthropic.Anthropic()
  files = client.files.list()
  print(files)
  ```

  ```typescript TypeScript
  const client = new Anthropic();
  const files = await client.files.list();
  console.log(files);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var files = await client.Files.List();
  Console.WriteLine(files);
  ```

  ```go Go
  client := anthropic.NewClient()

  files, err := client.Files.List(context.TODO(), anthropic.FileListParams{})
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(files)
  ```

  ```java Java
  import com.anthropic.models.files.FileListPage;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      FileListPage files = client.files().list();
      System.out.println(files);
  }
  ```

  ```php PHP
  $client = new Client();

  $files = $client->files->list();
  echo $files;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  files = client.files.list
  puts files
  ```
</CodeGroup>

ページングの代わりに、既知のファイルのセットを1回のリクエストで確認するには、最大100個のファイルIDを`ids[]`クエリパラメータとして渡します。`ids[]`リクエストは常に単一のページを返し（`next_page`は`null`）、ワークスペース内のファイルに解決されないIDは`data`から通知なしに除外されます。欠落を検出するには、返されたIDとリクエストしたIDを比較してください。`ids[]`は`page`または`limit`と組み合わせることはできません。

#### ファイルメタデータの取得

特定のファイルに関する情報を取得します：

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/files/$FILE_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21"
  ```

  ```bash CLI
  ant files retrieve-metadata --file-id "$FILE_ID"
  ```

  ```python Python
  file = client.files.retrieve_metadata(file_id)
  print(file)
  ```

  ```typescript TypeScript
  const file = await client.files.retrieveMetadata(uploaded.id);
  console.log(file);
  ```

  ```csharp C#
  var file = await client.Files.RetrieveMetadata(fileId);
  Console.WriteLine(file);
  ```

  ```go Go
  metadata, err := client.Files.GetMetadata(context.TODO(), fileID, anthropic.FileGetMetadataParams{})
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(metadata)
  ```

  ```java Java
  FileMetadata metadata = client.files().retrieveMetadata(fileId);

  System.out.println(metadata);
  ```

  ```php PHP
  $file = $client->files->retrieveMetadata($fileId);
  echo $file;
  ```

  ```ruby Ruby
  file = client.files.retrieve_metadata(file_id)
  puts file
  ```
</CodeGroup>

#### ファイルの削除

ワークスペースからファイルを削除します：

<CodeGroup>
  ```bash cURL
  curl -X DELETE "https://api.anthropic.com/v1/files/$FILE_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21"
  ```

  ```bash CLI
  ant files delete --file-id "$FILE_ID"
  ```

  ```python Python
  client.files.delete(file_id)
  ```

  ```typescript TypeScript
  await client.files.delete(uploaded.id);
  ```

  ```csharp C#
  await client.Files.Delete(fileId);
  ```

  ```go Go
  _, err = client.Files.Delete(context.TODO(), fileID, anthropic.FileDeleteParams{})
  if err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  client.files().delete(fileId);
  ```

  ```php PHP
  $client->files->delete($fileId);
  ```

  ```ruby Ruby
  client.files.delete(file_id)
  ```
</CodeGroup>

### ファイルのダウンロード

[スキル](https://platform.claude.com/docs/ja/build-with-claude/skills-guide)または[コード実行ツール](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool)によって作成されたファイルをダウンロードします。アップロードしたファイルはダウンロードできません。生成されたファイルの`file_id`は、そのファイルを作成したMessagesレスポンスの[`bash_code_execution_tool_result`コンテンツブロック](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool#retrieve-generated-files)に含まれています：

<CodeGroup>
  ```bash cURL
  curl -X GET "https://api.anthropic.com/v1/files/$FILE_ID/content" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -o downloaded_file.txt
  ```

  ```bash CLI
  ant files download --file-id "$FILE_ID" --output downloaded_file.txt
  ```

  ```python Python
  file_content = client.files.download(file_id)

  file_content.write_to_file("downloaded_file.txt")
  ```

  ```typescript TypeScript
  const content = await client.files.download(uploaded.id);

  const bytes = Buffer.from(await content.arrayBuffer());
  await fsp.writeFile("downloaded_file.txt", bytes);
  ```

  ```csharp C#
  using var fileContent = await client.Files.Download(fileId);
  await using var source = await fileContent.ReadAsStream();
  await using var destination = File.Create("downloaded_file.txt");
  await source.CopyToAsync(destination);
  ```

  ```go Go
  func downloadFile(client anthropic.Client, fileID string) error {
  	resp, err := client.Files.Download(context.TODO(), fileID, anthropic.FileDownloadParams{})
  	if err != nil {
  		return err
  	}
  	defer resp.Body.Close()

  	out, err := os.Create("downloaded_file.txt")
  	if err != nil {
  		return err
  	}
  	defer out.Close()

  	_, err = io.Copy(out, resp.Body)
  	return err
  }
  ```

  ```java Java
  try (HttpResponse response = client.files().download(fileId)) {
      try (InputStream body = response.body()) {
          Files.copy(body, Path.of("downloaded_file.txt"),
              StandardCopyOption.REPLACE_EXISTING);
      }
  }
  ```

  ```php PHP
  $fileContent = $client->files->download($fileId);

  file_put_contents('downloaded_file.txt', $fileContent);
  ```

  ```ruby Ruby
  file_content = client.files.download(file_id)

  File.binwrite("downloaded_file.txt", file_content.read)
  ```
</CodeGroup>

<Note>
  ファイルは、そのメタデータに`"downloadable": true`が表示されている場合にのみダウンロード可能です。これはスキルまたはコード実行ツールによって作成されたファイルに該当します。アップロードしたファイルをダウンロードしようとすると、400エラーが返されます。
</Note>

Claude APIでは、スキルによって作成されたファイルを含め、Claudeがコード実行ツールで生成したサポート対象の画像、動画、音声ファイルには、ダウンロード時に署名付きのC2PA Content Credentialsが付与されます。クレデンシャルの内容と検証方法については、[生成されたファイルのContent Credentials](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool#content-credentials-on-generated-files)を参照してください。

## ファイルストレージと制限

### ストレージ制限

* **最大ファイルサイズ：** ファイルあたり500 MB
* **合計ストレージ：** 組織あたり1 TB

### ファイルのライフサイクル

* ファイルは、アップロードされたワークスペースにスコープされます。同じワークスペース内のどのリクエストからも参照できます。信頼できないソースからファイルIDを受け入れないでください（[ワークスペースアクセスに関する警告](https://platform.claude.com/docs/ja/build-with-claude/files#workspace-scoped-access)を参照）。
* ファイルはアップロード後に変更したり名前を変更したりすることはできません。ファイルの内容を変更するには、新しいファイルをアップロードして古いファイルを削除してください。
* ファイルは、`DELETE /v1/files/{file_id}`エンドポイントで削除するか、`expires_at`に達するまで保持されます。
* 削除されたファイルは復元できません。
* ファイルは削除後まもなくAPI経由でアクセスできなくなりますが、アクティブなMessages API呼び出しおよび関連するツール使用では保持される場合があります。
* ユーザーが削除したファイルは、Anthropicの[データ保持ポリシー](https://privacy.claude.com/en/articles/7996866-how-long-do-you-store-my-organization-s-data)に従って削除されます。

### ファイルの有効期限

ファイルを自動的に期限切れにするには、アップロード時に[`expires_in_seconds`](https://platform.claude.com/docs/ja/api/files/upload#upload.expires_in_seconds)フォームフィールドを含めます。値は3,600（1時間）から7,776,000（90日）までの整数の秒数です。結果として得られる[`expires_at`](https://platform.claude.com/docs/ja/api/files#file_metadata.expires_at)タイムスタンプ（RFC 3339）はすべてのファイルレスポンスに表示され、有効期限なしでアップロードされたファイルでは`null`になります。有効期限はアップロード時に一度だけ設定され、変更することはできません。

ファイルが`expires_at`に達すると：

* そのコンテンツのダウンロード（`GET /v1/files/{file_id}/content`）は404エラーを返します。
* そのファイルを参照するMessagesリクエストは、推論の前に失敗します。
* そのメタデータ（`GET /v1/files/{file_id}`）は、`expires_at`が過去の日時となった状態で最大30日間読み取り可能なままです。
* その期間中は一覧レスポンスにも引き続き表示されます。期限切れのファイルを除外するには、`expires_at`を現在時刻と比較してください。

期限切れのファイルを`DELETE /v1/files/{file_id}`で削除すると、30日間の期間が経過するのを待たずに、そのメタデータが即座に削除されます。

<Note>
  有効期限はライフサイクル機能であり、削除を保証する制御ではありません。`expires_at`以降、ファイルコンテンツはAPI経由で取得できなくなり、ストレージクォータから解放されます。基盤となるコンテンツは、完全に削除される前に安全性審査のためにその後一定期間保持される場合があり、ファイルメタデータは有効期限後最大30日間表示されたままになります。予定された有効期限の前にファイルを削除するには、`DELETE /v1/files/{file_id}`を使用してください。
</Note>

### 監査ログ

組織で[Compliance API](https://platform.claude.com/docs/ja/manage-claude/compliance-api)が有効になっている場合、その[アクティビティフィード](https://platform.claude.com/docs/ja/manage-claude/compliance-activity-feed)には、Claude APIキーを使用して、またはClaude Consoleから行われたFiles API操作が記録されます。各アップロード（`POST /v1/files`）、コンテンツのダウンロード（`GET /v1/files/{file_id}/content`）、および削除（`DELETE /v1/files/{file_id}`）は、それぞれ`platform_file_uploaded`、`platform_file_content_downloaded`、または`platform_file_deleted`アクティビティとして表示されます。ファイルの一覧表示とファイルメタデータの取得は記録されません。Compliance APIが無効になっている間に発生した操作は記録されず、後から復元することもできないため、この監査証跡に依存する前に[Compliance APIをセットアップ](https://platform.claude.com/docs/ja/manage-claude/compliance-api-access)してください。[Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws#monitoring-and-logging)では、代わりにAWS CloudTrailデータイベントでファイル操作を監査してください。

## `files-api-2025-04-14`からの移行

Files APIはベータを終了しており、ベータヘッダーは不要です。`files-api-2025-04-14`からの移行は任意です。このヘッダーを送信するリクエストは動作し続け、ベータのレスポンス形式を返し続けるため、既存のインテグレーションは変更するまで動作し続けます。ヘッダーを削除すると、それらのリクエストはこのページに記載されている形式に切り替わります。

|                                 | `files-api-2025-04-14`あり                | ヘッダーなし                                                       |
| ------------------------------- | --------------------------------------- | ------------------------------------------------------------ |
| 一覧レスポンス                         | `{ data, has_more, first_id, last_id }` | `{ data, next_page }`。`next_page`を`page`クエリパラメータとして渡します      |
| 一覧カーソル                          | `before_id`、`after_id`                  | `page`、または最大100個の`ids[]`（`before_id`と`after_id`は400エラーを返します） |
| ファイルオブジェクトの`expires_at`         | 返されない                                   | 常に存在。ファイルに有効期限がない場合は`null`                                   |
| アップロードされたファイルパートの`Content-Type` | 必須                                      | 任意。省略時はタイプが検出されます                                            |

移行するには：

1. **ベータヘッダーを削除します。** リクエストから`anthropic-beta: files-api-2025-04-14`を削除します。SDKでは、`client.beta.files` (csharp, go: `client.Beta.Files`; java: `client.beta().files()`; php: `$client->beta->files`)の代わりに`client.files` (csharp, go: `client.Files`; java: `client.files()`; php: `$client->files`)を呼び出します。`client.beta.files` (csharp, go: `client.Beta.Files`; java: `client.beta().files()`; php: `$client->beta->files`)をそのまま使い続けられるのは、[ヘッダーを送信しなくなったSDKリリース](https://platform.claude.com/docs/ja/build-with-claude/files#sdk-beta-namespace)のみです。それより前のリリースでは、ベータ名を渡さなくても`client.beta.files` (csharp, go: `client.Beta.Files`; java: `client.beta().files()`; php: `$client->beta->files`)からヘッダーが送信されます。
2. **ページネーションを更新します。** `after_id`/`before_id`のループを`page`/`next_page`カーソルに置き換えるか、[ファイルの管理](https://platform.claude.com/docs/ja/build-with-claude/files#managing-files)に示されているSDKの自動ページネーションヘルパーを使用します。
3. **`expires_at`を読み取ります。** このフィールドはヘッダーなしの場合にのみ表示されます。`null`はファイルに有効期限がないことを意味します（[ファイルの有効期限](https://platform.claude.com/docs/ja/build-with-claude/files#file-expiration)を参照）。

### SDKのベータ名前空間

Python SDK 1.2.0、TypeScript SDK 0.122.0、Go SDK 1.68.0、Java SDK 2.59.0、PHP SDK 0.45.0、Ruby SDK 1.67.0、C# SDK 12.44.0以降では、`client.beta.files` (csharp, go: `client.Beta.Files`; java: `client.beta().files()`; php: `$client->beta->files`)は`files-api-2025-04-14`を送信しなくなり、`client.files` (csharp, go: `client.Files`; java: `client.files()`; php: `$client->files`)と同じ形式を、`Beta`プレフィックス付きの型名（PHPでは`Anthropic\Beta`名前空間のクラス）で返します。ベータ段階にあるFiles機能、たとえば[Managed Agents](https://platform.claude.com/docs/ja/managed-agents/files)ベータヘッダー下での`scope_id`によるフィルタリングなどについては、`betas` (csharp, go: `Betas`; java: `.addBeta()`)を通じてベータ名を受け付けます。それより前のSDKリリースはベータ版の形式に型付けされています。それらの型に依存している場合は、移行するまで以前のリリースを使い続けてください。

`files-api-2025-04-14`なしで`anthropic-beta: managed-agents-2026-04-01`を含むリクエストは、`GET /v1/files`における1つの互換性措置を除き、このページの形式を受け取ります。`before_id`と`after_id`は引き続き受け付けられ（`page`または`ids[]`とは組み合わせ不可）、一覧レスポンスには`next_page`に加えて`has_more`、`first_id`、`last_id`が含まれます。それ以降のManaged Agentsベータバージョンは通常の形式を受け取ります。

## エラー処理

Files APIを使用する際の一般的なエラーには以下があります：

* **ファイルが見つからない（404）：** 指定された`file_id`が存在しないか、アクセス権がありません。
* **無効なファイルタイプ（400）：** ファイルタイプがコンテンツブロックタイプと一致しません（たとえば、ドキュメントブロックで画像ファイルを使用する場合）。
* **ダウンロード不可（400）：** アップロードしたファイルは`"downloadable": false`であり、ダウンロードできません。ダウンロードできるのは、スキルまたはコード実行ツールによって作成されたファイルのみです。
* **コンテキストウィンドウサイズの超過（400）：** ファイルがコンテキストウィンドウのサイズより大きいです（たとえば、`/v1/messages`リクエストで500 MBのプレーンテキストファイルを使用する場合）。
* **無効なファイル名（400）：** ファイル名が長さの要件（1～255文字）を満たしていないか、禁止文字（`<`、`>`、`:`、`"`、`|`、`?`、`*`、`\`、`/`、またはUnicode文字0～31）が含まれています。
* **ファイルが大きすぎる（413）：** ファイルが500 MBの制限を超えています。
* **ストレージ制限の超過（400）：** 組織が1 TBのストレージ制限に達しています。

```json Output
{
  "type": "error",
  "error": {
    "type": "not_found_error",
    "message": "File `file_011CNha8iCJcU1wXNR6q4V8w` not found."
  },
  "request_id": "req_011CQFYcrRp7mCHLDsAYT8Qt"
}
```

## 使用量と請求

Files APIの操作は無料です：

* ファイルのアップロード
* ファイルのダウンロード
* ファイルの一覧表示
* ファイルメタデータの取得
* ファイルの削除

Messagesリクエストで使用されるファイルコンテンツは、入力トークンとして課金されます。

### レート制限

ファイル関連のAPI呼び出しは、1分あたり約500リクエストに制限されています。より高い制限をリクエストするには、[営業チームにお問い合わせ](mailto:sales@anthropic.com)ください。

## 次のステップ

<CardGroup cols={3}>
  <Card title="PDFサポート" icon="file" href="https://platform.claude.com/docs/ja/build-with-claude/pdf-support">
    ClaudeでPDFを処理します。ドキュメントからテキストを抽出し、チャートを分析し、視覚的なコンテンツを理解します。
  </Card>

  <Card title="コード実行ツール" icon="terminal" href="https://platform.claude.com/docs/ja/agents-and-tools/tool-use/code-execution-tool">
    サンドボックス化されたコンテナでPythonおよびBashコードを実行し、データの分析、ファイルの生成、ソリューションの反復改善を行います。
  </Card>

  <Card title="ビジョン" icon="image" href="https://platform.claude.com/docs/ja/build-with-claude/vision">
    視覚的な入力を処理・分析し、画像からテキストやコードを生成します。
  </Card>
</CardGroup>

## 利用可能状況

Files APIはすべてのモデルで利用可能です。

### APIサポート

#### [Messages API](https://platform.claude.com/docs/ja/build-with-claude/working-with-messages)

* 利用可能状況：利用可能
* 使用方法：アップロードしたファイルを、`document`、`image`、または`container_upload`ブロックで`file_id`により参照します。

| ステータス | クラウドプラットフォーム                                                                                                                                                                                                                                                                                                                                                                                                 |
| ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 利用可能  | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ja/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry) |

#### [Managed Agents](https://platform.claude.com/docs/ja/managed-agents/overview)

* 利用可能状況：利用可能
* 使用方法：アップロードしたファイルをセッションリソースとしてセッションのサンドボックスにマウントする（読み取り専用、`/mnt/session/uploads`配下）か、`user.message`イベントの`image`または`document`ブロックで`file_id`を参照します。エージェントが`/mnt/session/outputs/`に書き込んだファイルは、Files APIでダウンロードできます。

| ステータス | クラウドプラットフォーム          |
| ----- | --------------------- |
| 利用可能  | サポートされているすべてのプラットフォーム |

### データの取り扱い

[データの取り扱いの概要](https://platform.claude.com/docs/ja/manage-claude/api-and-data-retention#feature-eligibility)

| 項目    | ゼロデータ保持                                                                                                                     | HIPAA |
| ----- | --------------------------------------------------------------------------------------------------------------------------- | ----- |
| ステータス | 対象外                                                                                                                         | 対象外   |
| 詳細    | ファイルは明示的に削除されるか、設定された有効期限に達するまで保持されます。 [詳細はこちら](https://platform.claude.com/docs/ja/build-with-claude/files#data-retention) | —     |

対象エンドポイント：

* `/v1/files`