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, 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 :

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 :

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 :

{
  "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 :

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

Tâche en cours :

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

Tâche terminée :

{
  "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 :

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 '[email protected]'

Téléverser plusieurs images sources :

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 '[email protected]' \
  -F '[email protected]'

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

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.

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