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

FLUX.2 est la deuxième génération de modèles de génération et d'édition d'images de Black Forest Labs (sortie le 25 novembre 2025). Elle offre un photoréalisme de qualité professionnelle, l'édition multi-références jusqu'à 4 MP, des invites structurées/JSON et un choix de points de terminaison gérés (Pro, Flex) et d'options de poids ouvert (Dev).

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

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

FLUX.2 succède à la famille de modèles d'images FLUX. Conçu pour la génération d'images à partir de texte haute fidélité et l'édition d'images multi-références en résolutions de production (jusqu'à environ 4 mégapixels), FLUX.2 est destiné aux flux de travail créatifs réels (éléments graphiques conformes à l'image de marque, caractères et styles cohérents entre les références, typographie améliorée et souci du détail), et non aux démonstrations. Son objectif est de réduire l'écart entre les images générées et les images réelles.

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

Des rendus photoréalistes adaptés à la publicité, aux images de produits et aux maquettes d'interface utilisateur.
Édition multi-références native : combinez, échangez ou composez des éléments provenant de plusieurs images d’entrée en une seule modification.
Des variantes pour différents cas d'utilisation : des modèles de développement disponibles en open source, un point de terminaison Pro optimisé pour la production et un point de terminaison Flex pour un contrôle de bas niveau.

De manière générale, FLUX.2 combine une architecture générative latente (flux/transformateurs) avec un modèle vision-langage pour l'ancrage sémantique, et un VAE nouvellement entraîné afin de fournir un espace latent partagé entre les variantes. Cette conception permet au modèle d'effectuer à la fois la génération et la reconstruction (édition) avec une fidélité accrue, tout en conservant une représentation apprenable pour l'entraînement et l'ajustement fin. Le VAE ouvert est particulièrement remarquable car il standardise l'espace latent pour les flux de travail hébergés et auto-hébergés.

Pourquoi c'est important : l'association du langage et de la correspondance de flux latent permet un meilleur suivi des consignes (les instructions composées en plusieurs parties se comportent donc de manière prévisible), une typographie améliorée et une architecture unique prenant en charge la génération et l'édition avec de multiples références. Pour les créateurs, cela se traduit par des résultats plus fiables pour les instructions complexes et les entrées mixtes (texte et images).

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

Préparer l'environnement

Inscrivez-vous et connectez-vous à CometAPI pour obtenir votre clé API depuis votre profil. Idéalement, vous devriez avoir quelques connaissances en API en tant que développeur (nous vous accompagnerons dans ce domaine, rassurez-vous).

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

Quels sont les points de terminaison et l'authentification requis ?

L'API Replicate Predictions permet de générer des 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'utilisation, du prototypage rapide à la génération d'images de qualité professionnelle. Les utilisateurs peuvent facilement passer d'un modèle à l'autre en modifiant simplement son nom dans l'URL (https://api.cometapi.com/replicate/v1/models/{models}/predictions), ce qui la rend flexible pour diverses applications créatives et commerciales.

API Comet expose des points de terminaison gérés sous https://api.cometapi.com/flux/v1/{model} et les nomme, par exemple, 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. x-key en-tête .

Compromis entre la famille de modèles et le calcul

FLUX.2 (poids ouverts) Utilisez-le lorsque vous avez besoin d'un contrôle local, pour des expériences de recherche ou pour exécuter des inférences sur votre propre infrastructure. La version Dev, très légère (32 octets), est idéale pour la recherche exploratoire et l'optimisation. Elle est plus configurable, mais vous êtes responsable de l'infrastructure et de l'optimisation.
FLUX.2 pro — Le meilleur compromis entre vitesse, qualité et coût pour la production. La version Pro est optimisée pour une latence prévisible, un respect constant des prompts et un débit élevé. Elle prend en charge jusqu'à 8 images de référence API (9 MP au total via l'API). Utilisez-la pour le montage en grande série et lorsque vous avez besoin de fiabilité et d'une tarification prévisible.
FLUX.2 (géré + contrôlabilité) — Expose les commandes de génération de bas niveau (par exemple, steps, guidanceIl prend en charge davantage de références (jusqu'à 10) et offre une qualité/un niveau de détail légèrement supérieurs, moyennant une latence et un coût plus élevés. Utilisez Flex lorsque vous avez besoin d'un contrôle créatif total : fidélité typographique, couleurs exactes ou ajustements de composition très précis.

Prototype sur dev ou à faible coût Pro planifier, puis migrer vers Pro pour l'échelle ou Fléchir pour des rendus finaux hautement contrôlés.

Comment utiliser l'API FLUX.2 ?

Cycle de vie d'une requête (modèle de tâche et d'interrogation)

Les réponses aux demandes de modification/génération sont objets de tâche qui incluent un polling_url et idVous créez une requête, puis vous interrogez (ou utilisez des webhooks) le serveur pour récupérer l'URL du résultat signé. Les URL signées ont une durée de vie courte (environ 10 minutes), il est donc important de récupérer les résultats rapidement.

L'API hébergée suit un modèle de tâches asynchrones :

POST une requête de génération → renvoie un task id et polling_url plus estimation cost.
Sondage polling_url jusqu'au status == "Ready", puis récupérer le résultat de l'image (souvent en base64 ou via une URL hébergée).

Exemple : Python (requêtes) — soumission et sondage

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 modèle (soumission → sondage ou webhook) est le flux synchrone/asynchrone principal pour les points de terminaison gérés.

Édition d'images — 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 à références multiples, utilisez input_image, input_image_2, input_image_3… (La version Pro prend en charge jusqu'à 8 références via l'API ; la version Flex jusqu'à 10 ; la version Dev recommande un maximum d'environ 6 en fonction de la mémoire).

Quels paramètres de base dois-je envoyer ?

Les champs importants du corps de la requête (édition/génération d'images) comprennent :

guidance et steps — permettre un contrôle précis.
prompt (chaîne de caractères) — jusqu'à 32 000 jetons ; langage naturel détaillé ou JSON structuré.
input_image (chaîne de caractères) — requis pour les modifications (URL ou base64).
input_image_2 ... input_image_9 — images à références multiples.
width / height — multiples de 16 ; sortie max 4MP.
seed — un entier pour la reproductibilité.
safety_tolerance — niveau de modération.

Comment puis-je tirer parti de FLUX.2 Pro pour la génération professionnelle d'images à partir de texte ?

FLUX.2 Pro est optimisé pour des résultats fiables et de haute qualité. Utilisez-le lorsque vous avez besoin de résultats constants dignes d'une marque, de délais d'exécution rapides et de SLA d'entreprise.

Recette de flux de travail — imagerie de production

Invites de prétraitement : Conservez une brève ligne « intention » ainsi qu’une section structurée d’attributs (éclairage, objectif, ambiance, codes hexadécimaux des couleurs de la marque). FLUX.2 prend en charge le pilotage des couleurs hexadécimales pour vous aider à préserver les palettes de couleurs de votre marque.
Commencez par des valeurs par défaut conservatrices : étapes 30 à 50 et échelle de guidage 6 à 9.0 ; augmenter les étapes pour plus de détails, augmenter le guidage pour que les résultats adhèrent plus strictement à la consigne.
Utilisation de semences + échantillonnage déterministe pour la reproductibilité dans les tests A/B.
Utilisez le point de terminaison Pro pour l'échantillonnage à essais multiples : Demander N variations en parallèle et choisir la meilleure — moins cher et plus rapide que le réglage manuel des hyperparamètres.
Post-traitement : Débruitage, mappage tonal mineur ou retouches vectorielles dans un pipeline déterministe. Envisagez un petit GAN ou une passe de super-résolution si vous avez besoin d'une résolution supérieure à celle du rendu natif.

Pourquoi ces étapes sont utiles : Le mode Pro offre un équilibre entre vitesse et fidélité et applique généralement des filtres de sécurité/contenu après génération ; il constitue donc le choix par défaut judicieux pour les ressources destinées aux clients.

Meilleurs conseils pour générer des images

1. Des incitations structurées sont bénéfiques pour la production. Organisez les invites par priorité : sujet → action → style → contexte. Utilisez les invites JSON (scène, sujets, caméra, éclairage, palette de couleurs) lorsque vous avez besoin d’une composition déterministe pour plusieurs images. Exemple d’utilisation du 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é : Passé seed À reproduire ultérieurement. Conserver une invite de correspondance de catalogue + image de départ → image pour la traçabilité.

3. Traitement par lots et orchestration : Pour les productions à grande échelle, soumettez de nombreuses requêtes en parallèle à Pro, mais limitez le débit pour éviter la saturation ; privilégiez le point de terminaison Pro pour une latence prévisible. Utilisez les files d'attente de tâches et les pools de nœuds de calcul pour télécharger rapidement les résultats signés une fois prêts.

4. Modération et sécurité : Utilisez le safety_tolerance Pour contrôler la rigueur de la modération. Les points de terminaison Pro incluent des politiques d'utilisation et des points d'extension pour la modération de contenu ; intégrez des vérifications côté serveur avant publication.

5. Post-traitement : Les rendus professionnels sont de haute qualité, mais nécessitent parfois de petites retouches. Intégrez une étape de post-traitement automatisée (recadrage, étalonnage des couleurs, composition) à votre flux de production et conservez une vérification humaine pour les éléments sensibles liés à la marque.

Comment puis-je personnaliser les sorties avec le point de terminaison FLUX.2 Flex ?

Flex est la variante « outil chirurgical » : ajustez les étapes, le guidage, les avertissements négatifs, la taille des carreaux et les comptes de référence pour façonner le résultat avec précision.

Quand choisir Flex

Vous avez besoin d'un rendu typographique précis (maquettes d'interface utilisateur, étiquettes).
Vous devez composer plusieurs références en contrôlant la pose et l'éclairage.
Vous expérimentez des techniques d'incitation avancées (incitations structurées, chaînes de contraintes).

Exemple — Touches de contrôle flexibles et leurs effets

steps — plus d'étapes = détails plus précis (au prix d'une latence accrue).
guidance_scale — Valeur élevée = plus proche de la consigne textuelle, valeur basse = plus de créativité.
negative_prompt — supprimer explicitement les éléments (par exemple, « pas de filigrane, pas de doigts supplémentaires »).
tile_size / tiled_inference — pour la génération à très haute résolution, l'espace d'inférence des tuiles permet de privilégier la vitesse à la mémoire.
reference_weights — certains points d'extrémité permettent de pondérer les références afin d'orienter l'image vers la pose plutôt que vers le style.

Conseil pratique: Pour les compositions complexes, effectuez un aperçu rapide avec peu de détails afin de vérifier la composition, puis augmentez la taille en ajoutant des étapes et en augmentant le niveau de détail. Cette technique en deux passes permet de réduire les coûts tout en garantissant des résultats finaux précis.

Exemple : Demande Flex avec étapes et instructions

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
  }'

Astuce: Utilisez Flex pour les validations créatives finales et Pro pour les flux de production plus rapides et à grande échelle. Flex offre un contrôle nettement supérieur pour la typographie et les tâches de micro-détail.

Meilleures pratiques pour l'utilisation en production

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

1) Contrôler les coûts en suivant les mégapixels et en mettant en cache

La facturation de FLUX.2 est basée sur les mégapixels de entrée + sortiePour la génération en grande quantité, privilégiez les rendus de prévisualisation de petite taille (étapes rapides en basse résolution) et n'utilisez les rendus finaux haute résolution qu'en multiplicateur de pixels. Mettez en cache les ressources rendues (ou stockez les différences) afin d'éviter de refaire le rendu de tâches identiques. cost dans les réponses et les consigner pour chaque requête.

2) Utilisez intelligemment les calques : séparation entre prévisualisation et rendu final

Exécutez des rendus Pro rapides et à faible résolution pour le prototypage ou de nombreuses variantes.
Utilisez les formats Flex ou Pro haute résolution pour les rendus finaux approuvés où la fidélité est primordiale. Cette approche hybride offre un équilibre optimal entre débit et qualité d'image finale.

3) Ingénierie des invites → invites structurées et JSON

Profitez des avantages de FLUX.2 invite JSON structurée Lorsque vous avez besoin d'une composition déterministe (objets de la scène, caméra, poses, nuanciers hexadécimaux), cela réduit les cycles d'invites itératifs et permet d'obtenir des lots plus reproductibles. Les exemples de Cloudflare montrent des invites JSON intégrées dans des formulaires multipart.

4) Semence + versionnage pour la reproductibilité

Lorsque vous avez besoin de résultats reproductibles, transmettez un seed Enregistrez la version et l'horodatage du modèle dans les métadonnées. Pour les pipelines d'actifs déterministes, conservez un manifeste : invite, graine, variante du modèle, résolution et hachages des images de référence. Cela améliore la traçabilité et les options de restauration.

Conclusion

FLUX.2 vise précisément à combler le fossé entre « démo impressionnante » et « outil de création de production ». Grâce à l'édition multi-références, aux sorties haute résolution et à un ensemble de points de terminaison hébergés (ainsi qu'à un code d'inférence ouvert et à des versions quantifiées pour les consommateurs), il offre aux équipes de nombreuses options pratiques : exécution locale pour la recherche et la personnalisation, ou utilisation des points de terminaison Pro/Flex hébergés pour des pipelines de production stables.

Les développeurs peuvent accéder API de développement Flux.2, API Flux.2 Flex et API Flux.2 Pro via CometAPI. Pour commencer, explorez les fonctionnalités de modélisation de CometAPI dans le cour de récréation et consultez le Guide de l'API Pour des instructions détaillées, veuillez vous connecter à CometAPI et obtenir la clé API avant d'y accéder. Avec e tAPI proposer un prix bien inférieur au prix officiel pour vous aider à vous intégrer.

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

Si vous souhaitez connaître plus de conseils, de guides et d'actualités sur l'IA, suivez-nous sur VK, X et Discord!