---
title: Files API
url: https://platform.claude.com/docs/ja/build-with-claude/files
description: ファイルを一度アップロードすれば、Messagesリクエストでfile_idによって参照でき、スキルやコード実行ツールによって作成された出力をダウンロードできます。
featureMetadata:
  status: ga
  zdr: not-eligible
  supportedPlatforms:
    Claude API: ga
    Claude Platform on AWS: ga
    Microsoft Foundry:
      availability: ga
      note: "[Microsoft Foundry](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry)では、Files APIを使用するには[Hosted on Anthropicデプロイメント](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure)が必要です。"
---

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#compatibility)については、リンク先のページでモデルのサポート状況を確認してください。

## Files APIの仕組み

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

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

<Warning id="workspace-scoped-access">
  **アップロードされたファイルはワークスペース全体からアクセス可能であり、エンドユーザー、会話、またはセッションにスコープされません。** ワークスペースへのアクセス権を持つすべてのAPIキーは、そのワークスペースにアップロードされたすべてのファイルにアクセスできます。すべてのサービスアカウント、および組織ロールでAPIアクセスが許可されているすべてのユーザーは、追加されたワークスペースに加えてDefault Workspaceも使用できるため、分離しておく必要があるファイルは専用の[ワークスペース](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: 2023-06-01" \
    -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`は`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)を参照してください。

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

アップロード後、アップロードレスポンスの`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: 2023-06-01" \
    -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 MessageParam
              {
                  Role = Role.User,
                  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)
      .addUserMessageOfBlockParams(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: "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: 2023-06-01" \
    -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 \
    --transform 'content.#(type=="text").text' \
    --raw-output <<'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 is Anthropic.TextBlock => 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()
      {
          Role = Role.User,
          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: "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>

### ファイルの管理

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

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

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

  ```bash CLI
  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: 2023-06-01"
  ```

  ```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: 2023-06-01"
  ```

  ```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: 2023-06-01" \
    --output 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)を参照してください。

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

### ストレージ制限

* **最大ファイルサイズ：** 1ファイルあたり500 MB
* **合計ストレージ：** 1組織あたり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)に従って削除されます。すべての機能におけるZDRの適格性については、[APIとデータ保持](https://platform.claude.com/docs/ja/manage-claude/api-and-data-retention)を参照してください

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

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

ファイルが`expires_at`に達すると、次のようになります。

* そのコンテンツのダウンロード（`GET /v1/files/{file_id}/content`）は404エラーを返します
* そのファイルを参照するMessagesリクエストは推論前に失敗します
* そのメタデータ（`GET /v1/files/{file_id}`）は最大30日間読み取り可能なままで、`expires_at`は過去の時刻になります
* その期間中は一覧レスポンスに引き続き表示されます。期限切れのファイルを除外するには、`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)が有効になっている場合、その[Activity Feed](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`の代わりに`client.files`を呼び出します。`client.beta.files`を使い続けることができるのは、[ヘッダーを送信しなくなったSDKリリース](https://platform.claude.com/docs/ja/build-with-claude/files#sdk-beta-namespace)のみです。それ以前のリリースでは、`betas`引数がなくても`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のbeta名前空間

Python SDK 1.2.0、TypeScript SDK 0.122.0、Go SDK 1.68.0、Java SDK 2.59.0、Ruby SDK 1.67.0、およびC# SDK 12.44.0以降、`client.beta.files`は`files-api-2025-04-14`を送信しなくなり、`Beta`プレフィックス付きの型名で`client.files`と同じ形式を返します。[Managed Agents](https://platform.claude.com/docs/ja/managed-agents/files)ベータヘッダーでの`scope_id`フィルタリングなど、まだベータ段階のFiles機能のために`betas`引数を受け付けます。それ以前の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>