🎉 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

Windsurf kann jetzt Videos generieren

Windsurf funktioniert bereits in deinem Editor. 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 Video mit Erstbild 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.

Ein Papierlaternenfest in der Abenddämmerung, Laternen steigen auf, während die Kamera nach oben in den warmen Himmel schwenkt.

Beispiel-Prompt 01

Ein Papierlaternenfest in der Abenddämmerung, Laternen steigen auf, während die Kamera nach oben in den warmen Himmel schwenkt.

Ein historisches Zugfenster bei voller Fahrt, die Landschaft zieht vorbei, während draußen Dampf an der Scheibe vorbeiwirbelt.

Beispiel-Prompt 02

Ein historisches Zugfenster bei voller Fahrt, die Landschaft zieht vorbei, während draußen Dampf an der Scheibe vorbeiwirbelt.

Windsurf-Videogenerierung, ohne den Editor zu verlassen

Die Windsurf-Videogenerierung 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, JSON-Antworten zu lesen und mit Urteilsvermögen erneut zu versuchen, was genau das ist, was eine Image-to-Video-API braucht. Statt den Editor zu verlassen, um eine Web-App zu öffnen, kannst du Windsurf bitten, ./photo.png in einen fünfsekündigen 720p-Clip zu verwandeln und eine signierte Ergebnis-URL in derselben Konversation 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. Ein eingefügter Skill und eine Umgebungsvariable sind das gesamte Setup. 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 Image-Job, normalerweise zwischen einer und drei Minuten, daher ist die Polling-Schleife wichtig. Der Skill weist den Agenten an, mit Backoff zu warten, bei einem terminalen Fehler zu stoppen und niemals eine Ablehnung wegen Content-Richtlinien oder ein leeres Guthaben erneut zu versuchen. Er 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 der erste Render fertig 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 einen fehlgeschlagenen Render in derselben Stimme erklären, die er für einen fehlschlagenden Test verwendet, und er kann das Ergebnis neben dem Code behalten, der darauf verweist.

Was Sie erhalten

Eine Copy-and-paste-Fähigkeit

Füge den Skill-Block unten in den Windsurf-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 Fotos bearbeitet

Bitten Sie den Agenten, eine Datei im Projekt zu verwenden. Er sendet einen Multipart-Upload, empfängt 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 einen separaten Hosting-Schritt vermeiden.

Jede Videoform

Bild-zu-Video, Text-zu-Video und Übergänge vom ersten zum letzten Frame nutzen 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; Med 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 Aufträge 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 Auftrag 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.

Klartext-Bewegung

Beschreibe die Aufnahme, nicht die API: ein langsames Hineinfahren, ein Drift nach rechts, Haare, die sich im Wind bewegen. Die Fähigkeit ordnet deine Wörter den Modellstufen Lite, Med und Pro, 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 ausgibt.

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. Credits werden bei der Erstellung des Jobs berechnet und bei einem Fehlschlag automatisch zurückerstattet.

So funktioniert es

1

Erstelle und exportiere den Schlüssel

Öffne Profile, dann API keys, und erstelle einen benannten Schlüssel. Exportiere ihn als DREAMUTOPIA_API_KEY in der Shell, die Windsurf 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 Windsurf-Chat ein. Der Agent kennt dann die Endpunkte, Feldnamen und Polling-Regeln für diese Konversation. Die Skill beschreibt auch, 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: animiere ./portrait.png, Haare bewegen sich im Wind, fünf Sekunden. 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 Rückfrage, 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 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 Inhaltsrichtlinien 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 Windsurf ein

Kopiere die folgende Fähigkeit und füge sie in den Windsurf-Chat ein. Der Agent kennt dann die API-Oberfläche, die Videogrenzen, die Fehlerregeln und wann nicht erneut versucht werden soll, für den Rest der Unterhaltung.

Paste into Windsurf
Download
> Paste this into the Windsurf 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/windsurf.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 Windsurf Videos zu generieren?

▼
Nein. Die API ist reines HTTP, und der Skill bringt Windsurf 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 halbkonfigurierte 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 zu 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. Der Lite-Tarif ist auf 720p begrenzt, während Medium und Pro 1080p rendern. Das Seitenverhältnis ist standardmäßig adaptiv, und der Agent kann ein Hochformat-, Quadrat- oder Querformat auswählen, wenn das Ziel bekannt ist.

Wie werden Credits für ein Video berechnet?

▼
Guthaben werden bei der Erstellung des Auftrags belastet und bei einem Fehlschlag automatisch zurückerstattet. Die aktuelle Preisübersicht ist unter GET /v1/models verfügbar, und die 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 Windsurf 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.