🎉 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

Cursor peut désormais générer des vidéos

Cursor fonctionne déjà dans votre éditeur. Avec l'API REST DreamUtopia, la même session peut transformer une photo de produit en un court clip, animer un portrait ou enchaîner une image terminée dans une vidéo à première image. Collez un seul fichier de compétences, demandez en langage naturel, et l'agent gère le téléversement, la requête et l'interrogation répétée. Vous continuez à travailler dans la même conversation pendant que le rendu s'exécute sur nos serveurs.

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.

Une route côtière à l'heure dorée, la caméra avançant lentement tandis que l'océan scintille sous les falaises.

Exemple de prompt 01

Une route côtière à l'heure dorée, la caméra avançant lentement tandis que l'océan scintille sous les falaises.

Une montgolfière dérivant au-dessus de vignobles brumeux au lever du soleil, son reflet se déplaçant sur la rivière en contrebas.

Exemple de prompt 02

Une montgolfière dérivant au-dessus de vignobles brumeux au lever du soleil, son reflet se déplaçant sur la rivière en contrebas.

Un festival de lanternes en papier au crépuscule, les lanternes s'élevant tandis que la caméra bascule vers le ciel chaleureux.

Exemple de prompt 03

Un festival de lanternes en papier au crépuscule, les lanternes s'élevant tandis que la caméra bascule vers le ciel chaleureux.

Génération vidéo Cursor, sans quitter l'éditeur

La génération de vidéos par Cursor 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 des réponses JSON et réessayer avec discernement, ce qui est exactement ce dont une API image-vers-vidéo a besoin. Au lieu de quitter l'éditeur pour ouvrir une application web, vous pouvez demander à Cursor de transformer ./photo.png en un clip 720p de cinq secondes et d'obtenir une URL de résultat signée en retour dans la même conversation. Nous avons conçu l'API DreamUtopia comme du REST pur pour cette raison. Il n'y a pas de serveur MCP à configurer ni de plugin à installer. Un seul fichier de compétence enseigne à l'agent l'URL de base, l'en-tête d'authentification, l'upload multipart pour les images de référence, le point de terminaison de création de vidéo, le point de terminaison de tâche partagé et les règles d'état terminal. Une compétence collée et une variable d'environnement constituent toute la configuration. La même clé fonctionne aussi depuis vos propres scripts, de sorte que l'agent et votre pipeline de build partagent une seule intégration et un seul solde de crédits. Une tâche vidéo est plus lente qu'une tâche image, généralement entre une et trois minutes, donc la boucle de polling compte. La compétence indique à l'agent d'attendre avec un backoff, de s'arrêter sur un échec terminal, et de ne jamais réessayer un refus de politique de contenu ni un solde vide. Elle distingue également une tâche encore en file d'attente d'une tâche qui a cessé de progresser. Cette distinction fait la différence entre une attente sereine et une tempête de tentatives. Une boucle de polling qui réessaie sans discernement peut consommer l'allocation avant la fin du premier rendu, tandis qu'une boucle qui s'arrête trop tôt abandonne une tâche qui progressait encore. Pour un dépôt qui livre des médias aux côtés du code, le gain pratique est que la personne qui écrit le composant peut aussi produire le clip dont il a besoin, sans perdre le contexte du changement ni copier des fichiers entre outils. L'agent peut expliquer un rendu échoué du même ton qu'il utilise pour un test en échec, et il peut conserver le résultat à côté du code qui le référence.

Ce que vous obtenez

Une compétence à copier-coller

Collez le bloc de compétences ci-dessous dans le chat Cursor. L'agent suit la recette pour le reste de la conversation sans incitation 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é.

Photos locales traitées

Demandez à l'agent d'utiliser un fichier dans le projet. Il envoie un upload multipart, reçoit un upload id et utilise cet id comme première image. JPEG, PNG et WebP sont acceptés jusqu'à 30 MB. Un fichier dans le dépôt n'a jamais besoin d'une URL publique au préalable, ce qui évite aux visuels produits privés une étape d'hébergement séparée.

Chaque format de vidéo

Les transitions image-vers-vidéo, texte-vers-vidéo et première-et-dernière-image partagent une clé. Choisissez 480p, 720p ou 1080p et une durée de cinq à quinze secondes. Le niveau Lite est plafonné à 720p et dix secondes ; Medium et Pro atteignent 1080p et quinze secondes. La compétence lit ces plafonds à partir de la liste de modèles en direct au lieu de deviner.

Des emplois qui survivent au chat

Chaque rendu 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 signé reste valide pendant sept jours, suffisamment longtemps pour télécharger le fichier ou le copier dans un artefact de build. Une tâche échouée conserve son code d'erreur, de sorte que la session suivante peut expliquer ce qui s'est passé. Récupérer le résultat plus tard est également plus sûr que de garder un terminal ouvert pendant plusieurs minutes le temps que le rendu se termine, en particulier sur une machine distante ou une connexion intermittente.

Mouvement en anglais simple

Décrivez le plan, pas l'API : un lent travelling avant, une dérive vers la droite, des cheveux qui bougent au vent. La compétence associe vos mots au niveau de modèle, à la résolution, à la durée et au ratio d'aspect, 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, et l'agent rapporte les réglages qu'il a choisis afin qu'un résultat inattendu soit plus facile à diagnostiquer. Une demande ambiguë est résolue par une seule question de clarification plutôt que par un rendu spéculatif qui dépense des crédits sur la mauvaise durée.

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. Les crédits sont facturés à la création de la tâche et restitués automatiquement en cas d'échec.

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

Demander un clip

Rédige une requête normale : transforme ./hero.png en un clip vertical de six secondes avec de la neige qui tombe. L'agent choisit les paramètres, peut vérifier /v1/models d'abord, et gère le téléversement lorsque la source est un fichier local. Si la requête est ambiguë, il pose une seule question courte plutôt que de deviner une durée ou un rapport d'aspect.

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 applique un délai croissant entre les interrogations et s'arrête en cas d'échec définitif au lieu de réessayer après un refus lié à la politique de contenu ou un solde é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 Cursor

Copiez la compétence ci-dessous et collez-la dans le chat Cursor. L'agent connaît alors la surface de l'API, les plafonds vidéo, les règles d'erreur et les cas où il ne faut pas réessayer pour le reste de la conversation.

Paste into Cursor
Download
> Paste this into the Cursor 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/cursor.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équemment posées

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

Ai-je besoin d'un serveur MCP pour générer une vidéo depuis Cursor ?

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

Où la clé API doit-elle se trouver ?

▼
Dans l'environnement shell sous le nom DREAMUTOPIA_API_KEY. Gardez-le hors de la compétence collée, du dépôt et du prompt. La compétence indique à l'agent de s'arrêter et de demander si la variable est manquante, ce qui évite une requête à moitié configurée.

L'agent peut-il téléverser une photo locale comme première image ?

▼
Oui. Demandez-lui d'utiliser un fichier du projet. L'agent envoie un upload multipart, reçoit un identifiant d'upload et transmet cet identifiant à la requête vidéo. JPEG, PNG et WebP sont acceptés jusqu'à 30 Mo, ce qui couvre la plupart des images de caméra et de produit.

Quelle peut être la durée d’un clip généré ?

▼
Cinq à quinze secondes selon le niveau. Le niveau Lite s'arrête à dix secondes ; Medium et Pro atteignent quinze. La compétence lit le plafond depuis GET /v1/models avant d'envoyer la requête, de sorte qu'une durée trop longue est corrigée plutôt que rejetée.

Quelles résolutions sont disponibles ?

▼
480p, 720p et 1080p. Le niveau Lite est plafonné à 720p, tandis que Medium et Pro rendent en 1080p. Le rapport d'aspect est adaptatif par défaut, et l'agent peut choisir un cadre portrait, carré ou paysage lorsque la destination est connue.

Comment les crédits sont-ils facturés pour une vidéo ?

▼
Les crédits sont débités lors de la création de la tâche et restitués automatiquement en cas d'échec. La matrice tarifaire en temps réel est disponible à l'adresse GET /v1/models, et la compétence la consulte lorsque vous vous renseignez sur le coût. Un compte payant est requis avant qu'une clé puisse être créée.

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, il n'y a donc pas d'urgence à la récupérer.

Donnez à Cursor un outil vidéo

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