---
title: ビジョン
url: https://platform.claude.com/docs/ja/build-with-claude/vision
description: Claudeのビジョン機能により、Claudeは画像を理解・分析できるようになり、マルチモーダルなインタラクションの魅力的な可能性が広がります。
---

このガイドでは、Claudeに画像を送信する方法、適用される制限とコスト、そして[座標ベースのワークフロー](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates)に関するガイダンスの参照先について説明します。

***

## Claudeに画像を送信する

Claudeのビジョン機能は、次の方法で利用できます。

* [claude.ai](https://claude.ai/)。ファイルと同じように画像をアップロードするか、チャットウィンドウに画像を直接ドラッグ＆ドロップします。
* Claude Consoleの[Playground](https://platform.claude.com/playground)。任意のUserメッセージブロックに画像を直接追加します。
* APIリクエスト。以下の例を参照してください。

APIでは、次の3つのソースタイプのいずれかを使用して、`image`コンテンツブロックとしてClaudeに画像を提供します。

1. リクエスト本文に埋め込まれたbase64エンコード画像
2. オンラインでホストされている画像へのURL参照
3. [Files API](https://platform.claude.com/docs/ja/build-with-claude/files)から返される`file_id`（一度アップロードすれば、何度でも参照可能）

<Note>
  Amazon BedrockおよびGoogle Cloudでは、現在base64エンコードのソースのみが利用可能です。
</Note>

<Tip>
  テキストプロンプトにおいて[長いドキュメントをクエリの前に配置する](https://platform.claude.com/docs/ja/build-with-claude/prompt-engineering/claude-prompting-best-practices#long-context-prompting)と結果が向上するのと同様に、Claudeは画像がテキストの前にある場合に最も良く機能します。テキストの後に配置された画像やテキストの間に挿入された画像でも十分に機能しますが、ユースケースが許す場合は、画像の後にテキストを置く構成を推奨します。
</Tip>

### base64エンコード画像の例

<CodeGroup>
  ```bash cURL
  curl 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 @- <<EOF
  {
    "model": "claude-opus-5-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "base64",
              "media_type": "image/jpeg",
              "data": "$BASE64_IMAGE_DATA"
            }
          },
          {
            "type": "text",
            "text": "Describe this image."
          }
        ]
      }
    ]
  }
  EOF
  ```

  ```bash CLI
  curl -sSo ./vision-example.jpg \
    https://platform.claude.com/docs/images/vision-example.jpg

  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: image
          source:
            type: base64
            media_type: image/jpeg
            data: "@./vision-example.jpg"
        - type: text
          text: Describe this image.
  YAML
  ```

  ```python Python
  image1_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
  image1_media_type = "image/png"

  client = anthropic.Anthropic()
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "image",
                      "source": {
                          "type": "base64",
                          "media_type": image1_media_type,
                          "data": image1_data,
                      },
                  },
                  {"type": "text", "text": "Describe this image."},
              ],
          }
      ],
  )
  print(message)
  ```

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

  const message = await anthropic.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/jpeg",
              data: imageData // Base64-encoded image data as string
            }
          },
          {
            type: "text",
            text: "Describe this image."
          }
        ]
      }
    ]
  });

  console.log(message);
  ```

  ```csharp C#
  using System.Collections.Generic;
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  string imageData = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new MessageParamContent(new List<ContentBlockParam>
              {
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new Base64ImageSource()
                      {
                          Data = imageData,
                          MediaType = MediaType.ImagePng,
                      })
                  )),
                  new ContentBlockParam(new TextBlockParam("Describe this image.")),
              }),
          }
      ]
  });

  Console.WriteLine(message);
  ```

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

  imageData := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewImageBlockBase64("image/png", imageData),
  			anthropic.NewTextBlock("Describe this image."),
  		),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(message)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();
  String imageData =
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";

  List<ContentBlockParam> contentBlockParams = List.of(
    ContentBlockParam.ofImage(
      ImageBlockParam.builder()
        .source(
          Base64ImageSource.builder()
            .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
            .data(imageData)
            .build()
        )
        .build()
    ),
    ContentBlockParam.ofText(TextBlockParam.builder().text("Describe this image.").build())
  );
  Message message = client
    .messages()
    .create(
      MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addUserMessageOfBlockParams(contentBlockParams)
        .build()
    );

  IO.println(message);
  ```

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

  $imageData = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'image',
                      'source' => [
                          'type' => 'base64',
                          'media_type' => 'image/png',
                          'data' => $imageData,
                      ],
                  ],
                  ['type' => 'text', 'text' => 'Describe this image.'],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo json_encode($message, JSON_PRETTY_PRINT), PHP_EOL;
  ```

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

  image_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image_data
            }
          },
          { type: "text", text: "Describe this image." }
        ]
      }
    ]
  )

  puts message
  ```
</CodeGroup>

### URLベースの画像の例

<CodeGroup>
  ```bash cURL
  curl 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": "image",
              "source": {
                "type": "url",
                "url": "https://platform.claude.com/docs/images/vision-example.jpg"
              }
            },
            {
              "type": "text",
              "text": "Describe this image."
            }
          ]
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: image
          source:
            type: url
            url: https://platform.claude.com/docs/images/vision-example.jpg
        - type: text
          text: Describe this image.
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "image",
                      "source": {
                          "type": "url",
                          "url": "https://platform.claude.com/docs/images/vision-example.jpg",
                      },
                  },
                  {"type": "text", "text": "Describe this image."},
              ],
          }
      ],
  )
  print(message)
  ```

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

  const message = await anthropic.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "url",
              url: "https://platform.claude.com/docs/images/vision-example.jpg"
            }
          },
          {
            type: "text",
            text: "Describe this image."
          }
        ]
      }
    ]
  });

  console.log(message);
  ```

  ```csharp C#
  using System.Collections.Generic;
  using Anthropic;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new MessageParamContent(new List<ContentBlockParam>
              {
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new UrlImageSource()
                      {
                          Url = "https://platform.claude.com/docs/images/vision-example.jpg",
                      })
                  )),
                  new ContentBlockParam(new TextBlockParam("Describe this image.")),
              }),
          }
      ]
  });

  Console.WriteLine(message);
  ```

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

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewImageBlock(anthropic.URLImageSourceParam{
  				URL: "https://platform.claude.com/docs/images/vision-example.jpg",
  			}),
  			anthropic.NewTextBlock("Describe this image."),
  		),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(message)
  ```

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

  List<ContentBlockParam> contentBlockParams = List.of(
    ContentBlockParam.ofImage(
      ImageBlockParam.builder()
        .source(
          UrlImageSource.builder()
            .url("https://platform.claude.com/docs/images/vision-example.jpg")
            .build()
        )
        .build()
    ),
    ContentBlockParam.ofText(TextBlockParam.builder().text("Describe this image.").build())
  );
  Message message = client
    .messages()
    .create(
      MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addUserMessageOfBlockParams(contentBlockParams)
        .build()
    );
  System.out.println(message);
  ```

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

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'image',
                      'source' => [
                          'type' => 'url',
                          'url' => 'https://platform.claude.com/docs/images/vision-example.jpg',
                      ],
                  ],
                  ['type' => 'text', 'text' => 'Describe this image.'],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo json_encode($message, JSON_PRETTY_PRINT), PHP_EOL;
  ```

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

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "url",
              url: "https://platform.claude.com/docs/images/vision-example.jpg"
            }
          },
          { type: "text", text: "Describe this image." }
        ]
      }
    ]
  )

  puts message
  ```
</CodeGroup>

### Files APIを使用した画像の例

繰り返し使用する画像や、エンコードのオーバーヘッドを避けたい場合は、[Files API](https://platform.claude.com/docs/ja/build-with-claude/files)を使用してください。画像を一度アップロードし、以降のメッセージではbase64データを再送信する代わりに、返された`file_id`を参照します。

<Tip>
  マルチターンの会話やエージェント型ワークフローでは、各リクエストで 会話履歴全体が再送信されます。画像がbase64エンコードされている場合、画像の全バイトが 毎ターンのペイロードに含まれるため、会話が長くなるにつれて リクエストサイズと「latency」（レイテンシ）が大幅に増加する可能性があります。画像を Files APIにアップロードして`file_id`で参照すれば、会話履歴に蓄積される画像の数に 関係なく、リクエストペイロードを小さく保つことができます。
</Tip>

<CodeGroup>
  ```bash cURL
  # まず、画像を Files API にアップロードします
  FILE_ID=$(curl -sS -X POST https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -F "file=@vision-example.jpg" | jq -r '.id')

  # 次に、返された file_id をメッセージ内で使用します
  curl 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": "image",
              "source": {
                "type": "file",
                "file_id": "'"$FILE_ID"'"
              }
            },
            {
              "type": "text",
              "text": "Describe this image."
            }
          ]
        }
      ]
    }'
  ```

  ```bash CLI
  curl -sSo vision-example.jpg \
    https://platform.claude.com/docs/images/vision-example.jpg

  # まず、画像をFiles APIにアップロードします
  FILE_ID=$(ant files upload \
    --file ./vision-example.jpg \
    --transform id --raw-output)

  # 次に、返された file_id をメッセージ内で使用します
  ant messages create \
    --transform content --format yaml <<YAML
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: image
          source:
            type: file
            file_id: $FILE_ID
        - type: text
          text: Describe this image.
  YAML
  ```

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

  # 画像ファイルをアップロードします
  with open("vision-example.jpg", "rb") as f:
      file_upload = client.files.upload(file=("vision-example.jpg", f, "image/jpeg"))

  # アップロードしたファイルをメッセージで使用します
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "image",
                      "source": {"type": "file", "file_id": file_upload.id},
                  },
                  {"type": "text", "text": "Describe this image."},
              ],
          }
      ],
  )

  print(message.content)
  ```

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

  const anthropic = new Anthropic();

  // 画像ファイルをアップロードします
  const fileUpload = await anthropic.files.upload({
    file: await toFile(fs.createReadStream("vision-example.jpg"), undefined, {
      type: "image/jpeg"
    })
  });

  // アップロードしたファイルをメッセージで使用します
  const response = await anthropic.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: {
              type: "file",
              file_id: fileUpload.id
            }
          },
          {
            type: "text",
            text: "Describe this image."
          }
        ]
      }
    ]
  });

  console.log(response);
  ```

  ```csharp C#
  using System.Collections.Generic;
  using Anthropic;
  using Anthropic.Core;
  using Anthropic.Models.Files;
  using Anthropic.Models.Messages;

  AnthropicClient client = new();

  // 画像ファイルをアップロードします
  var fileUpload = await client.Files.Upload(new FileUploadParams
  {
      File = new BinaryContent
      {
          Stream = File.OpenRead("vision-example.jpg"),
          FileName = "vision-example.jpg",
          ContentType = new("image/jpeg"),
      },
  });

  // アップロードしたファイルをメッセージで使用します
  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new MessageParamContent(new List<ContentBlockParam>
              {
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new FileImageSource(fileUpload.ID))
                  )),
                  new ContentBlockParam(new TextBlockParam("Describe this image.")),
              }),
          }
      ]
  });

  Console.WriteLine(response);
  ```

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

  // 画像ファイルをアップロードします
  file, err := os.Open("vision-example.jpg")
  if err != nil {
  	log.Fatal(err)
  }
  defer file.Close()

  fileUpload, err := client.Files.Upload(context.Background(),
  	anthropic.FileUploadParams{
  		File: anthropic.File(file, "vision-example.jpg", "image/jpeg"),
  	})
  if err != nil {
  	log.Fatal(err)
  }

  // アップロードしたファイルをメッセージで使用します
  message, err := client.Messages.New(context.Background(),
  	anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(
  				anthropic.NewImageBlock(anthropic.FileImageSourceParam{
  					FileID: fileUpload.ID,
  				}),
  				anthropic.NewTextBlock("Describe this image."),
  			),
  		},
  	})
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(message.Content)
  ```

  ```java Java
  import com.anthropic.core.MultipartField;
  import com.anthropic.models.files.FileMetadata;
  import com.anthropic.models.files.FileUploadParams;
  // ...
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      // 画像ファイルをアップロードします
      FileMetadata file = client.files().upload(
        FileUploadParams.builder()
          .file(
            MultipartField.<InputStream>builder()
              .value(Files.newInputStream(Path.of("vision-example.jpg")))
              .filename("vision-example.jpg")
              .contentType("image/jpeg")
              .build()
          )
          .build()
      );

      // アップロードしたファイルをメッセージで使用します
      ImageBlockParam imageParam = ImageBlockParam.builder().fileSource(file.id()).build();

      MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addUserMessageOfBlockParams(
          List.of(
            ContentBlockParam.ofImage(imageParam),
            ContentBlockParam.ofText(
              TextBlockParam.builder().text("Describe this image.").build()
            )
          )
        )
        .build();

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

  ```php PHP
  use Anthropic\Core\FileParam;

  $client = new Client();

  // 画像ファイルをアップロードします
  $fileUpload = $client->files->upload(
      file: FileParam::fromResource(fopen('vision-example.jpg', 'rb'), contentType: 'image/jpeg'),
  );

  // アップロードしたファイルをメッセージで使用します
  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'image',
                      'source' => ['type' => 'file', 'fileID' => $fileUpload->id],
                  ],
                  ['type' => 'text', 'text' => 'Describe this image.'],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo json_encode($message, JSON_PRETTY_PRINT), PHP_EOL;
  ```

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

  # 画像ファイルをアップロードします
  file_upload = client.files.upload(
    file: Anthropic::FilePart.new(
      File.open("vision-example.jpg", "rb"),
      content_type: "image/jpeg"
    )
  )

  # アップロードしたファイルをメッセージで使用します
  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "image",
            source: { type: "file", file_id: file_upload.id }
          },
          { type: "text", text: "Describe this image." }
        ]
      }
    ]
  )

  puts message.content
  ```
</CodeGroup>

その他のサンプルコードやパラメータの詳細については、[Messages APIの例](https://platform.claude.com/docs/ja/api/messages/create)を参照してください。

### 複数の画像

1つのリクエストに複数の画像を含めることができ、Claudeはそれらをまとめて分析します。これは、画像の比較、相違点についての質問、またはドキュメントのページのような連続した画像を扱う場合に便利です。複数の画像を送信する場合は、各画像の前に短いテキストラベル（`Image 1:`、`Image 2:`など）を付けて紹介すると、プロンプトやその後のターンで名前によって画像を参照できます。

<CodeGroup>
  ```bash cURL
  curl 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": "Image 1:"
            },
            {
              "type": "image",
              "source": {
                "type": "base64",
                "media_type": "image/png",
                "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
              }
            },
            {
              "type": "text",
              "text": "Image 2:"
            },
            {
              "type": "image",
              "source": {
                "type": "base64",
                "media_type": "image/png",
                "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC"
              }
            },
            {
              "type": "text",
              "text": "How are these images different?"
            }
          ]
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: text
          text: "Image 1:"
        - type: image
          source:
            type: base64
            media_type: image/png
            data: iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC
        - type: text
          text: "Image 2:"
        - type: image
          source:
            type: base64
            media_type: image/png
            data: iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC
        - type: text
          text: How are these images different?
  YAML
  ```

  ```python Python
  image1_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
  image2_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC"

  client = anthropic.Anthropic()
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {"type": "text", "text": "Image 1:"},
                  {
                      "type": "image",
                      "source": {
                          "type": "base64",
                          "media_type": "image/png",
                          "data": image1_data,
                      },
                  },
                  {"type": "text", "text": "Image 2:"},
                  {
                      "type": "image",
                      "source": {
                          "type": "base64",
                          "media_type": "image/png",
                          "data": image2_data,
                      },
                  },
                  {"type": "text", "text": "How are these images different?"},
              ],
          }
      ],
  )
  print(message)
  ```

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

  const image1Data =
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";
  const image2Data =
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC";

  const message = await anthropic.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Image 1:"
          },
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image1Data
            }
          },
          {
            type: "text",
            text: "Image 2:"
          },
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image2Data
            }
          },
          {
            type: "text",
            text: "How are these images different?"
          }
        ]
      }
    ]
  });

  console.log(message);
  ```

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

  string image1Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";
  string image2Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC";

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new MessageParamContent(new List<ContentBlockParam>
              {
                  new ContentBlockParam(new TextBlockParam("Image 1:")),
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new Base64ImageSource()
                      {
                          Data = image1Data,
                          MediaType = MediaType.ImagePng,
                      })
                  )),
                  new ContentBlockParam(new TextBlockParam("Image 2:")),
                  new ContentBlockParam(new ImageBlockParam(
                      new ImageBlockParamSource(new Base64ImageSource()
                      {
                          Data = image2Data,
                          MediaType = MediaType.ImagePng,
                      })
                  )),
                  new ContentBlockParam(new TextBlockParam("How are these images different?")),
              }),
          }
      ]
  });

  Console.WriteLine(message);
  ```

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

  image1Data := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
  image2Data := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC"

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewTextBlock("Image 1:"),
  			anthropic.NewImageBlockBase64("image/png", image1Data),
  			anthropic.NewTextBlock("Image 2:"),
  			anthropic.NewImageBlockBase64("image/png", image2Data),
  			anthropic.NewTextBlock("How are these images different?"),
  		),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(message)
  ```

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

  String image1Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC";
  String image2Data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC";

  List<ContentBlockParam> contentBlockParams = List.of(
      ContentBlockParam.ofText(TextBlockParam.builder().text("Image 1:").build()),
      ContentBlockParam.ofImage(
          ImageBlockParam.builder()
              .source(
                  Base64ImageSource.builder()
                      .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
                      .data(image1Data)
                      .build()
              )
              .build()
      ),
      ContentBlockParam.ofText(TextBlockParam.builder().text("Image 2:").build()),
      ContentBlockParam.ofImage(
          ImageBlockParam.builder()
              .source(
                  Base64ImageSource.builder()
                      .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
                      .data(image2Data)
                      .build()
              )
              .build()
      ),
      ContentBlockParam.ofText(
          TextBlockParam.builder().text("How are these images different?").build()
      )
  );

  Message message = client
      .messages()
      .create(
          MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024)
              .addUserMessageOfBlockParams(contentBlockParams)
              .build()
      );

  IO.println(message);
  ```

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

  $image1Data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
  $image2Data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC';

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  ['type' => 'text', 'text' => 'Image 1:'],
                  [
                      'type' => 'image',
                      'source' => [
                          'type' => 'base64',
                          'media_type' => 'image/png',
                          'data' => $image1Data,
                      ],
                  ],
                  ['type' => 'text', 'text' => 'Image 2:'],
                  [
                      'type' => 'image',
                      'source' => [
                          'type' => 'base64',
                          'media_type' => 'image/png',
                          'data' => $image2Data,
                      ],
                  ],
                  ['type' => 'text', 'text' => 'How are these images different?'],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo $message;
  ```

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

  image1_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC"
  image2_data = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGNgYPgPAAEDAQAIicLsAAAAAElFTkSuQmCC"

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "Image 1:" },
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image1_data
            }
          },
          { type: "text", text: "Image 2:" },
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: image2_data
            }
          },
          { type: "text", text: "How are these images different?" }
        ]
      }
    ]
  )

  puts message
  ```
</CodeGroup>

マルチターンの会話では、後続の`user`ターンでも同じ方法で新しい画像を追加します。Claudeは以前のターンのすべての画像にアクセスできるため、「これらは最初の2枚と似ていますか？」のようなフォローアップの質問は、新しいターンのコンテンツに以前の画像を再度含めなくても機能します。

***

## 画像の制限とコスト

### リクエストの制限

メッセージまたはリクエストあたりの画像の最大数は次のとおりです。

* [claude.ai](https://claude.ai/)では、メッセージあたり20枚。
* APIでは、200kトークンのコンテキストウィンドウを持つモデルの場合、リクエストあたり100枚。
* APIでは、その他すべてのモデルの場合、リクエストあたり600枚。

画像あたりの最大サイズ（寸法）は8000x8000 pxです。

1つのAPIリクエストに20枚を超える画像が含まれる場合、そのリクエスト内のすべての画像に、より厳しい画像あたりの寸法制限が適用されます。リクエスト内のすべての`image`ブロックがこのしきい値にカウントされます。これには、再送信する以前の会話ターンの画像や、`tool_result`コンテンツ内にネストされた画像（たとえば、computer useツールに返されるスクリーンショット）も含まれます。Amazon BedrockおよびGoogle Cloudでは、PDFなどのドキュメントブロックもこのしきい値にカウントされます。より厳しい制限を超える画像は、「many-image requests」に言及し、現在の制限をピクセル単位で示すメッセージを含む`invalid_request_error`で拒否されます。すべてのプラットフォームで制限内に収めるには、各画像をどちらの辺も2000 pxを超えないようにリサイズするか、リクエスト内の画像ブロックとドキュメントブロックを合計20個以下に抑えてください。

画像あたりの最大ファイルサイズは次のとおりです。

* Claude APIを直接使用する場合は10 MB（base64エンコード後）。
* Amazon BedrockおよびGoogle Cloudでは5 MB（base64エンコード後）。
* [claude.ai](https://claude.ai/)では10 MB。

<Note>
  APIはリクエストあたり最大600枚の画像をサポートしていますが、[リクエストサイズの制限](https://platform.claude.com/docs/ja/api/overview#request-size-limits)（標準エンドポイントでは32 MB。Amazon BedrockやGoogle Cloudなど、一部のパートナー運営プラットフォームではより低い値）に先に達する場合があります。多数の画像を扱う場合は、[Files API](https://platform.claude.com/docs/ja/build-with-claude/vision#files-api-image-example)でアップロードし、`file_id`で参照してリクエストペイロードを小さく保つことを検討してください。

  Files APIを使用している場合でも、大きな画像を多数含むリクエストは、600枚に達する前に失敗する可能性があります。アップロードする前に、画像の寸法やファイルサイズを（たとえばダウンサンプリングによって）削減してください（[解像度とトークンコスト](https://platform.claude.com/docs/ja/build-with-claude/vision#evaluate-image-size)を参照）。
</Note>

### サポートされている形式

ClaudeはJPEG、PNG、GIF、WebP画像（`image/jpeg`、`image/png`、`image/gif`、`image/webp`）をサポートしています。アニメーションはサポートされておらず、最初のフレームのみが使用されます。

### 解像度とトークンコスト

Claudeは画像をピクセル単位ではなくパッチ単位で認識します。各パッチは画像の28×28ピクセルのブロックであり、「visual token」（ビジュアルトークン）と呼ばれます。したがって、画像のコストは`⌈width / 28⌉ × ⌈height / 28⌉`ビジュアルトークンとなります。

各モデルには、長辺の制限とビジュアルトークンの制限で表される、ネイティブ画像解像度の上限があります。いずれかの制限を超える画像は、処理前に縮小されます。正確なルールについては、[Claudeが画像をリサイズおよびパディングする方法](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images)を参照してください。例外は、[computer use](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)および[browser use](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/browser-use-tool#targets-and-coordinates)ツールセットに返すスクリーンショットやズーム画像です。APIは、モデルの制限を超える`tool_result`画像を縮小せずに検証エラーで拒否するため、それらの画像は返す前にアプリケーション側でリサイズしてください。その他のサイズ超過画像についても、縮小ではなくエラーで拒否させたい場合は、画像ブロックの[`transformations`フィールド](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates#oversized-image-error)を設定してください。

| 解像度ティア | モデル              | 最大長辺    | 最大ビジュアルトークン |
| ------ | ---------------- | ------- | ----------- |
| 高解像度   | Claude 4.7以降のモデル | 2576 px | 4784        |
| 標準     | その他すべてのモデル       | 1568 px | 1568        |

高解像度のサポートは、記載されているモデルで自動的に有効になり、ベータヘッダーやクライアント側でのオプトインは不要です。

次の表は、各ティアにおけるいくつかの画像サイズの縮小後の解像度とビジュアルトークンコストを示しています。

| 画像サイズ                    | 標準ティア：縮小後のサイズ | 標準ティア：トークン | 高解像度ティア：縮小後のサイズ | 高解像度ティア：トークン |
| ------------------------ | ------------- | ---------- | --------------- | ------------ |
| 200x200 px（0.04メガピクセル）   | リサイズなし        | 64         | リサイズなし          | 64           |
| 1000x1000 px（1メガピクセル）    | リサイズなし        | 1296       | リサイズなし          | 1296         |
| 1092x1092 px（1.19メガピクセル） | リサイズなし        | 1521       | リサイズなし          | 1521         |
| 1920x1080 px（2.07メガピクセル） | 1456x819 px   | 1560       | リサイズなし          | 2691         |
| 2000x1500 px（3メガピクセル）    | 1269x952 px   | 1564       | リサイズなし          | 3888         |
| 3840x2160 px（8.29メガピクセル） | 1456x819 px   | 1560       | 2576x1449 px    | 4784         |

画像が縮小される場合、Claudeはアスペクト比を維持しながら、ティアの制限内に収まる最大のサイズに画像をスケーリングします。これによりトークンコストに上限が設けられます。正確なルールとリファレンス実装については、[Claudeが画像をリサイズおよびパディングする方法](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images)を参照してください。

コストを見積もるには、トークン数に使用している[モデルのトークンあたりの価格](https://claude.com/pricing)を掛けます。たとえば、Claude Haiku 4.5の入力トークン100万あたり$1 USD（標準ティア）の場合、1000×1000の画像は1,000枚あたり約$1.30 USDになります。Claude Opus 5.5の100万あたり$4 USD（高解像度ティア）の場合、同じ画像は1,000枚あたり約$5.18 USD、4K画像は1,000枚あたり約$19.14 USDになります。

高解像度の画像は、標準ティアのモデルで同じ画像を使用する場合と比べて、最大で約3倍のビジュアルトークンを使用する可能性があります。computer use、スクリーンショットの理解、高密度なドキュメントにおいて高解像度がもたらす追加の忠実度が不要な場合は、トークンコストを抑えるために送信前に画像をダウンサンプリングしてください。レイテンシを最小限に抑え、[座標ベースのワークフロー](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates)を簡素化するために、アップロード前に画像をリサイズすることを推奨します。

### 画像品質に関するガイダンス

Claudeに画像を提供する際は、最良の結果を得るために次の点に留意してください。

* **画像の鮮明さ：** 画像が鮮明で、ぼやけすぎたりピクセル化しすぎたりしていないことを確認してください。
* **テキスト：** 画像に重要なテキストが含まれている場合は、判読可能で小さすぎないことを確認してください。テキストを拡大するためだけに、重要な視覚的コンテキストを切り取ることは避けてください。
* **リサイズ：** 画像が大きすぎる場合はリサイズされる可能性があることを考慮してください（[解像度とトークンコスト](https://platform.claude.com/docs/ja/build-with-claude/vision#evaluate-image-size)を参照）。これにより、たとえばテキストが読みにくくなる場合があります。画像を事前にリサイズするか、切り抜くか、またはその両方を検討してください。サイズ超過の画像をリサイズではなくエラーで拒否させるには（[座標ワークフロー](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates)で重要）、画像ブロックに[`"oversized_image": "error"`](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates#oversized-image-error)を指定してください。
* **画像の圧縮：** JPEGやWebP（非可逆モード）などの非可逆形式を使用して送信前に画像を圧縮すると、リクエストのサイズが小さくなり、レイテンシを削減できます。ただし、これによりモデルのパフォーマンスに悪影響を与えるアーティファクトが生じる可能性があり、特に複数回の圧縮が適用された場合に顕著です。たとえば、強いJPEG圧縮によってテキストが読みにくくなることがあります。APIに送信される実際の画像を確認して、圧縮設定がタスクに適していることを確かめてください。

***

## 座標とバウンディングボックス

「bounding box」（バウンディングボックス）、ポイント、ピクセル座標については、[座標とバウンディングボックス](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates)を参照してください。Claudeは、リサイズ後に認識した画像を基準とした絶対ピクセル座標を返します。このガイドでは、Claudeが画像をリサイズおよびパディングする方法と、座標が元の画像と一致するように事前にリサイズまたは再スケーリングする方法について説明しています。

***

## 制限事項

Claudeの画像理解機能は最先端のものですが、注意すべきいくつかの制限事項があります。

* **人物の識別：** Claudeを画像内の人物の名前を特定するために[使用することはできず](https://www.anthropic.com/legal/aup)、Claudeはそのような要求を拒否します。
* **精度：** Claudeは、低品質の画像、回転した画像、または200ピクセル未満の非常に小さな画像を解釈する際に、ハルシネーションを起こしたり誤りを犯したりする可能性があります。
* **空間推論：** Claudeの座標および位置特定の出力は近似値です。[座標とバウンディングボックス](https://platform.claude.com/docs/ja/build-with-claude/vision-coordinates)のガイダンスに従い、出力に依存する前に検証してください。
* **カウント：** Claudeは画像内のオブジェクトのおおよその数を示すことができますが、特に小さなオブジェクトが多数ある場合は、常に正確であるとは限りません。
* **AI生成画像：** Claudeは画像がAIによって生成されたものかどうかを判断できず、尋ねられた場合に誤った回答をする可能性があります。偽の画像や合成画像の検出にClaudeを頼らないでください。
* **不適切なコンテンツ：** Claudeは、[利用規約（Acceptable Use Policy）](https://www.anthropic.com/legal/aup)に違反する不適切または露骨な画像を処理しません。
* **医療用途：** Claudeは一般的な医療画像を分析できますが、CTやMRIなどの複雑な診断スキャンを解釈するようには設計されていません。Claudeの出力は、専門的な医学的助言や診断の代わりとみなすべきではありません。

特にリスクの高いユースケースでは、Claudeによる画像の解釈を常に慎重に確認・検証してください。完全な精度が求められるタスクや機密性の高い画像分析に、人間による監督なしでClaudeを使用しないでください。

***

## よくある質問

<AccordionGroup>
  <Accordion title="Claudeはどの画像ファイル形式をサポートしていますか？">
    JPEG、PNG、GIF、WebPです。[サポートされている形式](https://platform.claude.com/docs/ja/build-with-claude/vision#supported-formats)を参照してください。
  </Accordion>

  <Accordion title="Claudeは画像のURLを読み取れますか？">
    はい。`image`コンテンツブロックで、`base64`の代わりに`url`ソースタイプを使用してください。[URLベースの画像の例](https://platform.claude.com/docs/ja/build-with-claude/vision#url-based-image-example)を参照してください。
  </Accordion>

  <Accordion title="アップロードできる画像のファイルサイズに制限はありますか？">
    はい。Claude API、Amazon Bedrock、Google Cloud、claude.aiにおける画像あたりおよびリクエスト全体のサイズ制限については、[リクエストの制限](https://platform.claude.com/docs/ja/build-with-claude/vision#request-limits)を参照してください。
  </Accordion>

  <Accordion title="1つのリクエストに含められる画像は何枚ですか？">
    APIリクエストあたり最大600枚（200kトークンのコンテキストウィンドウを持つモデルでは100枚）、claude.aiではターンあたり20枚です。詳細と、20枚を超える場合に適用されるより低い画像あたりの寸法制限については、[リクエストの制限](https://platform.claude.com/docs/ja/build-with-claude/vision#request-limits)を参照してください。
  </Accordion>

  <Accordion title="Claudeは画像のメタデータを読み取りますか？">
    いいえ、Claudeは渡された画像からメタデータを解析したり受け取ったりすることはありません。
  </Accordion>

  <Accordion title="アップロードした画像を削除できますか？">
    いいえ。画像のアップロードは一時的なものであり、APIリクエストの期間を超えて 保存されることはありません。アップロードされた画像は、処理された後に 自動的に削除されます。
  </Accordion>

  <Accordion title="画像アップロードのデータプライバシーに関する詳細はどこで確認できますか？">
    アップロードされた画像やその他のデータの取り扱いについては、Anthropicの プライバシーポリシーのページを参照してください。Anthropicは、アップロードされた画像を モデルのトレーニングに使用しません。
  </Accordion>

  <Accordion title="Claudeの画像解釈が間違っているように思える場合はどうすればよいですか？">
    Claudeの画像解釈が正しくないと思われる場合：

    1. 画像が鮮明で高品質であり、正しい向きであることを確認してください。
    2. プロンプトエンジニアリングの手法を試して、結果を改善してください。
    3. 問題が解決しない場合は、claude.aiで出力にフラグを付ける（高評価/低評価）か、[サポートチーム](https://support.claude.com/)にお問い合わせください。

    皆様のフィードバックはClaudeの改善に役立ちます！
  </Accordion>

  <Accordion title="Claudeは画像を生成または編集できますか？">
    いいえ、Claudeは画像理解専用のモデルです。画像を解釈・分析することはできますが、画像を生成、作成、編集、加工、または制作することはできません。
  </Accordion>
</AccordionGroup>

***

## 次のステップ

<CardGroup cols={2}>
  <Card title="マルチモーダルクックブック" icon="image" href="https://platform.claude.com/cookbook/multimodal-getting-started-with-vision">
    グラフの解釈やフォームからのコンテンツ抽出などのタスクに関するヒントとベストプラクティスの手法を紹介します。
  </Card>

  <Card title="APIリファレンス" icon="code" href="https://platform.claude.com/docs/ja/api/messages/create">
    画像を含むAPI呼び出しの例を含む、Messages APIのドキュメントを参照してください。
  </Card>
</CardGroup>