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

Windsurf 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.

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 den weißen Becher und die Holztheke 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 den weißen Becher und die Holztheke bei, füge verstreute Zimtstangen, ein Leinentuch und wärmere tiefstehende Sonne hinzu.

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

Beispiel-Prompt 03

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

Windsurf-Bildgenerierung, ohne den Editor zu verlassen

Die Bildgenerierung in Windsurf 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 – genau das braucht eine Medien-API. Anstatt den Editor zu verlassen, um eine Web-App zu öffnen, kannst du Windsurf nach einem 16:9-Header-Bild fragen und bekommst eine Ergebnis-URL in derselben Unterhaltung zurück. Aus diesem Grund haben wir die DreamUtopia API als reines REST gebaut. Es gibt keinen MCP-Server zu konfigurieren und kein Plugin zu installieren. Die Skill-Datei vermittelt dem 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 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 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 Windsurf 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. Windsurf 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 Sinn: 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 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. Es wird nichts in Ihr Repository geschrieben und nichts 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 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.

Einfache Anfragen in klarer 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 Preis-Matrix, bevor sie 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 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 kostenpflichtige Konten verfügbar, werden einmal angezeigt und können widerrufen werden, ohne deine anderen Integrationen zu beeinträchtigen.

2

Füge die Fähigkeit ein

Kopiere den folgenden Block 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-Anleitung 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

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 unklar 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 zunehmender Verzögerung und stoppt bei einem Editor-Fehler, anstatt 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 den untenstehenden Skill und füge ihn in den Windsurf-Chat ein. Der Agent kennt dann die API-Oberfläche, die Fehlerregeln und wann er für den Rest der Unterhaltung nicht erneut versuchen soll.

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 DreamUtopia von Windsurf aus zu nutzen?

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

Wo sollte die Skill-Datei in Windsurf abgelegt werden?

▼
Füge den Skill-Block in den Windsurf-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 Windsurf 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 in der Generierung. JPEG, PNG und WebP werden bis zu 30 MB akzeptiert.

Erzeugt die Funktion sowohl Videos als auch 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 belastet und bei Fehlschlag 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 Job läuft weiter auf unseren Servern. Verwende GET /v1/generations/{id} mit der id oder liste die letzten 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. 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 Windsurf ein Medien-Tool

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