API Qwen Image 3.0 : tarifs et intégration

Qwen Image 3.0 réunit la génération texte-image et l'édition à partir d'images de référence dans une API asynchrone. Avec APIMart, vous soumettez une tâche, interrogez son état, puis récupérez une ou plusieurs images une fois le traitement terminé.

Ce guide couvre les points essentiels avant l'intégration : tarifs Standard et Pro, authentification, paramètres, lecture des réponses, polling, relances et stockage. Pour les capacités et benchmarks, consultez le guide de lancement de Qwen Image 3.0.

Tarifs et accès à Qwen Image 3.0

APIMart propose deux identifiants de modèle :

• qwen-image-3.0 pour Standard
• qwen-image-3.0-pro pour Pro

La facturation s'effectue par image générée et non par Token d'entrée. Le tableau reprend la page des tarifs APIMart au 27 août 2026 ; ces montants peuvent évoluer.

Comparaison des tarifs Standard et Pro

Standard affiche actuellement le même prix en 1K et en 2K. Pro 2K coûte deux fois plus que Pro 1K. Selon la documentation Qwen Image 3.0, les générations échouées sont remboursées et les images de référence n'ajoutent pas de frais de génération séparés.

Estimer une charge réelle

La formule de base est la suivante :

coût mensuel = nombre d'images terminées × prix par image

n définit le nombre de sorties : une requête avec n: 4 peut donc facturer quatre images. Incluez dans le budget les essais de prompts, les variantes et les régénérations.

Standard convient à la plupart des brouillons et ressources courantes. Évaluez Pro si l'amélioration du texte, de la composition ou des détails justifie le surcoût. Avec Pro, utilisez 1K pendant les itérations et réservez 2K aux résultats haute résolution validés.

Accès et authentification

Créez un compte APIMart, ajoutez un solde suffisant et générez une clé dans la console. Conservez-la dans un Secret ou une variable d'environnement côté serveur ; ne l'exposez jamais dans le navigateur ni dans une variable NEXT_PUBLIC_*.

Base URL et Bearer Token

Les exemples utilisent cette Base URL :

https://api.apimart.ai/v1

Envoyez la clé sous forme de Bearer Token :

Authorization: Bearer <your_api_key>
Content-Type: application/json

Une clé absente ou invalide produit généralement 401, un solde insuffisant peut produire 402 et une limitation de débit, 429. Journalisez la réponse et le contexte côté serveur, mais masquez la clé avant de conserver les logs.

Génération, édition et workflow asynchrone

La génération et l'édition utilisent toutes deux POST /v1/images/generations. L'API renvoie d'abord un identifiant de tâche au lieu d'attendre l'image finale.

Paramètres principaux

Pour des dimensions personnalisées, chaque côté doit mesurer entre 512 et 2 048 pixels et le ratio rester entre 1:8 et 8:1. Les références acceptent JPEG, PNG, BMP, TIFF, WebP et GIF, avec une limite documentée de 10 Mo par image. Vérifiez la référence de génération avant la mise en ligne, car les limites peuvent changer.

L'annonce officielle de Qwen Image 3.0 mentionne un rendu natif du texte dans 12 langues. Placez entre guillemets le texte qui doit apparaître exactement et contrôlez orthographe, style typographique et mise en page à la résolution cible.

Exemple texte-image

{
  "model": "qwen-image-3.0",
  "prompt": "Une bannière produit épurée avec le texte exact \"Soldes d'été\", typographie géométrique en gras et fond orange chaud",
  "resolution": "1K",
  "size": "16:9",
  "n": 1,
  "prompt_extend": true
}

Exemple d'édition avec une référence

Ajoutez image_urls pour transformer une image existante :

{
  "model": "qwen-image-3.0-pro",
  "prompt": "Conserver exactement la forme du produit et remplacer le fond par un studio à l'éclairage doux",
  "image_urls": [
    "https://example.com/reference-product.png"
  ],
  "resolution": "2K",
  "n": 1
}

L'URL de référence doit être accessible par l'API. Pour un fichier privé, utilisez une URL signée dont la validité couvre l'envoi et le traitement, ou une Data URL compatible lorsque cela convient.

Workflow asynchrone

Le flux comporte trois étapes :

1. Soumettre une tâche avec POST /v1/images/generations.
2. Lire data[0].task_id dans la réponse.
3. Interroger GET /v1/tasks/{task_id} jusqu'à la réussite ou l'échec.

Réponse de soumission

Une soumission réussie possède cette structure :

{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_example"
    }
  ]
}

Ne cherchez pas task_id à la racine : il se trouve dans le premier élément de data.

Polling et résultat final

Interrogez l'état toutes les trois à cinq secondes plutôt que d'envoyer des requêtes en continu. Les fichiers terminés se trouvent dans data.result.images :

{
  "code": 200,
  "data": {
    "status": "completed",
    "result": {
      "images": [
        {
          "url": [
            "https://example-cdn.com/generated-image.png"
          ]
        }
      ]
    }
  }
}

La documentation actuelle indique qu'APIMart réplique les images terminées sur son CDN et les conserve à long terme. Copiez tout de même les ressources validées vers votre propre stockage si vous devez maîtriser la conservation, la suppression, l'accès ou les performances de diffusion.

Exemples d'intégration

Intégration Python

Cet exemple côté serveur soumet une tâche, l'interroge toutes les trois secondes et arrête l'attente après trois minutes :

import os
import time
import requests

API_KEY = os.environ["QWEN_API_KEY"]
BASE_URL = "https://api.apimart.ai/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

def generate_image(prompt: str) -> str:
    response = requests.post(
        f"{BASE_URL}/images/generations",
        headers=HEADERS,
        json={"model": "qwen-image-3.0", "prompt": prompt, "resolution": "1K", "n": 1, "prompt_extend": True},
        timeout=30,
    )
    response.raise_for_status()
    task_id = response.json()["data"][0]["task_id"]
    deadline = time.monotonic() + 180

    while time.monotonic() < deadline:
        poll = requests.get(f"{BASE_URL}/tasks/{task_id}", headers=HEADERS, timeout=30)
        poll.raise_for_status()
        task = poll.json()["data"]
        if task["status"] == "completed":
            return task["result"]["images"][0]["url"][0]
        if task["status"] == "failed":
            raise RuntimeError(task.get("fail_reason", "Generation failed"))
        time.sleep(3)

    raise TimeoutError(f"Task {task_id} did not finish within 180 seconds")

Dans une application réelle, persistez l'identifiant avant le polling. Si un Worker redémarre, un autre pourra reprendre la tâche enregistrée sans soumettre et payer une génération en double.

Intégration JavaScript

Exécutez ce code uniquement dans un environnement serveur de confiance :

const apiKey = process.env.QWEN_API_KEY;
const baseUrl = "https://api.apimart.ai/v1";
const headers = { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" };

async function requestJson(url, options = {}) {
  const response = await fetch(url, { ...options, headers });
  const payload = await response.json();
  if (!response.ok) throw new Error(`APIMart ${response.status}: ${JSON.stringify(payload)}`);
  return payload;
}

async function generateImage(prompt) {
  const submission = await requestJson(`${baseUrl}/images/generations`, {
    method: "POST",
    body: JSON.stringify({
      model: "qwen-image-3.0", prompt, resolution: "1K", n: 1, prompt_extend: true,
    }),
  });
  const taskId = submission.data[0].task_id;
  const deadline = Date.now() + 180_000;

  while (Date.now() < deadline) {
    await new Promise((resolve) => setTimeout(resolve, 3000));
    const { data: task } = await requestJson(`${baseUrl}/tasks/${taskId}`);
    if (task.status === "completed") return task.result.images[0].url[0];
    if (task.status === "failed") throw new Error(task.fail_reason ?? "Generation failed");
  }
  throw new Error(`Task ${taskId} did not finish within 180 seconds`);
}

Le même flux peut être testé avec cURL :

curl -X POST https://api.apimart.ai/v1/images/generations \
  -H "Authorization: Bearer <your_api_key>" \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen-image-3.0","prompt":"Une photographie de produit minimaliste","resolution":"1K","n":1}'

curl https://api.apimart.ai/v1/tasks/<task_id> \
  -H "Authorization: Bearer <your_api_key>"

Checklist pour la production

Un appel réussi n'est qu'un début. Un pipeline fiable exige aussi des relances limitées, un état persistant, de l'observabilité et un stockage maîtrisé.

Erreurs et stratégie de relance

Ne resoumettez pas aveuglément une génération après un timeout réseau ambigu. Si le serveur a accepté la première requête, la seconde peut créer une tâche et un coût en double. Enregistrez chaque ID et séparez les relances de soumission de celles du polling.

Avant le lancement

• Conserver la clé uniquement dans un Secret serveur.
• Valider prompt, resolution, size, n et les références avant l'envoi.
• Persister l'identifiant et l'état de la tâche.
• Interroger toutes les trois à cinq secondes avec un timeout applicatif.
• Utiliser un backoff exponentiel avec jitter pour 429 et les 5xx relançables.
• Limiter la concurrence selon les débits et latences observés.
• Suivre séparément tâches terminées, échouées, expirées et dupliquées.
• Copier les résultats validés vers votre stockage si la conservation doit être maîtrisée.
• Avant la production, revérifier la page du modèle Qwen Image 3.0, les tarifs et la documentation.

Générez des images avec Qwen Image 3.0

Testez Standard et Pro avec l'API unifiée d'APIMart, comparez les sorties 1K et 2K et faites passer votre workflow d'image du prototype à la production.

Découvrir Qwen Image 3.0

Questions fréquentes

Combien de temps faut-il interroger avant le timeout ?

APIMart recommande un intervalle de trois à cinq secondes et environ trois minutes de timeout client. Utilisez ces valeurs comme point de départ, mesurez la latence réelle et conservez l'identifiant pour réconcilier plus tard les tâches expirées.

Les URL de résultat expirent-elles après 24 heures ?

La documentation actuelle indique que les sorties sont répliquées sur le CDN de la plateforme et restent disponibles à long terme. L'ancienne mention de 24 heures ne s'applique donc pas à cette intégration. Stockez les ressources critiques dans votre infrastructure plutôt que de dépendre d'une conservation externe sans durée garantie.

Puis-je envoyer une référence en Base64 ?

Oui. La documentation accepte une à trois URL publiques HTTP/HTTPS ou Data URL Base64 compatibles dans image_urls. Chaque image doit respecter les formats pris en charge et la limite de 10 Mo.

Quand choisir 1K ou 2K ?

Utilisez 1K pour les itérations rapides et les ressources qui n'exigent pas un maximum de détails. Choisissez 2K pour les images finales riches en texte, aux contours fins ou destinées à un grand affichage. Standard affiche actuellement le même tarif dans les deux résolutions, tandis que Pro 2K coûte plus cher que Pro 1K : comparez ensemble latence, qualité et coût.