canonical_url: https://yycode.net/docs/fr/gpt-image-quickstart
lang: fr
updated_at: 2026-07-04T13:33:48.616Z
source_html: https://yycode.net/docs/fr/gpt-image-quickstart

# Guide d'utilisation GPT-Image-2

GPT-Image-2 est le service de génération d'images IA fourni par YYCode. Il utilise l'interface image indépendante `gpt.yycode.net` pour la génération texte-vers-image, image-vers-image et la consultation de tâches asynchrones.

---

## Préparation

### 1. Créer une API Key

Accédez à la [page de gestion des jetons YYCode](https://yycode.net/console/token), puis créez ou copiez une API Key.

Après création, conservez-la soigneusement. Toutes les requêtes suivantes devront transporter cette Key dans le Header.

### 2. Adresse d'interface

GPT-Image-2 utilise une Base URL indépendante :

```
https://gpt.yycode.net
```

Toutes les requêtes image transportent également l'adresse du relais YYCode :

```
x-demo-base-url: https://yycode.net
```

---

## Intégration en un clic pour AI Agent

Lorsque vous utilisez Claude Code, Codex ou d'autres outils de codage IA prenant en charge les Skills, envoyez directement le contenu suivant à l'IA :

```text
Veuillez intégrer le service de génération d'images YYCode GPT-Image-2 à ce projet.

Base URL:
https://gpt.yycode.net

Texte vers image:
POST /api/images/generate

Image vers image:
POST /api/images/edit

Consulter une tâche:
GET /api/jobs/{jobId}

Headers de requête:
x-demo-base-url: https://yycode.net
x-demo-api-key: YOUR_API_KEY
x-demo-async: 1

Le texte-vers-image utilise un corps de requête JSON ; l'image-vers-image utilise multipart/form-data et téléverse l'image source via le champ image.
Après soumission de la tâche et retour du jobId, interroger /api/jobs/{jobId} toutes les 6 secondes.
Lorsque status=succeeded est renvoyé, lire images[].b64 et images[].mimeType, puis enregistrer le base64 en fichier image.
```

L'AI Agent réalisera l'intégration côté client selon les interfaces, Headers, méthode de polling et méthode d'enregistrement d'image ci-dessus.

---

## Détails de l'API

### Texte vers image (Text to Image)

Soumettre une tâche de génération :

```bash
curl 'https://gpt.yycode.net/api/images/generate' \
  -H 'Content-Type: application/json' \
  -H 'x-demo-base-url: https://yycode.net' \
  -H 'x-demo-api-key: YOUR_API_KEY' \
  -H 'x-demo-async: 1' \
  -d '{
    "model": "gpt-image-2",
    "prompt": "un chat mignon fait la sieste au soleil",
    "n": 1,
    "size": "1024x1024"
  }'
```

Réponse réussie :

```json
{
  "ok": true,
  "pending": true,
  "jobId": "job_1782732290788_3",
  "meta": {
    "requestId": "req_1782732290788_1"
  }
}
```

### Consulter le résultat d'une tâche

Remplacez `job_1782732290788_3` par le `jobId` renvoyé lors de la soumission :

```bash
curl 'https://gpt.yycode.net/api/jobs/job_1782732290788_3'
```

**Tâche en cours :**

```json
{
  "ok": true,
  "pending": true,
  "jobId": "job_1782732290788_3",
  "status": "running",
  "meta": {
    "requestId": "req_1782732290788_1"
  }
}
```

**Tâche terminée :**

```json
{
  "ok": true,
  "images": [
    {
      "b64": "iVBORw0KGgo...",
      "filename": null,
      "mimeType": "image/png"
    }
  ],
  "usage": null,
  "raw": {},
  "meta": {
    "requestId": "req_1782732290788_1"
  },
  "jobId": "job_1782732290788_3",
  "status": "succeeded"
}
```

Les données finales de l'image sont `images[0].b64`, et le format est `images[0].mimeType`. Pour l'affichage côté frontend, utilisez `data:${mimeType};base64,${b64}` ; pour le téléchargement, décodez le base64 en fichier image.

---

### Image vers image (Image to Image)

L'image-vers-image utilise `multipart/form-data` pour téléverser l'image source, via le champ `image`.

**Téléverser une image source :**

```bash
curl 'https://gpt.yycode.net/api/images/edit' \
  -H 'x-demo-base-url: https://yycode.net' \
  -H 'x-demo-api-key: YOUR_API_KEY' \
  -H 'x-demo-async: 1' \
  -F 'model=gpt-image-2' \
  -F 'prompt=transformer cette image en style aquarelle' \
  -F 'n=1' \
  -F 'size=1024x1024' \
  -F 'image=@input.png'
```

**Téléverser plusieurs images sources :**

```bash
curl 'https://gpt.yycode.net/api/images/edit' \
  -H 'x-demo-base-url: https://yycode.net' \
  -H 'x-demo-api-key: YOUR_API_KEY' \
  -H 'x-demo-async: 1' \
  -F 'model=gpt-image-2' \
  -F 'prompt=générer une affiche au style cyberpunk cohérent à partir de ces images de référence' \
  -F 'n=1' \
  -F 'size=1536x1024' \
  -F 'image=@subject.png' \
  -F 'image=@style.png'
```

**Points d'attention pour l'image-vers-image :**

- `image` est le champ du fichier image ; pour téléverser plusieurs images, répétez `image`
- `mask` est le champ de masque d'image, utilisé pour l'édition locale
- Ne définissez pas manuellement `Content-Type` dans les en-têtes ; laissez `curl` ou le SDK générer automatiquement la multipart boundary
- Une tâche image-vers-image renvoie également un `jobId`, puis le résultat est consulté via `GET /api/jobs/{jobId}`

---

## Paramètres

| Paramètre | Description |
|---|---|
| `model` | Toujours renseigner `gpt-image-2` |
| `prompt` | Prompt de génération ou d'édition d'image |
| `n` | Nombre d'images générées, de `1` à `10` |
| `size` | Dimensions de sortie, au format `<width>x<height>` |
| `output_format` | Format de sortie, prend en charge `png`, `jpeg`, `webp` |
| `quality` | Qualité d'image, prend en charge `auto`, `low`, `medium`, `high`, `standard`, `hd` |
| `background` | Mode d'arrière-plan, prend en charge `auto`, `opaque` |
| `image` | Champ de fichier image source pour l'image-vers-image, répétable |
| `mask` | Champ de fichier masque pour l'image-vers-image, utilisé pour l'édition locale |

### Prise en charge de size

`size` utilise des dimensions en pixels réels. La largeur et la hauteur doivent être des multiples de `16`, le côté le plus long ne doit pas dépasser `3840`, et le nombre total de pixels ne doit pas dépasser `3840x2160`.

| Taille | Description |
|---|---|
| `1024x1024` | Image carrée |
| `1536x1024` | Image horizontale |
| `1024x1536` | Image verticale |
| `1920x1080` | Image HD horizontale |
| `1080x1920` | Image HD verticale |
| `3840x2160` | Image 4K horizontale |
| `2160x3840` | Image 4K verticale |

---

## Exemple Python

```python
import base64
import time

import requests


# Remplacer par votre API Key YYCode
base_url = "https://gpt.yycode.net"
api_key = "YOUR_API_KEY"

headers = {
    "Content-Type": "application/json",
    "x-demo-base-url": "https://yycode.net",
    "x-demo-api-key": api_key,
    "x-demo-async": "1",
}

# Étape 1 : soumettre la tâche texte-vers-image
submit = requests.post(
    f"{base_url}/api/images/generate",
    headers=headers,
    json={
        "model": "gpt-image-2",
        "prompt": "un chat mignon fait la sieste au soleil",
        "n": 1,
        "size": "1024x1024",
    },
    timeout=30,
)

submit.raise_for_status()
job_id = submit.json()["jobId"]
print(f"Tâche soumise : {job_id}")

# Étape 2 : interroger l'état de la tâche toutes les 6 secondes
while True:
    result = requests.get(
        f"{base_url}/api/jobs/{job_id}",
        timeout=30,
    )
    result.raise_for_status()

    data = result.json()

    if data.get("pending"):
        print("Tâche en cours...")
        time.sleep(6)
        continue

    if data.get("status") == "succeeded":
        # Étape 3 : enregistrer l'image base64 dans un fichier local
        image = data["images"][0]
        mime_type = image.get("mimeType") or "image/png"
        suffix = mime_type.split("/")[-1].replace("jpeg", "jpg")
        filename = f"{job_id}.{suffix}"

        with open(filename, "wb") as file:
            file.write(base64.b64decode(image["b64"]))

        print(f"Génération d'image terminée : {filename}")
        break

    raise RuntimeError(data.get("error", {}).get("message", "Échec de la tâche"))
```

---

## Facturation

- La génération d'image consomme le quota du compte YYCode auquel appartient `x-demo-api-key`
- Le `jobId` renvoyé lors de la soumission indique que la tâche d'arrière-plan a été créée
- Lorsque l'état de la tâche est `succeeded` et que `images` est renvoyé, la génération de cette image est terminée
- Lorsque l'état de la tâche est `failed`, la réponse contient les informations d'erreur
- L'historique d'utilisation du compte est affiché dans l'admin YYCode

---

## Format de retour des images

L'interface image YYCode renvoie un tableau `images` normalisé. Chaque image contient les champs `b64` et `mimeType`. L'intégrateur utilise `b64` pour décoder et enregistrer le fichier, ou concatène `data:${mimeType};base64,${b64}` pour l'afficher côté frontend.
