Démarrage rapide avec l’API Qwen Image Text-to-Image pour générer des images à partir de prompts

L’API Qwen Image text-to-image sur Novita AI génère des images à partir de descriptions textuelles en utilisant le modèle Qwen Image 20B — la même base qui alimente l’API Qwen Image Edit pour des tâches d’édition précises. Ce démarrage rapide couvre l’intégralité du flux asynchrone : soumettre une demande de génération, obtenir un identifiant de tâche, interroger jusqu’à la fin et récupérer l’URL de votre image. Le point de terminaison est POST https://api.novita.ai/v3/async/qwen-image-txt2img.

Quand utiliser ce démarrage rapide

Utilisez ce guide lorsque vous avez besoin de :

• Générer des images à partir de prompts textuels avec un rendu textuel de haute qualité en anglais ou en chinois via POST /v3/async/qwen-image-txt2img.
• Construire des pipelines qui créent des affiches, des ressources graphiques ou du contenu illustré où la lisibilité du texte dans l’image est importante.
• Prototyper rapidement avec une API hébergée plutôt que d’exécuter le modèle 20B sur une infrastructure GPU locale.

Le modèle Qwen Image est particulièrement performant pour générer des images contenant du texte lisible et stylisé intégré à la sortie — pensez aux affiches, panneaux, maquettes de produits et graphiques de couverture. Si votre cas d’usage implique de modifier une image existante plutôt que de la générer à partir de zéro, consultez plutôt l’API Qwen Image Edit. Pour un aperçu complet des capacités et des benchmarks du modèle Qwen Image, le billet de lancement de Qwen Image sur Novita AI couvre l’architecture et les résultats des benchmarks en détail.

Étape 1 : Obtenir votre clé API Novita

Créez un compte Novita AI et accédez à la gestion des clés API. Générez une clé et stockez-la en tant que variable d’environnement :

export NOVITA_API_KEY="votre_cle_api_ici"

Gardez la clé hors du code côté client, des bundles frontend et du contrôle de version.

Étape 2 : Confirmer le point de terminaison et le modèle

Élément	Valeur
Point de terminaison de génération	POST https://api.novita.ai/v3/async/qwen-image-txt2img
Point de terminaison d’interrogation des résultats	GET https://api.novita.ai/v3/async/task-result?task_id=<id>
Modèle	Qwen Image (20B MMDiT)
Documentation API	Référence Qwen Image txt2img de Novita AI

L’API suit un modèle asynchrone en deux étapes commun à tous les points de terminaison de génération d’images de Novita AI. L’appel de génération ne renvoie qu’un task_id ; vous interrogez le point de terminaison de résultat séparément jusqu’à ce que la tâche soit terminée.

Le prix est de 0,02 $ par image, cohérent avec le point de terminaison Qwen Image Edit. Vérifiez le tarif actuel sur la page de tarification de Novita AI avant d’établir une estimation des coûts.

Étape 3 : Envoyer votre première requête

POSTez sur le point de terminaison de génération avec un prompt et un size facultatif :

curl -s -X POST https://api.novita.ai/v3/async/qwen-image-txt2img \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A cinematic mountain landscape at sunrise, warm golden light, ultra-detailed, 8K",
    "size": "1024*1024"
  }'

Une réponse 200 réussie renvoie :

{
  "task_id": "abc123..."
}

Enregistrez le task_id. Vous l’utiliserez à l’étape suivante.

Étape 4 : Interroger pour obtenir votre résultat

GET le point de terminaison de résultat de tâche avec le task_id comme paramètre de requête :

curl -s "https://api.novita.ai/v3/async/task-result?task_id=abc123..." \
  -H "Authorization: Bearer $NOVITA_API_KEY"

La réponse inclut un champ status. Continuez à interroger jusqu’à ce que le statut soit TASK_STATUS_SUCCEED :

{
  "task": {
    "task_id": "abc123...",
    "status": "TASK_STATUS_SUCCEED"
  },
  "images": [
    {
      "image_url": "https://...",
      "image_url_ttl": "3600",
      "image_type": "png"
    }
  ]
}

L’image_url est une URL temporaire — la valeur image_url_ttl (en secondes) indique sa durée de validité. Téléchargez l’image rapidement ou proxifiez-la via votre propre stockage si vous avez besoin d’un accès à long terme.

Les statuts à gérer :

Statut	Signification
TASK_STATUS_QUEUED	La requête est en file d’attente, pas encore démarrée
TASK_STATUS_PROCESSING	Génération en cours
TASK_STATUS_SUCCEED	L’image est prête ; lisez images[0].image_url
TASK_STATUS_FAILED	La génération a échoué ; vérifiez task.reason

Exemple Python : de bout en bout

Ce script soumet une demande de génération, interroge jusqu’à la fin et affiche l’URL de l’image.

import os
import time
import requests

API_KEY = os.environ["NOVITA_API_KEY"]
BASE_URL = "https://api.novita.ai"


def generate_image(prompt: str, size: str = "1024*1024") -> str:
    response = requests.post(
        f"{BASE_URL}/v3/async/qwen-image-txt2img",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json",
        },
        json={"prompt": prompt, "size": size},
    )
    response.raise_for_status()
    return response.json()["task_id"]


def poll_result(task_id: str, interval: float = 2.0, max_attempts: int = 60) -> str:
    for _ in range(max_attempts):
        response = requests.get(
            f"{BASE_URL}/v3/async/task-result",
            headers={"Authorization": f"Bearer {API_KEY}"},
            params={"task_id": task_id},
        )
        response.raise_for_status()
        data = response.json()
        status = data["task"]["status"]

        if status == "TASK_STATUS_SUCCEED":
            return data["images"][0]["image_url"]
        elif status == "TASK_STATUS_FAILED":
            reason = data["task"].get("reason", "unknown")
            raise RuntimeError(f"Generation failed: {reason}")

        time.sleep(interval)

    raise TimeoutError(f"Task {task_id} did not complete after {max_attempts} polls")


if __name__ == "__main__":
    prompt = (
        "A poster reading 'Welcome to Novita AI' in bold neon letters "
        "against a dark city skyline at night, cinematic lighting"
    )
    task_id = generate_image(prompt, size="1024*1024")
    print(f"Task ID: {task_id}")

    image_url = poll_result(task_id)
    print(f"Image URL: {image_url}")

Exemple cURL

Modèle en deux commandes pour le flux complet :

# Step 1: Submit generation request
TASK_ID=$(curl -s -X POST https://api.novita.ai/v3/async/qwen-image-txt2img \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A serene Japanese garden with cherry blossoms, koi pond, morning mist, watercolor style",
    "size": "1024*1536"
  }' | python3 -c "import sys,json; print(json.load(sys.stdin)['task_id'])")

echo "Task ID: $TASK_ID"

# Step 2: Poll until complete
while true; do
  STATUS=$(curl -s "https://api.novita.ai/v3/async/task-result?task_id=$TASK_ID" \
    -H "Authorization: Bearer $NOVITA_API_KEY")
  STATE=$(echo $STATUS | python3 -c "import sys,json; print(json.load(sys.stdin)['task']['status'])")
  echo "Status: $STATE"
  if [ "$STATE" = "TASK_STATUS_SUCCEED" ]; then
    echo $STATUS | python3 -c "import sys,json; print(json.load(sys.stdin)['images'][0]['image_url'])"
    break
  elif [ "$STATE" = "TASK_STATUS_FAILED" ]; then
    echo "Generation failed"
    break
  fi
  sleep 2
done

Paramètres clés

Paramètre	Type	Obligatoire	Défaut	Remarques
prompt	chaîne	Oui	—	Description textuelle de l’image à générer. Prend en charge l’anglais et le chinois.
size	chaîne	Non	1024*1024	Largeur × hauteur en pixels, formaté comme W*H. Chaque dimension : 256–1536.

Options de taille à considérer :

Cas d’usage	Taille recommandée
Carré (réseaux sociaux, profil)	1024*1024
Portrait (mobile, affiche)	1024*1536
Paysage (bannière, miniature)	1536*1024

Il n’y a pas de paramètre negative_prompt, steps ou cfg_scale sur ce point de terminaison — le modèle gère ces décisions en interne. Concentrez votre prompt sur ce que l’image doit contenir et son style visuel.

Ce que Qwen Image génère bien

L’architecture MMDiT de 20B donne à Qwen Image un avantage certain dans quelques domaines spécifiques :

Texte dans les images. La plupart des modèles de génération d’images ont du mal avec le texte lisible — les mots se brouillent, les lettres s’inversent et les mises en page multi-lignes s’effondrent. Qwen Image gère le texte en anglais et en chinois avec une précision nettement meilleure. Les affiches, panneaux, étiquettes et graphiques légendés sont des cas d’utilisation viables plutôt qu’un jeu de hasard.

Cohérence sémantique. Lorsqu’un prompt décrit une scène avec plusieurs éléments et des relations spatiales spécifiques, Qwen Image a tendance à respecter l’intention de mise en page de manière plus fiable que les architectures plus petites ou plus anciennes.

Respect des prompts à grande échelle. Les prompts longs et détaillés qui décrivent plusieurs attributs — scène, éclairage, style, palette de couleurs, objets spécifiques — produisent des sorties qui reflètent l’intégralité du prompt plutôt que de se focaliser sur un mot-clé.

Là où il est moins adapté : les workflows de génération en temps réel ou interactifs. Le modèle asynchrone implique une latence inhérente entre la demande et le résultat. Si votre cas d’usage nécessite un feedback en moins d’une seconde, ce point de terminaison n’est pas le bon choix.

Erreurs courantes et correctifs

401 Non autorisé : Vérifiez que l’en-tête Authorization est formaté comme Bearer <clé> avec un espace après Bearer. Vérifiez que la clé est active dans la console Novita AI.

400 Mauvaise requête sur size : Le paramètre size doit utiliser * comme séparateur (ex : 1024*1024), pas x, × ou un tableau JSON. Chaque dimension doit être comprise entre 256 et 1536.

TASK_STATUS_FAILED sans raison : Généralement causé par un prompt qui déclenche un filtrage de contenu. Simplifiez le prompt et réessayez. Évitez les prompts avec violence explicite, contenu sexuel ou contenu pouvant correspondre aux filtres de sécurité.

URL de l’image expirée (403 ou 404 sur l’URL) : Le champ image_url_ttl vous indique la durée de validité de l’URL. Téléchargez l’image immédiatement après la réussite de l’interrogation, ou stockez-la dans votre propre stockage d’objets.

Interrogation lente : Le temps de génération varie en fonction de la charge du serveur. Commencer l’interrogation à des intervalles de 2 secondes est raisonnable. Si la tâche est toujours TASK_STATUS_QUEUED après 10 secondes, continuez à interroger — la profondeur de la file d’attente peut augmenter en période de forte utilisation.

FAQ

Existe-t-il un point de terminaison compatible OpenAI pour Qwen Image txt2img ?

Non. Le point de terminaison /v3/async/qwen-image-txt2img utilise l’API d’image asynchrone native de Novita AI, et non le format de génération d’image OpenAI. Si vous avez besoin d’une génération d’image compatible OpenAI, Novita AI propose des modèles FLUX et SDXL via des points de terminaison compatibles — consultez la documentation Novita AI.

Quelle est la différence entre ce point de terminaison et le point de terminaison Qwen Image Edit ?

Ce point de terminaison génère des images uniquement à partir d’un prompt textuel — aucune image d’entrée n’est nécessaire. Le point de terminaison Qwen Image Edit prend une image existante ainsi qu’une instruction textuelle et modifie l’image en conséquence. Utilisez txt2img lorsque vous créez à partir de zéro ; utilisez edit lorsque vous devez modifier quelque chose dans une image existante.

Le modèle prend-il en charge des ratios d’aspect autres que le carré ?

Oui. Utilisez le paramètre size pour définir indépendamment la largeur et la hauteur, de 256 à 1536 pixels par dimension. Les ratios hauts (ex : 1024*1536) conviennent bien au contenu portrait ; les ratios larges (ex : 1536*1024) sont adaptés aux bannières et miniatures.

Comment obtenir des résultats cohérents sur plusieurs générations ?

Il n’y a pas de paramètre seed sur le point de terminaison txt2img. Chaque requête produit un résultat différent. Si vous avez besoin d’une sortie reproductible, sauvegardez l’URL de l’image immédiatement et stockez l’image dans votre propre stockage plutôt que de la régénérer.

Puis-je utiliser cette API dans un travail par lots ?

Oui. Soumettez plusieurs demandes de génération et collectez les identifiants de tâche, puis interrogez-les en parallèle. Chaque requête renvoie son propre task_id, donc les workflows par lots sont simples — vous n’avez pas besoin d’attendre la fin d’une pour soumettre la suivante.

Articles recommandés

• Qwen-Image sur Novita AI : rendu textuel supérieur avec le modèle 20B
• Qwen-Image-Edit sur Novita AI : édition de qualité professionnelle pour seulement 0,02 $
• FLUX.1 Kontext Pro vs Max vs Dev sur Novita AI