🎉 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

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

Codex modifie déjà votre code. Avec l'API REST DreamUtopia, la même session peut créer une image d'en-tête, restyler une photo de produit ou transformer une image fixe en une 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.

Transforme ce plan de travail de cuisine en une scène d'automne douillette. Garde la tasse blanche et le comptoir en bois, ajoute des bâtons de cannelle éparpillés, un linge en lin et une lumière de soleil basse plus chaude.

Exemple de prompt 02

Transforme ce plan de travail de cuisine en une scène d'automne douillette. Garde la tasse blanche et le comptoir en bois, ajoute des bâtons de cannelle éparpillés, un linge en lin et une lumière de soleil basse plus chaude.

Peins ce lac alpin à l'aquarelle, dans un style libre. Conserve les sommets et le reflet, adoucis les pins et réchauffe la lumière de l'aube.

Exemple de prompt 03

Peins ce lac alpin à l'aquarelle, dans un style libre. Conserve les sommets et le reflet, adoucis les pins et réchauffe la lumière de l'aube.

Génération d'images Codex, sans quitter le terminal

La génération d'images par Codex 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 le terminal pour ouvrir une application web, vous pouvez demander à Codex une image d'en-tête au format 16:9 et obtenir une URL de résultat dans la même conversation. C'est pour cette raison que nous avons conçu l'API DreamUtopia comme du REST simple. Il n'y a aucun serveur MCP à configurer et aucun 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 points de terminaison 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 flux de travail 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 à interroger. Cela signifie que Codex peut expliquer un échec avec la même voix qu'il utilise pour un test échoué, 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. Codex peut exécuter la requête, lire la réponse JSON et expliquer un échec sans quitter la tâche que vous lui avez confiée. Cette boucle de rétroaction 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 Codex. L'agent suit la recette pour le reste de la conversation sans incitation supplémentaire. Le texte est assez court pour être lu d'une seule traite et assez 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 de votre projet avec une requête multipart, puis transmet l'id renvoyé à la génération. La limite est de 30 Mo pour JPEG, PNG et WebP. Un fichier qui se trouve 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 signé vers le résultat 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 simple

Demandez une photo 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 rapport d'aspect, puis vérifie la matrice tarifaire en direct avant de dépenser. Vous pouvez toujours nommer des réglages exacts lorsqu'une tâche l'exige. L'agent vous renvoie 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 Codex. 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 Codex. 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 léger travelling avant. L'agent choisit les paramètres, peut d'abord consulter /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 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 requêtes 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 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 Codex

Copiez la compétence ci-dessous et collez-la dans le chat Codex. 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 Codex
Download
> Paste this into the Codex 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/codex.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 utiliser DreamUtopia depuis Codex ?

▼
Non. L'API est en HTTP simple, et la compétence apprend à Codex à 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ù faut-il placer le fichier de compétences dans Codex ?

▼
Collez le bloc de compétences dans le chat Codex. 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 ne doit être créé. Gardez la clé API dans l'environnement du shell sous DREAMUTOPIA_API_KEY, et non dans le texte collé.

Codex 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 aussi bien des vidéos que des images ?

▼
Oui. La même clé couvre le texte-vers-vidéo et l'image-vers-vidéo, avec des durées de cinq à quinze secondes selon le niveau du modèle. Les transitions premier-et-dernier-plan 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 grille tarifaire à jour est disponible via GET /v1/models, et la skill la consulte lorsque vous vous renseignez 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 tranquilles. Un compte peut contenir plusieurs clés afin qu'une intégration puisse être retirée sans toucher aux autres.

Donnez à Codex 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.