🎉 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

OpenCode kann jetzt Bilder generieren

OpenCode bearbeitet bereits deinen Code. Mit der DreamUtopia REST API kann dieselbe Sitzung ein Hero-Bild erstellen, einen Produktshot neu gestalten 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 Holztheke bei, füge verstreute Zimtstangen, ein Leinentuch und eine wärmere tiefstehende Sonne hinzu.

Beispiel-Prompt 02

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

Male diesen Bergsee als lockeres Aquarell. Behalte die Gipfel und die Spiegelung bei, mache die Kiefern weicher und wärme das Morgenlicht.

Beispiel-Prompt 03

Male diesen Bergsee als lockeres Aquarell. Behalte die Gipfel und die Spiegelung bei, mache die Kiefern weicher und wärme das Morgenlicht.

Opencode-Bildgenerierung, ohne das Terminal zu verlassen

Die Bildgenerierung mit OpenCode wird zu einem normalen Teil einer Coding-Session, wenn der Agent eine Media-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 Media-API braucht. Statt das Terminal zu verlassen, um eine Web-App zu öffnen, kannst du OpenCode nach einem 16:9-Header-Bild fragen und bekommst eine Ergebnis-URL in derselben Unterhaltung zurück. Wir haben die DreamUtopia API aus diesem Grund als reine REST-API 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, 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, OpenCode kann einen Fehler in derselben Stimme erklären, 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. OpenCode kann die Anfrage ausführen, die JSON-Antwort lesen und einen Fehler erklären, ohne die Aufgabe zu verlassen, die du ihm gegeben hast. 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üge den Skill-Block unten in den OpenCode-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 dein 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 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 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 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 Jobs 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.

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

Erstelle und exportiere den Schlüssel

Öffne Profil, dann API-Schlüssel, und erstelle einen benannten Schlüssel. Exportiere ihn als DREAMUTOPIA_API_KEY in der Shell, die OpenCode 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 Fertigkeit ein

Kopiere den Block unten und füge ihn in den OpenCode-Chat ein. Der Agent kennt dann die Endpunkte, Feldnamen und Polling-Regeln für diese Konversation. Die Skill legt außerdem fest, 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 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 unklar ist, stellt er eine kurze Frage, anstatt 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 zunehmendem Abstand und bricht bei einem endgültigen Fehler ab, 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 OpenCode ein

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

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

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

Wo sollte die Skill-Datei in OpenCode abgelegt werden?

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

Kann OpenCode ein lokales Bild hochladen?

▼
Ja. Bitte 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 gilt für Text-zu-Video und Bild-zu-Video, mit Dauern von fünf bis fünfzehn Sekunden je nach Modellstufe. Übergänge vom ersten zum letzten Frame sind in den höheren Stufen verfügbar.

Wie werden Credits berechnet?

▼
Guthaben werden bei der Erstellung eines Jobs berechnet 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 aktuelle 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. Ein Widerruf stoppt neue Anfragen sofort und lässt laufende Jobs unangetastet. Ein Konto kann mehrere Schlüssel enthalten, sodass eine Integration außer Betrieb genommen werden kann, ohne die anderen zu berühren.

Gib OpenCode ein Media-Tool

Erstelle einen Schlüssel, füge den Skill ein und fordere dein erstes Bild an. Die API-Dokumentation deckt jedes Feld, jeden Status und jeden Fehlercode ab.