NanoBanana direkt in Photoshop: So bindest du das Google-Modell über Replicate ein

NanoBanana (Codename für Googles Gemini 2.5 Flash Image) ist aktuell eines der spannendsten Bild-Modelle – ultraschnell, editierbar, und mit Fokus auf Konsistenz. Was viele noch nicht wissen: Über die Replicate-API kannst du NanoBanana direkt in Photoshop nutzen. Kein Umweg über externe Tools, sondern ein Button im Panel, der deine Ebene exportiert, den API-Call absetzt und das Resultat als neue Ebene wieder zurückschiebt.

In diesem Blogbeitrag zeige ich dir:

• was NanoBanana ist,
• wie du es technisch in Photoshop einbaust,
• und 20 Praxistipps, mit denen du aus dem Setup maximal rausholst.

Was ist NanoBanana?

NanoBanana ist Googles interner Codename für Gemini 2.5 Flash Image, ein multimodales Bildmodell, das auf Editing, Blending, Consistency spezialisiert ist. Es kann Bilder bearbeiten, zwei oder mehr Eingaben verschmelzen, Identitäten erhalten und Stile umwandeln. Besonders spannend: Die generierten Bilder tragen ein unsichtbares SynthID-Wasserzeichen für Transparenz.

Mehr dazu findest du hier:

• Google DeepMind Blog – Gemini 2.5
• Replicate Modellseite zu NanoBanana

Integration in Photoshop

Über ein kleines UXP-Plugin für Photoshop lässt sich NanoBanana direkt ansteuern:

1. Ebene exportieren → temporäres PNG
2. PNG an Replicate schicken (/v1/models/google/nano-banana/predictions)
3. Polling auf Status → fertige Ausgabe-URL
4. Neues Bild als Ebene zurück ins Dokument

Ein fertiges Skeleton-Plugin mit Manifest, HTML und JS (ca. 50 Zeilen) reicht schon aus, um NanoBanana per Klick im Panel auszuführen.

So geht’s – Schritt für Schritt

1) API-Zugang besorgen

• Lege dir einen Replicate-Account an und notiere den API-Token. Modell: google/nano-banana. Replicate+1
• Hintergrund: „Nano-Banana“ ist der Codenamen von Gemini 2.5 Flash Image (Googles neues Bild-Edit/Gen-Modell). Google Developers Blogblog.googleGoogle AI for Developers

2) Minimal-Test (optional, außerhalb von Photoshop)

Teste einmal per curl, ob der Account & die Inputs passen:

curl -s -X POST "https://api.replicate.com/v1/models/google/nano-banana/predictions" \
  -H "Authorization: Token $REPLICATE_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "task": "edit", 
      "prompt": "make it a glossy high-fashion look, soft light, keep the face identical",
      "image": "https://example.com/input.jpg"
    }
  }'

Danach das GET-Polling auf predictions/<id> bis status: succeeded und dann output[0] (Bild-URL) laden. Replicate

3) Photoshop-Integration (UXP Plugin)

Du baust ein kleines UXP-Panel (läuft in aktuellen Photoshop-Versionen). Es exportiert die aktuelle Ebene als PNG, schickt sie an Replicate, pollt das Ergebnis und legt es als neue Ebene ab.

Plugin-Skelett

manifest.json

{
  "manifestVersion": 5,
  "id": "brownz-nanobanana",
  "name": "NanoBanana Bridge",
  "version": "1.0.0",
  "host": { "app": "PS", "minVersion": "25.0.0" },
  "entryPoints": [
    { "type": "panel", "id": "panel", "label": "NanoBanana", "main": "index.js" }
  ],
  "permissions": {
    "network": { "domains": ["api.replicate.com", "storage.googleapis.com"] },
    "filesystem": "plugin"
  }
}

index.js (vereinfachtes Beispiel)

// UXP/Photoshop APIs
const app = require('photoshop').app;
const fs = require('uxp').storage.localFileSystem;

const REPLICATE_TOKEN = "<DEIN_REPLICATE_TOKEN>"; // sichere das später in uxp secure storage

async function exportActiveLayerToTempPng() {
  const doc = app.activeDocument;
  const tmpFolder = await fs.getTemporaryFolder();
  const file = await tmpFolder.createFile("nb_input.png", { overwrite: true });

  // Quick-Export der sichtbaren Ebene(n)
  await app.batchPlay([{
    _obj: "exportSelectionAsFileTypePressed",
    _target: [{ _ref: "document", _id: doc._id }],
    fileType: "png",
    quality: 32,
    metadata: 0,
    destFolder: file.nativePath
  }], { synchronousExecution: true });

  return file;
}

async function uploadToReplicate(file) {
  // 1) Datei in Base64 lesen (alternativ: extern hosten & URL übergeben)
  const data = await file.read({ format: fs.formats.binary });
  const base64 = btoa(String.fromCharCode(...new Uint8Array(data)));

  // 2) Prediction starten
  const req = await fetch("https://api.replicate.com/v1/models/google/nano-banana/predictions", {
    method: "POST",
    headers: {
      "Authorization": `Token ${REPLICATE_TOKEN}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      input: {
        task: "edit",
        // Typische Brownz-Usecases:
        // - "glossy high-fashion look, clean backdrop, keep likeness"
        // - "blend with another image" -> zusätzlich "image_2": "<url|base64>"
        prompt: "glossy high-fashion look, cinematic soft light, keep identity",
        // Variante A: Inline-Base64
        image_base64: `data:image/png;base64,${base64}`
        // Variante B: Wenn du eine URL hast:  image: "https://…/nb_input.png"
      }
    })
  });
  const prediction = await req.json();
  return prediction; // hat .id
}

async function pollResult(id) {
  while (true) {
    const r = await fetch(`https://api.replicate.com/v1/predictions/${id}`, {
      headers: { "Authorization": `Token ${REPLICATE_TOKEN}` }
    });
    const j = await r.json();
    if (j.status === "succeeded") return j.output[0]; // Bild-URL
    if (j.status === "failed" || j.status === "canceled") throw new Error(j.status);
    await new Promise(res => setTimeout(res, 1500));
  }
}

async function placeResultAsNewLayer(url) {
  const response = await fetch(url);
  const blob = await response.arrayBuffer();

  const tmp = await fs.getTemporaryFolder();
  const file = await tmp.createFile("nb_output.png", { overwrite: true });
  await file.write(blob);

  // Datei in Photoshop als neue Ebene platzieren
  await app.open(file);
  const resultDoc = app.activeDocument;
  await app.activeDocument.layers[0].duplicate(app.documents[0]); // in Ursprungsdokument kopieren
  await resultDoc.closeWithoutSaving();
}

async function runNanoBanana() {
  try {
    const file = await exportActiveLayerToTempPng();
    const pred = await uploadToReplicate(file);
    const url = await pollResult(pred.id);
    await placeResultAsNewLayer(url);
  } catch (e) {
    console.log("NB error:", e);
  }
}

// Minimal-UI (Button im Panel)
document.getElementById("run").addEventListener("click", runNanoBanana);

index.html (super schlicht)

<button id="run">NanoBanana Edit</button>

Was passiert hier?

1. Aktuelle Ebene(n) → temporäres PNG
2. Replicate-API-Call → google/nano-banana mit task: "edit" + Prompt
3. Polling bis fertig → Ausgabe-URL
4. Bild geladen → als neue Ebene ins aktive Dokument gesetzt

Wichtiges zu Inputs/Features

• Das Modell kann Edit/Blend/Style-Transfer/Consistent Likeness. Inputs sind u. a. image/image_base64, optionale Zweitbilder (image_2…), prompt, ggf. Masken je nach Schema-Stand. Sieh dir die API-Seite an, dort sind die aktuellen Input-Keys dokumentiert. Replicate
• Nano-Banana ist Gemini 2.5 Flash Image – Googles offizieller Blog & Doku beschreiben die neuen Edit-/Blend-Fähigkeiten & SynthID-Wasserzeichen. blog.googleGoogle AI for Developers

4) Varianten: Folder-Watcher statt Plugin

Falls du kein Panel bauen willst: kleines Node/Python-Script, das einen Ordner beobachtet (Export aus Photoshop), bei neuem PNG → Replicate anwerfen → Ergebnis nebenan ablegen → in Photoshop per Place Linked oder Drag-&-Drop rein. (Technisch identisch, nur ohne UXP-UI.)

Praxis-Tipps

• Gesichter/Identität konservieren: Im Prompt explizit „keep likeness / keep identity / same person“ sagen. Das Modell ist genau dafür getunt. blog.google
• Blend-Looks: Für „Brownz meets X“ nutze image_2 (oder mehrere) und nenne im Prompt klar die Stilachsen: „editorial high-fashion, glossy skin, controlled film grain, analog feel“.
• Non-destruktiv: Ergebnisse immer als neue Ebene oder Smart Object reinladen.
• Compliance: Gemini-Images tragen SynthID (unsichtbares Wasserzeichen). Für Kataloge: Herkunft transparent markieren. Google AI for Developers
• Limits prüfen: Aktuelle Input-Schema/Preis/Rate-Limits auf der Model-Seite checken—ändert sich gern. Replicate

Quellen / „Warum das so funktioniert“

• Replicate Modellseite & API für google/nano-banana. Replicate+2Replicate+2
• Google/DeepMind Ankündigung & Dev-Doku zu Gemini 2.5 Flash Image (Nano-Banana) inkl. Edit/Blend & SynthID. Google Developers Blogblog.googleGoogle AI for Developers

20 Tipps für die Praxis

1. „Keep likeness“ prompten – immer explizit dazuschreiben, wenn die Person gleich bleiben soll.
2. Arbeite mit Ebenenmasken: Nur der ausgewählte Bereich wird verändert.
3. Zwei-Bild-Blend: Nutze image_2 für Fusionen (z. B. Brownz meets Pop-Art).
4. Nicht-destruktiv: Ausgabe immer als neue Ebene einfügen.
5. Filmlook simulieren: Prompt mit „analog film grain, cinematic lens“ ergänzen.
6. Hintergründe cleanen: „clean backdrop, seamless studio wall“ im Prompt spart Retusche.
7. Fashion-Fokus: „editorial glossy look, Vogue-style lighting“ liefert High-Fashion-Ästhetik.
8. Lokale Einbindung: Bilder aus deiner Stadt im Blend → stärkere Authentizität.
9. Batch-Workflow: Folder-Watcher-Script nutzen für viele Bilder nacheinander.
10. GPU sparen: Kleinere Exportauflösung (z. B. 1024px) testen, dann Upscaling via Topaz oder Photoshop.
11. Farb-Consistency: Farbpalette im Prompt nennen („teal and orange“, „pastel minimal“).
12. Iterationen stacken: Ergebnisse mehrfach übereinanderlegen für Mischstile.
13. Maschinenästhetik: „cyberpunk cables, chrome reflections“ → für Brownz-typische Edges.
14. Masken kombinieren: Teilbereiche mehrfach mit verschiedenen Prompts überarbeiten.
15. Lighting-Studies: Nutze „softbox from left“ oder „rimlight neon pink“ für gezieltes Licht.
16. Schneller testen: Erst mit simplen Prompts, dann komplex verfeinern.
17. Stil-Kombos: Zwei Bildinputs + Prompt → dreifache Achse (Person, Style, Background).
18. Dokumentation: Prompts im Ebenennamen abspeichern → volle Nachvollziehbarkeit.
19. SynthID beachten: Alle Bilder sind gekennzeichnet – wichtig für Veröffentlichung.
20. Community inspo: Schau bei Replicate-„Examples“ oder GitHub-Snippets, welche Inputs gut funktionieren.

Linksammlung

• Replicate Modellseite: NanoBanana
• Replicate API Docs
• Google DeepMind – Gemini 2.5 Flash Image
• Adobe UXP Docs für Photoshop
• SynthID Wasserzeichen – Google AI

Fazit

NanoBanana ist ein Gamechanger – besonders, wenn man es direkt im Photoshop-Workflow nutzt. Wer seine Bilder ohnehin in Ebenen bearbeitet, spart sich den Export/Import-Wahnsinn und arbeitet quasi „in place“. Mit den 20 Tipps kannst du den Workflow perfektionieren – vom schnellen Fashion-Edit bis hin zum komplexen Blend mit künstlerischem Stilbruch.