---
title: Зрение
url: https://platform.claude.com/docs/ru/build-with-claude/vision
description: Возможности зрения Claude позволяют ему понимать и анализировать изображения, открывая захватывающие возможности для мультимодального взаимодействия.
---

В этом руководстве описывается, как отправлять изображения Claude, какие ограничения и затраты применяются, а также где найти рекомендации для [рабочих процессов на основе координат](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates).

***

## Отправка изображений Claude

Используйте возможности зрения Claude через:

* [claude.ai](https://claude.ai/). Загрузите изображение так же, как файл, или перетащите изображение прямо в окно чата.
* [Playground](https://platform.claude.com/playground) в Claude Console. Добавляйте изображения непосредственно в любой блок сообщения User.
* Запрос API. См. следующие примеры.

В API предоставляйте изображения Claude в виде блоков содержимого `image`, используя один из трёх типов источников:

1. Изображение в кодировке base64, встроенное в тело запроса
2. URL-ссылка на изображение, размещённое в интернете
3. `file_id`, возвращённый [Files API](https://platform.claude.com/docs/ru/build-with-claude/files) (загрузите один раз, ссылайтесь многократно)

<Note>
  На Amazon Bedrock и Google Cloud в настоящее время доступны только источники в кодировке base64.
</Note>

<Tip>
  Так же как [размещение длинных документов перед вашим запросом](https://platform.claude.com/docs/ru/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/ru/build-with-claude/files). Загрузите изображение один раз, а затем ссылайтесь на возвращённый `file_id` в последующих сообщениях вместо повторной отправки данных base64.

<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/ru/api/messages/create) для получения дополнительных примеров кода и подробностей о параметрах.

### Несколько изображений

Вы можете включить несколько изображений в один запрос, и 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 имеет доступ ко всем изображениям из предыдущих ходов, поэтому уточняющие вопросы, такие как «Похожи ли они на первые два?», работают без повторного включения предыдущих изображений в содержимое нового хода.

***

## Ограничения и стоимость изображений

### Ограничения запросов

Максимальное количество изображений на сообщение или запрос:

* 20 на сообщение на [claude.ai](https://claude.ai/).
* 100 на запрос в API для моделей с контекстным окном в 200 тыс. токенов.
* 600 на запрос в API для всех остальных моделей.

Максимальные размеры одного изображения — 8000x8000 пикселей.

Если один запрос API содержит более 20 изображений, к каждому изображению в этом запросе применяется более строгое ограничение размеров. Все блоки `image` в запросе учитываются при подсчёте этого порога, включая изображения из предыдущих ходов диалога, которые вы отправляете повторно, и изображения, вложенные в содержимое `tool_result` (например, снимки экрана, возвращаемые инструменту использования компьютера). На Amazon Bedrock и Google Cloud блоки документов, такие как PDF, также учитываются при подсчёте этого порога. Изображения, превышающие более строгое ограничение, отклоняются с ошибкой `invalid_request_error`, сообщение которой ссылается на «many-image requests» и указывает текущее ограничение в пикселях. Чтобы оставаться в пределах ограничения на всех платформах, либо измените размер каждого изображения так, чтобы ни одна из сторон не превышала 2000 пикселей, либо ограничьте запрос 20 или менее блоками изображений и документов.

Максимальный размер одного изображения:

* 10 МБ (в кодировке base64) при прямом использовании Claude API.
* 5 МБ (в кодировке base64) на Amazon Bedrock и Google Cloud.
* 10 МБ на [claude.ai](https://claude.ai/).

<Note>
  Хотя API поддерживает до 600 изображений на запрос, [ограничения размера запроса](https://platform.claude.com/docs/ru/api/overview#request-size-limits) (32 МБ для стандартных конечных точек; меньше на некоторых платформах, управляемых партнёрами, например Amazon Bedrock и Google Cloud) могут быть достигнуты раньше. Для большого количества изображений рассмотрите загрузку через [Files API](https://platform.claude.com/docs/ru/build-with-claude/vision#files-api-image-example) и ссылку по `file_id`, чтобы сохранять полезную нагрузку запросов небольшой.

  Даже при использовании Files API запросы с большим количеством крупных изображений могут завершиться ошибкой до достижения количества в 600 изображений. Уменьшите размеры изображений или размеры файлов (например, путём понижения разрешения) перед загрузкой (см. [Разрешение и стоимость в токенах](https://platform.claude.com/docs/ru/build-with-claude/vision#evaluate-image-size)).
</Note>

### Поддерживаемые форматы

Claude поддерживает изображения JPEG, PNG, GIF и WebP (`image/jpeg`, `image/png`, `image/gif`, `image/webp`). Анимация не поддерживается, используется только первый кадр.

### Разрешение и стоимость в токенах

Claude рассматривает изображения фрагментами (patches), а не пикселями. Каждый фрагмент — это блок изображения размером 28×28 пикселей, называемый визуальным токеном. Таким образом, изображение стоит `⌈width / 28⌉ × ⌈height / 28⌉` визуальных токенов.

Каждая модель имеет максимальное нативное разрешение изображения, выраженное в виде ограничения по длинной стороне и ограничения по визуальным токенам. Изображения, превышающие любое из этих ограничений, уменьшаются перед обработкой; точное правило см. в разделе [Как Claude изменяет размер и дополняет изображения](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images). Исключение составляют снимки экрана и увеличенные изображения, которые вы возвращаете наборам инструментов [использования компьютера](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions) и [использования браузера](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/browser-use-tool#targets-and-coordinates): API отклоняет изображение `tool_result`, превышающее ограничения модели, с ошибкой валидации вместо его уменьшения, поэтому изменяйте размер таких изображений в вашем приложении перед их возвратом. Чтобы любое другое изображение чрезмерного размера отклонялось с ошибкой вместо уменьшения, задайте [поле `transformations`](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates#oversized-image-error) блока изображения.

| Уровень разрешения | Модели                            | Макс. длинная сторона | Макс. визуальных токенов |
| ------------------ | --------------------------------- | --------------------- | ------------------------ |
| Высокое разрешение | Claude 4.7 и более поздние модели | 2576 пикселей         | 4784                     |
| Стандартное        | Все остальные модели              | 1568 пикселей         | 1568                     |

Поддержка высокого разрешения включается автоматически на перечисленных моделях и не требует бета-заголовка или включения на стороне клиента.

В следующей таблице показаны уменьшенное разрешение и стоимость в визуальных токенах для нескольких размеров изображений на каждом уровне:

| Размер изображения                    | Стандартный уровень: уменьшено до | Стандартный уровень: токены | Уровень высокого разрешения: уменьшено до | Уровень высокого разрешения: токены |
| ------------------------------------- | --------------------------------- | --------------------------- | ----------------------------------------- | ----------------------------------- |
| 200x200 пикселей (0,04 мегапикселя)   | Без изменения размера             | 64                          | Без изменения размера                     | 64                                  |
| 1000x1000 пикселей (1 мегапиксель)    | Без изменения размера             | 1296                        | Без изменения размера                     | 1296                                |
| 1092x1092 пикселей (1,19 мегапикселя) | Без изменения размера             | 1521                        | Без изменения размера                     | 1521                                |
| 1920x1080 пикселей (2,07 мегапикселя) | 1456x819 пикселей                 | 1560                        | Без изменения размера                     | 2691                                |
| 2000x1500 пикселей (3 мегапикселя)    | 1269x952 пикселей                 | 1564                        | Без изменения размера                     | 3888                                |
| 3840x2160 пикселей (8,29 мегапикселя) | 1456x819 пикселей                 | 1560                        | 2576x1449 пикселей                        | 4784                                |

Когда изображение уменьшается, Claude масштабирует его до наибольшего размера, укладывающегося в ограничения уровня, с сохранением соотношения сторон. Это ограничивает стоимость в токенах. Точное правило и эталонную реализацию см. в разделе [Как Claude изменяет размер и дополняет изображения](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images).

Чтобы оценить стоимость, умножьте количество токенов на [цену за токен используемой модели](https://claude.com/pricing). Например, при цене Claude Haiku 4.5 в $1 USD за миллион входных токенов (стандартный уровень) изображение 1000×1000 стоит около $1,30 USD за тысячу изображений. При цене Claude Opus 5.5 в $4 USD за миллион (уровень высокого разрешения) то же изображение стоит около $5,18 USD за тысячу, а изображение 4K — около $19,14 USD за тысячу.

Изображения высокого разрешения могут использовать примерно до трёх раз больше визуальных токенов, чем то же изображение на модели стандартного уровня. Если вам не нужна дополнительная точность, которую высокое разрешение обеспечивает для использования компьютера, понимания снимков экрана и плотных документов, понижайте разрешение изображений перед отправкой, чтобы контролировать затраты на токены. Чтобы минимизировать задержку и упростить [рабочие процессы на основе координат](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates), предпочитайте изменять размер изображений перед их загрузкой.

### Рекомендации по качеству изображений

Предоставляя изображения Claude, учитывайте следующее для достижения наилучших результатов:

* **Чёткость изображения:** Убедитесь, что изображения чёткие и не слишком размытые или пикселизированные.
* **Текст:** Если изображение содержит важный текст, убедитесь, что он разборчив и не слишком мелкий. Избегайте обрезки ключевого визуального контекста исключительно ради увеличения текста.
* **Изменение размера:** Учитывайте, что размер вашего изображения может быть изменён, если оно слишком большое (см. [Разрешение и стоимость в токенах](https://platform.claude.com/docs/ru/build-with-claude/vision#evaluate-image-size)); это может, например, сделать текст менее разборчивым. Рассмотрите предварительное изменение размера изображений, их обрезку или и то, и другое. Чтобы изображение чрезмерного размера отклонялось с ошибкой вместо изменения размера (важно для [рабочих процессов с координатами](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates)), пометьте блок изображения с помощью [`"oversized_image": "error"`](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates#oversized-image-error).
* **Сжатие изображений:** Сжатие изображений перед отправкой с использованием формата с потерями, такого как JPEG или WebP (режим с потерями), может снизить задержку за счёт уменьшения размера запросов. Однако это может привести к появлению артефактов, которые ухудшают производительность модели, особенно при применении нескольких проходов сжатия. Например, сильное сжатие JPEG может затруднить чтение текста. Убедитесь, что ваши настройки сжатия подходят для задачи, проверив фактические изображения, отправляемые в API.

***

## Координаты и ограничивающие рамки

Информацию об ограничивающих рамках, точках и пиксельных координатах см. в разделе [Координаты и ограничивающие рамки](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates). Claude возвращает абсолютные пиксельные координаты относительно изображения, которое он видит после изменения размера; в этом руководстве описывается, как Claude изменяет размер и дополняет изображения и как предварительно изменить размер или пересчитать масштаб, чтобы координаты совпадали с вашим исходным изображением.

***

## Ограничения

Хотя возможности Claude по пониманию изображений являются передовыми, существуют некоторые ограничения, о которых следует знать:

* **Идентификация людей:** Claude [нельзя использовать](https://www.anthropic.com/legal/aup) для называния имён людей на изображениях, и он отказывается это делать.
* **Точность:** Claude может галлюцинировать или допускать ошибки при интерпретации изображений низкого качества, повёрнутых или очень маленьких изображений размером менее 200 пикселей.
* **Пространственное мышление:** Выходные данные Claude по координатам и локализации являются приблизительными. Следуйте рекомендациям в разделе [Координаты и ограничивающие рамки](https://platform.claude.com/docs/ru/build-with-claude/vision-coordinates) и проверяйте результаты, прежде чем полагаться на них.
* **Подсчёт:** Claude может давать приблизительное количество объектов на изображении, но не всегда может быть абсолютно точным, особенно при большом количестве мелких объектов.
* **Изображения, созданные ИИ:** Claude не может определить, создано ли изображение ИИ, и может ошибаться, если его об этом спросить. Не полагайтесь на него для обнаружения поддельных или синтетических изображений.
* **Неприемлемый контент:** Claude не обрабатывает неприемлемые или откровенные изображения, нарушающие [Политику допустимого использования](https://www.anthropic.com/legal/aup).
* **Применение в здравоохранении:** Хотя Claude может анализировать общие медицинские изображения, он не предназначен для интерпретации сложных диагностических снимков, таких как КТ или МРТ. Результаты Claude не следует рассматривать как замену профессиональной медицинской консультации или диагноза.

Всегда тщательно проверяйте и верифицируйте интерпретации изображений Claude, особенно в сценариях использования с высокими ставками. Не используйте Claude для задач, требующих идеальной точности или анализа чувствительных изображений, без контроля со стороны человека.

***

## Часто задаваемые вопросы

<AccordionGroup>
  <Accordion title="Какие типы файлов изображений поддерживает Claude?">
    JPEG, PNG, GIF и WebP. См. [Поддерживаемые форматы](https://platform.claude.com/docs/ru/build-with-claude/vision#supported-formats).
  </Accordion>

  <Accordion title="Может ли Claude читать URL изображений?">
    Да. Используйте тип источника `url` вместо `base64` в блоке содержимого `image`. См. [пример изображения на основе URL](https://platform.claude.com/docs/ru/build-with-claude/vision#url-based-image-example).
  </Accordion>

  <Accordion title="Есть ли ограничение на размер файла изображения, который я могу загрузить?">
    Да. См. [Ограничения запросов](https://platform.claude.com/docs/ru/build-with-claude/vision#request-limits) для получения информации об ограничениях на одно изображение и общий размер запроса в Claude API, Amazon Bedrock, Google Cloud и claude.ai.
  </Accordion>

  <Accordion title="Сколько изображений я могу включить в один запрос?">
    До 600 на запрос API (100 для моделей с контекстным окном в 200 тыс. токенов) и 20 на ход на claude.ai. См. [Ограничения запросов](https://platform.claude.com/docs/ru/build-with-claude/vision#request-limits) для получения подробностей и информации о более низком ограничении размеров одного изображения, которое применяется при более чем 20 изображениях.
  </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="Мультимодальный cookbook" 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/ru/api/messages/create">
    См. документацию Messages API, включая примеры вызовов API с изображениями.
  </Card>
</CardGroup>