Comment utiliser l'API Flux.2 ? Tout ce que vous devez savoir

FLUX.2 est la famille de modèles de génération et d’édition d’images de deuxième génération de Black Forest Labs (publiée le 25 nov. 2025). Elle offre un photoréalisme de niveau production, l’édition multi-référence jusqu’à 4 MP, le prompting structuré/JSON, ainsi qu’un choix entre des endpoints managés (Pro, Flex) et des options à poids ouverts (Dev).

La bonne nouvelle, c’est que CometAPI a intégré l’API Flux.2. Ce guide explique ce qu’est FLUX.2, comment appeler l’API, ainsi que des workflows avancés (texte→image, contrôle flexible, édition multi-référence), avec des exemples de code et des bonnes pratiques.

Qu’est-ce que FLUX.2 et pourquoi est-ce important ?

FLUX.2 est la suite de la famille de modèles d’image FLUX — conçue pour la génération texte-vers-image haute fidélité et l’édition d’images multi-référence à des résolutions de production (jusqu’à ~4 mégapixels). FLUX.2 est pensé pour de véritables workflows créatifs (assets compatibles avec l’image de marque, cohérence des personnages et des styles entre les références, meilleure typographie et meilleurs petits détails) plutôt que pour des démos, et vise à combler l’écart entre les images générées et les images réelles.

Principaux résultats que FLUX.2 est conçu pour offrir

Des rendus photoréalistes adaptés à la publicité, aux visuels produit et aux maquettes UI.
Édition multi-référence native : combiner, permuter ou composer des éléments provenant de plusieurs images d’entrée dans une seule édition.
Variantes pour différents cas d’usage : modèles développeur disponibles en accès ouvert, un endpoint Pro optimisé pour la production, et un endpoint Flex pour le contrôle de bas niveau.

À haut niveau, FLUX.2 combine une base générative latente (architecture flow/transformer) avec un modèle vision-langage pour l’ancrage sémantique, ainsi qu’un VAE nouvellement entraîné pour fournir un espace latent partagé entre les variantes. Cette conception permet au modèle de faire à la fois de la génération et de la reconstruction (édition) avec une fidélité plus élevée, tout en gardant une représentation exploitable pour l’entraînement et le fine-tuning. Le VAE ouvert est particulièrement remarquable, car il standardise l’espace latent pour les workflows hébergés et auto-hébergés.

Pourquoi c’est important : le couplage entre langage et latent flow matching permet une meilleure adhérence au prompt (de sorte que les instructions multiparties et compositionnelles se comportent de façon prévisible), une meilleure typographie, et une architecture unique qui prend en charge à la fois la génération et l’édition avec plusieurs références. Pour les créateurs, cela signifie des résultats plus fiables pour des instructions complexes et des entrées mixtes (texte + images).

Comment accéder à l’API FLUX.2 ?

Préparer l’environnement

Inscrivez-vous et connectez-vous à CometAPI, puis récupérez votre clé API depuis votre panneau de profil. Idéalement, vous devriez avoir quelques connaissances en API en tant que développeur (nous fournirons de l’aide à ce sujet, alors ne vous inquiétez pas).

Vous devrez également sélectionner la méthode de requête souhaitée et le modèle Flux.2 approprié.

Quels endpoints et quelle authentification sont requis ?

L’API Replicate Predictions permet d’accéder à la génération d’images de haute qualité à l’aide de différents modèles FLUX de Black Forest Labs via le format standard Replicate. Cette API prend en charge une gamme complète de variantes de modèles FLUX, chacune optimisée pour différents cas d’usage, du prototypage rapide à la génération d’images de niveau professionnel. Les utilisateurs peuvent passer facilement d’un modèle à un autre en changeant simplement le nom du modèle dans le chemin de l’URL (https://api.cometapi.com/replicate/v1/models/{models}/predictions), ce qui la rend flexible pour diverses applications créatives et commerciales.

CometAPI expose des endpoints managés sous https://api.cometapi.com/flux/v1/{model} et nomme les endpoints flux-2-pro, flux-2-flex et flux-2-flex pour la création et l’édition d’images. Les requêtes nécessitent une clé API dans l’en-tête x-key .

Famille de modèles et compromis de calcul

FLUX.2 (poids ouverts) — À utiliser lorsque vous avez besoin d’un contrôle local, d’expériences de recherche ou d’exécuter l’inférence sur votre propre infrastructure. Dev est à poids ouverts (32B) et excellent pour la recherche exploratoire et le fine-tuning. Il est plus configurable, mais vous êtes responsable de l’infrastructure et de l’optimisation.
FLUX.2 pro — Meilleur équilibre entre vitesse, qualité et coût pour la production. Pro est optimisé pour une latence prévisible, une adhérence constante au prompt, un débit rapide, et prend en charge jusqu’à 8 images de référence API (9 MP au total via l’API). Utilisez-le pour l’édition à grand volume et lorsque vous avez besoin de fiabilité et d’une tarification prévisible.
FLUX.2 (managé + contrôlabilité) — Expose des contrôles de génération de bas niveau (par ex. steps, guidance) et prend en charge davantage de références (jusqu’à 10) ainsi qu’une qualité/détail légèrement supérieurs lorsque vous acceptez une latence et un coût plus élevés. Utilisez Flex lorsque vous avez besoin du contrôle créatif final — fidélité typographique, couleurs exactes ou ajustements de composition très détaillés.

Prototyper sur Dev ou un forfait Pro à faible coût, puis migrer vers Pro pour le passage à l’échelle ou vers Flex pour des rendus finaux hautement contrôlés.

Comment utiliser l’API FLUX.2 ?

Cycle de vie des requêtes (modèle tâche + polling)

Les réponses aux requêtes d’édition/génération sont des objets de tâche qui incluent un polling_url et un id ; vous créez une requête, puis vous interrogez périodiquement le statut (ou utilisez des webhooks) pour récupérer l’URL signée du résultat. Les URL signées ont une durée de vie courte (généralement ~10 minutes), alors récupérez les sorties rapidement.

L’API hébergée suit un modèle de tâche asynchrone :

Envoyer une requête POST de génération → renvoie un task id et un polling_url ainsi qu’un cost estimé.
Interroger le polling_url jusqu’à status == "Ready", puis récupérer le résultat de l’image (souvent en base64 ou via une URL hébergée).

Exemple : Python (requests) — soumettre et interroger

import time, requests, os

API_KEY = os.environ
API_URL = "https://api.cometapi.com/flux/v1/flux-2-pro"

payload = {
    "prompt": "A high-end product photo of a ceramic mug on a wooden desk, soft window light.",
    "width": 1024, "height": 1024, "seed": 42
}

r = requests.post(API_URL, headers={"x-key": API_KEY, "accept":"application/json"}, json=payload)
r.raise_for_status()
task = r.json()
polling_url = task

while True:
    time.sleep(0.5)
    status_r = requests.get(polling_url, headers={"x-key": API_KEY})
    status_r.raise_for_status()
    status = status_r.json()
    if status == "Ready":
        print("Result URL:", status)
        break
    elif status in ("Error", "Failed"):
        print("Generation failed:", status)
        break

Ce schéma (soumettre → interroger ou webhook) est le flux synchrone/asynchrone principal pour les endpoints managés.

Édition d’image — exemple minimal (curl avec URL d’entrée)

curl -X POST "https://api.cometapi.com/flux/v1/flux-2-pro" \
  -H "accept: application/json" \
  -H "x-key: $CometAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Replace the background with a sunlit seaside boardwalk, keep the person intact and match lighting",
    "input_image": "https://example.com/my-photo.jpg",
    "width": 2048,
    "height": 1536
  }'

Pour l’édition multi-référence, utilisez input_image, input_image_2, input_image_3, … (Pro prend en charge jusqu’à 8 références via l’API ; Flex jusqu’à 10 ; maximum recommandé pour Dev ~6 selon la mémoire).

Quels paramètres de base dois-je envoyer ?

Les champs importants du corps de requête (édition / génération d’image) incluent :

guidance et steps — permettent un contrôle fin.
prompt (string) — jusqu’à 32K tokens ; langage naturel détaillé ou JSON structuré.
input_image (string) — requis pour les éditions (URL ou base64).
input_image_2 … input_image_9 — images multi-référence.
width / height — multiples de 16 ; sortie max. 4 MP.
seed — entier pour la reproductibilité.
safety_tolerance — niveau de modération.

Comment tirer parti de FLUX.2 Pro pour une génération texte-vers-image professionnelle ?

FLUX.2 Pro est optimisé pour des résultats fiables et de haute qualité. Utilisez-le lorsque vous avez besoin de résultats constants au niveau de la marque, d’un délai d’exécution rapide et de SLA d’entreprise.

Recette de workflow — visuels de production

Prétraitez les prompts : gardez une courte ligne d’“intention” plus une section structurée d’attributs (éclairage, objectif, ambiance, codes hexadécimaux des couleurs de marque). FLUX.2 prend en charge le guidage par couleur hexadécimale pour aider à préserver les palettes de marque.
Commencez avec des valeurs par défaut prudentes : steps 30–50 et guidance scale 6–9.0 ; augmentez les steps pour plus de détails, augmentez la guidance pour que les résultats adhèrent plus strictement au prompt.
Utilisez des seeds + un échantillonnage déterministe pour la reproductibilité dans les tests A/B.
Utilisez l’endpoint Pro pour l’échantillonnage multi-essais : demandez N variantes en parallèle et choisissez la meilleure — moins cher et plus rapide qu’un réglage manuel des hyperparamètres.
Post-traitez : débruitage, léger tone mapping ou retouches de type vectoriel dans un pipeline déterministe. Envisagez un petit GAN ou un passage de super-résolution si vous avez besoin d’une sortie supérieure à la résolution native.

Pourquoi ces étapes aident : Pro équilibre vitesse et fidélité et applique généralement des filtres de sécurité/de contenu après génération ; c’est donc le choix par défaut le plus judicieux pour les assets destinés aux clients.

Meilleurs conseils pour générer des images

1. Le prompting structuré gagne en production. Organisez les prompts par priorité : sujet → action → style → contexte. Utilisez le prompting JSON (scene, subjects, camera, lighting, color_palette) lorsque vous avez besoin d’une composition déterministe sur de nombreuses images. Exemple d’utilisation d’un schéma JSON (pseudo) :

{
  "scene": "product shot",
  "subjects": [
    {"type":"mug","pose":"center","style":"ceramic, matte"},
    {"type":"background","style":"wooden desk, window light"}
  ],
  "camera": {"focal_length":"85mm","aperture":"f2.8","angle":"slightly above"}
}

2. Reproductibilité : passez seed pour reproduire plus tard. Conservez un catalogue associant prompt + seed → image pour la traçabilité.

3. Batch et orchestration : pour de grands volumes en production, soumettez de nombreuses requêtes en parallèle à Pro, mais limitez le débit pour éviter le throttling ; préférez l’endpoint Pro pour une latence prévisible. Utilisez des files de tâches et des pools de workers pour télécharger rapidement les résultats signés dès qu’ils sont prêts.

4. Modération et sécurité : utilisez safety_tolerance pour contrôler la rigueur de la modération. Les endpoints Pro incluent des politiques d’usage et des hooks de modération de contenu ; intégrez des vérifications côté serveur avant publication.

5. Post-traitement : les sorties Pro sont de haute qualité mais nécessitent parfois de petites retouches. Intégrez une étape automatisée de post-traitement (recadrage, étalonnage couleur, composition) dans votre pipeline et conservez une revue humaine pour les assets sensibles à l’image de marque.

Comment personnaliser les sorties avec l’endpoint FLUX.2 Flex ?

Flex est la variante “outil chirurgical” : ajustez steps, guidance, prompts négatifs, tailles de tuiles et nombre de références pour façonner précisément la sortie.

Quand choisir Flex

Vous avez besoin d’un rendu typographique précis (maquettes UI, étiquettes).
Vous devez composer plusieurs références avec un contrôle sur la pose et l’éclairage.
Vous expérimentez des techniques avancées de prompting (prompts structurés, chaînes de contraintes).

Exemple — clés de contrôle Flex et leurs effets

steps — plus de steps = détails plus fins (au prix de la latence).
guidance_scale — plus élevé = plus proche du prompt textuel, plus bas = plus de créativité.
negative_prompt — supprime explicitement des éléments (par ex. “no watermark, no extra fingers”).
tile_size / tiled_inference — pour la génération en très haute résolution, tuiler l’espace d’inférence afin d’échanger de la mémoire contre de la vitesse.
reference_weights — certains endpoints permettent de pondérer les références pour orienter quelle image pilote la pose vs le style.

Conseil pratique : pour les compositions complexes, exécutez un aperçu court avec faible guidance pour vérifier la composition, puis effectuez un upscale avec davantage de steps et une guidance plus élevée. Cette technique en deux passes réduit le coût tout en donnant des sorties finales précises.

Exemple : requête Flex avec steps et guidance

curl -X POST "https://api.bfl.ai/v1/flux-2-flex" \
  -H "Content-Type: application/json" \
  -H "x-key: $BFL_API_KEY" \
  -d '{
    "prompt": "Cinematic movie poster, bold typography at top, main character centered, dramatic rim lighting",
    "width": 1536, "height": 2048,
    "steps": 50,
    "guidance": 7.5,
    "seed": 99999
  }'

Conseil : utilisez Flex pendant les validations créatives finales et Pro pour des pipelines plus rapides à grande échelle. Flex offre nettement plus de contrôlabilité pour la typographie et les tâches de micro-détail.

Bonnes pratiques pour un usage en production

Vous trouverez ci-dessous des schémas éprouvés et des conseils pragmatiques pour intégrer FLUX.2 à grande échelle.

1) Contrôlez les coûts en suivant les mégapixels et le cache

La facturation de FLUX.2 est basée sur les mégapixels d’entrée + sortie. Pour la génération à grand volume, privilégiez des rendus d’aperçu plus petits (basse résolution, peu de steps) et ne passez à des rendus finaux à plus haute résolution qu’en cas de besoin. Mettez en cache les assets rendus (ou stockez les diffs) afin de ne pas re-rendre des tâches identiques. Faites toujours remonter le cost dans les réponses et consignez-le pour chaque requête.

2) Utilisez intelligemment les niveaux : aperçu vs rendu final

Exécutez des rendus Pro rapides avec peu de steps pour le prototypage ou de nombreuses variantes.
Utilisez Flex ou des exécutions Pro à haut MP pour les sorties finales approuvées lorsque la fidélité importe. Cette approche hybride équilibre le débit et la qualité finale de l’image.

3) Prompt engineering → prompts structurés et JSON

Tirez parti du prompting JSON structuré de FLUX.2 lorsque vous avez besoin d’une composition déterministe (objets de scène, caméra, poses, nuanciers hexadécimaux). Cela réduit les cycles de prompting itératif et conduit à des lots plus reproductibles. Les exemples Cloudflare montrent des prompts JSON intégrés dans des formulaires multipart.

4) Seed + versioning pour la reproductibilité

Lorsque vous avez besoin de résultats reproductibles, passez un seed et enregistrez la version du modèle / l’horodatage dans les métadonnées. Pour les pipelines d’assets déterministes, conservez un manifeste : prompt, seed, variante du modèle, résolution, hachages des images de référence. Cela améliore la traçabilité et les possibilités de rollback.

Conclusion

FLUX.2 vise clairement à combler l’écart entre la “démo impressionnante” et le “véritable outil créatif de production”. Avec l’édition multi-référence, les sorties haute résolution et un ensemble d’endpoints hébergés (plus un code d’inférence ouvert et des builds consommateurs quantifiés), il offre aux équipes de nombreuses options pratiques : exécuter localement pour la recherche et la personnalisation, ou utiliser les endpoints Pro/Flex hébergés pour des pipelines de production stables.

Les développeurs peuvent accéder à la Flux.2 Dev API, à la Flux.2 Flex API et à la Flux.2 Pro API via CometAPI. Pour commencer, explorez les capacités des modèles de CometAPI dans le Playground et consultez le guide API pour des instructions détaillées. Avant d’y accéder, assurez-vous d’être connecté à CometAPI et d’avoir obtenu la clé API. CometAPI propose un prix bien inférieur au prix officiel pour vous aider dans votre intégration.

Prêt à partir ?→ Inscrivez-vous à CometAPI dès aujourd’hui !

Si vous voulez en savoir plus sur les astuces, guides et actualités autour de l’IA, suivez-nous sur VK, X et Discord !