> ## Documentation Index
> Fetch the complete documentation index at: https://veniceai-mintlify-ce69695c.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Génération d'images

> Générez des images à partir de prompts textuels avec l'endpoint /image/generate de Venice ou l'API compatible OpenAI : styles prédéfinis, sortie base64.

La génération d'images sur Venice est synchrone. Envoyez un prompt à `/image/generate` et recevez votre image dans la même réponse, soit en base64 dans un JSON, soit sous forme binaire brute lorsque `return_binary` est `true`.

## Endpoints

| Endpoint | Objectif | Quand l'utiliser |
| - | - | - |
| `POST /image/generate` | API de génération d'images native de Venice | À utiliser pour bénéficier du support complet des fonctionnalités |
| `GET /image/styles` | Lister les presets de style disponibles | À utiliser avant d'envoyer `style_preset` |
| `POST /images/generations` | API de génération d'images compatible OpenAI | À utiliser lors de la migration de clients d'images OpenAI existants |

## Étape 1 : Envoyer une requête de génération

Le dimensionnement est spécifique au modèle. Certains modèles acceptent `width` et `height` explicites ; d'autres exposent `aspect_ratio` ; et les modèles à paliers de résolution exposent `aspect_ratio` plus des valeurs `resolution` telles que `1K`, `2K` ou `4K`.

<Warning>
  `qwen-image`, `qwen-image-3` et `qwen-image-3-pro` n'acceptent plus `width` ni `height`. L'envoi de l'un ou l'autre renvoie `400` avec *"`width` and `height` are no longer supported for this model. Use `aspect_ratio` instead."* Vérifiez `model_spec.constraints` depuis `GET /models?type=image` avant de choisir les champs de dimensionnement.
</Warning>

**Exemple de dimensionnement basé sur les pixels :**

```bash theme={null}
POST https://api.venice.ai/api/v1/image/generate
Authorization: Bearer $VENICE_API_KEY
Content-Type: application/json

{
  "model": "venice-sd35",
  "prompt": "A cinematic photo of a gondola passing through a narrow Venice canal at blue hour, warm window lights reflecting on the water",
  "negative_prompt": "blurry, low quality, distorted anatomy, text, watermark",
  "width": 1024,
  "height": 1024,
  "format": "webp"
}
```

**Exemple de dimensionnement par ratio d'aspect :**

```bash theme={null}
POST https://api.venice.ai/api/v1/image/generate
Authorization: Bearer $VENICE_API_KEY
Content-Type: application/json

{
  "model": "qwen-image-2",
  "prompt": "A cinematic photo of a gondola passing through a narrow Venice canal at blue hour",
  "aspect_ratio": "16:9",
  "format": "webp"
}
```

**Exemple de dimensionnement par palier de résolution :**

```bash theme={null}
POST https://api.venice.ai/api/v1/image/generate
Authorization: Bearer $VENICE_API_KEY
Content-Type: application/json

{
  "model": "gpt-image-2",
  "prompt": "A cinematic wide shot of a gondola passing through a narrow Venice canal at blue hour",
  "aspect_ratio": "16:9",
  "resolution": "4K",
  "format": "png"
}
```

Le même schéma s'applique aux autres modèles à paliers de résolution :

```json theme={null}
{
  "model": "nano-banana-pro",
  "prompt": "A serene canal in Venice at sunset",
  "aspect_ratio": "16:9",
  "resolution": "2K"
}
```

Utilisez [Modèles d'image](/models/image) ou l'[API Models](/api-reference/endpoint/models/list) pour confirmer quels champs de dimensionnement chaque modèle accepte.

**Réponse (200) :**

```json theme={null}
{
  "id": "generate-image-1234567890",
  "images": [
    "UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoQABAAPm..."
  ],
  "timing": {
    "inferenceDuration": 1840,
    "inferencePreprocessingTime": 22,
    "inferenceQueueTime": 31,
    "total": 1893
  }
}
```

Le tableau `images` contient des données d'image encodées en base64. Décodez le premier élément pour l'enregistrer ou l'afficher. `timing.total` correspond à la durée complète de la requête en millisecondes.

## Étape 2 : Décoder et enregistrer l'image

<CodeGroup>
  ```python Python theme={null}
  import base64
  import os
  import requests

  response = requests.post(
      "https://api.venice.ai/api/v1/image/generate",
      headers={
          "Authorization": f"Bearer {os.environ['VENICE_API_KEY']}",
          "Content-Type": "application/json",
      },
      json={
          "model": "venice-sd35",
          "prompt": "A cinematic photo of a gondola passing through a narrow Venice canal at blue hour, warm window lights reflecting on the water",
          "width": 1024,
          "height": 1024,
          "format": "webp",
      },
  )

  data = response.json()
  image_bytes = base64.b64decode(data["images"][0])

  with open("output.webp", "wb") as f:
      f.write(image_bytes)

  print(f"Saved image from request {data['id']}")
  ```

  ```javascript Node.js theme={null}
  import fs from "fs";

  const response = await fetch("https://api.venice.ai/api/v1/image/generate", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.VENICE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "venice-sd35",
      prompt: "A cinematic photo of a gondola passing through a narrow Venice canal at blue hour, warm window lights reflecting on the water",
      width: 1024,
      height: 1024,
      format: "webp",
    }),
  });

  const data = await response.json();
  const imageBuffer = Buffer.from(data.images[0], "base64");
  fs.writeFileSync("output.webp", imageBuffer);

  console.log(`Saved image from request ${data.id}`);
  ```
</CodeGroup>

## Étape 3 : Renvoyer du binaire au lieu de JSON (optionnel)

Si vous souhaitez que le corps de la réponse soit le fichier image lui-même, définissez `return_binary: true`. C'est utile lorsque vous voulez diffuser ou enregistrer l'image directement sans décodage base64.

```bash theme={null}
curl https://api.venice.ai/api/v1/image/generate \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -o output.png \
  -d '{
    "model": "qwen-image-2",
    "prompt": "Minimalist poster of a moonlit Venetian bridge in deep blue tones",
    "format": "png",
    "return_binary": true
  }'
```

Lorsque `return_binary` est `true`, le corps de la réponse correspond à des données brutes `image/jpeg`, `image/png` ou `image/webp` selon le `format` que vous avez demandé.

<Note>
  `variants` n'est pris en charge que lorsque `return_binary` est `false`.
</Note>

***

## Étape 4 : Lister les styles d'image disponibles (optionnel)

Si vous souhaitez utiliser `style_preset`, récupérez d'abord les styles disponibles depuis `/image/styles` :

```bash theme={null}
curl https://api.venice.ai/api/v1/image/styles \
  -H "Authorization: Bearer $VENICE_API_KEY"
```

**Réponse (200) :**

```json theme={null}
{
  "object": "list",
  "data": [
    "3D Model",
    "Analog Film",
    "Anime",
    "Cinematic",
    "Digital Art"
  ]
}
```

Les noms de styles se trouvent dans `data`, pas au niveau supérieur — lisez `response.data` plutôt que d'itérer directement sur l'objet de réponse.

Puis transmettez l'une de ces valeurs dans votre requête de génération :

```json theme={null}
{
  "model": "qwen-image-2",
  "prompt": "A futuristic Venice skyline at sunrise",
  "style_preset": "Cinematic"
}
```

Utilisez l'endpoint des styles lorsque vous voulez les noms exacts des presets plutôt que de les deviner.

***

## Paramètres de la requête

| Paramètre | Type | Requis | Par défaut | Description |
| - | - | - | - | - |
| `model` | string | Oui | - | Identifiant du modèle à utiliser pour la génération |
| `prompt` | string | Oui | - | Ce qu'il faut générer |
| `negative_prompt` | string | Non | - | Ce qu'il faut éviter dans l'image |
| `width` | integer | Non | `1024` | Largeur de sortie en pixels pour les modèles basés sur les pixels tels que `venice-sd35`. Rejeté par la famille Qwen Image — voir la note ci-dessous |
| `height` | integer | Non | `1024` | Hauteur de sortie en pixels pour les modèles basés sur les pixels tels que `venice-sd35`. Rejeté par la famille Qwen Image — voir la note ci-dessous |
| `format` | string | Non | `webp` | Format de sortie : `jpeg`, `png` ou `webp` |
| `variants` | integer | Non | `1` | Nombre d'images à générer (`1`-`4`), uniquement lorsque `return_binary` est `false` |
| `return_binary` | boolean | Non | `false` | Renvoyer les octets bruts de l'image au lieu de JSON base64 |
| `safe_mode` | boolean | Non | `true` | Floute le contenu pour adultes lorsque activé |
| `seed` | integer | Non | aléatoire | Réutilisez la même seed pour des itérations plus cohérentes |
| `cfg_scale` | number | Non | dépend du modèle | Des valeurs plus élevées poussent le modèle à suivre le prompt plus étroitement |
| `style_preset` | string | Non | - | Applique un style préréglé depuis [Image Styles](/api-reference/endpoint/image/styles) |
| `aspect_ratio` | string | Conditionnel | - | Utilisé par les modèles prenant en charge le dimensionnement basé sur le ratio, tels que `qwen-image-2`, `gpt-image-2`, `nano-banana-2` et `nano-banana-pro` |
| `resolution` | string | Conditionnel | - | Utilisé par les modèles prenant en charge les paliers de résolution tels que `1K`, `2K` ou `4K` |
| `enable_web_search` | boolean | Conditionnel | `false` | Permet aux modèles compatibles d'utiliser des informations web actuelles ; coût supplémentaire |

La validation est spécifique au modèle. Consultez [Modèles d'image](/models/image) et l'[API Models](/api-reference/endpoint/models/list) avant de compter sur un paramètre à travers plusieurs modèles.

***

## Options spécifiques aux modèles

### Génération haute résolution

Certains modèles d'image prennent en charge `aspect_ratio` sans palier `resolution` sélectionnable. Par exemple, `qwen-image-2` accepte le ratio d'aspect et le mappe à des dimensions de sortie spécifiques au modèle :

```json theme={null}
{
  "model": "qwen-image-2",
  "prompt": "Editorial product photo of a luxury watch on black marble, dramatic studio lighting",
  "aspect_ratio": "16:9"
}
```

D'autres modèles d'image prennent en charge `aspect_ratio` plus un palier `resolution`. Par exemple, `gpt-image-2`, `nano-banana-2` et `nano-banana-pro` prennent en charge `1K`, `2K` et `4K` :

```json theme={null}
{
  "model": "gpt-image-2",
  "prompt": "Editorial product photo of a luxury watch on black marble, dramatic studio lighting",
  "aspect_ratio": "16:9",
  "resolution": "4K"
}
```

```json theme={null}
{
  "model": "nano-banana-2",
  "prompt": "Editorial product photo of a luxury watch on black marble, dramatic studio lighting",
  "aspect_ratio": "16:9",
  "resolution": "2K"
}
```

Utilisez [Modèles d'image](/models/image) pour voir quels modèles prennent en charge des résolutions plus élevées et comment ils sont tarifés.

### Contenu adulte et mode sûr

`safe_mode` contrôle si le contenu adulte présent dans la sortie de génération est flouté. La valeur par défaut est `true`. Définissez-le à `false` si votre cas d'usage autorise le contenu adulte et que vous souhaitez la sortie brute :

```json theme={null}
{
  "model": "lustify-v8",
  "prompt": "…",
  "safe_mode": false
}
```

Certains modèles d'image sont spécifiquement conçus pour la génération adulte / non censurée et se combinent bien avec `safe_mode: false`. Parmi les exemples figurant sur la page de tarification, on trouve `lustify-sdxl`, `lustify-v7` et `lustify-v8`. Voir [Modèles d'image](/models/image) et [Tarification](/overview/pricing) pour la liste actuelle et les coûts par modèle.

Pour l'édition d'images existantes, le modèle d'édition par défaut `qwen-edit` bloque l'imagerie sexuelle explicite. Si vous avez besoin d'une édition non censurée, utilisez `qwen-edit-uncensored` via [Édition d'image](/guides/media/image-editing).

Lorsque `safe_mode` est activé et que le modèle renvoie une sortie floutée ou modérée, inspectez les en-têtes de réponse `x-venice-is-blurred` et `x-venice-is-content-violation` si vous avez besoin de détecter cela de manière programmatique.

### Presets de style

Si le modèle sélectionné le prend en charge, `style_preset` vous permet d'orienter la sortie sans réécrire l'intégralité de votre prompt. Vous pouvez récupérer les noms valides des presets depuis [Image Styles](/api-reference/endpoint/image/styles) :

```json theme={null}
{
  "model": "qwen-image-2",
  "prompt": "A futuristic Venice skyline at sunrise",
  "style_preset": "3D Model"
}
```

Voir [Image Styles](/api-reference/endpoint/image/styles) pour la liste actuelle des styles.

***

## Endpoint compatible OpenAI

Si vous utilisez déjà les SDK d'image OpenAI ou des intégrations DALL-E existantes, Venice prend également en charge `POST /images/generations`. Il offre un format de requête plus simple, mais moins de fonctionnalités que l'endpoint natif de Venice.

**Requête :**

```json theme={null}
{
  "model": "qwen-image-2",
  "prompt": "A clean isometric illustration of an AI control room",
  "size": "1024x1024",
  "response_format": "b64_json"
}
```

Utilisez la route compatible OpenAI pour des migrations plus rapides. Utilisez `/image/generate` lorsque vous avez besoin d'options spécifiques à Venice telles que `cfg_scale`, `style_preset`, `variants` ou des réponses binaires.

### Contrôler le floutage du contenu adulte sur `/images/generations`

L'endpoint compatible OpenAI n'accepte pas `safe_mode`. Son envoi renvoie une erreur `400` avec `Unrecognized key(s) in object: 'safe_mode'`. Utilisez plutôt le paramètre `moderation` de style OpenAI :

| Valeur | Comportement |
| - | - |
| `auto` (par défaut) | Active le mode Safe Venice et floute le contenu adulte |
| `low` | Désactive le mode Safe Venice ; renvoie la sortie non floutée |

```json theme={null}
{
  "model": "lustify-v8",
  "prompt": "…",
  "size": "1024x1024",
  "response_format": "b64_json",
  "moderation": "low"
}
```

`safe_mode` ne fonctionne que sur l'endpoint natif `POST /image/generate`. `moderation` ne fonctionne que sur l'endpoint compatible OpenAI `POST /images/generations`.

***

## Conseils de prompting

1. Commencez par le sujet, puis ajoutez le médium, l'éclairage, la composition et l'ambiance.
2. Placez les détails à éviter absolument dans `negative_prompt` plutôt que de surcharger le prompt principal.
3. Réutilisez `seed` lors des itérations afin de comparer les changements de prompt sans modifier totalement la composition.
4. Adaptez le dimensionnement au modèle. Certains modèles utilisent `width`/`height`, d'autres `aspect_ratio`, et les modèles à paliers de résolution utilisent `aspect_ratio` plus `resolution`.
5. Utilisez `variants` pendant l'exploration, puis revenez à une seule sortie une fois la direction définie.

***

## Erreurs

| Statut | Signification | Action |
| - | - | - |
| `400` | Paramètres de requête invalides | Vérifiez les noms de champs, les types et les contraintes spécifiques au modèle |
| `401` | Échec d'authentification ou le modèle requiert un palier d'accès supérieur | Vérifiez votre clé API et votre accès au modèle |
| `402` | Solde insuffisant | Ajoutez des crédits sur [venice.ai/settings/api](https://venice.ai/settings/api?utm_source=venice-api-documentation) |
| `415` | Type de contenu invalide | Envoyez du JSON avec `Content-Type: application/json` |
| `429` | Limite de débit dépassée ou modèle surchargé | Réessayez avec un backoff ; vérifiez l'en-tête `Retry-After` |
| `500` | Échec du traitement d'inférence | Réessayez la requête |
| `503` | Modèle à pleine capacité | Réessayez après un court délai |

<Note>
  Lorsque Safe Venice est activé, inspectez les en-têtes de réponse tels que `x-venice-is-blurred` et `x-venice-is-content-violation` si vous devez détecter les résultats de modération de manière programmatique.
</Note>

***

## Modèles disponibles

Voir [Modèles d'image](/models/image) pour la liste actuelle des modèles, les tarifs et le support des fonctionnalités.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.