---
title: Vision
url: https://platform.claude.com/docs/de/build-with-claude/vision
description: Claudes Vision-Fähigkeiten ermöglichen es, Bilder zu verstehen und zu analysieren, und eröffnen spannende Möglichkeiten für multimodale Interaktion.
---

Dieser Leitfaden beschreibt, wie du Bilder an Claude sendest, welche Limits und Kosten gelten und wo du Hinweise für [koordinatenbasierte Workflows](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates) findest.

***

## Bilder an Claude senden

Nutze Claudes Vision-Fähigkeiten über:

* [claude.ai](https://claude.ai/). Lade ein Bild hoch, wie du es mit einer Datei tun würdest, oder ziehe ein Bild per Drag-and-drop direkt in das Chatfenster.
* [Playground](https://platform.claude.com/playground) in der Claude Console. Füge Bilder direkt zu einem beliebigen User-Nachrichtenblock hinzu.
* API-Anfrage. Siehe die folgenden Beispiele.

Über die API stellst du Claude Bilder als `image`-Content-Blöcke bereit, wobei du einen von drei Quelltypen verwendest:

1. Ein base64-kodiertes Bild, das in den Request-Body eingebettet ist
2. Eine URL-Referenz auf ein online gehostetes Bild
3. Eine `file_id`, die von der [Files API](https://platform.claude.com/docs/de/build-with-claude/files) zurückgegeben wird (einmal hochladen, beliebig oft referenzieren)

<Note>
  Auf Amazon Bedrock und Google Cloud sind derzeit nur base64-kodierte Quellen verfügbar.
</Note>

<Tip>
  Genauso wie das [Platzieren langer Dokumente vor deiner Anfrage](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices#long-context-prompting) die Ergebnisse bei Text-Prompts verbessert, arbeitet Claude am besten, wenn Bilder vor dem Text stehen. Bilder, die nach dem Text platziert oder mit Text vermischt werden, funktionieren weiterhin gut, aber wenn dein Anwendungsfall es erlaubt, bevorzuge eine Bild-dann-Text-Struktur.
</Tip>

### Beispiel mit base64-kodiertem Bild

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

### Beispiel mit URL-basiertem Bild

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

### Beispiel mit Files-API-Bild

Für Bilder, die du wiederholt verwendest, oder wenn du den Kodierungsaufwand vermeiden möchtest, verwende die [Files API](https://platform.claude.com/docs/de/build-with-claude/files). Lade das Bild einmal hoch und referenziere dann die zurückgegebene `file_id` in nachfolgenden Nachrichten, anstatt die base64-Daten erneut zu senden.

<Tip>
  In mehrstufigen Konversationen und agentischen Workflows sendet jede Anfrage den gesamten Konversationsverlauf erneut. Wenn Bilder base64-kodiert sind, werden die vollständigen Bild-Bytes bei jedem Turn in die Payload aufgenommen, was die Anfragegröße und die Latenz erheblich erhöhen kann, je länger die Konversation wird. Wenn du Bilder in die Files API hochlädst und sie per `file_id` referenzierst, bleiben die Request-Payloads klein, unabhängig davon, wie viele Bilder sich im Konversationsverlauf ansammeln.
</Tip>

<CodeGroup>
  ```bash cURL
  # Lade zuerst dein Bild über die Files API hoch
  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')

  # Verwende dann die zurückgegebene file_id in deiner Nachricht
  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

  # Lade zuerst dein Bild über die Files API hoch
  FILE_ID=$(ant files upload \
    --file ./vision-example.jpg \
    --transform id --raw-output)

  # Verwende dann die zurückgegebene file_id in deiner Nachricht
  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()

  # Lade die Bilddatei hoch
  with open("vision-example.jpg", "rb") as f:
      file_upload = client.files.upload(file=("vision-example.jpg", f, "image/jpeg"))

  # Verwende die hochgeladene Datei in einer Nachricht
  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();

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

  // Verwende die hochgeladene Datei in einer Nachricht
  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();

  // Lade die Bilddatei hoch
  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"),
      },
  });

  // Verwende die hochgeladene Datei in einer Nachricht
  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()

  // Lade die Bilddatei hoch
  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)
  }

  // Verwende die hochgeladene Datei in einer Nachricht
  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();

      // Lade die Bilddatei hoch
      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()
      );

      // Verwende die hochgeladene Datei in einer Nachricht
      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();

  // Lade die Bilddatei hoch
  $fileUpload = $client->files->upload(
      file: FileParam::fromResource(fopen('vision-example.jpg', 'rb'), contentType: 'image/jpeg'),
  );

  // Verwende die hochgeladene Datei in einer Nachricht
  $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

  # Lade die Bilddatei hoch
  file_upload = client.files.upload(
    file: Anthropic::FilePart.new(
      File.open("vision-example.jpg", "rb"),
      content_type: "image/jpeg"
    )
  )

  # Verwende die hochgeladene Datei in einer Nachricht
  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>

Siehe [Messages-API-Beispiele](https://platform.claude.com/docs/de/api/messages/create) für weiteren Beispielcode und Parameterdetails.

### Mehrere Bilder

Du kannst mehrere Bilder in eine einzelne Anfrage aufnehmen, und Claude analysiert sie gemeinsam. Das ist nützlich, um Bilder zu vergleichen, nach Unterschieden zu fragen oder mit einer Sequenz wie den Seiten eines Dokuments zu arbeiten. Wenn du mehrere Bilder sendest, leite jedes mit einem kurzen Textlabel ein (`Image 1:`, `Image 2:` und so weiter), damit du in deinem Prompt und in Folge-Turns namentlich darauf verweisen kannst.

<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 einer mehrstufigen Konversation fügst du neue Bilder in späteren `user`-Turns auf dieselbe Weise hinzu. Claude hat Zugriff auf jedes Bild aus früheren Turns, sodass Folgefragen wie „Sind diese den ersten beiden ähnlich?“ funktionieren, ohne dass du die früheren Bilder erneut in den Inhalt des neuen Turns aufnehmen musst.

***

## Bildlimits und Kosten

### Anfragelimits

Die maximale Anzahl von Bildern pro Nachricht oder Anfrage beträgt:

* 20 pro Nachricht auf [claude.ai](https://claude.ai/).
* 100 pro Anfrage über die API, für Modelle mit einem „context window“ (Kontextfenster) von 200k Token.
* 600 pro Anfrage über die API, für alle anderen Modelle.

Die maximalen Abmessungen pro Bild betragen 8000x8000 px.

Wenn eine einzelne API-Anfrage mehr als 20 Bilder enthält, gilt für jedes Bild in dieser Anfrage ein strengeres Abmessungslimit pro Bild. Alle `image`-Blöcke in der Anfrage zählen zu diesem Schwellenwert, einschließlich Bildern aus früheren Konversations-Turns, die du erneut sendest, und Bildern, die in `tool_result`-Inhalten verschachtelt sind (zum Beispiel Screenshots, die an das Computer-Use-Tool zurückgegeben werden). Auf Amazon Bedrock und Google Cloud zählen auch Dokumentblöcke wie PDFs zu diesem Schwellenwert. Bilder, die das strengere Limit überschreiten, werden mit einem `invalid_request_error` abgelehnt, dessen Meldung auf „many-image requests“ verweist und das aktuelle Limit in Pixeln angibt. Um auf allen Plattformen unter dem Limit zu bleiben, skaliere entweder jedes Bild so, dass keine der beiden Abmessungen 2000 px überschreitet, oder beschränke die Anfrage auf 20 oder weniger Bild- und Dokumentblöcke.

Die maximale Größe pro Bild beträgt:

* 10 MB (base64-kodiert) bei direkter Nutzung der Claude API.
* 5 MB (base64-kodiert) auf Amazon Bedrock und Google Cloud.
* 10 MB auf [claude.ai](https://claude.ai/).

<Note>
  Obwohl die API bis zu 600 Bilder pro Anfrage unterstützt, können die [Limits für die Anfragegröße](https://platform.claude.com/docs/de/api/overview#request-size-limits) (32 MB für Standard-Endpunkte; niedriger auf einigen von Partnern betriebenen Plattformen, zum Beispiel Amazon Bedrock und Google Cloud) zuerst erreicht werden. Bei vielen Bildern solltest du in Erwägung ziehen, sie mit der [Files API](https://platform.claude.com/docs/de/build-with-claude/vision#files-api-image-example) hochzuladen und per `file_id` zu referenzieren, um die Request-Payloads klein zu halten.

  Selbst bei Verwendung der Files API können Anfragen mit vielen großen Bildern fehlschlagen, bevor die Anzahl von 600 Bildern erreicht wird. Reduziere die Bildabmessungen oder Dateigrößen (zum Beispiel durch Downsampling) vor dem Hochladen (siehe [Auflösung und Token-Kosten](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size)).
</Note>

### Unterstützte Formate

Claude unterstützt JPEG-, PNG-, GIF- und WebP-Bilder (`image/jpeg`, `image/png`, `image/gif`, `image/webp`). Animationen werden nicht unterstützt, und es wird nur das erste Frame verwendet.

### Auflösung und Token-Kosten

Claude betrachtet Bilder in Patches statt in Pixeln. Jeder Patch ist ein 28×28-Pixel-Block des Bildes, der als „visual token“ (visuelles Token) bezeichnet wird. Ein Bild kostet daher `⌈width / 28⌉ × ⌈height / 28⌉` visuelle Token.

Jedes Modell hat eine maximale native Bildauflösung, ausgedrückt als Limit für die lange Kante und als Limit für visuelle Token. Bilder, die eines der beiden Limits überschreiten, werden vor der Verarbeitung herunterskaliert; siehe [Wie Claude Bilder skaliert und auffüllt](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images) für die genaue Regel. Die Ausnahme sind Screenshots und Zoom-Bilder, die du an die Toolsets für [Computer Use](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions) und [Browser Use](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#targets-and-coordinates) zurückgibst: Die API lehnt ein `tool_result`-Bild, das die Limits des Modells überschreitet, mit einem Validierungsfehler ab, anstatt es herunterzuskalieren. Skaliere diese Bilder daher in deiner Anwendung, bevor du sie zurückgibst. Damit jedes andere übergroße Bild mit einem Fehler abgelehnt statt herunterskaliert wird, setze das [`transformations`-Feld](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates#oversized-image-error) des Bildblocks.

| Auflösungsstufe | Modelle                       | Max. lange Kante | Max. visuelle Token |
| --------------- | ----------------------------- | ---------------- | ------------------- |
| Hochauflösend   | Claude 4.7 und neuere Modelle | 2576 px          | 4784                |
| Standard        | Alle anderen Modelle          | 1568 px          | 1568                |

Die Unterstützung für hohe Auflösung ist bei den aufgeführten Modellen automatisch aktiv und erfordert weder einen Beta-Header noch ein clientseitiges Opt-in.

Die folgende Tabelle zeigt die herunterskalierte Auflösung und die Kosten in visuellen Token für mehrere Bildgrößen auf jeder Stufe:

| Bildgröße                     | Standard-Stufe: herunterskaliert auf | Standard-Stufe: Token | Hochauflösende Stufe: herunterskaliert auf | Hochauflösende Stufe: Token |
| ----------------------------- | ------------------------------------ | --------------------- | ------------------------------------------ | --------------------------- |
| 200x200 px (0,04 Megapixel)   | Nicht skaliert                       | 64                    | Nicht skaliert                             | 64                          |
| 1000x1000 px (1 Megapixel)    | Nicht skaliert                       | 1296                  | Nicht skaliert                             | 1296                        |
| 1092x1092 px (1,19 Megapixel) | Nicht skaliert                       | 1521                  | Nicht skaliert                             | 1521                        |
| 1920x1080 px (2,07 Megapixel) | 1456x819 px                          | 1560                  | Nicht skaliert                             | 2691                        |
| 2000x1500 px (3 Megapixel)    | 1269x952 px                          | 1564                  | Nicht skaliert                             | 3888                        |
| 3840x2160 px (8,29 Megapixel) | 1456x819 px                          | 1560                  | 2576x1449 px                               | 4784                        |

Wenn ein Bild herunterskaliert wird, skaliert Claude es auf die größte Größe, die in die Limits der Stufe passt, und behält dabei das Seitenverhältnis bei. Dadurch werden die Token-Kosten gedeckelt. Die genaue Regel und eine Referenzimplementierung findest du unter [Wie Claude Bilder skaliert und auffüllt](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates#how-claude-resizes-and-pads-images).

Um die Kosten abzuschätzen, multipliziere die Token-Anzahl mit dem [Preis pro Token des Modells](https://claude.com/pricing), das du verwendest. Bei Claude Haiku 4.5 mit 1 $ USD pro Million Input-Token (Standard-Stufe) kostet das 1000×1000-Bild beispielsweise etwa 1,30 $ USD pro tausend Bilder. Bei Claude Opus 5.5 mit 4 $ USD pro Million (hochauflösende Stufe) kostet dasselbe Bild etwa 5,18 $ USD pro tausend und das 4K-Bild etwa 19,14 $ USD pro tausend.

Hochauflösende Bilder können bis zu etwa dreimal mehr visuelle Token verbrauchen als dasselbe Bild auf einem Modell der Standard-Stufe. Wenn du die zusätzliche Detailtreue, die hohe Auflösung für Computer Use, Screenshot-Verständnis und dichte Dokumente bietet, nicht benötigst, führe vor dem Senden ein Downsampling der Bilder durch, um die Token-Kosten zu kontrollieren. Um die Latenz zu minimieren und [koordinatenbasierte Workflows](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates) zu vereinfachen, skaliere Bilder bevorzugt vor dem Hochladen.

### Hinweise zur Bildqualität

Wenn du Claude Bilder bereitstellst, beachte für beste Ergebnisse Folgendes:

* **Bildklarheit:** Stelle sicher, dass Bilder klar und nicht zu unscharf oder verpixelt sind.
* **Text:** Wenn das Bild wichtigen Text enthält, achte darauf, dass er lesbar und nicht zu klein ist. Vermeide es, wichtigen visuellen Kontext wegzuschneiden, nur um den Text zu vergrößern.
* **Skalierung:** Berücksichtige, dass dein Bild möglicherweise skaliert wird, wenn es zu groß ist (siehe [Auflösung und Token-Kosten](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size)); dadurch kann zum Beispiel Text schlechter lesbar werden. Ziehe in Erwägung, deine Bilder vorab zu skalieren, zuzuschneiden oder beides. Damit ein übergroßes Bild mit einem Fehler abgelehnt statt skaliert wird (wichtig für [Koordinaten-Workflows](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates)), markiere den Bildblock mit [`"oversized_image": "error"`](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates#oversized-image-error).
* **Bildkomprimierung:** Das Komprimieren von Bildern vor dem Senden mit einem verlustbehafteten Format wie JPEG oder WebP (verlustbehafteter Modus) kann die Latenz verringern, indem die Größe der Anfragen reduziert wird. Dies kann jedoch Artefakte einführen, die der Modellleistung schaden, insbesondere wenn mehrere Komprimierungsdurchläufe angewendet werden. Starke JPEG-Komprimierung kann zum Beispiel Text schwer lesbar machen. Vergewissere dich, dass deine Komprimierungseinstellungen für die Aufgabe geeignet sind, indem du die tatsächlich an die API gesendeten Bilder überprüfst.

***

## Koordinaten und Bounding Boxes

Für „bounding boxes“ (Begrenzungsrahmen), Punkte und Pixelkoordinaten siehe [Koordinaten und Bounding Boxes](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates). Claude gibt absolute Pixelkoordinaten relativ zu dem Bild zurück, das es nach der Skalierung sieht; dieser Leitfaden behandelt, wie Claude Bilder skaliert und auffüllt und wie du vorab skalierst oder umrechnest, damit die Koordinaten mit deinem Originalbild übereinstimmen.

***

## Einschränkungen

Obwohl Claudes Fähigkeiten zum Bildverständnis auf dem neuesten Stand sind, gibt es einige Einschränkungen, die du kennen solltest:

* **Personenidentifikation:** Claude [darf nicht verwendet werden](https://www.anthropic.com/legal/aup), um Personen in Bildern namentlich zu identifizieren, und lehnt dies ab.
* **Genauigkeit:** Claude kann halluzinieren oder Fehler machen, wenn es Bilder von geringer Qualität, gedrehte Bilder oder sehr kleine Bilder unter 200 Pixeln interpretiert.
* **Räumliches Denken:** Claudes Koordinaten- und Lokalisierungsausgaben sind Näherungswerte. Befolge die Hinweise in [Koordinaten und Bounding Boxes](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates) und überprüfe die Ausgaben, bevor du dich auf sie verlässt.
* **Zählen:** Claude kann ungefähre Anzahlen von Objekten in einem Bild angeben, ist aber möglicherweise nicht immer exakt, insbesondere bei großen Mengen kleiner Objekte.
* **KI-generierte Bilder:** Claude kann nicht feststellen, ob ein Bild KI-generiert ist, und kann falsch liegen, wenn es danach gefragt wird. Verlasse dich nicht darauf, um gefälschte oder synthetische Bilder zu erkennen.
* **Unangemessene Inhalte:** Claude verarbeitet keine unangemessenen oder expliziten Bilder, die gegen die [Acceptable Use Policy](https://www.anthropic.com/legal/aup) verstoßen.
* **Anwendungen im Gesundheitswesen:** Obwohl Claude allgemeine medizinische Bilder analysieren kann, ist es nicht dafür ausgelegt, komplexe diagnostische Scans wie CTs oder MRTs zu interpretieren. Claudes Ausgaben sollten nicht als Ersatz für professionelle medizinische Beratung oder Diagnose betrachtet werden.

Überprüfe und verifiziere Claudes Bildinterpretationen stets sorgfältig, insbesondere bei Anwendungsfällen mit hohem Risiko. Verwende Claude nicht ohne menschliche Aufsicht für Aufgaben, die perfekte Präzision oder sensible Bildanalyse erfordern.

***

## FAQ

<AccordionGroup>
  <Accordion title="Welche Bilddateitypen unterstützt Claude?">
    JPEG, PNG, GIF und WebP. Siehe [Unterstützte Formate](https://platform.claude.com/docs/de/build-with-claude/vision#supported-formats).
  </Accordion>

  <Accordion title="Kann Claude Bild-URLs lesen?">
    Ja. Verwende im `image`-Content-Block den Quelltyp `url` anstelle von `base64`. Siehe das [Beispiel mit URL-basiertem Bild](https://platform.claude.com/docs/de/build-with-claude/vision#url-based-image-example).
  </Accordion>

  <Accordion title="Gibt es ein Limit für die Bilddateigröße, die ich hochladen kann?">
    Ja. Siehe [Anfragelimits](https://platform.claude.com/docs/de/build-with-claude/vision#request-limits) für die Limits pro Bild und die Gesamtlimits für die Anfragegröße über die Claude API, Amazon Bedrock, Google Cloud und claude.ai hinweg.
  </Accordion>

  <Accordion title="Wie viele Bilder kann ich in eine Anfrage aufnehmen?">
    Bis zu 600 pro API-Anfrage (100 für Modelle mit einem Kontextfenster von 200k Token) und 20 pro Turn auf claude.ai. Siehe [Anfragelimits](https://platform.claude.com/docs/de/build-with-claude/vision#request-limits) für Details und das niedrigere Abmessungslimit pro Bild, das bei mehr als 20 Bildern gilt.
  </Accordion>

  <Accordion title="Liest Claude Bildmetadaten?">
    Nein, Claude parst oder empfängt keine Metadaten aus Bildern, die ihm übergeben werden.
  </Accordion>

  <Accordion title="Kann ich hochgeladene Bilder löschen?">
    Nein. Bild-Uploads sind flüchtig und werden nicht über die Dauer der API-Anfrage hinaus gespeichert. Hochgeladene Bilder werden automatisch gelöscht, nachdem sie verarbeitet wurden.
  </Accordion>

  <Accordion title="Wo finde ich Details zum Datenschutz bei Bild-Uploads?">
    Informationen dazu, wie hochgeladene Bilder und andere Daten behandelt werden, findest du auf der Seite mit der Datenschutzrichtlinie von Anthropic. Anthropic verwendet hochgeladene Bilder nicht, um Modelle zu trainieren.
  </Accordion>

  <Accordion title="Was, wenn Claudes Bildinterpretation falsch erscheint?">
    Wenn Claudes Bildinterpretation falsch erscheint:

    1. Stelle sicher, dass das Bild klar, hochwertig und korrekt ausgerichtet ist.
    2. Probiere Prompt-Engineering-Techniken aus, um die Ergebnisse zu verbessern.
    3. Wenn das Problem weiterhin besteht, markiere die Ausgabe in claude.ai (Daumen hoch/runter) oder kontaktiere das [Support-Team](https://support.claude.com/).

    Dein Feedback hilft, Claude zu verbessern!
  </Accordion>

  <Accordion title="Kann Claude Bilder generieren oder bearbeiten?">
    Nein, Claude ist ausschließlich ein Modell zum Bildverständnis. Es kann Bilder interpretieren und analysieren, aber es kann keine Bilder generieren, produzieren, bearbeiten, manipulieren oder erstellen.
  </Accordion>
</AccordionGroup>

***

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Multimodales Cookbook" icon="image" href="https://platform.claude.com/cookbook/multimodal-getting-started-with-vision">
    Erhalte Tipps und Best-Practice-Techniken für Aufgaben wie das Interpretieren von Diagrammen und das Extrahieren von Inhalten aus Formularen.
  </Card>

  <Card title="API-Referenz" icon="code" href="https://platform.claude.com/docs/de/api/messages/create">
    Sieh dir die Messages-API-Dokumentation an, einschließlich Beispiel-API-Aufrufen mit Bildern.
  </Card>
</CardGroup>