🎉 Générations offertes au premier achat de chaque pack — jusqu'à 20 vidéos Lite + 20 images Lite + 10 vidéos Medium + 10 images Pro + 2 vidéos Pro.

Commencer
DreamUtopia
fr

Windsurf peut désormais générer des images

Windsurf édite déjà votre code. Avec l'API REST DreamUtopia, la même session peut créer une image de héros, restyler une photo de produit ou transformer une image fixe en vidéo de huit secondes. Collez un seul fichier de compétences, demandez en langage courant, et l'agent gère le téléversement, la requête et l'interrogation répétée.

Commencez par un exemple concret

Voici les prompts associés aux exemples de cette page. Ouvrez le générateur, choisissez un exemple, puis modifiez un détail à la fois.

Repeins ce littoral tempétueux au crépuscule. Garde le phare et les rochers noirs, fais balayer son faisceau dans la brume marine et intensifie les nuages d'orage.

Exemple de prompt 01

Repeins ce littoral tempétueux au crépuscule. Garde le phare et les rochers noirs, fais balayer son faisceau dans la brume marine et intensifie les nuages d'orage.

Transformez ce comptoir de cuisine en une scène d'automne douillette. Conservez la tasse blanche et le comptoir en bois, ajoutez des bâtons de cannelle éparpillés, un linge en lin et un soleil bas plus chaleureux.

Exemple de prompt 02

Transformez ce comptoir de cuisine en une scène d'automne douillette. Conservez la tasse blanche et le comptoir en bois, ajoutez des bâtons de cannelle éparpillés, un linge en lin et un soleil bas plus chaleureux.

Peins ce lac alpin comme une aquarelle libre. Conserve les pics et le reflet, adoucis les pins et réchauffe la lumière de l'aube.

Exemple de prompt 03

Peins ce lac alpin comme une aquarelle libre. Conserve les pics et le reflet, adoucis les pins et réchauffe la lumière de l'aube.

Génération d'images Windsurf, sans quitter l'éditeur

La génération d'images Windsurf devient une partie normale d'une session de codage lorsque l'agent peut appeler directement une API média. Les agents de codage savent exécuter des commandes, lire les réponses et réessayer intelligemment, ce qui est exactement ce dont une API média a besoin. Au lieu de quitter l'éditeur pour ouvrir une application web, vous pouvez demander à Windsurf une image d'en-tête 16:9 et obtenir une URL de résultat dans la même conversation. Nous avons conçu l'API DreamUtopia comme du REST simple pour cette raison. Il n'y a pas de serveur MCP à configurer ni de plugin à installer. Le fichier de compétences enseigne à l'agent l'URL de base, l'en-tête d'authentification, l'upload multipart, les deux endpoints de création, la boucle de polling et les règles d'erreur. Une compétence collée et une variable d'environnement constituent toute la configuration. La même clé fonctionne aussi depuis vos propres scripts, ce qui signifie que l'agent et votre pipeline de build partagent une seule intégration et un seul solde de crédits. Cela compte lorsqu'une tâche de design commence dans un chat et se termine dans un script de déploiement : la forme de la requête ne change pas entre les deux. Le workflow correspond aussi à la façon dont les agents de codage travaillent déjà : une requête est une commande shell normale, un échec est un statut HTTP normal, et une tâche longue est un id normal à poller. Cela signifie que Windsurf peut expliquer un échec avec la même voix qu'il utilise pour un test en échec, et il peut conserver l'asset généré à côté du code qui le référence. Pour un dépôt à forte composante design, la différence est pratique plutôt que cosmétique : la personne qui écrit le composant est aussi celle qui peut produire l'image dont il a besoin, sans changer d'outil ni perdre le contexte de la modification. Windsurf peut exécuter la requête, lire la réponse JSON et expliquer un échec sans quitter le fichier que vous êtes en train d'éditer. Cette boucle de feedback est tout l'intérêt : l'agent sait déjà exécuter une commande et interpréter le résultat, donc la génération média devient un autre outil qu'il peut utiliser.

Ce que vous obtenez

Une compétence copier-coller

Collez le bloc de compétences ci-dessous dans le chat Windsurf. L'agent suit la recette pour le reste de la conversation sans invite supplémentaire. Le texte est suffisamment court pour être lu d'une seule traite et suffisamment précis pour que l'agent n'improvise pas les noms de champs. Il indique les valeurs exactes que chaque champ accepte, de sorte qu'une requête mal formée est corrigée avant d'atteindre l'API. Rien n'est écrit dans votre dépôt et rien n'est installé.

Fichiers locaux traités

L'agent téléverse une photo depuis votre projet avec une requête multipart, puis transmet l'id renvoyé dans la génération. La limite est de 30 Mo pour JPEG, PNG et WebP. Un fichier qui réside dans le dépôt n'a jamais besoin d'une URL publique au préalable.

Images et vidéo, une seule clé

La génération d'images à partir de texte, d'images à partir d'images, de vidéos à partir de texte, de vidéos à partir d'images et les transitions première/dernière image utilisent toutes la même clé et le même solde de crédits. Vous ne gérez pas de comptes séparés pour les images fixes et les animations, et la compétence peut enchaîner une image terminée vers la requête vidéo suivante.

Des emplois qui survivent au chat

Chaque génération s'exécute sur nos serveurs. Si la session se termine, l'agent peut lister les tâches récentes par id et récupérer le résultat plus tard. Le lien de résultat signé reste valide pendant sept jours, ce qui laisse suffisamment de temps pour le télécharger ou le copier dans un artefact de build.

Demandes en anglais clair

Demandez une prise de vue produit carrée ou un clip social vertical. La compétence associe vos mots au modèle, à la résolution, à la durée et au format d'image, puis vérifie la matrice tarifaire en direct avant de dépenser. Vous pouvez toujours indiquer des réglages exacts lorsqu'une tâche l'exige. L'agent vous communique les réglages choisis, ce qui facilite le diagnostic d'un résultat inattendu.

Une liste de prix

L'API et l'application web facturent les mêmes crédits. GET /v1/models renvoie la matrice en temps réel des résolutions, durées et crédits, afin que l'agent puisse comparer un clip de cinq secondes avec un de dix secondes avant de créer quoi que ce soit.

Comment ça marche

1

Créer et exporter la clé

Ouvrez Profil, puis Clés API, et créez une clé nommée. Exportez-la en tant que DREAMUTOPIA_API_KEY dans le shell qui lance Windsurf. Les clés sont disponibles pour les comptes payants, ne sont affichées qu'une seule fois et peuvent être révoquées sans affecter vos autres intégrations.

2

Collez la compétence

Copiez le bloc ci-dessous et collez-le dans le chat Windsurf. L'agent connaît alors les points de terminaison, les noms de champs et les règles d'interrogation pour cette conversation. La compétence précise également ce qu'il ne faut pas faire : ne pas réessayer une tâche refusée, et ne pas coller la clé dans la conversation. Répétez le collage dans une nouvelle session ; rien n'est ajouté à votre dépôt.

3

Demandez ce dont vous avez besoin

Rédigez une requête normale : générez une image 2K d'un renard roux dans la neige, ou transformez ./photo.png en un clip 720p avec un lent travelling avant. L'agent choisit les paramètres, peut d'abord vérifier /v1/models, et gère le téléversement lorsque la source est un fichier local. Si la requête est ambiguë, il pose une courte question plutôt que de deviner une durée ou un ratio d'image.

4

Sondez et utilisez le résultat

L'agent interroge GET /v1/generations/{id} jusqu'à ce que la tâche réussisse, puis renvoie l'URL signée du résultat. Il marque une pause entre les interrogations et s'arrête en cas d'échec de l'éditeur plutôt que de réessayer après un refus lié à la politique de contenu ou un solde de crédits épuisé. La réponse finale inclut l'identifiant de la tâche ainsi que le lien, afin que le résultat puisse être retrouvé une fois la conversation terminée.

Collez la compétence DreamUtopia dans Windsurf

Copiez la compétence ci-dessous et collez-la dans le chat Windsurf. L'agent connaît alors la surface de l'API, les règles d'erreur et quand ne pas réessayer pour le reste de la conversation.

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
```

Découvrir les outils associés

Choisissez l’outil adapté à votre prochaine étape.

Questions fréquentes

Par l’équipe DreamUtopia · Dernière mise à jour 15 novembre 2026

Ai-je besoin d’un serveur MCP pour utiliser DreamUtopia depuis Windsurf ?

▼
Non. L'API est du HTTP simple, et la compétence apprend à Windsurf à l'appeler avec curl. Vous n'avez besoin ni d'un serveur MCP, ni d'un binaire CLI, ni d'un plugin. La seule configuration consiste à coller la compétence et la variable d'environnement.

Où doit aller le fichier de compétences dans Windsurf ?

▼
Collez le bloc de compétences dans le chat Windsurf. Il s'applique pour cette conversation ; répétez le collage dans une nouvelle session. Rien n'est ajouté à votre dépôt et aucun fichier n'a besoin d'être créé. Gardez la clé API dans l'environnement du shell en tant que DREAMUTOPIA_API_KEY, et non dans le texte collé.

Windsurf peut-il téléverser une image locale ?

▼
Oui. Demandez-lui d'utiliser un fichier dans le projet. L'agent envoie un envoi multipart, reçoit un identifiant d'envoi et utilise cet identifiant dans la génération. JPEG, PNG et WebP sont acceptés jusqu'à 30 Mo.

La compétence génère-t-elle des vidéos ainsi que des images ?

▼
Oui. La même clé couvre la génération de texte vers vidéo et d'image vers vidéo, avec des durées de cinq à quinze secondes selon le niveau du modèle. Les transitions entre première et dernière image sont disponibles sur les niveaux supérieurs.

Comment les crédits sont-ils facturés ?

▼
Les crédits sont débités lors de la création d’une tâche et remboursés en cas d’échec. La matrice tarifaire en direct se trouve à GET /v1/models, et la skill la consulte lorsque vous posez une question sur le coût. Un compte payant est requis avant de pouvoir créer une clé.

Que se passe-t-il si je ferme la session ?

▼
La tâche continue de s'exécuter sur nos serveurs. Utilisez GET /v1/generations/{id} avec l'id ou listez les tâches récentes avec GET /v1/generations?limit=20. L'URL signée du résultat reste valide pendant sept jours.

Est-il sûr de révoquer une clé ?

▼
Oui. La révocation bloque immédiatement les nouvelles requêtes et laisse les tâches en cours intactes. Un compte peut contenir plusieurs clés afin qu'une intégration puisse être retirée sans toucher aux autres.

Donnez à Windsurf un outil multimédia

Créez une clé, collez la compétence et demandez votre première image. La documentation de l'API couvre chaque champ, statut et code d'erreur.