ComfyUI als Backend: KI-Bildgenerierung in eigene Apps integrieren

ComfyUI hat sich zum mächtigsten Open-Source-Frontend für Stable Diffusion und verwandte Modelle entwickelt. Was viele übersehen: ComfyUI ist gleichzeitig ein vollwertiges Backend mit einer REST- und WebSocket-API — ideal, um KI-Bildgenerierung in eigene Web-Applikationen einzubinden.

ComfyUI vs. Automatic1111

Beide Tools erlauben lokale Bildgenerierung, verfolgen aber unterschiedliche Philosophien:

Kriterium	ComfyUI	Automatic1111 (AUTOMATIC1111)
Interface	Node-basierter Workflow-Editor	Klassisches Formular-UI
API-Qualität	Vollständig, stabil, WebSocket	Eingeschränkt
Flexibilität	Jede Verbindung konfigurierbar	Limitiert auf UI-Optionen
Lernkurve	Steiler	Flacher
Modell-Support	SD 1.x, 2, XL, SD3, Flux, Video	SD 1.x, 2, XL
Community	Wächst stark	Etabliert, langsamer

Für Backend-Integration ist ComfyUI klar die bessere Wahl — die API ist vollständig und für programmatischen Zugriff ausgelegt.

Wie funktioniert die ComfyUI API?

ComfyUI startet standardmäßig auf http://127.0.0.1:8188 und bietet:

• REST API — Workflow als JSON einreichen über /prompt
• WebSocket — Echtzeitstatus-Updates während der Generierung
• History API — Abgeschlossene Generierungen abrufen
• View API — Generierte Bilder direkt herunterladen

Workflow exportieren

Der erste Schritt für die API-Integration ist der Export des Workflows im API-Format:

1. ComfyUI im Browser öffnen
2. Zahnrad-Icon über dem Queue-Button klicken (Developer Mode aktivieren)
3. Workflow fertigstellen und testen
4. "Save (API Format)" klicken — lädt workflow_api.json herunter

Workflow per API einreichen

import websocket
import json
import uuid
import urllib.request

SERVER_ADDRESS = "127.0.0.1:8188"
CLIENT_ID = str(uuid.uuid4())

def generate_image(workflow: dict, prompt_text: str) -> bytes:
    # Prompt in Workflow einfuegen (Node-ID anpassen)
    workflow["6"]["inputs"]["text"] = prompt_text

    # Workflow einreichen
    payload = json.dumps({"prompt": workflow, "client_id": CLIENT_ID}).encode()
    req = urllib.request.Request(
        f"http://{SERVER_ADDRESS}/prompt",
        data=payload,
        headers={"Content-Type": "application/json"}
    )
    response = json.loads(urllib.request.urlopen(req).read())
    prompt_id = response["prompt_id"]

    # Per WebSocket auf Fertigstellung warten
    ws = websocket.WebSocket()
    ws.connect(f"ws://{SERVER_ADDRESS}/ws?clientId={CLIENT_ID}")
    while True:
        msg = json.loads(ws.recv())
        if msg["type"] == "executing" and msg["data"]["node"] is None:
            break  # Generierung abgeschlossen

    # Bild herunterladen
    history_url = f"http://{SERVER_ADDRESS}/history/{prompt_id}"
    history = json.loads(urllib.request.urlopen(history_url).read())
    output = history[prompt_id]["outputs"]
    filename = list(output.values())[0]["images"][0]["filename"]
    image_data = urllib.request.urlopen(
        f"http://{SERVER_ADDRESS}/view?filename={filename}"
    ).read()
    return image_data

Integration in eine Web-App

Für eine Next.js oder Express-App wird ComfyUI als lokaler Microservice betrieben:

Next.js App  →  /api/generate  →  ComfyUI (localhost:8188)  →  Bild

// Next.js API Route: src/app/api/generate/route.ts
export async function POST(req: Request) {
  const { prompt } = await req.json();

  // Gespeicherten Workflow laden
  const workflow = JSON.parse(fs.readFileSync("./workflows/sdxl.json", "utf-8"));
  workflow["6"]["inputs"]["text"] = prompt;

  const response = await fetch("http://localhost:8188/prompt", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ prompt: workflow }),
  });

  const { prompt_id } = await response.json();
  // ... WebSocket-Polling fuer Ergebnis

  return Response.json({ imageUrl: `/api/image/${filename}` });
}

Produktions-Deployment

Fuer skalierbaren Einsatz gibt es drei Optionen:

SaladTechnologies comfyui-api (Open Source, GitHub) bietet einen stateless REST-Wrapper, der horizontal skalierbar ist und Bilder direkt in der Response zurückgibt — oder asynchron per Webhook.

RunComfy ist ein Cloud-Dienst, der jeden gespeicherten Workflow als autoskalierende API bereitstellt — ohne eigene Server-Verwaltung.

Baseten/Truss ermöglicht das Deployment als produktionsreifer API-Endpunkt auf dedizierten GPU-Servern.

Unterstützte Modelle 2026

ComfyUI unterstützt heute weit mehr als klassisches Stable Diffusion:

• Flux.1 — Hochqualitative Bildgenerierung, aktuell beliebtestes Modell
• Stable Diffusion 3.5 — SD3.5 Large mit verbesserten Prompts
• SDXL — Bewährtes 1024x1024 Modell
• AnimateDiff — Videos aus Bildsequenzen
• ControlNet — Pose-, Edge- und Depth-gesteuertes Rendering
• Stable Video Diffusion — Kurzvideos aus Einzelbildern

Fazit

ComfyUI ist 2026 weit mehr als ein GUI-Tool. Mit seiner vollständigen API ist es ein ernstzunehmendes Backend für KI-Bildgenerierung, das sich nahtlos in jede Web-Applikation integrieren lässt. Wer lokale, datenschutzkonforme Bildgenerierung ohne Per-Image-Kosten benötigt, sollte ComfyUI als Backend evaluieren.