🎉 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 Videos generieren

OpenCode funktioniert bereits in deinem Terminal. Mit der DreamUtopia REST API kann dieselbe Sitzung ein Produktfoto in einen kurzen Clip verwandeln, ein Porträt animieren oder ein fertiges Bild zu einem Erstbild-Video verketten. Füge eine Skill-Datei ein, frage in einfachem Englisch, und der Agent übernimmt den Upload, die Anfrage und das Polling. Du arbeitest weiter in derselben Unterhaltung, während das Rendering auf unseren Servern läuft.

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.

Eine Küstenstraße zur goldenen Stunde, die Kamera treibt vorwärts, während der Ozean unter den Klippen glitzert.

Beispiel-Prompt 01

Eine Küstenstraße zur goldenen Stunde, die Kamera treibt vorwärts, während der Ozean unter den Klippen glitzert.

Ein Heißluftballon, der bei Sonnenaufgang über nebligen Weinbergen schwebt, seine Spiegelung wandert über den Fluss darunter.

Beispiel-Prompt 02

Ein Heißluftballon, der bei Sonnenaufgang über nebligen Weinbergen schwebt, seine Spiegelung wandert über den Fluss darunter.

Ein Laternenfest aus Papier in der Dämmerung, Laternen steigen auf, während die Kamera in den warmen Himmel schwenkt.

Beispiel-Prompt 03

Ein Laternenfest aus Papier in der Dämmerung, Laternen steigen auf, während die Kamera in den warmen Himmel schwenkt.

OpenCode-Videogenerierung, ohne das Terminal zu verlassen

Die Videogenerierung in OpenCode wird zu einem normalen Teil einer Codingsitzung, wenn der Agent eine Medien-API direkt aufrufen kann. Coding-Agenten sind gut darin, Befehle auszuführen, JSON-Antworten zu lesen und mit Urteilsvermögen erneut zu versuchen, was genau das ist, was eine Image-to-Video-API braucht. Statt das Terminal zu verlassen, um eine Web-App zu öffnen, kannst du OpenCode bitten, ./photo.png in einen fünfsekündigen 720p-Clip zu verwandeln und eine signierte Ergebnis-URL in derselben Unterhaltung zurückzubekommen. Wir haben die DreamUtopia API aus diesem Grund als reines REST gebaut. Es gibt keinen MCP-Server zu konfigurieren und kein Plugin zu installieren. Eine Skill-Datei bringt dem Agenten die Basis-URL, den Authentifizierungs-Header, den Multipart-Upload für Referenzbilder, den Video-Erstellungs-Endpunkt, den gemeinsamen Job-Endpunkt und die Regeln für Terminalzustände bei. Eine eingefügte Skill und eine Umgebungsvariable sind die gesamte Einrichtung. Derselbe Schlüssel funktioniert auch aus deinen eigenen Skripten, sodass der Agent und deine Build-Pipeline eine Integration und ein Guthaben teilen. Ein Video-Job ist langsamer als ein Bild-Job, normalerweise zwischen einer und drei Minuten, daher ist die Polling-Schleife wichtig. Die Skill weist den Agenten an, mit Backoff zu warten, bei einem terminalen Fehler zu stoppen und niemals eine Ablehnung wegen Inhaltsrichtlinien oder ein leeres Guthaben erneut zu versuchen. Sie unterscheidet auch einen Job, der noch in der Warteschlange steht, von einem, der keine Fortschritte mehr macht. Diese Unterscheidung ist der Unterschied zwischen einem ruhigen Warten und einem Wiederholungssturm. Eine Polling-Schleife, die unterschiedslos erneut versucht, kann das Kontingent verbrauchen, bevor das erste Rendering abgeschlossen ist, während eine Schleife, die zu früh stoppt, einen Job aufgibt, der noch Fortschritte machte. Für ein Repository, das Medien zusammen mit Code ausliefert, besteht der praktische Gewinn darin, dass die Person, die die Komponente schreibt, auch den Clip produzieren kann, den sie benötigt, ohne den Kontext der Änderung zu verlieren oder Dateien zwischen Tools zu kopieren. Der Agent kann ein fehlgeschlagenes Rendering in derselben Stimme erklären, die er für einen fehlschlagenden Test verwendet, und er kann das Ergebnis neben dem Code aufbewahren, der darauf verweist.

Was Sie bekommen

Eine Copy-Paste-Fähigkeit

Fügen Sie 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 Ihr Repository geschrieben und nichts wird installiert.

Lokale Fotos bearbeitet

Bitte den Agenten, eine Datei im Projekt zu verwenden. Er sendet einen Multipart-Upload, erhält eine Upload-ID und verwendet diese ID als erstes Frame. JPEG, PNG und WebP werden bis 30 MB akzeptiert. Eine Datei im Repository benötigt nie zuerst eine öffentliche URL, wodurch private Produktaufnahmen keinen separaten Hosting-Schritt benötigen.

Jede Videoform

Bild-zu-Video, Text-zu-Video und Übergänge mit erstem und letztem Frame verwenden einen Schlüssel. Wähle 480p, 720p oder 1080p und eine Dauer von fünf bis fünfzehn Sekunden. Die Lite-Stufe ist auf 720p und zehn Sekunden begrenzt; Medium und Pro erreichen 1080p und fünfzehn Sekunden. Der Skill liest diese Obergrenzen aus der Live-Modellliste, statt zu raten.

Jobs, die den Chat überdauern

Jedes Rendering 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 Link bleibt sieben Tage gültig, lange genug, um die Datei herunterzuladen oder sie in ein Build-Artefakt zu kopieren. Ein fehlgeschlagener Job behält seinen Fehlercode, sodass die nächste Sitzung erklären kann, was passiert ist. Das spätere Abholen des Ergebnisses ist auch sicherer, als ein Terminal mehrere Minuten lang offen zu halten, während das Rendering abgeschlossen wird, insbesondere auf einer Remote-Maschine oder bei einer instabilen Verbindung.

Klare, einfache Bewegung

Beschreibe die Aufnahme, nicht die API: ein langsamer Push-in, ein Drift nach rechts, Haare, die sich im Wind bewegen. Die Skill ordnet deine Worte den Modell-Tiers, der Auflösung, der Dauer und dem Seitenverhältnis zu und prüft dann die Live-Preismatrix, bevor sie ausgibt. Du kannst bei Bedarf weiterhin exakte Einstellungen nennen, und der Agent meldet die von ihm gewählten Einstellungen, damit ein unerwartetes Ergebnis leichter zu diagnostizieren ist. Eine mehrdeutige Anfrage wird mit einer klärenden Frage aufgelöst statt mit einem spekulativen Render, der Credits für die falsche Dauer verbraucht.

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ünf-Sekunden-Clip mit einem Zehn-Sekunden-Clip vergleichen kann, bevor er etwas erstellt. Credits werden bei der Erstellung des Jobs berechnet und bei einem Fehlschlag automatisch zurückerstattet.

So funktioniert es

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 OpenCode startet. Schlüssel sind für bezahlte Konten verfügbar, werden einmal 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 OpenCode-Chat ein. Der Agent kennt dann die Endpunkte, Feldnamen und Polling-Regeln für diese Konversation. Der Skill gibt außerdem an, 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

Nach einem Clip fragen

Schreibe eine normale Anfrage: Erstelle einen fünfsekündigen 1080p-Clip aus ./beach.jpg mit einer Kamera, die nach rechts schwenkt. 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, anstatt eine Dauer oder ein Seitenverhältnis zu raten.

4

Umfrage 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 zunehmenden Abständen 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 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 folgenden Skill und füge ihn in den OpenCode-Chat ein. Der Agent kennt dann die API-Oberfläche, die Video-Limits, die Fehlerregeln und wann nicht erneut versucht werden soll für den Rest der Unterhaltung.

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 aus OpenCode ein Video zu generieren?

▼
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 der API-Schlüssel gespeichert werden?

▼
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 der Agent ein lokales Foto als erstes Frame hochladen?

▼
Ja. Bitten Sie es, eine Datei im Projekt zu verwenden. Der Agent sendet einen Multipart-Upload, erhält eine Upload-ID und übergibt diese ID an die Videoanfrage. JPEG, PNG und WebP werden bis 30 MB akzeptiert, was die meisten Kamera- und Produktbilder abdeckt.

Wie lang kann ein generierter Clip sein?

▼
Fünf bis fünfzehn Sekunden, je nach Tier. Der Lite-Tier endet bei zehn Sekunden; Medium und Pro erreichen fünfzehn. Der Skill liest die Obergrenze aus GET /v1/models, bevor er die Anfrage sendet, sodass eine zu lange Dauer korrigiert statt abgelehnt wird.

Welche Auflösungen sind verfügbar?

▼
480p, 720p und 1080p. Die Lite-Stufe ist auf 720p begrenzt, während Medium und Pro 1080p rendern. Das Seitenverhältnis ist standardmäßig adaptiv, und der Agent kann einen Hochformat-, Quadrat- oder Querformat-Rahmen wählen, wenn das Ziel bekannt ist.

Wie werden Credits für ein Video berechnet?

▼
Credits werden bei der Erstellung des Jobs belastet und bei einem Fehler automatisch zurückerstattet. Die aktuelle Preisstruktur 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, es besteht also keine Eile, sie abzurufen.

Gib OpenCode ein Video-Tool

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