|

Nano Banana Pro Fehlermeldung Unsupported file URI type Vollständige Fehlerbehebung: 5 Hauptursachen und eine Komplettlösung

VonAPIYI - Stable and affordable AI API

Kürzlich meldete ein Kunde bei der Verwendung von Nano Banana Pro (Modell-ID: gemini-3-pro-image-preview) für die Bilderzeugung einen "Google-typischen" 400-Fehler:

{
  "status_code": 400,
  "error": {
    "message": "Unsupported file URI type: {{ $json.imageUrls }}. File URI must be a File API (e.g. https://generativelanguage.googleapis.com/files/<id>), Youtube (e.g. https://www.youtube.com/watch?v=<id>), or HTTPS (e.g. http://path/to/file).), or a valid gURI (e.g. gs://bucket/object",
    "type": "",
    "code": 400
  }
}

Diese Nano Banana Pro Fehlermeldung zeigt direkt auf den "Täter": Unsupported file URI type: {{ $json.imageUrls }}. Beachten Sie, dass {{ $json.imageUrls }} eine nicht aufgelöste n8n-Template-Variable ist. Das bedeutet, der Kunde hat im Workflow einen dynamischen Ausdruck verwendet, der jedoch nicht von der Engine in eine echte URL umgewandelt wurde. Stattdessen wurde er als reiner String in das Feld fileUri der Gemini-API eingefügt. Google kann mit einem URI, der wie {{ ... }} aussieht, nichts anfangen und lehnt die Anfrage ab.

Basierend auf diesem Fehler und den offiziellen Google-Dokumenten zu den Anforderungen für gemini-3-pro-image-preview analysieren wir hier die 5 häufigsten Szenarien und bieten für jedes eine Lösung. Nach dem Lesen können Sie jeden Fehler vom Typ Unsupported file URI type innerhalb von 5 Minuten lokalisieren und beheben.

nano-banana-pro-unsupported-file-uri-type-error-fix-de 图示

Nano Banana Pro: Übersicht der Fehlerinformationen

Bevor wir den Code anpassen, fassen wir die wichtigsten Fakten zur Fehlermeldung und die offiziellen Anforderungen an die Eingabe-URI zusammen.

Dimension Wichtiger Fakt
Modell-ID gemini-3-pro-image-preview (offizieller Name von Nano Banana Pro in der Gemini-API)
HTTP-Status 400 (Bad Request, Fehler in den Client-Parametern)
Fehlerfeld Unsupported file URI type
Ursache Feld fileData.fileUri im Request-Body
Literal im Fehler {{ $json.imageUrls }} (nicht aufgelöster n8n-Ausdruck)
Akzeptierte URI-Typen File API URI / YouTube URL / öffentliche HTTPS-URL / GCS gs:// URI
Akzeptierte Bildformate JPEG, JPG, PNG, WEBP, HEIF
Externe URLs unterstützt? ✅ Ja (Gemini 2.5+ unterstützt nativ öffentliche HTTPS- / signierte URLs)
Hauptursache Nicht aufgelöste Template-Variablen in Low-Code-Workflows (n8n, Make, Zapier)

🎯 Tipp zur Fehlersuche: Wenn der Kunde den vollständigen Request-Body nicht teilen möchte, lassen Sie ihn einen erfolgreichen Aufruf im APIYI-Kontrollzentrum (apiyi.com) mit demselben Modell und demselben Referenzbild durchführen. Vergleichen Sie dann den Body der erfolgreichen Anfrage mit der fehlerhaften. Dies ist der schnellste Weg, um die Nano Banana Pro Fehlermeldung zu isolieren.

Die 5 Hauptursachen für den Fehler "Unsupported file URI type" bei Nano Banana Pro

Nach der Kategorisierung aller realen Fälle lässt sich die Fehlermeldung Unsupported file URI type auf 5 typische Ursachen zurückführen. Wir haben sie nach ihrer Häufigkeit sortiert.

Ursache 1: Template-Variablen in n8n / Make / Zapier wurden nicht gerendert

Dies ist der Hauptverdächtige für diesen spezifischen Fehler. {{ $json.imageUrls }} ist eine n8n-Ausdruckssyntax, die normalerweise vor der Ausführung durch die tatsächliche URL aus dem vorherigen Knoten ersetzt werden sollte, z. B. https://cdn.example.com/uploads/abc.jpg. Es gibt jedoch einige typische Szenarien, in denen diese Ersetzung fehlschlägt:

  1. Das Feld "Body" des HTTP-Request-Knotens steht nicht im "Expression"-Modus, sondern im "Fixed"-Modus, wodurch das gesamte JSON als reiner Text-String gesendet wird.
  2. Der JSON-Body verwendet doppelte Anführungszeichen, wodurch n8n fälschlicherweise annimmt, der Ausdruck sei Teil des String-Inhalts, und das Rendern überspringt.
  3. Die Ausgabestruktur des vorherigen Knotens stimmt nicht mit dem Pfad überein – zum Beispiel gibt der vorherige Knoten imageUrl (Singular) aus, Sie haben aber $json.imageUrls (Plural) geschrieben. Nach dem Scheitern der Auflösung gibt n8n den Ausdruck als Originaltext zurück.
  4. Ausdrücke in Sub-Nodes iterieren nicht über Items, sondern greifen fest auf das erste Element zu. Bei bestimmten Eingaben wird dies zu undefined, was nach der Serialisierung als String zum Originaltext wird.

Diagnose: Wenn Sie in der Gemini-Fehlermeldung {{ ... }} sehen, handelt es sich zu 100 % um dieses Problem, da eine gültige URL niemals so aussieht.

Ursache 2: Tippfehler im Feldnamen führen zu undefined / null

Dicht gefolgt von Problemen mit Feldnamen. In Kundencode kommt häufig Folgendes vor:

// Das Upstream-Interface gibt tatsächlich das Feld imageUrl (Singular) zurück
const upstream = { imageUrl: "https://cdn.example.com/a.jpg" };

// Aber im Downstream wurde imageUrls (Plural, mit s) geschrieben
fileUri: upstream.imageUrls   // Ergebnis ist undefined

undefined wird bei der JSON-Serialisierung oder String-Verkettung zum String "undefined". Gemini kann dies ebenfalls nicht erkennen und wirft einen 400er-Fehler, der fast identisch mit dem Fehler bei nicht gerenderten Template-Variablen ist. Der Unterschied besteht darin, dass das Literal undefined statt {{ ... }} in der Fehlermeldung erscheint.

Ursache 3: Ein Array wurde als String an fileUri übergeben

Diese dritte Ursache tritt häufig in Szenarien auf, in denen "mehrere Bilder gleichzeitig verarbeitet" werden. Das Feld fileData.fileUri der Gemini API akzeptiert nur einen einzelnen String, kein Array. Viele Entwickler schreiben jedoch:

// ❌ Fehler: Array direkt in fileUri eingefügt
{
  "fileData": {
    "fileUri": ["https://cdn.example.com/a.jpg", "https://cdn.example.com/b.jpg"],
    "mimeType": "image/jpeg"
  }
}

Nach der JSON-Serialisierung wird das Feld fileUri zu einem String wie ["https://...", "https://..."]. Gemini kann dies nicht parsen und meldet direkt Unsupported file URI type. Der richtige Weg ist, für jedes Bild ein separates parts-Element zu erstellen, anstatt ein Array in ein einzelnes fileUri-Feld zu stopfen.

Ursache 4: URL-Protokoll oder Pfadformat wird nicht unterstützt

Das vierte Problem betrifft "Formatabweichungen". Die Gemini API akzeptiert nur 4 Arten von URIs; jede Abweichung löst denselben Fehler aus:

URI-Typ Beispiel Akzeptiert von gemini-3-pro-image-preview
File API Pfad https://generativelanguage.googleapis.com/files/abc123 ✅
YouTube URL https://www.youtube.com/watch?v=xxxxx ✅ (hauptsächlich für Videoverständnis)
Öffentliche HTTPS URL https://cdn.example.com/img.jpg ✅ (nativ ab Gemini 2.5+)
GCS gs:// URI gs://my-bucket/img.jpg ✅ (Vertex AI Pfad)
http:// Klartext http://cdn.example.com/img.jpg ⚠️ Teilweise abgelehnt, Upgrade auf HTTPS empfohlen
file:// lokaler Pfad file:///Users/me/a.jpg ❌
data:image/...;base64, base64 dataURL ❌ (sollte in inlineData platziert werden)
Pre-signed S3 URL https://bucket.s3.amazonaws.com/...?X-Amz-... ✅
Azure SAS URL https://account.blob.core.windows.net/...?sv=... ✅

Wenn Sie lokale Dateipfade, Base64-Strings mit data:-Präfix oder private interne URLs in fileUri einfügen, wird ausnahmslos der Nano Banana Pro-Fehler ausgelöst.

Ursache 5: URL ist erreichbar, erfordert aber Authentifizierung oder liefert kein Bild

Die letzte Kategorie ist: "Die URL sieht korrekt aus, aber Gemini kann den Inhalt nicht abrufen". Häufige Fälle:

  • Private OSS / Qiniu / Cloudinary-Links ohne öffentliche Berechtigung führen zu einem 403-Fehler bei Gemini.
  • Temporäre Signatur-URLs sind abgelaufen.
  • Die URL liefert kein Bild, sondern eine HTML-Seite (z. B. eine "Freigabeseite" eines Bildhosters statt eines Direktlinks).
  • Die URL leitet auf eine Anmeldeseite um.
  • Der MIME-Typ stimmt nicht mit dem Feld mimeType überein.

Solche Probleme werden manchmal ebenfalls als Unsupported file URI type gemeldet, manchmal aber auch als 400 Invalid or unsupported file uri. Die Lösung ist in beiden Fällen gleich: Besuchen Sie die URL direkt in einem Inkognito-Fenster Ihres Browsers und prüfen Sie, ob Sie ein gültiges Bild herunterladen können. Das ist der einfachste und effektivste Weg.

nano-banana-pro-unsupported-file-uri-type-error-fix-de 图示

Minimale Reproduktion und Sofortlösung für Nano Banana Pro-Fehler

Nachdem wir die 5 Hauptursachen durchgegangen sind, finden Sie hier für jedes Szenario den minimalen reproduzierbaren Code sowie die korrigierte Version. Sie können diese direkt in Ihren Workflow oder Ihr Backend kopieren und anpassen.

Korrektur 1: Korrekte Übergabe des Parameters imageUrls in n8n

Wenn bei der Nano Banana Pro-Fehlermeldung der HTTP Request-Node in n8n verwendet wird, sollte die korrekte Konfiguration wie folgt aussehen:

Konfiguration des HTTP Request-Nodes:

  • Methode: POST
  • URL: https://api.apiyi.com/v1/messages (ersetzen Sie dies durch Ihre APIYI-Weiterleitungsadresse)
  • Authentifizierung: Header Auth (fügen Sie Ihren API-Schlüssel ein)
  • Body Content Type: JSON
  • Specify Body: Wählen Sie Using JSON (statt Using Fields)
  • JSON Body (Achtung: Der gesamte JSON-Block muss im Ausdrucksmodus sein, d. h. der lila „fx“-Button auf der linken Seite muss aktiviert sein):
={
  "model": "gemini-3-pro-image-preview",
  "contents": [
    {
      "parts": [
        { "text": "Verwandle dieses Bild in den Stil von Hayao Miyazaki" },
        {
          "fileData": {
            "fileUri": "{{ $json.imageUrls }}",
            "mimeType": "image/jpeg"
          }
        }
      ]
    }
  ]
}

Es gibt 3 entscheidende Punkte:

  1. Der JSON-String muss mit einem = beginnen, um n8n mitzuteilen, dass es sich um einen Ausdruck handelt, der ausgewertet werden muss;
  2. "{{ $json.imageUrls }}" muss von Anführungszeichen umschlossen sein, damit der innere {{ }}-Teil durch den tatsächlichen String ersetzt wird;
  3. Der vorherige Node muss tatsächlich ein Feld namens imageUrls ausgeben. Falls er imageUrl (Singular) oder image_url ausgibt, müssen Sie den Feldnamen entsprechend anpassen.

Sobald diese 3 Punkte erfüllt sind, verschwindet der Fehler Unsupported file URI type sofort.

Korrektur 2: Vermeidung von Tippfehlern bei Feldnamen in Python / Node.js

Wenn Sie Backend-Code verwenden, empfiehlt es sich, eine Eingabevalidierung hinzuzufügen, um Tippfehler zu erkennen, bevor die Anfrage an Gemini gesendet wird:

import requests

def call_nano_banana_pro(prompt: str, image_url: str):
    # Defensive Prüfung: Abfangen von None / leeren Strings / Template-Strings vor dem Request
    if not image_url or not isinstance(image_url, str):
        raise ValueError(f"image_url muss ein nicht-leerer String sein, aktueller Wert: {image_url!r}")
    if image_url.startswith("{{") or "undefined" in image_url:
        raise ValueError(f"image_url scheint eine nicht gerenderte Template-Variable zu sein: {image_url}")
    if not image_url.startswith(("https://", "gs://")):
        raise ValueError(f"image_url muss mit https:// oder gs:// beginnen: {image_url}")

    payload = {
        "model": "gemini-3-pro-image-preview",
        "contents": [{
            "parts": [
                {"text": prompt},
                {"fileData": {
                    "fileUri": image_url,
                    "mimeType": "image/jpeg"
                }}
            ]
        }]
    }

    resp = requests.post(
        "https://api.apiyi.com/v1/messages",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json=payload,
        timeout=120
    )
    return resp.json()

Diese "Erst prüfen, dann senden"-Methode verhindert 90 % der Nano Banana Pro-Fehler, bevor sie auftreten, und hält Ihre Fehlerprotokolle bei Gemini sauber.

Korrektur 3: Korrekte Aufteilung von Batch-Bildern in mehrere parts

Wenn Sie tatsächlich mehrere Referenzbilder an Nano Banana Pro übergeben müssen (z. B. für Stiltransfer + Gesichtskonsistenz), ist der korrekte Weg, für jedes Bild ein eigenes parts-Element zu erstellen, anstatt ein Array in fileUri zu stopfen:

// ✅ Korrekte Schreibweise
const imageUrls = [
  "https://cdn.example.com/style.jpg",
  "https://cdn.example.com/person.jpg"
];

const payload = {
  model: "gemini-3-pro-image-preview",
  contents: [{
    parts: [
      { text: "Zeichne die Person aus dem zweiten Bild im Stil des ersten Bildes" },
      ...imageUrls.map(url => ({
        fileData: { fileUri: url, mimeType: "image/jpeg" }
      }))
    ]
  }]
};

const resp = await fetch("https://api.apiyi.com/v1/messages", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer YOUR_API_KEY"
  },
  body: JSON.stringify(payload)
});

Diese Methode vermeidet nicht nur den Fehler Unsupported file URI type, sondern hilft Gemini auch dabei, die semantischen Beziehungen zwischen den Bildern korrekt zu verstehen.

Korrektur 4: Fallback auf Base64-Inline bei nicht erreichbaren URLs

Wenn die URL zu einem privaten Bucket, einem internen Netzwerk oder einer temporären URL gehört, kann der Gemini-Server diese möglicherweise nicht abrufen. Der sicherste Ausweg ist die Verwendung von inlineData + Base64:

import base64
import requests

def call_with_base64(prompt: str, local_path: str):
    with open(local_path, "rb") as f:
        b64 = base64.b64encode(f.read()).decode("utf-8")

    payload = {
        "model": "gemini-3-pro-image-preview",
        "contents": [{
            "parts": [
                {"text": prompt},
                {"inlineData": {
                    "mimeType": "image/jpeg",
                    "data": b64
                }}
            ]
        }]
    }

    return requests.post(
        "https://api.apiyi.com/v1/messages",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json=payload
    ).json()

Hinweis: inlineData verwendet das Feld data (reines Base64, ohne das Präfix data:image/jpeg;base64,), während fileData das Feld fileUri verwendet. Beide sind exklusiv, verwenden Sie nicht beide gleichzeitig.

🎯 Stabilitätsempfehlung: Für Szenarien mit unkontrollierten URL-Quellen (z. B. Kunden-Uploads oder Drittanbieter-Schnittstellen) empfehlen wir, für die Bild-zu-Bild-Funktion standardmäßig Base64-Inline zu verwenden und den Aufruf über einen API-Proxy-Dienst wie APIYI (apiyi.com) für das Modell gemini-3-pro-image-preview abzuwickeln, um zu verhindern, dass Gemini externe URLs aufgrund von Netzwerk- oder Berechtigungsproblemen ablehnt.

Checkliste zur Fehlerbehebung bei Nano Banana Pro

Hier ist eine Zusammenfassung für eine "5-Minuten-Fehlerbehebung", die Sie direkt verwenden können, wenn ein Unsupported file URI type-Fehler auftritt.

5-Minuten-Checkliste

Schritt Aktion Erwartetes Ergebnis
1 Kopieren Sie den Wert hinter Unsupported file URI type: aus der Fehlermeldung Sie erhalten den tatsächlichen fileUri-Wert, den Gemini empfangen hat
2 Prüfen Sie, ob dieser Wert {{, undefined, null oder [ enthält Treffer → 90 % Wahrscheinlichkeit: Template nicht gerendert oder Feldname falsch
3 Öffnen Sie die URL in einem Inkognito-Fenster des Browsers Erwartung: Ein valides JPEG/PNG/WEBP-Bild wird heruntergeladen
4 Prüfen Sie, ob das URL-Protokoll https:// oder gs:// ist Nein → Protokoll anpassen oder Base64 verwenden
5 Prüfen Sie auf private Buckets, abgelaufene Signaturen oder Redirects Ja → Öffentliche URL verwenden oder Base64 verwenden
6 Testen Sie dasselbe Modell + ein bekanntes öffentliches Bild in der APIYI-Konsole Erfolg → Problem liegt clientseitig; Fehler bleibt → Feedback an uns

Wenn Sie diese 6 Schritte durchlaufen, lässt sich die Grundursache für nahezu jeden Nano Banana Pro-Fehler zweifelsfrei identifizieren.

Nano Banana Pro: FAQ zu „Unsupported file URI type“

F1: Warum erscheint in der Fehlermeldung direkt das Literal {{ $json.imageUrls }}?

Wenn die Gemini-API eine Anfrage erhält, gibt sie den Wert des Feldes fileUri unverändert in der Fehlermeldung wieder – das ist das Standardverhalten von Google, um dir bei der Fehlersuche zu helfen („Was genau habe ich eigentlich gesendet?“). Wenn du ein Literal wie {{ ... }} siehst, wurde die Variable in deinem Low-Code-Workflow nicht gerendert. Wenn dort undefined oder null steht, liegt ein Tippfehler im Feldnamen vor. Ich empfehle, den Aufruf zuerst auf APIYI (apiyi.com) mit einer festen, öffentlichen URL zu testen und dann den Client an diesen funktionierenden Body anzupassen.

F2: Welche URLs unterstützt Nano Banana Pro / gemini-3-pro-image-preview eigentlich?

Laut der offiziellen Google-Dokumentation akzeptiert fileUri vier Arten von URIs: File API-Pfade (https://generativelanguage.googleapis.com/files/...), YouTube-URLs (für die Videoanalyse), öffentliche HTTPS-URLs (inkl. S3 Pre-signed oder Azure SAS) sowie GCS gs://-URIs. Da Gemini 2.5 und neuere Modelle öffentliche HTTPS-URLs nativ unterstützen, muss gemini-3-pro-image-preview Bilder nicht erst über die File API hochladen.

F3: Was tun, wenn {{ $json.imageUrls }} in n8n nicht gerendert wird?

Es gibt drei häufige Ursachen: Erstens: Der JSON-Body des HTTP-Request-Nodes muss im Ausdrucksmodus (Expression Mode) sein (das = Zeichen oder der leuchtende fx-Button). Zweitens: Der Feldpfad muss mit der tatsächlichen Ausgabe des vorherigen Nodes übereinstimmen – prüfe dies im „Output“-Panel nach dem „Execute Node“. Drittens: Falls du Sub-Nodes verwendest, greift der Ausdruck standardmäßig nur auf das erste Element zu. Nutze entweder den Haupt-Node oder verwende einen „Item Lists“-Node, um die Daten vorher zu entpacken.

F4: Wie behebe ich die Fehlermeldung undefined?

Das bedeutet, dass du im Code auf ein nicht existierendes Feld zugreifst. Die schnellste Lösung ist eine Assertion vor dem Gemini-Aufruf: assert image_url is not None and isinstance(image_url, str). Überprüfe danach den Rückgabewert der vorgelagerten Schnittstelle auf Tippfehler wie imageUrls vs. imageUrl, image_url vs. imageUrl oder url vs. uri. In der Produktion empfehle ich, wie in „Fix 2“ des Artikels gezeigt, Strings, die nicht mit https oder gs beginnen, direkt abzufangen.

F5: Kann ich mehrere Bilder direkt in fileUri einfügen?

Nein. fileUri akzeptiert nur einen einzelnen String. Um mehrere Bilder zu übertragen, musst du für jedes Bild ein neues { "fileData": { "fileUri": "...", "mimeType": "..." } }-Element erstellen und diese alle in dasselbe parts-Array einfügen. Nur so kann Gemini die semantischen Beziehungen zwischen den Bildern korrekt erfassen.

F6: Was tun, wenn private Buckets oder temporäre Signatur-URLs nicht öffentlich zugänglich sind?

Die sicherste Lösung ist die Verwendung von inlineData + Base64: Lade das Bild lokal, kodiere es als Base64 und füge es direkt in den Request-Body ein. So muss der Gemini-Server keine externen Ressourcen abrufen, wodurch Probleme mit Authentifizierung, abgelaufenen Signaturen oder falschen MIME-Typen entfallen. Der Nachteil ist ein größerer Request-Body, was sich nur für einzelne, kleine Bilder eignet. Bei hochfrequenten Bild-zu-Bild-Anwendungen empfehlen wir dennoch, die Bilder auf ein öffentlich zugängliches CDN hochzuladen und dann über APIYI (apiyi.com) gemini-3-pro-image-preview aufzurufen. Das verhindert das Aufblähen durch Base64 und ermöglicht eine zentrale Zwischenspeicherung und Wiederholungslogik.

nano-banana-pro-unsupported-file-uri-type-error-fix-de 图示

Zusammenfassung: Best Practices nach der Fehlerbehebung bei Nano Banana Pro

Bei der konkreten Fehlermeldung Nano Banana Pro Unsupported file URI type: {{ $json.imageUrls }} können wir nun sicher sagen: Es liegt nicht an Gemini, sondern daran, dass n8n bzw. der Low-Code-Workflow die Vorlagenvariable nicht durch eine echte URL ersetzt hat, wodurch das Literal {{ ... }} unverändert an die Gemini-API gesendet wurde. Die Lösung findet sich in „Fix 1“: Aktiviere den Ausdrucksmodus im JSON-Body des HTTP-Request-Nodes und stelle sicher, dass der vorherige Node das Feld imageUrls tatsächlich ausgibt.

Auf einer allgemeineren Ebene zeigt der Fehler Unsupported file URI type, dass vielen Teams bei der Nutzung von Bild-APIs eine „Eingabevalidierung“ fehlt. Wenn Gemini die Anfrage ablehnt, ist oft unklar, ob es am Modell, am Netzwerk oder an den Parametern liegt. Die in diesem Artikel bereitgestellte 5-Minuten-Checkliste, der Python-Validierungscode und die n8n-Ausdrucksweise können als Standardvorgehensweise für dein Team dienen.

🎯 Abschließende Empfehlung: Wenn du einen Bild-zu-Bild-Workflow auf Basis von gemini-3-pro-image-preview für Kunden aufbaust, empfehlen wir, alle Nano Banana Pro-Aufrufe über eine API-Proxy-Plattform wie APIYI (apiyi.com) zu bündeln. Dies ermöglicht es, fehlerhafte Anfragen in der Konsole schnell zu reproduzieren und zu vergleichen, sowie bei Störungen seitens Google nahtlos auf vergleichbare Modelle wie Nano Banana 2 oder Seedream zu wechseln, damit Parameterfehler wie Unsupported file URI type sofort erkannt und behoben werden können.

Autor: APIYI Team | Wir konzentrieren uns auf die Implementierung und Stabilität von großen Sprachmodellen. Weitere Tipps zur Fehlerbehebung bei Gemini und Bild-APIs findest du auf APIYI (apiyi.com).

Try AI Large Model https://api.apiyi.com for free
Stable and reliable AI LM API aggregation service, Get 300 Millions Tokens for Free~

Ähnliche Beiträge