Eine NSFW-Bildgenerierungs-API für Entwickler

Die meisten APIs zur Bildgenerierung lehnen NSFW-Inhalte grundsätzlich ab, aus Prinzip, noch bevor du überhaupt an eine technische Grenze stößt. Für eine allgemeine Plattform ist das eine vernünftige Entscheidung, aber für einen Entwickler, der wirklich programmatischen Zugriff auf einen Generator braucht, der Inhalte für Erwachsene erlaubt, bleibt kaum etwas übrig. Fellowis öffentliche API existiert genau für diesen Fall. Sie erlaubt explizite Generierung für registrierte erwachsene Accounts, unter strengen Grenzen, die sich nie ändern: kein Inhalt mit Minderjährigen, kein Inhalt, der fehlende Zustimmung darstellt. Das sind keine Einstellungen, die man umschalten kann - solche Anfragen werden ausnahmslos abgelehnt.

Ansonsten ist es eine ganz normale REST-API: ein Schlüssel, ein POST, der einen Job in die Warteschlange stellt, ein Polling, ein Download. Wenn du schon mit einer anderen asynchronen Generierungs-API gearbeitet hast, wird dir das bekannt vorkommen.

Einen Schlüssel besorgen

Erstelle einen Account und dann einen API-Schlüssel in der API Console. Der Schlüssel sieht aus wie fk_live_<zufällige Zeichenfolge> und wird dir bei der Erstellung genau einmal vollständig angezeigt. Danach wird auf unserer Seite nur noch ein Hash plus eine kurze Vorschau gespeichert - wenn du ihn verlierst, widerrufst du ihn und erstellst einen neuen, genau wie bei jedem anderen API-Schlüssel, mit dem du schon gearbeitet hast. Speichere ihn irgendwo sicher, bevor du den Tab schließt.

Jede Anfrage authentifiziert sich mit einem Standard-Bearer-Header:

Authorization: Bearer fk_live_your_key_here

Eine Generierung in die Warteschlange stellen

POST /v1/api/images mit einem Prompt und deinen Optionen. Der Aufruf gibt sofort HTTP 202 zurück - er blockiert nicht, während das Bild gerendert wird:

POST /v1/api/images
Content-Type: application/json
Authorization: Bearer fk_live_your_key_here
Idempotency-Key: a-key-you-generate-per-attempt

{
  "prompt": "a neon-lit rooftop at night, wide shot, cinematic lighting",
  "quality": "standard",
  "format": "png",
  "aspectRatio": "16:9"
}

Die Antwort enthält eine Job-ID, eine etaMs-Schätzung und dein verbleibendes Coin-Guthaben nach der Belastung. Der optionale Idempotency-Key-Header macht einen erneuten Versuch sicher - sende beim Retry denselben Key, und du wirst nicht doppelt für denselben Versuch belastet.

Der Job selbst liegt unter image, daneben dein Wallet-Guthaben:

{
  "image": { "id": "0f9c...", "status": "queued", "etaMs": 42000, "coinsCharged": 40 },
  "coins": 360
}

Polling, dann Download

Frage GET /v1/api/images/:id ab, bis status "succeeded" oder "failed" erreicht. Bei Erfolg lädst du die eigentlichen Bytes über GET /v1/api/images/:id/content herunter. Schlägt es fehl, werden die ausgegebenen Coins automatisch erstattet, und failureCode ist immer genau einer von vier Werten: TIMEOUT, MODERATION_REJECTED, VENDOR_ERROR oder UNKNOWN. Es gibt keinen fünften Code zu behandeln und keine Teil-Belastung abzugleichen - mehr dazu, warum das so ist, in unserem Beitrag zur API-Preisgestaltung und zum Umgang mit fehlgeschlagenen Generierungen.

curl, von Anfang bis Ende

API_KEY="fk_live_your_key_here"

# 1. Job in die Warteschlange stellen
JOB=$(curl -s https://fellowi.com/api/v1/api/images \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"a neon-lit rooftop at night","quality":"standard","format":"png","aspectRatio":"16:9"}')
ID=$(echo "$JOB" | jq -r .image.id)

# 2. bis zum Abschluss abfragen
while true; do
  STATUS=$(curl -s https://fellowi.com/api/v1/api/images/$ID \
    -H "Authorization: Bearer $API_KEY" | jq -r .image.status)
  [ "$STATUS" = "succeeded" ] && break
  [ "$STATUS" = "failed" ] && { echo "generation failed"; exit 1; }
  sleep 3
done

# 3. Bild herunterladen
curl -s https://fellowi.com/api/v1/api/images/$ID/content \
  -H "Authorization: Bearer $API_KEY" -o output.png

Node

const API_KEY = process.env.FELLOWI_API_KEY;
const base = "https://fellowi.com/api/v1/api";
const headers = { Authorization: `Bearer ${API_KEY}` };

const create = await fetch(`${base}/images`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({ prompt: "a neon-lit rooftop at night", quality: "standard", format: "png", aspectRatio: "16:9" }),
});
const { image } = await create.json();
const id = image.id;

let job;
do {
  await new Promise((r) => setTimeout(r, 3000));
  job = await fetch(`${base}/images/${id}`, { headers }).then((r) => r.json());
} while (job.image.status !== "succeeded" && job.image.status !== "failed");

if (job.image.status === "failed") throw new Error(job.image.failureCode);

const bytes = await fetch(`${base}/images/${id}/content`, { headers }).then((r) => r.arrayBuffer());
await Bun.write("output.png", bytes);

Python

import os, time, requests

API_KEY = os.environ["FELLOWI_API_KEY"]
base = "https://fellowi.com/api/v1/api"
headers = {"Authorization": f"Bearer {API_KEY}"}

job = requests.post(f"{base}/images", headers=headers, json={
    "prompt": "a neon-lit rooftop at night",
    "quality": "standard",
    "format": "png",
    "aspectRatio": "16:9",
}).json()

while True:
    time.sleep(3)
    status = requests.get(f"{base}/images/{job['image']['id']}", headers=headers).json()
    if status["image"]["status"] in ("succeeded", "failed"):
        break

if status["image"]["status"] == "failed":
    raise RuntimeError(status["image"]["failureCode"])

content = requests.get(f"{base}/images/{job['image']['id']}/content", headers=headers)
open("output.png", "wb").write(content.content)

Modell, Preis und Limits

Jede Antwort meldet das Modell als fellowi-nsfw-image-1. Das ist der einzige Name, den du zu sehen bekommst - es ist derselbe Generator, der auch hinter der Web-App Fellowi Images steckt, und er wird über dieselbe Fellowi-Coins- Wallet zum selben Preis abgerechnet: 40 Coins für Standard (1,5K), 60 für hohe Qualität (2K). Es gibt keine separate API-Preisliste, die man mit der Web-App abgleichen müsste.

Rate-Limits sind ein Schutz gegen Missbrauch, nicht die eigentliche Obergrenze: standardmäßig 20 Anfragen pro Minute für Generierungsaufrufe, 120 pro Minute für Lesezugriffe. GET /v1/api/me gibt dein aktuelles Coin-Guthaben, das Rate-Limit deines Schlüssels und zurück, wie viele Bilder dir heute unter dem Tageslimit noch bleiben - prüfe das, bevor du einen Batch losschickst, nicht erst, wenn du an eine Wand läufst.

Vollständige Referenzdokumentation, aktuelle Preise und Schlüsselverwaltung findest du alle in der API Console.