---
title: Visión
url: https://platform.claude.com/docs/es/build-with-claude/vision
description: Las capacidades de visión de Claude le permiten comprender y analizar imágenes, lo que abre posibilidades emocionantes para la interacción multimodal.
---

Esta guía describe cómo enviar imágenes a Claude, los límites y costos que aplican, y dónde encontrar orientación para los [flujos de trabajo basados en coordenadas](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates).

***

## Enviar imágenes a Claude

Usa las capacidades de visión de Claude a través de:

* [claude.ai](https://claude.ai/). Sube una imagen como lo harías con un archivo, o arrastra y suelta una imagen directamente en la ventana del chat.
* [Playground](https://platform.claude.com/playground) en la Claude Console. Agrega imágenes directamente a cualquier bloque de mensaje de usuario (User).
* Solicitud a la API. Consulta los siguientes ejemplos.

En la API, proporciona imágenes a Claude como bloques de contenido `image` usando uno de tres tipos de fuente:

1. Una imagen codificada en base64 incrustada en el cuerpo de la solicitud
2. Una referencia URL a una imagen alojada en línea
3. Un `file_id` devuelto por la [Files API](https://platform.claude.com/docs/es/build-with-claude/files) (sube una vez, referencia muchas veces)

<Note>
  En Amazon Bedrock y Google Cloud, actualmente solo están disponibles las fuentes codificadas en base64.
</Note>

<Tip>
  Así como [colocar documentos largos antes de tu consulta](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/claude-prompting-best-practices#long-context-prompting) mejora los resultados en prompts de texto, Claude funciona mejor cuando las imágenes van antes del texto. Las imágenes colocadas después del texto o intercaladas con texto siguen funcionando bien, pero si tu caso de uso lo permite, prefiere una estructura de imagen y luego texto.
</Tip>

### Ejemplo de imagen codificada en 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>

### Ejemplo de imagen basada en 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>

### Ejemplo de imagen con la Files API

Para imágenes que usarás repetidamente o cuando quieras evitar la sobrecarga de codificación, usa la [Files API](https://platform.claude.com/docs/es/build-with-claude/files). Sube la imagen una vez y luego referencia el `file_id` devuelto en mensajes posteriores en lugar de volver a enviar los datos en base64.

<Tip>
  En conversaciones de múltiples turnos y flujos de trabajo agénticos, cada solicitud vuelve a enviar el historial completo de la conversación. Si las imágenes están codificadas en base64, los bytes completos de la imagen se incluyen en la carga útil en cada turno, lo que puede aumentar significativamente el tamaño de la solicitud y la "latency" (latencia) a medida que crece la conversación. Subir imágenes a la Files API y referenciarlas por `file_id` mantiene pequeñas las cargas útiles de las solicitudes sin importar cuántas imágenes se acumulen en el historial de la conversación.
</Tip>

<CodeGroup>
  ```bash cURL
  # Primero, sube tu imagen a la 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')

  # Luego usa el file_id devuelto en tu mensaje
  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

  # Primero, sube tu imagen a la Files API
  FILE_ID=$(ant files upload \
    --file ./vision-example.jpg \
    --transform id --raw-output)

  # Luego usa el file_id devuelto en tu mensaje
  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()

  # Sube el archivo de imagen
  with open("vision-example.jpg", "rb") as f:
      file_upload = client.files.upload(file=("vision-example.jpg", f, "image/jpeg"))

  # Usa el archivo subido en un mensaje
  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();

  // Sube el archivo de imagen
  const fileUpload = await anthropic.files.upload({
    file: await toFile(fs.createReadStream("vision-example.jpg"), undefined, {
      type: "image/jpeg"
    })
  });

  // Usa el archivo subido en un mensaje
  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();

  // Sube el archivo de imagen
  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 el archivo subido en un mensaje
  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()

  // Sube el archivo de imagen
  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 el archivo subido en un mensaje
  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();

      // Sube el archivo de imagen
      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 el archivo subido en un mensaje
      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();

  // Sube el archivo de imagen
  $fileUpload = $client->files->upload(
      file: FileParam::fromResource(fopen('vision-example.jpg', 'rb'), contentType: 'image/jpeg'),
  );

  // Usa el archivo subido en un mensaje
  $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

  # Sube el archivo de imagen
  file_upload = client.files.upload(
    file: Anthropic::FilePart.new(
      File.open("vision-example.jpg", "rb"),
      content_type: "image/jpeg"
    )
  )

  # Usa el archivo subido en un mensaje
  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 los [ejemplos de la Messages API](https://platform.claude.com/docs/es/api/messages/create) para ver más código de ejemplo y detalles de los parámetros.

### Múltiples imágenes

Puedes incluir múltiples imágenes en una sola solicitud, y Claude las analiza en conjunto. Esto es útil para comparar imágenes, preguntar sobre diferencias o trabajar con una secuencia, como las páginas de un documento. Al enviar varias imágenes, introduce cada una con una etiqueta de texto corta (`Image 1:`, `Image 2:`, y así sucesivamente) para que puedas referirte a ellas por nombre en tu prompt y en turnos posteriores.

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

En una conversación de múltiples turnos, agrega nuevas imágenes en turnos `user` posteriores de la misma manera. Claude tiene acceso a todas las imágenes de turnos anteriores, por lo que preguntas de seguimiento como "¿Son estas similares a las dos primeras?" funcionan sin volver a incluir las imágenes anteriores en el contenido del nuevo turno.

***

## Límites y costos de las imágenes

### Límites de solicitud

El número máximo de imágenes por mensaje o solicitud es:

* 20 por mensaje en [claude.ai](https://claude.ai/).
* 100 por solicitud en la API, para modelos con una "context window" (ventana de contexto) de 200k tokens.
* 600 por solicitud en la API, para todos los demás modelos.

Las dimensiones máximas por imagen son 8000x8000 px.

Si una sola solicitud a la API contiene más de 20 imágenes, se aplica un límite de dimensiones por imagen más estricto a cada imagen de esa solicitud. Todos los bloques `image` de la solicitud cuentan para este umbral, incluidas las imágenes de turnos anteriores de la conversación que vuelves a enviar y las imágenes anidadas dentro del contenido `tool_result` (por ejemplo, capturas de pantalla devueltas a la herramienta de uso de computadora). En Amazon Bedrock y Google Cloud, los bloques de documento como los PDF también cuentan para este umbral. Las imágenes que exceden el límite más estricto se rechazan con un `invalid_request_error` cuyo mensaje hace referencia a "many-image requests" e indica el límite actual en píxeles. Para mantenerte por debajo del límite en todas las plataformas, redimensiona cada imagen de modo que ninguna dimensión exceda los 2000 px, o mantén la solicitud en 20 o menos bloques de imagen y documento.

El tamaño máximo por imagen es:

* 10 MB (codificada en base64) al usar la Claude API directamente.
* 5 MB (codificada en base64) en Amazon Bedrock y Google Cloud.
* 10 MB en [claude.ai](https://claude.ai/).

<Note>
  Aunque la API admite hasta 600 imágenes por solicitud, los [límites de tamaño de solicitud](https://platform.claude.com/docs/es/api/overview#request-size-limits) (32 MB para endpoints estándar; menores en algunas plataformas operadas por socios, por ejemplo, Amazon Bedrock y Google Cloud) pueden alcanzarse primero. Para muchas imágenes, considera subirlas con la [Files API](https://platform.claude.com/docs/es/build-with-claude/vision#files-api-image-example) y referenciarlas por `file_id` para mantener pequeñas las cargas útiles de las solicitudes.

  Incluso al usar la Files API, las solicitudes con muchas imágenes grandes pueden fallar antes de alcanzar el conteo de 600 imágenes. Reduce las dimensiones o los tamaños de archivo de las imágenes (por ejemplo, mediante submuestreo) antes de subirlas (consulta [Resolución y costo en tokens](https://platform.claude.com/docs/es/build-with-claude/vision#evaluate-image-size)).
</Note>

### Formatos admitidos

Claude admite imágenes JPEG, PNG, GIF y WebP (`image/jpeg`, `image/png`, `image/gif`, `image/webp`). Las animaciones no son compatibles y solo se usa el primer fotograma.

### Resolución y costo en tokens

Claude ve las imágenes en parches en lugar de píxeles. Cada parche es un bloque de 28×28 píxeles de la imagen, denominado token visual. Por lo tanto, una imagen cuesta `⌈width / 28⌉ × ⌈height / 28⌉` tokens visuales.

Cada modelo tiene una resolución de imagen nativa máxima, expresada como un límite del lado largo y un límite de tokens visuales. Las imágenes que superan cualquiera de los dos límites se reducen de escala antes de procesarse; consulta [Cómo Claude redimensiona y rellena las imágenes](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images) para conocer la regla exacta. La excepción son las capturas de pantalla y las imágenes de zoom que devuelves a los conjuntos de herramientas de [uso de computadora](https://platform.claude.com/docs/es/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions) y [uso de navegador](https://platform.claude.com/docs/es/agents-and-tools/tool-use/browser-use-tool#targets-and-coordinates): la API rechaza una imagen `tool_result` que excede los límites del modelo con un error de validación en lugar de reducirla de escala, así que redimensiona esas imágenes en tu aplicación antes de devolverlas. Para que cualquier otra imagen de tamaño excesivo sea rechazada con un error en lugar de reducida de escala, establece el [campo `transformations`](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates#oversized-image-error) del bloque de imagen.

| Nivel de resolución | Modelos                          | Lado largo máximo | Tokens visuales máximos |
| ------------------- | -------------------------------- | ----------------- | ----------------------- |
| Alta resolución     | Claude 4.7 y modelos posteriores | 2576 px           | 4784                    |
| Estándar            | Todos los demás modelos          | 1568 px           | 1568                    |

La compatibilidad con alta resolución es automática en los modelos indicados y no requiere ningún encabezado beta ni activación del lado del cliente.

La siguiente tabla muestra la resolución reducida y el costo en tokens visuales para varios tamaños de imagen en cada nivel:

| Tamaño de imagen                | Nivel estándar: reducida a | Nivel estándar: tokens | Nivel de alta resolución: reducida a | Nivel de alta resolución: tokens |
| ------------------------------- | -------------------------- | ---------------------- | ------------------------------------ | -------------------------------- |
| 200x200 px (0.04 megapíxeles)   | Sin redimensionar          | 64                     | Sin redimensionar                    | 64                               |
| 1000x1000 px (1 megapíxel)      | Sin redimensionar          | 1296                   | Sin redimensionar                    | 1296                             |
| 1092x1092 px (1.19 megapíxeles) | Sin redimensionar          | 1521                   | Sin redimensionar                    | 1521                             |
| 1920x1080 px (2.07 megapíxeles) | 1456x819 px                | 1560                   | Sin redimensionar                    | 2691                             |
| 2000x1500 px (3 megapíxeles)    | 1269x952 px                | 1564                   | Sin redimensionar                    | 3888                             |
| 3840x2160 px (8.29 megapíxeles) | 1456x819 px                | 1560                   | 2576x1449 px                         | 4784                             |

Cuando una imagen se reduce, Claude la escala al tamaño más grande que se ajuste a los límites del nivel, preservando su relación de aspecto. Esto limita el costo en tokens. Para conocer la regla precisa y una implementación de referencia, consulta [Cómo Claude redimensiona y rellena las imágenes](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images).

Para estimar el costo, multiplica el conteo de tokens por el [precio por token del modelo](https://claude.com/pricing) que estés usando. Por ejemplo, con el precio de Claude Haiku 4.5 de $1 USD por millón de tokens de entrada (nivel estándar), la imagen de 1000×1000 cuesta aproximadamente $1.30 USD por cada mil imágenes. Con el precio de Claude Opus 5.5 de $4 USD por millón (nivel de alta resolución), la misma imagen cuesta aproximadamente $5.18 USD por cada mil y la imagen 4K aproximadamente $19.14 USD por cada mil.

Las imágenes de alta resolución pueden usar hasta aproximadamente tres veces más tokens visuales que la misma imagen en un modelo de nivel estándar. Si no necesitas la fidelidad adicional que la alta resolución proporciona para el uso de computadora, la comprensión de capturas de pantalla y los documentos densos, submuestrea las imágenes antes de enviarlas para controlar los costos en tokens. Para minimizar la latencia y simplificar los [flujos de trabajo basados en coordenadas](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates), prefiere redimensionar las imágenes antes de subirlas.

### Orientación sobre la calidad de imagen

Al proporcionar imágenes a Claude, ten en cuenta lo siguiente para obtener los mejores resultados:

* **Claridad de la imagen:** Asegúrate de que las imágenes sean claras y no estén demasiado borrosas o pixeladas.
* **Texto:** Si la imagen contiene texto importante, asegúrate de que sea legible y no demasiado pequeño. Evita recortar contexto visual clave únicamente para agrandar el texto.
* **Redimensionamiento:** Ten en cuenta que tu imagen podría redimensionarse si es demasiado grande (consulta [Resolución y costo en tokens](https://platform.claude.com/docs/es/build-with-claude/vision#evaluate-image-size)); esto podría, por ejemplo, hacer que el texto sea menos legible. Considera redimensionar previamente tus imágenes, recortarlas, o ambas cosas. Para que una imagen de tamaño excesivo sea rechazada con un error en lugar de redimensionada (importante para los [flujos de trabajo de coordenadas](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates)), marca el bloque de imagen con [`"oversized_image": "error"`](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates#oversized-image-error).
* **Compresión de imagen:** Comprimir las imágenes antes de enviarlas, usando un formato con pérdida como JPEG o WebP (modo con pérdida), puede reducir la latencia al reducir el tamaño de las solicitudes. Sin embargo, esto puede introducir artefactos perjudiciales para el rendimiento del modelo, especialmente cuando se aplican múltiples pasadas de compresión. Por ejemplo, una compresión JPEG intensa puede hacer que el texto sea difícil de leer. Confirma que tu configuración de compresión sea apropiada para la tarea inspeccionando las imágenes reales enviadas a la API.

***

## Coordenadas y cuadros delimitadores

Para cuadros delimitadores, puntos y coordenadas en píxeles, consulta [Coordenadas y cuadros delimitadores](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates). Claude devuelve coordenadas absolutas en píxeles relativas a la imagen que ve después del redimensionamiento; esa guía cubre cómo Claude redimensiona y rellena las imágenes y cómo redimensionar previamente o reescalar para que las coordenadas coincidan con tu imagen original.

***

## Limitaciones

Aunque las capacidades de comprensión de imágenes de Claude son de vanguardia, hay algunas limitaciones que debes tener en cuenta:

* **Identificación de personas:** Claude [no puede usarse](https://www.anthropic.com/legal/aup) para nombrar personas en imágenes y se niega a hacerlo.
* **Precisión:** Claude podría alucinar o cometer errores al interpretar imágenes de baja calidad, rotadas o muy pequeñas, de menos de 200 píxeles.
* **Razonamiento espacial:** Las salidas de coordenadas y localización de Claude son aproximadas. Sigue la orientación en [Coordenadas y cuadros delimitadores](https://platform.claude.com/docs/es/build-with-claude/vision-coordinates) y verifica las salidas antes de confiar en ellas.
* **Conteo:** Claude puede dar conteos aproximados de objetos en una imagen, pero podría no ser siempre exactamente preciso, especialmente con grandes cantidades de objetos pequeños.
* **Imágenes generadas por IA:** Claude no puede determinar si una imagen fue generada por IA y podría equivocarse si se le pregunta. No confíes en él para detectar imágenes falsas o sintéticas.
* **Contenido inapropiado:** Claude no procesa imágenes inapropiadas o explícitas que violen la [Política de uso aceptable](https://www.anthropic.com/legal/aup).
* **Aplicaciones de salud:** Aunque Claude puede analizar imágenes médicas generales, no está diseñado para interpretar estudios diagnósticos complejos como tomografías computarizadas o resonancias magnéticas. Las salidas de Claude no deben considerarse un sustituto del consejo o diagnóstico médico profesional.

Siempre revisa y verifica cuidadosamente las interpretaciones de imágenes de Claude, especialmente en casos de uso de alto riesgo. No uses Claude para tareas que requieran precisión perfecta o análisis de imágenes sensibles sin supervisión humana.

***

## Preguntas frecuentes

<AccordionGroup>
  <Accordion title="¿Qué tipos de archivo de imagen admite Claude?">
    JPEG, PNG, GIF y WebP. Consulta [Formatos admitidos](https://platform.claude.com/docs/es/build-with-claude/vision#supported-formats).
  </Accordion>

  <Accordion title="¿Puede Claude leer URL de imágenes?">
    Sí. Usa el tipo de fuente `url` en lugar de `base64` en el bloque de contenido `image`. Consulta el [ejemplo de imagen basada en URL](https://platform.claude.com/docs/es/build-with-claude/vision#url-based-image-example).
  </Accordion>

  <Accordion title="¿Hay un límite para el tamaño de archivo de imagen que puedo subir?">
    Sí. Consulta [Límites de solicitud](https://platform.claude.com/docs/es/build-with-claude/vision#request-limits) para conocer los límites de tamaño por imagen y de solicitud total en la Claude API, Amazon Bedrock, Google Cloud y claude.ai.
  </Accordion>

  <Accordion title="¿Cuántas imágenes puedo incluir en una solicitud?">
    Hasta 600 por solicitud a la API (100 para modelos con una ventana de contexto de 200k tokens) y 20 por turno en claude.ai. Consulta [Límites de solicitud](https://platform.claude.com/docs/es/build-with-claude/vision#request-limits) para conocer los detalles y el límite de dimensiones por imagen más bajo que se aplica por encima de 20 imágenes.
  </Accordion>

  <Accordion title="¿Claude lee los metadatos de las imágenes?">
    No, Claude no analiza ni recibe ningún metadato de las imágenes que se le pasan.
  </Accordion>

  <Accordion title="¿Puedo eliminar las imágenes que he subido?">
    No. Las subidas de imágenes son efímeras y no se almacenan más allá de la duración de la solicitud a la API. Las imágenes subidas se eliminan automáticamente después de haber sido procesadas.
  </Accordion>

  <Accordion title="¿Dónde puedo encontrar detalles sobre la privacidad de datos para las subidas de imágenes?">
    Consulta la página de la política de privacidad de Anthropic para obtener información sobre cómo se manejan las imágenes subidas y otros datos. Anthropic no usa las imágenes subidas para entrenar modelos.
  </Accordion>

  <Accordion title="¿Qué pasa si la interpretación de imágenes de Claude parece incorrecta?">
    Si la interpretación de imágenes de Claude parece incorrecta:

    1. Asegúrate de que la imagen sea clara, de alta calidad y esté correctamente orientada.
    2. Prueba técnicas de ingeniería de prompts para mejorar los resultados.
    3. Si el problema persiste, marca la salida en claude.ai (pulgar arriba/abajo) o contacta al [equipo de soporte](https://support.claude.com/).

    ¡Tus comentarios ayudan a mejorar Claude!
  </Accordion>

  <Accordion title="¿Puede Claude generar o editar imágenes?">
    No, Claude es únicamente un modelo de comprensión de imágenes. Puede interpretar y analizar imágenes, pero no puede generar, producir, editar, manipular ni crear imágenes.
  </Accordion>
</AccordionGroup>

***

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Cookbook multimodal" icon="image" href="https://platform.claude.com/cookbook/multimodal-getting-started-with-vision">
    Obtén consejos y técnicas de mejores prácticas para tareas como interpretar gráficos y extraer contenido de formularios.
  </Card>

  <Card title="Referencia de la API" icon="code" href="https://platform.claude.com/docs/es/api/messages/create">
    Consulta la documentación de la Messages API, incluidos ejemplos de llamadas a la API que involucran imágenes.
  </Card>
</CardGroup>