> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bettertoken.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Gemini API zur Bildbearbeitung

> Bearbeite Nano-Banana-Bilder über die Gemini API von BetterToken. Sende Referenzbilder und Anweisungen, teste Anfragen online und lies die erzeugten Bilddaten aus.

export const GeminiImageInput = ({labels}) => {
  const [images, setImages] = useState([]);
  const [busy, setBusy] = useState(false);
  const [feedback, setFeedback] = useState("");
  const selection = useRef(0);
  const inputId = useId();
  const readImages = async event => {
    const version = ++selection.current;
    const files = Array.from(event.target.files || []);
    setImages([]);
    setFeedback("");
    if (files.some(file => !["image/png", "image/jpeg"].includes(file.type))) {
      setFeedback(labels[4]);
      setBusy(false);
      return;
    }
    setBusy(true);
    try {
      const next = await Promise.all(files.map(file => new Promise((resolve, reject) => {
        const reader = new FileReader();
        reader.onload = () => resolve({
          name: file.name,
          type: file.type,
          data: String(reader.result).split(",")[1]
        });
        reader.onerror = reject;
        reader.onabort = reject;
        reader.readAsDataURL(file);
      })));
      if (version === selection.current) setImages(next);
    } catch {
      if (version === selection.current) setFeedback(labels[5]);
    } finally {
      if (version === selection.current) setBusy(false);
    }
  };
  const copy = async value => {
    try {
      await navigator.clipboard.writeText(value);
      setFeedback(labels[2]);
    } catch {
      setFeedback(labels[3]);
    }
  };
  return <section className="bt-gemini-input not-prose" aria-label={labels[0]}>
      <label htmlFor={inputId}>{labels[0]}</label>
      <input id={inputId} type="file" accept="image/png,image/jpeg" multiple onChange={readImages} />
      <p>{labels[7]}</p>
      <p role="status" aria-live="polite">{busy ? labels[6] : feedback}</p>
      {images.map((image, index) => <div key={index} className="bt-gemini-input-image">
          <div className="bt-gemini-input-header">
            <img src={"data:" + image.type + ";base64," + image.data} alt={image.name} />
            <span>{image.name}</span>
            <code>{image.type}</code>
            <button type="button" title={labels[1]} aria-label={labels[1] + " " + image.name} onClick={() => copy(image.data)}><Icon icon="copy" size={16} /></button>
          </div>
          <textarea aria-label={labels[1] + " " + image.name} rows={3} readOnly value={image.data} spellCheck={false} />
        </div>)}
    </section>;
};

Sende ein Referenzbild und eine Anweisung an Nano Banana Pro, 2 oder 2.1, um ein bearbeitetes Bild zu erhalten.

`POST /v1beta/models/{model}:generateContent`

Textgenerierung und Bildbearbeitung nutzen denselben Endpunkt. Bei der Bearbeitung wird ein Referenzbild zur Anfrage hinzugefügt.

## Referenzbilder vorbereiten

Sende Text und jedes Bild in eigenen Elementen. `inlineData.data` enthält base64 ohne Data-URL-Präfix. Nutze PNG- oder JPEG-Referenzen; dieser Endpunkt akzeptiert JSON, kein multipart und keine Bild-URLs.

Ersetze vor dem Senden `REPLACE_WITH_IMAGE_BASE64` durch Base64 deines Bildes und passe `inlineData.mimeType` an die Datei an. Die Beispielanweisung beschreibt eine Tasse; ändere sie bei einem anderen Motiv ebenfalls.

<GeminiImageInput labels={["Referenzbilder","base64 kopieren","Kopiert","Markiere und kopiere den base64-Text unten.","Wähle PNG- oder JPEG-Bilder.","Bild konnte nicht gelesen werden. Wähle es erneut.","Bilder werden vorbereitet...","Die Bilder werden lokal umgewandelt. Ersetze im Playground inlineData.data durch den kopierten base64-Text und trage den angezeigten MIME-Typ unter inlineData.mimeType ein. Nutze für jedes weitere Bild ein eigenes Element."]} />

## Anfrage testen

Bereite zuerst das Referenzbild vor. Trage BetterToken API Key unter **x-goog-api-key** ein und wähle **model**. Ergänze in **contents** die Anweisung und Bilddaten. Prüfe, ob `inlineData.data` ersetzt wurde und `inlineData.mimeType` zur Datei passt, und klicke dann auf **Send**.

<Note>
  Ein Klick auf **Send** sendet eine echte Generierungsanfrage, die Kosten verursachen kann. Warte auf die synchrone Antwort. Prüfe nach einem Timeout oder Verbindungsabbruch Verbrauch und Ergebnis, bevor du die Anfrage erneut sendest.
</Note>

Alle drei bieten `1K`, `2K` und `4K`. Nano Banana 2 und 2.1 unterstützen 14 Seitenverhältnisse, Pro unterstützt 10. `X-BetterToken-Max-Images` begrenzt gelieferte und berechnete Bilder, garantiert aber keine Anzahl. [Seitenverhältnisse](/de/api-reference/nano-banana#aspect-ratios)

<Warning>
  Die BetterToken API unterstützt keine Bildgenerierung mit Suche, einschließlich Google Web Search und Image Search grounding. Füge keine Suchwerkzeuge hinzu.
</Warning>

Nutze `generateContent` ohne Streaming. Files / `fileData`, Batch, Interactions und Streaming werden hier nicht unterstützt.

## Antwort lesen

Bilder stehen in `candidates[].content.parts[].inlineData`. Durchlaufe die Elemente, überspringe `thought: true`, dekodiere `data` und wähle die Dateiendung anhand von `mimeType`. Das Bild ist nicht immer das erste Element oder eine PNG-Datei.

## Weitere Anleitungen

* [Text zu Bild](/de/api-reference/gemini-images-generations)
* [SDK, Bildspeicherung und Folgeänderungen](/de/api-reference/nano-banana)
* [Modellübersicht](/de/model-updates/nano-banana)
* <a href={"https://bettertoken.ai/pricing"}>Modellkatalog</a>


## OpenAPI

````yaml api-reference/gemini-images-edits.de.json POST /v1beta/models/{model}:generateContent
openapi: 3.1.0
info:
  title: Gemini API zur Bildbearbeitung
  description: >-
    Bearbeite Nano-Banana-Bilder über die Gemini API von BetterToken. Sende
    Referenzbilder und Anweisungen, teste Anfragen online und lies die erzeugten
    Bilddaten aus.
  version: 1.0.0
servers:
  - url: https://bettertoken.ai
security:
  - geminiApiKey: []
paths:
  /v1beta/models/{model}:generateContent:
    post:
      summary: Gemini API zur Bildbearbeitung
      description: >-
        Sende ein Referenzbild und eine Anweisung an Nano Banana Pro, 2 oder
        2.1, um ein bearbeitetes Bild zu erhalten. Die BetterToken API
        unterstützt keine Bildgenerierung mit Suche, einschließlich Google Web
        Search und Image Search grounding. Füge keine Suchwerkzeuge hinzu.
      operationId: editGeminiImage_de
      parameters:
        - name: model
          in: path
          required: true
          description: BetterToken Model ID. Wähle eines der drei Nano-Banana-Modelle.
          schema:
            type: string
            enum:
              - nano-banana-pro
              - nano-banana-2
              - nano-banana-2.1
            default: nano-banana-2.1
        - name: X-BetterToken-Max-Images
          in: header
          description: >-
            Höchstzahl gelieferter und berechneter Bilder, keine garantierte
            Anzahl. Standard: 1.
          schema:
            type: integer
            minimum: 1
            maximum: 4
            default: 1
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - contents
              properties:
                contents:
                  type: array
                  description: >-
                    Verlauf. Bewahre den vollständigen Modell-content und
                    thoughtSignature für Folgeänderungen auf.
                  minItems: 1
                  items:
                    type: object
                    required:
                      - parts
                    properties:
                      role:
                        type: string
                        description: >-
                          user für neue Anfragen; model für frühere
                          Modellantworten im Verlauf.
                        enum:
                          - user
                          - model
                        default: user
                      parts:
                        type: array
                        description: >-
                          Text und Bilder. Sende text und inlineData als eigene
                          Elemente.
                        minItems: 1
                        items:
                          anyOf:
                            - type: object
                              required:
                                - text
                              properties:
                                text:
                                  type: string
                                  description: Bildbeschreibung oder Bearbeitungsanweisung.
                                  example: >-
                                    Ändere die Tasse in Rot. Behalte Form,
                                    Hintergrund und Beleuchtung bei.
                              additionalProperties: true
                            - type: object
                              required:
                                - inlineData
                              properties:
                                inlineData:
                                  type: object
                                  description: In base64 eingebettetes Referenzbild.
                                  required:
                                    - mimeType
                                    - data
                                  properties:
                                    mimeType:
                                      type: string
                                      description: MIME-Typ des Referenzbildes.
                                      enum:
                                        - image/png
                                        - image/jpeg
                                      example: image/png
                                    data:
                                      type: string
                                      description: >-
                                        Ursprüngliche Bildbytes als Base64 ohne
                                        Data-URL-Präfix. Ersetze vor dem Senden
                                        REPLACE_WITH_IMAGE_BASE64 durch Daten
                                        deines eigenen PNG- oder JPEG-Bildes.
                                      contentEncoding: base64
                                      example: REPLACE_WITH_IMAGE_BASE64
                                  additionalProperties: false
                              additionalProperties: true
                    additionalProperties: false
                generationConfig:
                  type: object
                  description: Einstellungen zur Bildgenerierung.
                  properties:
                    responseModalities:
                      type: array
                      description: Fordere ausdrücklich Bildausgabe an.
                      items:
                        type: string
                        enum:
                          - IMAGE
                      default:
                        - IMAGE
                    candidateCount:
                      type: integer
                      enum:
                        - 1
                      default: 1
                      description: >-
                        Weglassen oder Ganzzahl 1 verwenden. Kein n auf
                        Wurzelebene.
                    imageConfig:
                      type: object
                      description: Einstellungen des Ausgabebildes.
                      properties:
                        imageSize:
                          type: string
                          description: Auflösung. Großes K verwenden.
                          enum:
                            - 1K
                            - 2K
                            - 4K
                          default: 1K
                        aspectRatio:
                          type: string
                          description: >-
                            Seitenverhältnis. Pro unterstützt 10; 2 und 2.1 auch
                            1:4, 4:1, 1:8 und 8:1.
                          enum:
                            - '1:1'
                            - '1:4'
                            - '1:8'
                            - '2:3'
                            - '3:2'
                            - '3:4'
                            - '4:1'
                            - '4:3'
                            - '4:5'
                            - '5:4'
                            - '8:1'
                            - '9:16'
                            - '16:9'
                            - '21:9'
                          default: '1:1'
                      additionalProperties: false
                  additionalProperties: false
              additionalProperties: false
            example:
              contents:
                - role: user
                  parts:
                    - text: >-
                        Ändere die Tasse in Rot. Behalte Form, Hintergrund und
                        Beleuchtung bei.
                    - inlineData:
                        mimeType: image/png
                        data: REPLACE_WITH_IMAGE_BASE64
              generationConfig:
                responseModalities:
                  - IMAGE
                candidateCount: 1
                imageConfig:
                  imageSize: 1K
                  aspectRatio: '1:1'
      responses:
        '200':
          description: Ergebnis. Prüfe finale Bildteile und finishReason.
          content:
            application/json:
              schema:
                type: object
                properties:
                  candidates:
                    type: array
                    items:
                      type: object
                      properties:
                        content:
                          type: object
                          properties:
                            role:
                              type: string
                            parts:
                              type: array
                              items:
                                type: object
                                properties:
                                  text:
                                    type: string
                                  thought:
                                    type: boolean
                                  thoughtSignature:
                                    type: string
                                  inlineData:
                                    type: object
                                    properties:
                                      mimeType:
                                        type: string
                                      data:
                                        type: string
                                        contentEncoding: base64
                        finishReason:
                          type: string
                  promptFeedback:
                    type: object
                    additionalProperties: true
                  usageMetadata:
                    type: object
                    additionalProperties: true
              example:
                candidates:
                  - content:
                      role: model
                      parts:
                        - inlineData:
                            mimeType: image/png
                            data: BASE64_IMAGE_DATA
                    finishReason: STOP
        '400':
          description: Ungültige Parameter oder nicht unterstützte Funktion.
        '401':
          description: API Key fehlt oder ist ungültig.
        '402':
          description: Guthaben reicht nicht aus.
        '429':
          description: Anfragelimit oder ausgelasteter Dienst.
        '500':
          description: Generierungsfehler. Prüfe das Ergebnis vor einem neuen Versuch.
components:
  securitySchemes:
    geminiApiKey:
      type: apiKey
      in: header
      name: x-goog-api-key
      description: BetterToken API Key.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.