Bilder und Bildverständnis

Übersicht

Verwende GPT Image-Modelle, um Bilder zu generieren oder zu bearbeiten.

Nutze das Bildverständnis unserer Modelle, um Bilder zu analysieren.

Neuere Sprachmodelle können Bildeingaben verarbeiten und analysieren. Diese Fähigkeit wird als Bildverständnis bezeichnet. GPT Image-Modelle können anhand von Text- und Bildeingaben neue Bilder erstellen oder bestehende bearbeiten.

Wähle einen Endpunkt danach aus, ob du Bilder analysieren oder generieren möchtest:

API	Unterstützte Anwendungsfälle
Responses API	Bilder analysieren oder mit dem Tool zur Bildgenerierung Bilder generieren und bearbeiten
Images API	Bilder als Ausgabe generieren, optional mit Bildern als Eingabe
Chat Completions API	Bilder analysieren und Textantworten generieren

Mehr über die von unseren Modellen unterstützten Ein- und Ausgabemodalitäten erfährst du auf unserer Modellübersicht.

Bilder generieren oder bearbeiten

Wähle bei der Images API gpt-image-2.5-sunburst, um Bilder aus Text zu generieren oder bestehende Bilder zu bearbeiten. Wähle bei der Responses API ein Modell aus der Hauptmodellreihe, das das Tool zur Bildgenerierung unterstützt. Das Tool übernimmt die Auswahl des GPT Image-Modells.

Bilder mit Responses generieren

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import OpenAI from "openai";
const openai = new OpenAI();

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input:
    "Generate an image of gray tabby cat hugging an otter with an orange scarf",
  tools: [{ type: "image_generation" }],
});

// Save the image to a file
const imageData = response.output
  .filter((output) => output.type === "image_generation_call")
  .map((output) => output.result);

if (imageData.length > 0) {
  const imageBase64 = imageData[0];
  const fs = await import("fs");
  fs.writeFileSync("cat_and_otter.png", Buffer.from(imageBase64, "base64"));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22from openai import OpenAI
import base64

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Generate an image of gray tabby cat hugging an otter with an orange scarf",
    tools=[{"type": "image_generation"}],
)

# Save the image to a file
image_data = [
    output.result
    for output in response.output
    if output.type == "image_generation_call"
]

if image_data:
    image_base64 = image_data[0]
    with open("cat_and_otter.png", "wb") as f:
        f.write(base64.b64decode(image_base64))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43package main

import (
	"context"
	"encoding/base64"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Generate an image of a gray tabby cat hugging an otter with an orange scarf."),
		},
		Tools: []responses.ToolUnionParam{{
			OfImageGeneration: &responses.ToolImageGenerationParam{},
		}},
	})
	if err != nil {
		panic(err)
	}

	for _, output := range response.Output {
		if output.Type != "image_generation_call" {
			continue
		}
		image, err := base64.StdEncoding.DecodeString(output.AsImageGenerationCall().Result)
		if err != nil {
			panic(err)
		}
		if err := os.WriteFile("cat_and_otter.png", image, 0o600); err != nil {
			panic(err)
		}
		return
	}

	panic("response did not include an image generation call")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Generate an image of a gray tabby cat hugging an otter with an orange scarf.")
        .addTool(Tool.ImageGeneration.builder().build())
        .build();

String imageResult =
    client.responses().create(params).output().stream()
        .flatMap(item -> item.imageGenerationCall().stream())
        .flatMap(call -> call.result().stream())
        .findFirst()
        .orElseThrow(() -> new IllegalStateException("No generated image returned"));
Files.write(Path.of("cat_and_otter.png"), Base64.getDecoder().decode(imageResult));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem(
        "Generate an image of a gray tabby cat hugging an otter with an orange scarf."
    )
);
options.Tools.Add(
    ResponseTool.CreateImageGenerationTool(model: "gpt-image-2")
);

ResponseResult response = await client.CreateResponseAsync(options);
ImageGenerationCallResponseItem image = response
    .OutputItems.OfType<ImageGenerationCallResponseItem>()
    .FirstOrDefault()
    ?? throw new InvalidOperationException("No generated image was returned.");
await File.WriteAllBytesAsync(
    "cat_and_otter.png",
    image.ImageResultBytes.ToArray()
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "base64"
require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  input: "Generate an image of a gray tabby cat hugging an otter with an orange scarf.",
  tools: [{ type: :image_generation }]
)

image_call = response.output.find do |item|
  item.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)
end
unless image_call.is_a?(OpenAI::Models::Responses::ResponseOutputItem::ImageGenerationCall)
  raise "No image generation call returned"
end

File.binwrite(
  "cat_and_otter.png",
  Base64.strict_decode64(image_call.result)
)

1
2
3
4
5
6
7
8openai responses create \
  --model gpt-6-astra \
  --raw-output \
  --transform 'output.#(type=="image_generation_call").result' <<'YAML' | base64 --decode > cat_and_otter.png
tools:
  - type: image_generation
input: Generate an image of a gray tabby cat hugging an otter with an orange scarf.
YAML

Mehr über Bildgenerierung erfährst du in unserem Leitfaden zur Bildgenerierung.

Weltwissen für die Bildgenerierung nutzen

GPT Image-Modelle können auch ohne Referenzbild auf Weltwissen zurückgreifen. So kann ein Prompt für eine Vitrine mit Halbedelsteinen eine Szene mit erkennbaren Schmucksteinen wie Amethyst, Rosenquarz und Jade erzeugen.

Bilder analysieren

Verwende ein Modell mit Bildverständnis, um Bilder zu beschreiben, sichtbaren Text zu lesen und Fragen zu Objekten, Formen, Farben oder Texturen zu beantworten. Berücksichtige die Einschränkungen des Modells, wenn du seine Antworten verwendest.

Bilder als Eingabe an ein Modell übergeben

Stelle ein Bild zur Analyse bereit, indem du entweder eine vollständig qualifizierte Bild-URL oder eine Base64-kodierte Daten-URL angibst.

Du kannst mehrere Bilder in einer einzigen Anfrage als Eingabe übergeben, indem du sie in das Array content aufnimmst. Beachte dabei, dass Bilder als Token zählen und entsprechend abgerechnet werden.

Den Inhalt eines Bildes analysieren

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import OpenAI from "openai";
const openai = new OpenAI();

const response = await openai.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "What is in this image?" },
        {
          type: "image_url",
          image_url: {
            url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
          },
        },
      ],
    },
  ],
});

console.log(response.choices[0].message.content);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
                    },
                },
            ],
        }
    ],
)

print(response.choices[0].message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{
				openai.TextContentPart("What's in this image?"),
				openai.ImageContentPart(openai.ChatCompletionContentPartImageImageURLParam{
					URL: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
				}),
			}),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionContentPart;
import com.openai.models.chat.completions.ChatCompletionContentPartImage;
import com.openai.models.chat.completions.ChatCompletionContentPartText;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import java.util.List;

String imageUrl =
    "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg";
ChatCompletionContentPart text =
    ChatCompletionContentPart.ofText(
        ChatCompletionContentPartText.builder().text("What's in this image?").build());
ChatCompletionContentPart image =
    ChatCompletionContentPart.ofImageUrl(
        ChatCompletionContentPartImage.builder()
            .imageUrl(ChatCompletionContentPartImage.ImageUrl.builder().url(imageUrl).build())
            .build());

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addMessage(
            ChatCompletionUserMessageParam.builder()
                .contentOfArrayOfContentParts(List.of(text, image))
                .build())
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19using OpenAI.Chat;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

Uri imageUrl = new(
    "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
);
UserChatMessage message = new(
    [
        ChatMessageContentPart.CreateTextPart("What is in this image?"),
        ChatMessageContentPart.CreateImagePart(imageUrl),
    ]
);

ChatCompletion completion = await client.CompleteChatAsync(message);

Console.WriteLine(completion.Content[0].Text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26require "openai"

client = OpenAI::Client.new

completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: [
        {
          type: :text,
          text: "What's in this image?"
        },
        {
          type: :image_url,
          image_url: {
            url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
          }
        }
      ]
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What is in this image?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
            }
          }
        ]
      }
    ],
    "max_completion_tokens": 300
  }'

Den Inhalt eines Bildes analysieren

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import fs from "fs";
import OpenAI from "openai";

const openai = new OpenAI();

const imagePath = "fixtures/example.jpg";
const base64Image = fs.readFileSync(imagePath, "base64");

const completion = await openai.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "what's in this image?" },
        {
          type: "image_url",
          image_url: {
            url: `data:image/jpeg;base64,${base64Image}`,
          },
        },
      ],
    },
  ],
});

console.log(completion.choices[0].message.content);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import base64
from openai import OpenAI

client = OpenAI()


# Function to encode the image
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")


# Path to your image
image_path = "path_to_your_image.jpg"

# Getting the Base64 string
base64_image = encode_image(image_path)

completion = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "what's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}",
                    },
                },
            ],
        }
    ],
)

print(completion.choices[0].message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34package main

import (
	"context"
	"encoding/base64"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()
	image, err := os.ReadFile("image.png")
	if err != nil {
		panic(err)
	}
	imageURL := "data:image/png;base64," + base64.StdEncoding.EncodeToString(image)

	completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: "gpt-6-astra",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{
				openai.TextContentPart("What's in this image?"),
				openai.ImageContentPart(openai.ChatCompletionContentPartImageImageURLParam{URL: imageURL}),
			}),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(completion.Choices[0].Message.Content)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionContentPart;
import com.openai.models.chat.completions.ChatCompletionContentPartImage;
import com.openai.models.chat.completions.ChatCompletionContentPartText;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.List;

String imageUrl =
    "data:image/jpeg;base64,"
        + Base64.getEncoder()
            .encodeToString(
                Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_IMAGE_PATH"))));
ChatCompletionContentPart text =
    ChatCompletionContentPart.ofText(
        ChatCompletionContentPartText.builder().text("What's in this image?").build());
ChatCompletionContentPart image =
    ChatCompletionContentPart.ofImageUrl(
        ChatCompletionContentPartImage.builder()
            .imageUrl(ChatCompletionContentPartImage.ImageUrl.builder().url(imageUrl).build())
            .build());

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addMessage(
            ChatCompletionUserMessageParam.builder()
                .contentOfArrayOfContentParts(List.of(text, image))
                .build())
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using OpenAI.Chat;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

Uri imageUrl = new(
    "https://openai-documentation.vercel.app/images/cat_and_otter.png"
);

using HttpClient http = new();
BinaryData image = BinaryData.FromBytes(
    await http.GetByteArrayAsync(imageUrl)
);
UserChatMessage message = new(
    [
        ChatMessageContentPart.CreateTextPart("What's in this image?"),
        ChatMessageContentPart.CreateImagePart(image, "image/png"),
    ]
);

ChatCompletion completion = await client.CompleteChatAsync(message);

Console.WriteLine(completion.Content[0].Text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26require "base64"
require "openai"

client = OpenAI::Client.new
image = Base64.strict_encode64(File.binread("image.png"))

completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: [
        {
          type: :text,
          text: "What's in this image?"
        },
        {
          type: :image_url,
          image_url: { url: "data:image/png;base64,#{image}" }
        }
      ]
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23BASE64_IMAGE=$(base64 < path_to_your_image.jpg) && curl https://api.openai.com/v1/chat/completions   -H "Content-Type: application/json"   -H "Authorization: Bearer $OPENAI_API_KEY"   -d @- <<EOF
  {
    "model": "gpt-6-astra",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What is in this image?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "data:image/jpeg;base64,$BASE64_IMAGE"
            }
          }
        ]
      }
    ],
    "max_completion_tokens": 300
  }
EOF

Du kannst ein Bild auf eine der folgenden Arten zur Analyse bereitstellen:

Indem du eine vollständig qualifizierte URL zu einer Bilddatei angibst
Indem du ein Bild als Base64-kodierte Daten-URL angibst
Indem du eine Datei-ID angibst (erstellt mit der Files API)

Den Inhalt eines Bildes analysieren

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import OpenAI from "openai";

const openai = new OpenAI();

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "what's in this image?" },
        {
          type: "input_image",
          image_url:
            "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
          detail: "auto",
        },
      ],
    },
  ],
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "what's in this image?"},
                {
                    "type": "input_image",
                    "image_url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
                },
            ],
        }
    ],
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Input: responses.ResponseNewParamsInputUnion{
			OfInputItemList: responses.ResponseInputParam{
				responses.ResponseInputItemParamOfMessage(
					responses.ResponseInputMessageContentListParam{
						responses.ResponseInputContentParamOfInputText("What's in this image?"),
						{OfInputImage: &responses.ResponseInputImageParam{
							Detail:   responses.ResponseInputImageDetailAuto,
							ImageURL: openai.String("https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"),
						}},
					},
					responses.EasyInputMessageRoleUser,
				),
			},
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;

ResponseInputItem imageInput =
    ResponseInputItem.ofMessage(
        ResponseInputItem.Message.builder()
            .role(ResponseInputItem.Message.Role.USER)
            .addInputTextContent("What's in this image?")
            .addContent(
                ResponseInputImage.builder()
                    .detail(ResponseInputImage.Detail.AUTO)
                    .imageUrl(
                        "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg")
                    .build())
            .build());

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .inputOfResponse(List.of(imageInput))
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

Uri imageUrl = new(
    "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("What is in this image?"),
                ResponseContentPart.CreateInputImagePart(imageUrl),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25require "openai"

client = OpenAI::Client.new

response = client.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: :user,
      content: [
        {
          type: :input_text,
          text: "What's in this image?"
        },
        {
          type: :input_image,
          detail: :auto,
          image_url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
        }
      ]
    }
  ]
)

puts(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6-astra",
    "input": [
      {
        "role": "user",
        "content": [
          {"type": "input_text", "text": "what is in this image?"},
          {
            "type": "input_image",
            "image_url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg"
          }
        ]
      }
    ]
  }'

1
2
3
4
5
6
7
8
9
10
11
12openai responses create \
  --model gpt-6-astra \
  --raw-output \
  --transform 'output.#(type=="message").content.0.text' <<'YAML'
input:
  - role: user
    content:
      - type: input_text
        text: What is in this image?
      - type: input_image
        image_url: https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg
YAML

Den Inhalt eines Bildes analysieren

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import fs from "fs";
import OpenAI from "openai";

const openai = new OpenAI();

const imagePath = "fixtures/example.jpg";
const base64Image = fs.readFileSync(imagePath, "base64");

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "what's in this image?" },
        {
          type: "input_image",
          image_url: `data:image/jpeg;base64,${base64Image}`,
          detail: "auto",
        },
      ],
    },
  ],
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36import base64
from openai import OpenAI

client = OpenAI()


# Function to encode the image
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")


# Path to your image
image_path = "path_to_your_image.jpg"

# Getting the Base64 string
base64_image = encode_image(image_path)


response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "what's in this image?"},
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{base64_image}",
                },
            ],
        }
    ],
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43package main

import (
	"context"
	"encoding/base64"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	image, err := os.ReadFile("image.png")
	if err != nil {
		panic(err)
	}
	imageURL := "data:image/png;base64," + base64.StdEncoding.EncodeToString(image)

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Input: responses.ResponseNewParamsInputUnion{
			OfInputItemList: responses.ResponseInputParam{
				responses.ResponseInputItemParamOfMessage(
					responses.ResponseInputMessageContentListParam{
						responses.ResponseInputContentParamOfInputText("What's in this image?"),
						{OfInputImage: &responses.ResponseInputImageParam{
							Detail:   responses.ResponseInputImageDetailAuto,
							ImageURL: openai.String(imageURL),
						}},
					},
					responses.EasyInputMessageRoleUser,
				),
			},
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.List;

String imageBase64 =
    Base64.getEncoder()
        .encodeToString(
            Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_IMAGE_PATH"))));

ResponseInputItem imageInput =
    ResponseInputItem.ofMessage(
        ResponseInputItem.Message.builder()
            .role(ResponseInputItem.Message.Role.USER)
            .addInputTextContent("What's in this image?")
            .addContent(
                ResponseInputImage.builder()
                    .detail(ResponseInputImage.Detail.AUTO)
                    .imageUrl("data:image/png;base64," + imageBase64)
                    .build())
            .build());

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .inputOfResponse(List.of(imageInput))
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

Uri imageUrl = new(
    "https://openai-documentation.vercel.app/images/cat_and_otter.png"
);

using HttpClient http = new();

// Download an image as a stream.
using Stream stream = await http.GetStreamAsync(imageUrl);
BinaryData imageData = BinaryData.FromStream(stream, "image/png");

ResponseResult response1 = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("What is in this image?"),
                ResponseContentPart.CreateInputImagePart(imageData),
            ]
        ),
    ]
);

Console.WriteLine($"From image stream: {response1.GetOutputText()}");

// Download an image as a byte array.
byte[] bytes = await http.GetByteArrayAsync(imageUrl);
imageData = BinaryData.FromBytes(bytes, "image/png");

ResponseResult response2 = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("What is in this image?"),
                ResponseContentPart.CreateInputImagePart(imageData),
            ]
        ),
    ]
);

Console.WriteLine($"From byte array: {response2.GetOutputText()}");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27require "base64"
require "openai"

client = OpenAI::Client.new
image = Base64.strict_encode64(File.binread("image.png"))

response = client.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: :user,
      content: [
        {
          type: :input_text,
          text: "What's in this image?"
        },
        {
          type: :input_image,
          detail: :auto,
          image_url: "data:image/png;base64,#{image}"
        }
      ]
    }
  ]
)

puts(response.output_text)

Den Inhalt eines Bildes analysieren

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36import OpenAI from "openai";
import fs from "fs";

const openai = new OpenAI();

// Function to create a file with the Files API
async function createFile(filePath) {
  const fileContent = fs.createReadStream(filePath);
  const result = await openai.files.create({
    file: fileContent,
    purpose: "vision",
  });
  return result.id;
}

// Getting the file ID
const fileId = await createFile("fixtures/example.jpg");

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "what's in this image?" },
        {
          type: "input_image",
          file_id: fileId,
          detail: "auto",
        },
      ],
    },
  ],
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35from openai import OpenAI

client = OpenAI()


# Function to create a file with the Files API
def create_file(file_path):
    with open(file_path, "rb") as file_content:
        result = client.files.create(
            file=file_content,
            purpose="vision",
        )
        return result.id


# Getting the file ID
file_id = create_file("path_to_your_image.jpg")

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "what's in this image?"},
                {
                    "type": "input_image",
                    "file_id": file_id,
                },
            ],
        }
    ],
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	file, err := os.Open("image.png")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	uploaded, err := client.Files.New(context.Background(), openai.FileNewParams{
		File:    file,
		Purpose: openai.FilePurposeVision,
	})
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Input: responses.ResponseNewParamsInputUnion{
			OfInputItemList: responses.ResponseInputParam{
				responses.ResponseInputItemParamOfMessage(
					responses.ResponseInputMessageContentListParam{
						responses.ResponseInputContentParamOfInputText("What's in this image?"),
						{OfInputImage: &responses.ResponseInputImageParam{
							Detail: responses.ResponseInputImageDetailAuto,
							FileID: openai.String(uploaded.ID),
						}},
					},
					responses.EasyInputMessageRoleUser,
				),
			},
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.files.FileCreateParams;
import com.openai.models.files.FilePurpose;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.nio.file.Path;
import java.util.List;

var file =
    client
        .files()
        .create(
            FileCreateParams.builder()
                .file(Path.of(System.getenv("OPENAI_EXAMPLE_FILE_PATH")))
                .purpose(FilePurpose.VISION)
                .build());

var response =
    client
        .responses()
        .create(
            ResponseCreateParams.builder()
                .model("gpt-6-astra")
                .inputOfResponse(
                    List.of(
                        ResponseInputItem.ofMessage(
                            ResponseInputItem.Message.builder()
                                .role(ResponseInputItem.Message.Role.USER)
                                .addInputTextContent("What's in this image?")
                                .addContent(
                                    ResponseInputImage.builder()
                                        .detail(ResponseInputImage.Detail.AUTO)
                                        .fileId(file.id())
                                        .build())
                                .build())))
                .build());
response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38using OpenAI.Files;
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

string filename = "cat_and_otter.png";
Uri imageUrl = new(
    $"https://openai-documentation.vercel.app/images/{filename}"
);

using HttpClient http = new();

// Download an image as a stream.
using Stream stream = await http.GetStreamAsync(imageUrl);

OpenAIFileClient files = new(key);

OpenAIFile file = await files.UploadFileAsync(
    stream,
    filename,
    FileUploadPurpose.Vision
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart("what's in this image?"),
                ResponseContentPart.CreateInputImagePart(file.Id),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30require "openai"
require "pathname"

client = OpenAI::Client.new
uploaded = client.files.create(
  file: Pathname("image.png"),
  purpose: :vision
)

response = client.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: :user,
      content: [
        {
          type: :input_text,
          text: "What's in this image?"
        },
        {
          type: :input_image,
          detail: :auto,
          file_id: uploaded.id
        }
      ]
    }
  ]
)

puts(response.output_text)

Anforderungen an Bildeingaben

Verwende unterstützte Bilddateien, deren Inhalt für die Analyse durch das Modell deutlich genug erkennbar ist.

Anforderung	Unterstützte Eingaben
Dateitypen	PNG (`.png`), JPEG (`.jpeg` oder `.jpg`), WEBP (`.webp`) und nicht animierte GIFs (`.gif`)
Anfragegröße	Bis zu 512 MB Gesamtnutzdaten pro Anfrage
Bildanzahl	Bis zu 1.500 Bilder pro Anfrage

Bei patchbasierten Bildeingaben unterstützt die API bis zu 30.000 Patches pro Bild, nachdem die Skalierungsregeln für das gewählte Modell und die gewählte detail-Stufe angewendet wurden. Diese Grenze gilt für alle unterstützten Detailstufen und für jedes Bild einzeln, nicht für die Gesamtzahl der Patches in der Anfrage.

Niedrigere Skalierungsbudgets für bestimmte Modelle und Detailstufen gelten weiterhin. Bilder, die nach der Verarbeitung die Grenze von 30.000 Patches überschreiten, werden abgelehnt und nicht automatisch auf diese Grenze verkleinert. Reduziere die Bildabmessungen und versuche es erneut.

Die Bild-Token und der restliche Prompt müssen außerdem innerhalb der Eingabe- und Kontextgrenzen des Modells liegen. Eine Token-Schätzung garantiert nicht, dass eine Anfrage alle Eingabegrenzen einhält. Die Verwendung von Bildern muss unseren Nutzungsrichtlinien entsprechen.

Detailstufe für Bilder wählen

Der Parameter detail steuert die Vorverarbeitung von Bildern. Welche Werte unterstützt werden, hängt vom Modell ab: low, high, original oder auto. Wenn du den Parameter weglässt, wird sowohl in der Responses API als auch in der Chat Completions API standardmäßig auto verwendet. Die Tabelle zur Bildskalierung nach Modell zeigt das jeweilige Verhalten.

1
2
3
4
5{
    "type": "input_image",
    "image_url": "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
    "detail": "original"
}

Orientiere dich bei der Wahl der Detailstufe an den folgenden Hinweisen:

Detailstufe	Am besten geeignet für
`low`	Grobes Bildverständnis. Skalierung und Token-Verbrauch hängen vom Modell ab. `low` verbraucht nicht immer weniger Token als `high`.
`high`	Standardmäßiges, detailgetreues Bildverständnis, wenn keine präzisen Koordinaten im Originalbild benötigt werden.
`original`	Große, inhaltsreiche Bilder, Bilder, bei denen die genaue räumliche Zuordnung wichtig ist, oder Bilder für die Computernutzung, sofern das Modell dies unterstützt.
`auto`	Verwendet die standardmäßige Bildskalierung des Modells, wie in der Tabelle zur Bildskalierung nach Modell angegeben.

Verwende für Aufgaben, die feine visuelle Details oder präzise Koordinaten erfordern, etwa optische Zeichenerkennung (OCR), die Erkennung kleiner Objekte oder Computernutzung, "detail": "original", sofern dies unterstützt wird. Auch bei der Detailstufe Original können Bilder verkleinert werden, um die maximale Seitenlänge oder das Patch-Budget für die Skalierung des Modells einzuhalten. Die separate Ablehnungsgrenze von 30.000 Patches führt dagegen nicht zu einer Skalierung. Wenn es bei einer Aufgabe auf genaue Koordinaten ankommt, verkleinere die Bilder vor dem Senden so, dass sie diese Grenzen einhalten, und rechne die zurückgegebenen Koordinaten auf das Originalbild um. Hinweise zum Umgang mit Koordinaten findest du im Leitfaden zur Computernutzung.

Bildskalierung nach Modell

Die folgende Tabelle fasst zusammen, wie universell einsetzbare Bildverarbeitungsmodelle Bilder skalieren. Für andere Modelle und spezialisierte Varianten können andere Grenzwerte gelten. Bei jeder Skalierung bleibt das Seitenverhältnis erhalten; kleinere Bilder werden nicht vergrößert.

Modellfamilie	Unterstützte Detailstufen	Patches und Bildskalierung
`gpt-6-astra`	`low`, `high`, `original`, `auto`	Bei `low` beträgt die Bildgröße höchstens 512 × 512 Pixel. `high` erlaubt bis zu 2.500 Patches und eine maximale Seitenlänge von 65.535 Pixeln. Beide Grenzwerte gelten. `original` behält die Bildabmessungen bei. Bilder mit mehr als 65.535 Pixeln auf einer Seite werden jedoch so verkleinert, dass sie diesen Grenzwert einhalten. Wenn das resultierende Bild mehr als 30.000 Patches benötigt, lehnt die API die Anfrage ab; das Bild wird nicht verkleinert, um das Patch-Limit einzuhalten. `auto` skaliert Bilder genauso wie `original`.
`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`	`low`, `high`, `original`, `auto`	Bei `low` ist das Bild höchstens 512 × 512 Pixel groß. Bei `high` gelten höchstens 2.048 × 2.048 Pixel und 2.500 Patches. `original` behält die Bildabmessungen bei. Nur Bilder, bei denen eine Seite länger als 65.535 Pixel ist, werden auf diese Grenze verkleinert. Benötigt das resultierende Bild mehr als 30.000 Patches, lehnt die API die Anfrage ab. Das Bild wird nicht auf die Patch-Grenze verkleinert. `auto` verwendet dieselbe Bildskalierung wie `original`.
`gpt-5.5`	`low`, `high`, `original`, `auto`	Bei `low` ist das Bild höchstens 512 × 512 Pixel groß. `high` erlaubt bis zu 2.500 Patches und eine maximale Seitenlänge von 2.048 Pixeln. `original` erlaubt bis zu 10.000 Patches und eine maximale Seitenlänge von 6.000 Pixeln. Beide Grenzen gelten. `auto` verwendet dieselbe Bildskalierung wie `original`.
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`	`low`, `high`, `original`, `auto`	Bei `low` gelten eine maximale Seitenlänge von 2.048 Pixeln und ein Budget von 6.144 Patches. Daher kann diese Stufe mehr Token verbrauchen als `high`. `high` erlaubt bis zu 2.500 Patches und eine maximale Seitenlänge von 2.048 Pixeln. `original` erlaubt bis zu 10.000 Patches und eine maximale Seitenlänge von 6.000 Pixeln. Beide Grenzen gelten. `auto` verwendet dieselbe Bildskalierung wie `high`.
`gpt-5.2`, `gpt-4.1-mini`	`low`, `high`, `auto`	Für diese Detailstufen gelten dieselben Skalierungsgrenzen: eine maximale Seitenlänge von 2.048 Pixeln und ein Budget von 6.144 Patches. `original` wird nicht unterstützt.
`gpt-5.1`, `gpt-4.1`, `gpt-4o`, `gpt-4o-mini`	`low`, `high`, `auto`	`low` verwendet eine feste Token-Anzahl. `high` und `auto` verwenden die kachelbasierten Skalierungsregeln.

Kosten berechnen

Modelle mit Bildverständnis wandeln Bildeingaben in abrechenbare Eingabe-Token um. Der Kostenrechner für Bildeingaben und die Patch- und Kachelregeln in diesem Abschnitt gelten für Eingaben dieser Modelle, nicht für die Bildgenerierung oder -bearbeitung mit GPT Image. Die dafür geltenden separaten Preise findest du unter Eingaben für GPT Image-Modelle.

Bild-Token werden auch auf deine Grenzen für Token pro Minute (TPM) angerechnet. Der Rechner schätzt die Kosten für ein einzelnes Bild zu den Standardpreisen für Eingaben. Den restlichen Prompt und die Modellausgabe berücksichtigt er nicht.

Kostenrechner für Bildeingaben

Mit dem Kostenrechner für Bildeingaben kannst du die Eingabe-Token und Kosten für ein einzelnes Bild anhand von Modell, Bildgröße und Detailstufe schätzen.

Patchbasierte Bildtokenisierung

Einige Modelle tokenisieren Bilder, indem sie diese mit Patches von 32 × 32 Pixeln abdecken. Für viele Kombinationen aus Modell und Detailstufe ist ein Patch-Budget für die Skalierung festgelegt. Zunächst passt die API das Bild an die maximale Seitenlänge der gewählten Detailstufe an. Dabei bleibt das Seitenverhältnis erhalten, die Abmessungen werden auf ganze Pixel gerundet und kleinere Bilder werden nicht vergrößert. Anschließend wird der Token-Verbrauch wie folgt ermittelt:

A. Berechne, wie viele Patches von 32 × 32 Pixeln benötigt werden, um das Bild nach Anwendung der maximalen Seitenlänge abzudecken. Ein Patch darf über den Bildrand hinausragen.

patch_count = ceil(width/32)×ceil(height/32)

B. Wenn für das gewählte Modell und die Detailstufe ein Patch-Budget für die Skalierung festgelegt ist, verkleinere das Bild proportional, falls es dieses Budget überschreitet. Andernfalls überspringe diesen Schritt. Passe den Skalierungsfaktor so an, dass das Budget auch nach der Umrechnung in ganzzahlige Pixelabmessungen und der Berechnung der benötigten Patches eingehalten wird. Behalte bis zur Berechnung der endgültigen Abmessungen die volle Genauigkeit bei.

shrink_factor = sqrt((32^2 * patch_budget) / (width * height))
adjusted_shrink_factor = shrink_factor * min(
  floor(width * shrink_factor / 32) / (width * shrink_factor / 32),
  floor(height * shrink_factor / 32) / (height * shrink_factor / 32)
)

C. Wenn das Bild in Schritt B skaliert wurde, runde die endgültige skalierte Breite und Höhe auf ganze Pixel ab. Berechne die Anzahl der Patches, die zur Abdeckung des resultierenden Bildes benötigt werden. Dies ist die Anzahl der Bild-Token vor Anwendung des Modellmultiplikators. Wenn ein Patch-Budget gilt, bleibt diese Anzahl innerhalb des Budgets.

resized_patch_count = ceil(resized_width/32)×ceil(resized_height/32)

Überschreitet diese Anzahl 30.000 Patches, lehnt die API die Anfrage ab. Prüfe diese Grenze, bevor du den Token-Multiplikator anwendest.

D. Multipliziere die Patch-Anzahl mit dem Multiplikator des Modells und runde auf, um die abrechenbaren Bildeingabe-Token zu erhalten. Wende den Eingabepreis des Modells einmal auf diese Token an. Der Multiplikator gilt weder für andere Prompt-Token noch erneut für den Preis.

Modell	Multiplikator
`gpt-6-astra`	1,2
`gpt-5.6-sol`	1,2
`gpt-5.6-terra`	1,2
`gpt-5.6-luna`	1,2
`gpt-5.5`	1,2
`gpt-5.4`	1,2
`gpt-5.4-mini`	1,2
`gpt-5.4-nano`	1,2
`gpt-5.2`	1,2
`gpt-5-mini`*	1,2
`gpt-5-nano`*	1,5
`gpt-4.1-mini`	1,62
`gpt-4.1-nano`* (Snapshot vom 14.04.2025)	2,46
`o4-mini`*	1,72

Bei gpt-4.1-mini gilt dies für den Snapshot vom 14.04.2025.

* Veraltet und zur Abschaltung vorgesehen. Termine und Ersatzmodelle findest du im Zeitplan für die Einstellung. Diese Modelle sind weder im Rechner noch in der obigen Tabelle zur Größenanpassung enthalten.

Beispiele zur Berechnung von Bild-Token für gpt-6-astra mit detail: high

Für diese Kombination gelten eine maximale Seitenlänge von 65.535 Pixeln, ein Budget von 2.500 Patches und ein Multiplikator von 1,2.

Ein Bild mit 1024 × 1024 Pixeln benötigt 32 × 32 = 1024 Patches. Eine Größenanpassung ist nicht nötig. Für die Bildeingabe werden ceil(1024 × 1.2) = 1229 Token abgerechnet.
Ein Bild mit 2048 × 2048 Pixeln benötigt zunächst 64 × 64 = 4096 Patches. Aufgrund des Patch-Budgets wird es auf 1600 × 1600 Pixel verkleinert, was 50 × 50 = 2500 Patches entspricht. Die Schätzung beträgt ceil(2500 × 1.2) = 3000 Token.
Ein Bild mit 4096 × 512 Pixeln behält seine ursprüngliche Größe: 128 × 16 = 2048 Patches und ceil(2048 × 1.2) = 2458 Token.

Durch die Rundung von Gleitkommazahlen bei der Abrechnung kann die endgültige Anzahl um ein Token von der Schätzung abweichen.

Kachelbasierte Bildtokenisierung

Die Modelle in dieser Tabelle verwenden eine Basisanzahl an Token zuzüglich Token für Bildkacheln:

Modell	Basis-Token	Token pro Kachel
`gpt-5.1`	70	140
`gpt-5`*	70	140
`gpt-4o`, `gpt-4.1`	85	170
`gpt-4o-mini`	2.833	5.667
`o1`, `o1-pro`, `o3`*	75	150

Mit "detail": "low" fallen für ein Bild unabhängig von seinen Abmessungen nur die Basis-Token des Modells an. Mit "detail": "high" oder "detail": "auto" gilt:

Verkleinere das Bild unter Beibehaltung des Seitenverhältnisses so, dass es in ein Quadrat mit 2048 × 2048 Pixeln passt. Kleinere Bilder werden nicht vergrößert.
Wenn die kürzere Seite länger als 768 Pixel ist, verkleinere sie auf 768 Pixel und runde die andere Seitenlänge ab.
Zähle die Quadrate mit 512 Pixeln Seitenlänge, die zum Abdecken des Bildes nötig sind. Für jedes Quadrat fällt die modellspezifische Anzahl an Token pro Kachel an.
Addiere die Basis-Token des Modells zu den Token für die Kacheln.

Eingaben für GPT Image-Modelle

Für GPT Image-Modelle gelten separate Preise für Bild-Token bei der Generierung und Bearbeitung. Der Rechner für Bildanalyse schätzt ihre Eingabe- oder Ausgabekosten nicht. Aktuelle Preise findest du unter Preise für Bildgenerierung. Arbeitsabläufe für die Generierung und Bearbeitung findest du im Leitfaden zur Bildgenerierung.

GPT Image 1

Die folgenden Regeln für Eingabe-Token gelten für gpt-image-1. Verwende die kachelbasierte Größenanpassung, verkleinere die kürzere Seite aber auf 512 statt auf 768 Pixel. Der Tokenverbrauch hängt von den Bildabmessungen und dem Parameter input_fidelity in der Images API ab.

Bei niedriger Eingabetreue betragen die Basiskosten 65 Bild-Token. Jede Kachel kostet 129 Bild-Token. Bei hoher Eingabetreue addieren wir zu den oben beschriebenen Bild-Token eine feste Anzahl an Token, die vom Seitenverhältnis des Bildes abhängt.

Wenn dein Bild quadratisch ist, addieren wir 4.160 zusätzliche Bild-Eingabe-Token.
Wenn es eher einem Hoch- oder Querformat entspricht, addieren wir 6.240 zusätzliche Token.

Die Preise für Bild-Eingabe-Token findest du im Abschnitt zu Bildpreisen.

Einschränkungen

Modelle mit Bildverarbeitung können Fehler machen. Berücksichtige bei der Entwicklung deiner Anwendung diese Einschränkungen:

Medizinische Bilder: Das Modell eignet sich nicht zur Interpretation spezieller medizinischer Bilder wie CT-Aufnahmen und sollte nicht für medizinische Beratung verwendet werden.
Nicht englischsprachige Inhalte: Bei Bildern mit Text in nicht lateinischen Schriftsystemen, etwa Japanisch oder Koreanisch, liefert das Modell möglicherweise keine optimalen Ergebnisse.
Kleine Schrift: Vergrößere den Text im Bild, um die Lesbarkeit zu verbessern. Wenn verfügbar, kann auch "detail": "original" die Ergebnisse verbessern.
Drehung: Das Modell kann gedrehte oder auf dem Kopf stehende Texte und Bilder falsch interpretieren.
Visuelle Elemente: Das Modell kann Schwierigkeiten haben, Diagramme oder Texte mit unterschiedlichen Farben oder Darstellungsstilen zu verstehen, etwa mit durchgezogenen, gestrichelten oder gepunkteten Linien.
Räumliches Denken: Das Modell hat Schwierigkeiten mit Aufgaben, die eine präzise räumliche Zuordnung erfordern, etwa dem Erkennen von Schachstellungen.
Genauigkeit: Das Modell kann in bestimmten Situationen falsche Beschreibungen oder Bildunterschriften erzeugen.
Bildform: Das Modell hat Schwierigkeiten mit Panorama- und Fischaugenbildern.
Metadaten und Größenanpassung: Das Modell verarbeitet weder ursprüngliche Dateinamen noch Metadaten. Bilder können vor der Analyse in ihrer Größe angepasst werden, auch bei der Detailstufe original. Die für jedes Modell geltenden Grenzen findest du unter Größenanpassung nach Modell.
Zählen: Das Modell gibt die Anzahl von Objekten in Bildern möglicherweise nur näherungsweise an.
CAPTCHAs: Aus Sicherheitsgründen blockiert unser System die Übermittlung von CAPTCHAs.

Vorschläge

Erste Schritte

Grundlegende Konzepte

SDKs und CLI

Ressourcen

Ältere APIs

Modell auswählen

Text und Code

Prompts formulieren

Reasoning-Aufwand

Bilder und Video

Echtzeit und Audio

Spezialisierte Modelle

Agents API

Agents SDK

ChatKit

Suche und Informationsabruf

Tools und Daten anbinden

Arbeitsabläufe mit Tools erstellen

Computer und Code

Medien

GPT-Live

Realtime API

Anwendungen mit Sprachfunktionen entwickeln

Verbindungen

Audioverarbeitung

In Produktion gehen

Leistung und Qualität

Kosten und Durchsatz

Sicherheit und Governance

Infrastruktur und Zugriff

Betrieb

Grundlegende Konzepte

Plan

Build

Test and publish

Conversion specs

Leitfäden

Ressourcen

Erste Schritte

Leitfäden

File Upload

API

Measurement

Advertiser API

API-Referenz

Erste Schritte

Grundlagen

Entdecken

Verfügbar auf

Versionen

Arbeitsabläufe

Funktionen

Referenz

Anpassung

Konfigurationsdatei

Agentenkonfiguration

ChatGPT und Codex erweitern

Linux

Windows

Arbeitsabläufe für die Entwicklung

Erweitern und automatisieren

Umgebungen

Mit Codex entwickeln

Integrationen von Drittanbietern

Referenz

Berechtigungen

Codex Security

Cybersicherheit

Erste Schritte

ChatGPT Work

Identität und Authentifizierung

Workspace-Zugriff, Richtlinien und Modelle

Kontrollen für Plug-ins und Konnektoren

Nutzung, Governance und Compliance

Bereitstellung und Modellanbieter

Community

Blog

Community

Blog