🎉 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

Cline kann jetzt Bilder generieren

Cline bearbeitet bereits deinen Code. Mit der DreamUtopia REST API kann dieselbe Sitzung ein Hero-Bild erstellen, einen Produktshot umstylen 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.

Male diese stürmische Küste im Abendlicht neu. Behalte den Leuchtturm und die schwarzen Felsen, lass seinen Strahl durch den Meernebel streichen und vertiefe die Sturmwolken.

Beispiel-Prompt 01

Male diese stürmische Küste im Abendlicht neu. Behalte den Leuchtturm und die schwarzen Felsen, lass seinen Strahl durch den Meernebel streichen und vertiefe die Sturmwolken.

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

Beispiel-Prompt 02

Verwandle diese Küchenarbeitsplatte in eine gemütliche Herbstszene. Behalte die weiße Tasse und die Holzplatte 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, machen Sie die Kiefern weicher und wärmen Sie das Morgenlicht.

Beispiel-Prompt 03

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

Cline-Bildgenerierung, ohne den Editor zu verlassen

Die Cline-Bildgenerierung wird zu einem normalen Teil einer Codierungssitzung, wenn der Agent eine Medien-API direkt aufrufen kann. Codierungsagenten sind gut darin, Befehle auszuführen, Antworten zu lesen und intelligent erneut zu versuchen, was genau das ist, was eine Medien-API braucht. Anstatt den Editor zu verlassen, um eine Web-App zu öffnen, kannst du Cline um ein 16:9-Header-Bild bitten und bekommst eine Ergebnis-URL in derselben Unterhaltung 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 bringt dem Agenten die Basis-URL, den Authentifizierungs-Header, den Multipart-Upload, die beiden Create-Endpunkte, die Polling-Schleife und die Fehlerregeln bei. Ein eingefügter Skill und eine Umgebungsvariable sind die gesamte Einrichtung. 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 und Weise, wie Codierungsagenten 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 Cline einen Fehler in derselben Stimme erklären kann, die es für einen fehlschlagenden Test verwendet, und es 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. Cline kann die Anfrage ausführen, die JSON-Antwort lesen und einen Fehler erklären, ohne die Datei zu verlassen, die du gerade bearbeitest. Diese Rückkopplungsschleife ist der ganze Punkt: Der Agent weiß bereits, wie man einen Befehl ausführt und das Ergebnis interpretiert, sodass die Mediengenerierung zu einem weiteren Werkzeug wird, das er nutzen kann.

Was du bekommst

Eine Copy-and-paste-Fähigkeit

Fügen Sie den Skill-Block unten in den Cline-Chat ein. Der Agent folgt dem Rezept für den Rest der Unterhaltung 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 Ihr Repository geschrieben und nichts wird installiert.

Lokale Dateien verarbeitet

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

Bilder und Video, 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 der Skill kann ein fertiges Bild direkt in die nächste Videoanfrage überführen.

Jobs, die den Chat überdauern

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

Anfragen in einfacher Sprache

Bitte um eine quadratische Produktaufnahme oder einen vertikalen Social-Clip. Die Skill ordnet deine Angaben Modell, Auflösung, Dauer und Seitenverhältnis zu und prüft dann die aktuelle Preis-Matrix, bevor sie ausgibt. Du kannst bei Bedarf weiterhin exakte Einstellungen nennen. Der Agent meldet dir die gewählten Einstellungen zurück, was ein unerwartetes Ergebnis leichter diagnostizierbar macht.

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.

So funktioniert es

1

Erstelle und exportiere den Schlüssel

Profil öffnen, dann API-Schlüssel, und einen benannten Schlüssel erstellen. Exportiere ihn als DREAMUTOPIA_API_KEY in der Shell, die Cline startet. Schlüssel sind für kostenpflichtige Konten verfügbar, werden einmal angezeigt und können widerrufen werden, ohne deine anderen Integrationen zu berühren.

2

Füge die Fertigkeit ein

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

3

Bitte um das, was du brauchst

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

4

Umfrage durchführen und das Ergebnis verwenden

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

Füge den DreamUtopia Skill in Cline ein

Kopiere den folgenden Skill und füge ihn in den Cline-Chat ein. Der Agent kennt dann die API-Oberfläche, die Fehlerregeln und wann er für den Rest der Konversation nicht erneut versuchen soll.

Paste into Cline
Download
> Paste this into the Cline 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/cline.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 Cline aus zu nutzen?

▼
Nein. Die API ist reines HTTP, und der Skill bringt Cline bei, sie mit curl aufzurufen. Du brauchst keinen MCP-Server, kein CLI-Binary und kein Plugin. Die einzige Einrichtung besteht darin, den Skill und die Umgebungsvariable einzufügen.

Wohin sollte die Skill-Datei in Cline?

▼
Füge den Skill-Block in den Cline-Chat ein. Er gilt für diese Unterhaltung; wiederhole das Einfügen in einer neuen Sitzung. Deinem Repository wird nichts hinzugefügt und es muss keine Datei erstellt werden. Bewahre den API-Schlüssel als DREAMUTOPIA_API_KEY in der Shell-Umgebung auf, nicht im eingefügten Text.

Kann Cline ein lokales Bild hochladen?

▼
Ja. Bitten Sie es, eine Datei im Projekt zu verwenden. Der Agent sendet einen Multipart-Upload, erhält eine Upload-ID und verwendet diese ID bei 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?

▼
Credits werden bei der Erstellung eines Jobs berechnet und bei einem Fehlschlag zurückerstattet. Die aktuelle Preismatrix 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 Job läuft weiter auf unseren Servern. Verwende GET /v1/generations/{id} mit der id oder liste aktuelle Jobs 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. Widerrufen stoppt neue Anfragen sofort und lässt laufende Aufträge 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 Cline 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.