---
title: Visione
url: https://platform.claude.com/docs/it/build-with-claude/vision
description: Le capacità di visione di Claude gli consentono di comprendere e analizzare immagini, aprendo possibilità entusiasmanti per l'interazione multimodale.
---

Questa guida descrive come inviare immagini a Claude, i limiti e i costi applicabili e dove trovare indicazioni per i [flussi di lavoro basati su coordinate](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates).

***

## Inviare immagini a Claude

Usa le capacità di visione di Claude tramite:

* [claude.ai](https://claude.ai/). Carica un'immagine come faresti con un file, oppure trascina e rilascia un'immagine direttamente nella finestra della chat.
* [Playground](https://platform.claude.com/playground) nella Claude Console. Aggiungi immagini direttamente a qualsiasi blocco di messaggio User.
* Richiesta API. Consulta gli esempi seguenti.

Sull'API, fornisci le immagini a Claude come blocchi di contenuto `image` usando uno dei tre tipi di sorgente:

1. Un'immagine codificata in base64 incorporata nel corpo della richiesta
2. Un riferimento URL a un'immagine ospitata online
3. Un `file_id` restituito dalla [Files API](https://platform.claude.com/docs/it/build-with-claude/files) (carica una volta, fai riferimento molte volte)

<Note>
  Su Amazon Bedrock e Google Cloud, attualmente sono disponibili solo sorgenti codificate in base64.
</Note>

<Tip>
  Proprio come [posizionare i documenti lunghi prima della tua query](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/claude-prompting-best-practices#long-context-prompting) migliora i risultati nei prompt testuali, Claude funziona meglio quando le immagini precedono il testo. Le immagini posizionate dopo il testo o intercalate con il testo funzionano comunque bene, ma se il tuo caso d'uso lo consente, preferisci una struttura immagine-poi-testo.
</Tip>

### Esempio di immagine codificata in 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>

### Esempio di immagine basata su 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>

### Esempio di immagine con Files API

Per le immagini che userai ripetutamente o quando vuoi evitare l'overhead della codifica, usa la [Files API](https://platform.claude.com/docs/it/build-with-claude/files). Carica l'immagine una volta, poi fai riferimento al `file_id` restituito nei messaggi successivi invece di inviare nuovamente i dati base64.

<Tip>
  Nelle conversazioni multi-turno e nei flussi di lavoro agentici, ogni richiesta invia nuovamente l'intera cronologia della conversazione. Se le immagini sono codificate in base64, i byte completi dell'immagine vengono inclusi nel payload a ogni turno, il che può aumentare significativamente la dimensione della richiesta e la "latency" (latenza) man mano che la conversazione cresce. Caricare le immagini sulla Files API e farvi riferimento tramite `file_id` mantiene piccoli i payload delle richieste indipendentemente da quante immagini si accumulano nella cronologia della conversazione.
</Tip>

<CodeGroup>
  ```bash cURL
  # Per prima cosa, carica la tua immagine nella 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')

  # Poi usa il file_id restituito nel tuo messaggio
  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

  # Per prima cosa, carica la tua immagine nella Files API
  FILE_ID=$(ant files upload \
    --file ./vision-example.jpg \
    --transform id --raw-output)

  # Poi usa il file_id restituito nel tuo messaggio
  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()

  # Carica il file immagine
  with open("vision-example.jpg", "rb") as f:
      file_upload = client.files.upload(file=("vision-example.jpg", f, "image/jpeg"))

  # Usa il file caricato in un messaggio
  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();

  // Carica il file immagine
  const fileUpload = await anthropic.files.upload({
    file: await toFile(fs.createReadStream("vision-example.jpg"), undefined, {
      type: "image/jpeg"
    })
  });

  // Usa il file caricato in un messaggio
  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();

  // Carica il file immagine
  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"),
      },
  });

  // Usa il file caricato in un messaggio
  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()

  // Carica il file immagine
  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)
  }

  // Usa il file caricato in un messaggio
  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();

      // Carica il file immagine
      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()
      );

      // Usa il file caricato in un messaggio
      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();

  // Carica il file immagine
  $fileUpload = $client->files->upload(
      file: FileParam::fromResource(fopen('vision-example.jpg', 'rb'), contentType: 'image/jpeg'),
  );

  // Usa il file caricato in un messaggio
  $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

  # Carica il file immagine
  file_upload = client.files.upload(
    file: Anthropic::FilePart.new(
      File.open("vision-example.jpg", "rb"),
      content_type: "image/jpeg"
    )
  )

  # Usa il file caricato in un messaggio
  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>

Consulta gli [esempi della Messages API](https://platform.claude.com/docs/it/api/messages/create) per ulteriore codice di esempio e dettagli sui parametri.

### Immagini multiple

Puoi includere più immagini in una singola richiesta e Claude le analizza congiuntamente. Questo è utile per confrontare immagini, chiedere informazioni sulle differenze o lavorare con una sequenza come le pagine di un documento. Quando invii diverse immagini, introduci ciascuna con una breve etichetta testuale (`Image 1:`, `Image 2:` e così via) in modo da poterle richiamare per nome nel tuo prompt e nei turni successivi.

<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>

In una conversazione multi-turno, aggiungi nuove immagini nei turni `user` successivi allo stesso modo. Claude ha accesso a ogni immagine dei turni precedenti, quindi domande di follow-up come "Queste sono simili alle prime due?" funzionano senza includere nuovamente le immagini precedenti nel contenuto del nuovo turno.

***

## Limiti e costi delle immagini

### Limiti delle richieste

Il numero massimo di immagini per messaggio o richiesta è:

* 20 per messaggio su [claude.ai](https://claude.ai/).
* 100 per richiesta sull'API, per i modelli con una "context window" (finestra di contesto) da 200k token.
* 600 per richiesta sull'API, per tutti gli altri modelli.

Le dimensioni massime per immagine sono 8000x8000 px.

Se una singola richiesta API contiene più di 20 immagini, si applica un limite di dimensioni per immagine più restrittivo a ogni immagine in quella richiesta. Tutti i blocchi `image` nella richiesta contano ai fini di questa soglia, incluse le immagini dei turni precedenti della conversazione che invii nuovamente e le immagini annidate all'interno del contenuto `tool_result` (ad esempio, gli screenshot restituiti allo strumento computer use). Su Amazon Bedrock e Google Cloud, anche i blocchi documento come i PDF contano ai fini di questa soglia. Le immagini che superano il limite più restrittivo vengono rifiutate con un `invalid_request_error` il cui messaggio fa riferimento a "many-image requests" e indica il limite corrente in pixel. Per rimanere sotto il limite su tutte le piattaforme, ridimensiona ogni immagine in modo che nessuna delle due dimensioni superi 2000 px, oppure mantieni la richiesta a 20 o meno blocchi immagine e documento.

La dimensione massima per immagine è:

* 10 MB (codificata in base64) quando usi direttamente la Claude API.
* 5 MB (codificata in base64) su Amazon Bedrock e Google Cloud.
* 10 MB su [claude.ai](https://claude.ai/).

<Note>
  Sebbene l'API supporti fino a 600 immagini per richiesta, i [limiti di dimensione delle richieste](https://platform.claude.com/docs/it/api/overview#request-size-limits) (32 MB per gli endpoint standard; inferiori su alcune piattaforme gestite da partner, ad esempio Amazon Bedrock e Google Cloud) possono essere raggiunti prima. Per molte immagini, considera di caricarle con la [Files API](https://platform.claude.com/docs/it/build-with-claude/vision#files-api-image-example) e di farvi riferimento tramite `file_id` per mantenere piccoli i payload delle richieste.

  Anche usando la Files API, le richieste con molte immagini di grandi dimensioni possono fallire prima di raggiungere il conteggio di 600 immagini. Riduci le dimensioni delle immagini o le dimensioni dei file (ad esempio, tramite downsampling) prima del caricamento (vedi [Risoluzione e costo in token](https://platform.claude.com/docs/it/build-with-claude/vision#evaluate-image-size)).
</Note>

### Formati supportati

Claude supporta immagini JPEG, PNG, GIF e WebP (`image/jpeg`, `image/png`, `image/gif`, `image/webp`). Le animazioni non sono supportate e viene usato solo il primo fotogramma.

### Risoluzione e costo in token

Claude vede le immagini in patch anziché in pixel. Ogni patch è un blocco di 28×28 pixel dell'immagine, chiamato token visivo. Un'immagine, quindi, costa `⌈width / 28⌉ × ⌈height / 28⌉` token visivi.

Ogni modello ha una risoluzione nativa massima delle immagini, espressa come limite del lato lungo e limite di token visivi. Le immagini più grandi di uno dei due limiti vengono ridotte prima dell'elaborazione; vedi [Come Claude ridimensiona e aggiunge padding alle immagini](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images) per la regola esatta. L'eccezione sono gli screenshot e le immagini di zoom che restituisci ai set di strumenti [computer use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions) e [browser use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/browser-use-tool#targets-and-coordinates): l'API rifiuta un'immagine `tool_result` che supera i limiti del modello con un errore di validazione invece di ridurla, quindi ridimensiona quelle immagini nella tua applicazione prima di restituirle. Per fare in modo che qualsiasi altra immagine sovradimensionata venga rifiutata con un errore invece di essere ridotta, imposta il [campo `transformations`](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates#oversized-image-error) del blocco immagine.

| Livello di risoluzione | Modelli                         | Lato lungo massimo | Token visivi massimi |
| ---------------------- | ------------------------------- | ------------------ | -------------------- |
| Alta risoluzione       | Claude 4.7 e modelli successivi | 2576 px            | 4784                 |
| Standard               | Tutti gli altri modelli         | 1568 px            | 1568                 |

Il supporto per l'alta risoluzione è automatico sui modelli elencati e non richiede alcun header beta né opt-in lato client.

La tabella seguente mostra la risoluzione ridotta e il costo in token visivi per diverse dimensioni di immagine su ciascun livello:

| Dimensione immagine           | Livello standard: ridotta a | Livello standard: token | Livello alta risoluzione: ridotta a | Livello alta risoluzione: token |
| ----------------------------- | --------------------------- | ----------------------- | ----------------------------------- | ------------------------------- |
| 200x200 px (0,04 megapixel)   | Non ridimensionata          | 64                      | Non ridimensionata                  | 64                              |
| 1000x1000 px (1 megapixel)    | Non ridimensionata          | 1296                    | Non ridimensionata                  | 1296                            |
| 1092x1092 px (1,19 megapixel) | Non ridimensionata          | 1521                    | Non ridimensionata                  | 1521                            |
| 1920x1080 px (2,07 megapixel) | 1456x819 px                 | 1560                    | Non ridimensionata                  | 2691                            |
| 2000x1500 px (3 megapixel)    | 1269x952 px                 | 1564                    | Non ridimensionata                  | 3888                            |
| 3840x2160 px (8,29 megapixel) | 1456x819 px                 | 1560                    | 2576x1449 px                        | 4784                            |

Quando un'immagine viene ridotta, Claude la scala alla dimensione più grande che rientra nei limiti del livello preservandone le proporzioni. Questo pone un tetto al costo in token. Per la regola precisa e un'implementazione di riferimento, vedi [Come Claude ridimensiona e aggiunge padding alle immagini](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images).

Per stimare il costo, moltiplica il numero di token per il [prezzo per token del modello](https://claude.com/pricing) che stai usando. Ad esempio, al prezzo di Claude Haiku 4.5 di $1 USD per milione di token di input (livello standard), l'immagine 1000×1000 costa circa $1,30 USD ogni mille immagini. Al prezzo di Claude Opus 5.5 di $4 USD per milione (livello alta risoluzione), la stessa immagine costa circa $5,18 USD ogni mille e l'immagine 4K circa $19,14 USD ogni mille.

Le immagini ad alta risoluzione possono usare fino a circa tre volte più token visivi rispetto alla stessa immagine su un modello di livello standard. Se non hai bisogno della fedeltà aggiuntiva che l'alta risoluzione offre per computer use, comprensione degli screenshot e documenti densi, esegui il downsampling delle immagini prima dell'invio per controllare i costi in token. Per minimizzare la latenza e semplificare i [flussi di lavoro basati su coordinate](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates), preferisci ridimensionare le immagini prima di caricarle.

### Indicazioni sulla qualità delle immagini

Quando fornisci immagini a Claude, tieni presente quanto segue per ottenere i migliori risultati:

* **Nitidezza dell'immagine:** Assicurati che le immagini siano nitide e non troppo sfocate o pixelate.
* **Testo:** Se l'immagine contiene testo importante, assicurati che sia leggibile e non troppo piccolo. Evita di ritagliare contesto visivo chiave solo per ingrandire il testo.
* **Ridimensionamento:** Tieni conto che la tua immagine potrebbe essere ridimensionata se è troppo grande (vedi [Risoluzione e costo in token](https://platform.claude.com/docs/it/build-with-claude/vision#evaluate-image-size)); questo potrebbe, ad esempio, rendere il testo meno leggibile. Considera di pre-ridimensionare le tue immagini, ritagliarle o entrambe le cose. Per fare in modo che un'immagine sovradimensionata venga rifiutata con un errore invece di essere ridimensionata (importante per i [flussi di lavoro con coordinate](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates)), contrassegna il blocco immagine con [`"oversized_image": "error"`](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates#oversized-image-error).
* **Compressione dell'immagine:** Comprimere le immagini prima di inviarle, usando un formato con perdita come JPEG o WebP (modalità lossy), può ridurre la latenza riducendo la dimensione delle richieste. Tuttavia, questo può introdurre artefatti dannosi per le prestazioni del modello, specialmente quando vengono applicati più passaggi di compressione. Ad esempio, una forte compressione JPEG può rendere il testo difficile da leggere. Verifica che le tue impostazioni di compressione siano appropriate per il compito ispezionando le immagini effettivamente inviate all'API.

***

## Coordinate e bounding box

Per bounding box, punti e coordinate in pixel, vedi [Coordinate e bounding box](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates). Claude restituisce coordinate assolute in pixel relative all'immagine che vede dopo il ridimensionamento; quella guida spiega come Claude ridimensiona e aggiunge padding alle immagini e come pre-ridimensionare o riscalare in modo che le coordinate corrispondano alla tua immagine originale.

***

## Limitazioni

Sebbene le capacità di comprensione delle immagini di Claude siano all'avanguardia, ci sono alcune limitazioni di cui essere consapevoli:

* **Identificazione delle persone:** Claude [non può essere usato](https://www.anthropic.com/legal/aup) per identificare per nome le persone nelle immagini e si rifiuta di farlo.
* **Accuratezza:** Claude potrebbe allucinare o commettere errori nell'interpretare immagini di bassa qualità, ruotate o molto piccole sotto i 200 pixel.
* **Ragionamento spaziale:** Gli output di coordinate e localizzazione di Claude sono approssimativi. Segui le indicazioni in [Coordinate e bounding box](https://platform.claude.com/docs/it/build-with-claude/vision-coordinates) e verifica gli output prima di farvi affidamento.
* **Conteggio:** Claude può fornire conteggi approssimativi degli oggetti in un'immagine ma potrebbe non essere sempre precisamente accurato, specialmente con grandi quantità di oggetti piccoli.
* **Immagini generate dall'IA:** Claude non può determinare se un'immagine è generata dall'IA e potrebbe sbagliarsi se interrogato. Non fare affidamento su di esso per rilevare immagini false o sintetiche.
* **Contenuti inappropriati:** Claude non elabora immagini inappropriate o esplicite che violano la [Acceptable Use Policy](https://www.anthropic.com/legal/aup).
* **Applicazioni sanitarie:** Sebbene Claude possa analizzare immagini mediche generiche, non è progettato per interpretare scansioni diagnostiche complesse come TAC o risonanze magnetiche. Gli output di Claude non devono essere considerati un sostituto della consulenza o della diagnosi medica professionale.

Rivedi e verifica sempre attentamente le interpretazioni delle immagini di Claude, specialmente per casi d'uso ad alto rischio. Non usare Claude per compiti che richiedono precisione perfetta o analisi di immagini sensibili senza supervisione umana.

***

## Domande frequenti

<AccordionGroup>
  <Accordion title="Quali tipi di file immagine supporta Claude?">
    JPEG, PNG, GIF e WebP. Vedi [Formati supportati](https://platform.claude.com/docs/it/build-with-claude/vision#supported-formats).
  </Accordion>

  <Accordion title="Claude può leggere URL di immagini?">
    Sì. Usa il tipo di sorgente `url` invece di `base64` nel blocco di contenuto `image`. Vedi l'[esempio di immagine basata su URL](https://platform.claude.com/docs/it/build-with-claude/vision#url-based-image-example).
  </Accordion>

  <Accordion title="C'è un limite alla dimensione del file immagine che posso caricare?">
    Sì. Vedi [Limiti delle richieste](https://platform.claude.com/docs/it/build-with-claude/vision#request-limits) per i limiti per immagine e di dimensione complessiva delle richieste su Claude API, Amazon Bedrock, Google Cloud e claude.ai.
  </Accordion>

  <Accordion title="Quante immagini posso includere in una richiesta?">
    Fino a 600 per richiesta API (100 per i modelli con una finestra di contesto da 200k token) e 20 per turno su claude.ai. Vedi [Limiti delle richieste](https://platform.claude.com/docs/it/build-with-claude/vision#request-limits) per i dettagli e per il limite di dimensioni per immagine inferiore che si applica oltre le 20 immagini.
  </Accordion>

  <Accordion title="Claude legge i metadati delle immagini?">
    No, Claude non analizza né riceve alcun metadato dalle immagini che gli vengono passate.
  </Accordion>

  <Accordion title="Posso eliminare le immagini che ho caricato?">
    No. I caricamenti di immagini sono effimeri e non vengono conservati oltre la durata della richiesta API. Le immagini caricate vengono eliminate automaticamente dopo essere state elaborate.
  </Accordion>

  <Accordion title="Dove posso trovare dettagli sulla privacy dei dati per i caricamenti di immagini?">
    Consulta la pagina dell'informativa sulla privacy di Anthropic per informazioni su come vengono gestite le immagini caricate e gli altri dati. Anthropic non usa le immagini caricate per addestrare i modelli.
  </Accordion>

  <Accordion title="Cosa fare se l'interpretazione dell'immagine di Claude sembra sbagliata?">
    Se l'interpretazione dell'immagine di Claude sembra errata:

    1. Assicurati che l'immagine sia nitida, di alta qualità e orientata correttamente.
    2. Prova tecniche di prompt engineering per migliorare i risultati.
    3. Se il problema persiste, segnala l'output in claude.ai (pollice su/giù) o contatta il [team di supporto](https://support.claude.com/).

    Il tuo feedback aiuta a migliorare Claude!
  </Accordion>

  <Accordion title="Claude può generare o modificare immagini?">
    No, Claude è esclusivamente un modello di comprensione delle immagini. Può interpretare e analizzare immagini, ma non può generare, produrre, modificare, manipolare o creare immagini.
  </Accordion>
</AccordionGroup>

***

## Prossimi passi

<CardGroup cols={2}>
  <Card title="Cookbook multimodale" icon="image" href="https://platform.claude.com/cookbook/multimodal-getting-started-with-vision">
    Ottieni suggerimenti e tecniche di best practice per compiti come l'interpretazione di grafici e l'estrazione di contenuti da moduli.
  </Card>

  <Card title="Riferimento API" icon="code" href="https://platform.claude.com/docs/it/api/messages/create">
    Consulta la documentazione della Messages API, inclusi esempi di chiamate API che coinvolgono immagini.
  </Card>
</CardGroup>