- Quand utiliser ce démarrage rapide
- Étape 1 : Obtenez votre clé API Novita
- Étape 2 : Confirmez l'endpoint et le modèle
- Étape 3 : Envoyez votre première requête
- Étape 4 : Interrogez votre résultat
- Exemple Python : de bout en bout
- Exemple cURL
- Paramètres clés
- Ce que Qwen Image génère bien
- Erreurs courantes et correctifs
- FAQ
- Articles recommandés
L’API Qwen Image text-to-image sur Novita AI génère des images à partir de prompts textuels 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 workflow asynchrone : soumettre une requête de génération, obtenir un ID de tâche, interroger pour la complétion et récupérer l’URL de votre image. L’endpoint est POST https://api.novita.ai/v3/async/qwen-image-txt2img.
Quand utiliser ce démarrage rapide
Utilisez ce guide lorsque vous devez :
- Générer des images à partir de prompts textuels avec un rendu de texte 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 sur 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 avec du texte lisible et stylisé intégré dans le résultat — pensez aux affiches, panneaux, maquettes de produits et graphiques de couverture. Si votre cas d’utilisation implique l’édition d’une image existante plutôt que la génération à partir de zéro, consultez plutôt l’API Qwen Image Edit. Si vous souhaitez un aperçu complet des capacités et des benchmarks du modèle Qwen Image, le post de lancement de Qwen Image sur Novita AI couvre en détail l’architecture et les résultats des benchmarks.
Étape 1 : Obtenez 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 comme variable d’environnement :
export NOVITA_API_KEY="votre_clé_api_ici"
Gardez la clé hors du code côté client, des bundles frontend et du contrôle de version.
Étape 2 : Confirmez l’endpoint et le modèle
| Élément | Valeur |
|---|---|
| Endpoint de génération | POST https://api.novita.ai/v3/async/qwen-image-txt2img |
| Endpoint de polling 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 endpoints de génération d’images de Novita AI. L’appel de génération ne renvoie qu’un task_id ; vous interrogez séparément l’endpoint de résultat jusqu’à ce que la tâche soit terminée.
Le tarif est de 0,02 $ par image, cohérent avec l’endpoint 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 : Envoyez votre première requête
Envoyez une requête POST à l’endpoint de génération avec un prompt et un size optionnel :
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 : Interrogez votre résultat
Faites un GET sur l’endpoint de résultat 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"
}
]
}
Le image_url est une URL temporaire — la valeur image_url_ttl (en secondes) vous indique combien de temps elle reste valide. Téléchargez l’image rapidement ou passez par votre propre stockage si vous avez besoin d’un accès à long terme.
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 requête de génération, interroge jusqu’à complétion 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", "inconnu")
raise RuntimeError(f"Échec de la génération : {reason}")
time.sleep(interval)
raise TimeoutError(f"La tâche {task_id} ne s'est pas terminée après {max_attempts} interrogations")
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"ID de la tâche : {task_id}")
image_url = poll_result(task_id)
print(f"URL de l'image : {image_url}")
Exemple cURL
Modèle à deux commandes pour le workflow complet :
# Étape 1 : Soumettre la requête de génération
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 "ID de la tâche : $TASK_ID"
# Étape 2 : Interroger jusqu'à complétion
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 "Statut : $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 "Échec de la génération"
break
fi
sleep 2
done
Paramètres clés
| Paramètre | Type | Requis | Défaut | Remarques |
|---|---|---|---|---|
prompt |
string | Oui | — | Description textuelle de l’image à générer. Prend en charge l’anglais et le chinois. |
size |
string | Non | 1024*1024 |
Largeur × hauteur en pixels, formaté comme W*H. Chaque dimension : 256–1536. |
Options de taille à considérer :
| Cas d’utilisation | 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 séparé negative_prompt, steps ou cfg_scale sur cet endpoint — 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 20B MMDiT 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 peinent avec le texte lisible — les mots deviennent flous, les lettres s’échangent 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 avec légendes deviennent des cas d’utilisation viables plutôt qu’un pari.
Cohérence sémantique. Lorsqu’un prompt décrit une scène avec plusieurs éléments et des relations spatiales spécifiques, Qwen Image tend à respecter l’intention de mise en page de manière plus fiable que les architectures plus petites ou plus anciennes.
Suivi 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 résultats qui reflètent l’ensemble 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 requête et le résultat. Si votre cas d’utilisation nécessite un retour en moins d’une seconde, cet endpoint 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 Bad Request pour size : Le paramètre size doit utiliser * comme séparateur (par exemple, 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 le 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 combien de temps l’URL est valide. Téléchargez l’image immédiatement après la réussite de l’interrogation, ou stockez-la dans votre propre stockage objet.
Interrogation lente : Le temps de génération varie en fonction de la charge du serveur. Commencez l’interrogation à intervalles de 2 secondes, c’est raisonnable. Si la tâche est encore TASK_STATUS_QUEUED après 10 secondes, continuez à interroger — la profondeur de la file d’attente peut augmenter pendant les périodes de pointe.
FAQ
Existe-t-il un endpoint compatible OpenAI pour Qwen Image txt2img ?
Non. L’endpoint /v3/async/qwen-image-txt2img utilise l’API native asynchrone de Novita AI, et non le format de génération d’images OpenAI. Si vous avez besoin d’une génération d’images compatible OpenAI, Novita AI propose des modèles FLUX et SDXL via des endpoints compatibles — consultez la documentation Novita AI.
Quelle est la différence entre cet endpoint et l’endpoint Qwen Image Edit ?
Cet endpoint génère des images à partir d’un prompt textuel uniquement — aucune image d’entrée n’est nécessaire. L’endpoint Qwen Image Edit prend une image existante plus 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 la largeur et la hauteur indépendamment, de 256 à 1536 pixels par dimension. Les ratios hauts (par exemple 1024*1536) fonctionnent bien pour le contenu portrait ; les ratios larges (par exemple 1536*1024) conviennent 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 l’endpoint txt2img. Chaque requête produit un résultat différent. Si vous avez besoin d’une sortie reproductible, enregistrez immédiatement l’URL de l’image 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 requêtes de génération et collectez les ID 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 tâche pour soumettre la suivante.
