🎉 Gratis-Generierungen beim Erstkauf jedes Pakets — bis zu 20 Lite-Videos + 20 Lite-Bilder + 10 Medium-Videos + 10 Pro-Bilder + 2 Pro-Videos.

Loslegen
DreamUtopia
de

Claude Code kann jetzt Bilder generieren

Claude Code bearbeitet bereits deinen Code. Mit der DreamUtopia REST API kann dieselbe Sitzung ein Hero-Bild erstellen, einen Produktshot umgestalten oder ein Standbild in ein achtsekündiges Video verwandeln. Füge eine Skill-Datei ein, frage in einfachem Englisch, und der Agent übernimmt den Upload, die Anfrage und das Polling.

Mit einem konkreten Beispiel starten

Das sind die Prompts zu den Beispielen auf dieser Seite. Öffne den Generator, wähle ein Beispiel und ändere dann jeweils ein Detail.

Verwandle diese Küchenarbeitsplatte in eine gemütliche Herbstszene. Behalte den weißen Becher und die Holzablage bei, füge verstreute Zimtstangen, ein Leinentuch und wärmere tiefstehende Sonne hinzu.

Beispiel-Prompt 01

Verwandle diese Küchenarbeitsplatte in eine gemütliche Herbstszene. Behalte den weißen Becher und die Holzablage bei, füge verstreute Zimtstangen, ein Leinentuch und wärmere tiefstehende Sonne hinzu.

Malen Sie diesen Bergsee als lockeres Aquarell. Behalten Sie die Gipfel und die Spiegelung bei, lassen Sie die Kiefern weicher wirken und wärmen Sie das Morgenlicht.

Beispiel-Prompt 02

Malen Sie diesen Bergsee als lockeres Aquarell. Behalten Sie die Gipfel und die Spiegelung bei, lassen Sie die Kiefern weicher wirken und wärmen Sie das Morgenlicht.

Zeichne diese Bäckereifassade als illustrierte Postkarte neu. Behalte das Schild, die Schaufensterauslage und den Gehweg bei, und verwende saubere Tuschelinien mit einer warmen Abendpalette.

Beispiel-Prompt 03

Zeichne diese Bäckereifassade als illustrierte Postkarte neu. Behalte das Schild, die Schaufensterauslage und den Gehweg bei, und verwende saubere Tuschelinien mit einer warmen Abendpalette.

Claude Code Bildgenerierung, ohne das Terminal zu verlassen

Claude Code Bildgenerierung wird zu einem normalen Teil einer Coding-Session, wenn der Agent eine Medien-API direkt aufrufen kann. Coding-Agenten sind gut darin, Befehle auszuführen, Antworten zu lesen und intelligent erneut zu versuchen, was genau das ist, was eine Medien-API braucht. Statt das Terminal zu verlassen, um eine Web-App zu öffnen, kannst du Claude Code nach einem 16:9-Header-Bild fragen und bekommst eine Ergebnis-URL in derselben Konversation zurück. Wir haben die DreamUtopia API aus diesem Grund als reines REST gebaut. Es gibt keinen MCP-Server zu konfigurieren und kein Plugin zu installieren. Die Skill-Datei lehrt den Agenten die Basis-URL, den Authentifizierungs-Header, den Multipart-Upload, die beiden Create-Endpunkte, die Polling-Schleife und die Fehlerregeln. Ein eingefügter Skill und eine Umgebungsvariable sind das gesamte Setup. Derselbe Schlüssel funktioniert auch aus deinen eigenen Skripten, was bedeutet, dass der Agent und deine Build-Pipeline eine Integration und ein Guthaben teilen. Das ist wichtig, wenn eine Design-Aufgabe in einem Chat beginnt und in einem Deploy-Skript endet: Die Anfrageform ändert sich zwischen den beiden nicht. Der Workflow passt auch zu der Art, wie Coding-Agenten bereits arbeiten: Eine Anfrage ist ein normaler Shell-Befehl, ein Fehler ist ein normaler HTTP-Status und ein langer Job ist eine normale ID zum Pollen. Das bedeutet, dass Claude Code einen Fehler in derselben Stimme erklären kann, die er für einen fehlschlagenden Test verwendet, und er kann das generierte Asset neben dem Code behalten, der darauf verweist. Für ein designlastiges Repository ist der Unterschied praktisch statt kosmetisch: Die Person, die die Komponente schreibt, ist auch die Person, die das benötigte Bild erzeugen kann, ohne die Tools zu wechseln oder den Kontext der Änderung zu verlieren. Da derselbe Schlüssel sowohl Stills als auch Motion abdeckt, kann ein Team eine Integration und ein Guthaben für beides beibehalten, und der Agent kann ein fertiges Bild direkt in die nächste Clip-Anfrage einreihen.

Was Sie erhalten

Eine Copy-and-paste-Fähigkeit

Füge den Skill-Block unten in den Claude Code Chat ein. Der Agent folgt dem Rezept für den Rest der Konversation ohne zusätzliche Aufforderung. Der Text ist kurz genug, um ihn in einem Durchgang zu lesen, und spezifisch genug, dass der Agent keine Feldnamen improvisiert. Er gibt die genauen Werte an, die jedes Feld akzeptiert, sodass eine fehlerhafte Anfrage korrigiert wird, bevor sie die API erreicht. Nichts wird in dein Repository geschrieben und nichts wird installiert.

Lokale Dateien verarbeitet

Der Agent lädt ein Foto aus Ihrem Projekt mit einer Multipart-Anfrage hoch und übergibt dann die zurückgegebene id an die Generierung. Das Limit beträgt 30 MB für JPEG, PNG und WebP. Eine Datei, die im Repository liegt, benötigt nie zuerst eine öffentliche URL.

Bilder und Videos, ein Schlüssel

Text-zu-Bild, Bild-zu-Bild, Text-zu-Video, Bild-zu-Video und Übergänge vom ersten/zum letzten Frame verwenden alle denselben Schlüssel und dasselbe Guthaben. Du verwaltest keine separaten Konten für Standbilder und Bewegung, und die Skill kann ein fertiges Bild in die nächste Videoanfrage einreihen.

Jobs, die den Chat überdauern

Jede Generierung läuft auf unseren Servern. Wenn die Sitzung endet, kann der Agent aktuelle Aufträge nach ID auflisten und das Ergebnis später abholen. Der signierte Ergebnislink bleibt sieben Tage lang gültig, was ausreicht, um ihn herunterzuladen oder in ein Build-Artefakt zu kopieren.

Klare Anfragen in einfacher Sprache

Fordere eine quadratische Produktaufnahme oder einen vertikalen Social-Clip an. Die Skill ordnet deine Angaben Modell, Auflösung, Dauer und Seitenverhältnis zu und prüft dann die aktuelle Preismatrix, bevor sie etwas ausgibt. Du kannst bei Bedarf weiterhin exakte Einstellungen nennen. Der Agent meldet dir die gewählten Einstellungen zurück, was die Diagnose eines unerwarteten Ergebnisses erleichtert.

Eine Preisliste

Die API und die Web-App berechnen dieselben Credits. GET /v1/models gibt die aktuelle Auflösungs-, Dauer- und Credit-Matrix zurück, sodass der Agent einen fünfsekündigen Clip mit einem zehnsekündigen vergleichen kann, bevor er etwas erstellt.

Wie es funktioniert

1

Erstellen und exportieren Sie den Schlüssel

Öffne Profile, dann API keys, und erstelle einen benannten Schlüssel. Exportiere ihn als DREAMUTOPIA_API_KEY in der Shell, die Claude Code startet. Schlüssel sind für kostenpflichtige Konten verfügbar, werden einmalig angezeigt und können widerrufen werden, ohne deine anderen Integrationen zu berühren.

2

Füge die Fähigkeit ein

Kopiere den Block unten und füge ihn in den Claude Code Chat ein. Der Agent kennt dann die Endpunkte, Feldnamen und Polling-Regeln für diese Konversation. Die Skill beschreibt außerdem, was nicht zu tun ist: einen abgelehnten Job nicht erneut versuchen und den Schlüssel nicht in die Konversation einfügen. Wiederhole das Einfügen in einer neuen Sitzung; deinem Repository wird nichts hinzugefügt.

3

Bitte um das, was du brauchst

Formuliere eine normale Anfrage: Erzeuge ein 2K-Bild eines Rotfuchses im Schnee oder verwandle ./photo.png in einen 720p-Clip mit langsamem Push. Der Agent wählt die Einstellungen, kann zuerst /v1/models prüfen und übernimmt den Upload, wenn die Quelle eine lokale Datei ist. Ist die Anfrage mehrdeutig, stellt er eine kurze Rückfrage, statt bei Dauer oder Seitenverhältnis zu raten.

4

Umfrage durchführen und das Ergebnis verwenden

Der Agent ruft wiederholt GET /v1/generations/{id} ab, bis der Job erfolgreich ist, und gibt dann die signierte Ergebnis-URL zurück. Zwischen den Abfragen wartet er mit zunehmendem Abstand und bricht bei einem endgültigen Fehler ab, statt eine Ablehnung wegen der Inhaltsrichtlinie oder ein aufgebrauchtes Guthaben erneut zu versuchen. Die endgültige Antwort enthält sowohl die Job-ID als auch den Link, sodass das Ergebnis auch nach dem Ende der Konversation wiedergefunden werden kann.

Füge den DreamUtopia Skill in Claude Code ein

Kopiere den untenstehenden Skill und füge ihn in den Claude Code Chat ein. Der Agent kennt dann für den Rest der Unterhaltung die API-Oberfläche, die Fehlerregeln und wann nicht erneut versucht werden soll.

Paste into Claude Code
Download
> Paste this into the Claude Code chat. It teaches the agent the DreamUtopia API for the
> rest of the conversation. Keep the `DREAMUTOPIA_API_KEY` in your shell environment,
> not in the pasted text.

# DreamUtopia media generation

Use this skill when the user asks you to generate an image or a video with DreamUtopia.

## Prerequisites

- **API access requires a paid account.** Keys cannot be minted by a free account.
- The user sets their key in the environment:

  ```sh
  export DREAMUTOPIA_API_KEY="du_live_..."
  ```

  If `DREAMUTOPIA_API_KEY` is unset, **stop and ask the user to set it**. Never write the key
  into a project file, a commit, or a message.
- Base URL: `https://api.dreamutopia.net/v1`
- Every request sends `Authorization: Bearer $DREAMUTOPIA_API_KEY`.

## Keeping this skill current

This skill is served by the product and can change without notice. If a request fails in a way
this document does not describe — an unknown field, an unexpected status or error code, or a
route that returns `404` — the skill may be stale. Re-fetch it, paste the new version into the
conversation, and re-read it before retrying:

```sh
curl -fsSL https://dreamutopia.net/skills/dreamutopia/claude-code.md
```

Do not invent request fields from memory. The re-fetched file is the current contract; the copy
in the conversation is only a snapshot.

## 1. Upload a local reference image (optional)

Only needed when the user has a local file. A previous generation's `result.url` can be used
directly instead.

```sh
curl -sS -X POST https://api.dreamutopia.net/v1/uploads \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY" \
  -F "file=@/path/to/photo.png"
```

Response `201`:

```json
{ "id": "<upload_id>",
  "url": "<upload_url>",
  "expires_at": "2026-10-31T12:00:00Z" }
```

Use `id` (not `url`) in the next request. Accepted: JPEG, PNG, WebP, up to 30 MB.
`id` only works for the account that uploaded it.

## 2. Create an image

```sh
curl -sS -X POST https://api.dreamutopia.net/v1/images/generations \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lite",
    "prompt": "a red fox in fresh snow, cinematic",
    "resolution": "2k",
    "aspect_ratio": "1:1"
  }'
```

| Field | Values |
|---|---|
| `model` | `lite`, `pro` |
| `resolution` | `2k`, `4k` (`lite` accepts `2k` only) |
| `aspect_ratio` | `1:1`, `4:3`, `3:4`, `16:9`, `9:16`, `3:2`, `2:3`, `adaptive` |
| `reference_images` | array of upload ids or DreamUtopia URLs; 0–3 for `lite`, 0–14 for `pro` |
| `prompt` | non-empty, up to 8000 characters |

`adaptive` requires at least one reference image. `resolution` defaults to `2k` and
`aspect_ratio` to `1:1`.

Response `202`:

```json
{ "id": "3f2b…", "type": "image", "status": "queued", "created_at": "2026-10-24T12:00:00Z" }
```

## 3. Create a video

```sh
curl -sS -X POST https://api.dreamutopia.net/v1/videos/generations \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "medium",
    "prompt": "the fox turns and looks at the camera",
    "image": "<upload_id>",
    "resolution": "720p",
    "duration": 8
  }'
```

| Field | Values |
|---|---|
| `model` | `lite`, `medium`, `pro` |
| `resolution` | `480p`, `720p`, `1080p` (`lite` cannot use `1080p`) |
| `duration` | 5–10 seconds (`lite`), 5–15 (`medium`), 5–30 (`pro`) |
| `image` | first-frame upload id or DreamUtopia URL (omit for text-to-video) |
| `last_frame_image` | requires `image`; not supported by `lite` |
| `generate_audio` | `pro` only, and the account must hold premium; `lite` and `medium` are rejected |

Response `202` with `type: "video"`.

## 4. Poll until it finishes

```sh
curl -sS https://api.dreamutopia.net/v1/generations/$MID \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY"
```

`status` is one of `queued`, `processing`, `succeeded`, `failed`.

- Poll every 3–5 seconds, backing off to 10 seconds. Give up after about 10 minutes.
- On `succeeded`, download `result.url`. The link is valid for 7 days.
- On `failed`, report `error.message` to the user and stop. A failed job is terminal; do
  **not** submit it again automatically.
- If an id is lost, `GET /generations?limit=20` lists recent jobs, newest first.

Terminal response:

```json
{
  "id": "3f2b…",
  "type": "video",
  "status": "succeeded",
  "model": "medium",
  "credits_used": 12,
  "created_at": "2026-10-24T12:00:00Z",
  "updated_at": "2026-10-24T12:02:10Z",
  "result": { "url": "<result_url>" },
  "error": null
}
```

## 5. Check credits and prices

```sh
curl -sS https://api.dreamutopia.net/v1/account -H "Authorization: Bearer $DREAMUTOPIA_API_KEY"
curl -sS https://api.dreamutopia.net/v1/models
```

`/models` is public and returns every tier's allowed resolutions and durations plus the
`resolution → duration → credits` matrix. Check it before choosing settings when the user
cares about cost.

## Errors

Every error body is exactly:

```json
{ "error": { "code": "insufficient_credits", "message": "You need more credits to generate." } }
```

| HTTP | Meaning |
|---|---|
| 400 | invalid input (`invalid_request`, `prompt_too_long`, `invalid_reference_image`, …) |
| 401 | missing, malformed, revoked or removed-account key |
| 402 | not enough credits |
| 403 | unpaid key creation, or audio requested without premium |
| 404 | unknown job, or a job belonging to another account |
| 409 | `Idempotency-Key` reused with a different body, or still in flight |
| 413 / 415 | upload too large / not a supported image |
| 429 | rate limited; read `Retry-After` |
| 500 / 503 | internal; retry later |

Retry only HTTP `429`, `timeout` and `internal` responses. Never retry
`insufficient_credits`, and never resubmit a job that already finished as `failed`.

## Idempotency

Send `Idempotency-Key: <unique value>` on a create request. A retry with the same key and
body returns the existing job (`200`) instead of creating and charging a second one. Use a
fresh value for every genuinely different request.

## Complete example

```sh
#!/usr/bin/env bash
set -euo pipefail
: "${DREAMUTOPIA_API_KEY:?set DREAMUTOPIA_API_KEY first}"
API="https://api.dreamutopia.net/v1"

ID=$(curl -sS -X POST "$API/images/generations" \
  -H "Authorization: Bearer $DREAMUTOPIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"lite","prompt":"a red fox in fresh snow","resolution":"2k","aspect_ratio":"1:1"}' \
  | jq -r .id)

while :; do
  BODY=$(curl -sS "$API/generations/$ID" -H "Authorization: Bearer $DREAMUTOPIA_API_KEY")
  STATUS=$(jq -r .status <<<"$BODY")
  case "$STATUS" in
    succeeded) jq -r .result.url <<<"$BODY"; break ;;
    failed)    jq -r .error.message <<<"$BODY" >&2; exit 1 ;;
    *)         sleep 4 ;;
  esac
done
```

Weitere passende Tools entdecken

Wähle das Tool, das zu deinem nächsten Schritt passt.

Häufig gestellte Fragen

Vom DreamUtopia-Team · Zuletzt aktualisiert 15. November 2026

Brauche ich einen MCP-Server, um DreamUtopia von Claude Code aus zu nutzen?

▼
Nein. Die API ist reines HTTP, und die Skill lehrt Claude Code, sie mit curl aufzurufen. Du brauchst keinen MCP-Server, keine CLI-Binärdatei und kein Plugin. Die einzige Einrichtung besteht darin, die Skill und die Umgebungsvariable einzufügen.

Wo sollte der API-Schlüssel liegen?

▼
In der Shell-Umgebung als DREAMUTOPIA_API_KEY. Halte ihn aus dem eingefügten Skill, dem Repository und dem Prompt heraus. Der Skill weist den Agenten an, anzuhalten und nachzufragen, wenn die Variable fehlt, was eine halb konfigurierte Anfrage verhindert.

Kann Claude Code ein lokales Bild hochladen?

▼
Ja. Bitten Sie es, eine Datei im Projekt zu verwenden. Der Agent sendet einen Multipart-Upload, empfängt eine Upload-ID und verwendet diese ID in der Generierung. JPEG, PNG und WebP werden bis zu 30 MB akzeptiert.

Erzeugt die Skill auch Videos sowie Bilder?

▼
Ja. Derselbe Schlüssel deckt Text-zu-Video und Bild-zu-Video ab, mit Dauern von fünf bis fünfzehn Sekunden je nach Modell-Tier. Übergänge vom ersten zum letzten Frame sind in den höheren Tiers verfügbar.

Wie werden Credits berechnet?

▼
Guthaben werden bei der Erstellung eines Jobs belastet und bei Fehlschlag zurückerstattet. Die aktuelle Preisübersicht ist unter GET /v1/models verfügbar, und der Skill prüft sie, wenn du nach den Kosten fragst. Ein bezahltes Konto ist erforderlich, bevor ein Schlüssel erstellt werden kann.

Was passiert, wenn ich die Sitzung schließe?

▼
Der Auftrag läuft weiter auf unseren Servern. Verwende GET /v1/generations/{id} mit der id oder liste die letzten Aufträge mit GET /v1/generations?limit=20 auf. Die signierte Ergebnis-URL bleibt sieben Tage lang gültig.

Ist es sicher, einen Schlüssel zu widerrufen?

▼
Ja. Das Widerrufen stoppt neue Anfragen sofort und lässt laufende Jobs unberührt. Ein Konto kann mehrere Schlüssel enthalten, sodass eine Integration außer Betrieb genommen werden kann, ohne die anderen zu berühren.

Gib Claude Code ein Media-Tool

Erstelle einen Schlüssel, füge den Skill ein und frage nach deinem ersten Bild. Die API-Dokumentation deckt jedes Feld, jeden Status und jeden Fehlercode ab.