R

Black Forest Labs/FLUX 2 FLEX

Par requête:$0.192

Publié:Nov 25, 2025

Nouveau

Usage commercial

Qu'est-ce que FLUX.2 Flex

FLUX.2 est le membre « flexible » (API gérée) de la famille de produits FLUX.2 de Black Forest Labs. Il est conçu pour les développeurs et les équipes créatives qui ont besoin :

d'un contrôle explicite des paramètres de génération (steps d'inférence, guidance scale, etc.) afin de pouvoir arbitrer vitesse et fidélité au prompt lors de workflows itératifs ;
d'une typographie / rendu de texte robuste et d'une gestion des détails très fins (infographies, maquettes UI, étiquettes de produits) ; et
d'un montage multi-références fiable (combiner des éléments provenant de plusieurs photos tout en préservant l'identité/la cohérence).

FLUX.2 est proposé en plusieurs variantes (Pro, Flex, Dev, Klein) ciblant différents usages — Flex se situe entre Pro (qualité maximale + latence fixe) et Dev (checkpoint à poids ouverts pour la recherche/l’usage local).

Fonctionnalités clés (ce que FLUX.2 Flex apporte)

Génération contrôlable : paramètres explicites (steps, guidance scale) pour équilibrer vitesse et fidélité au prompt.
Sortie haute résolution : capable de produire jusqu’à 4 mégapixels (4MP) tout en préservant les détails.
Entrées multi‑références : accepte plusieurs images de référence (Flex prend en charge jusqu’à 10 images de référence ; les nombres pour Dev/Pro varient selon le niveau). Cela permet des rendus cohérents de personnages/produits sur l’ensemble des sorties.
Typographie et rendu de texte améliorés : BFL met en avant un rendu nettement amélioré des glyphes, du crénage et des mises en page multi‑lignes — rendant FLUX.2 attractif pour l’UI, le packaging et les infographies.
API gérée avec tarification au mégapixel (modèle de coût prévisible) : la tarification de Flex utilise un modèle au mégapixel (voir la section Tarification).

Détails techniques de FLUX.2 Flex

Architecture de base : FLUX.2 utilise une ossature de latent flow‑matching (flow transformer) combinée à un modèle vision‑langage (BFL indique qu’il couple un VLM Mistral‑3 24B avec un flow transformer rectifié). Le VAE utilisé par FLUX.2 a été ré‑entraîné pour améliorer le compromis apprentissabilité/qualité/compression. Ces choix aident aux connaissances du monde, à la logique compositionnelle et à une adhérence plus stricte au prompt.

FLUX.2 : temps de génération typiques rapportés ~22 s (texte seul) et ~40 s (avec image d’entrée), accepte jusqu’à 10 entrées et est facturé environ $0.048 par mégapixel (entrée + sortie combinées) sur CometAPI.

Nom du modèle : black-forest-labs/flux-2-flex

Contraintes d’entrée : Flex accepte plusieurs entrées (jusqu’à 10 dans l’offre gérée) et une limite totale en mégapixels d’entrée est appliquée (on cite un maximum agrégé de 14MP). La résolution de sortie au‑delà de 4MP est généralement rééchantillonnée à la baisse ou limitée par le service.

Performances de référence de FLUX.2 Flex

Évaluation du taux de victoire de type humain (benchmark fournisseur) : Dans les tests en confrontation directe publiés par BFL, les variantes de FLUX.2 (notamment ) ont affiché de forts taux de victoire face aux modèles ouverts contemporains : ~66.6% en texte‑vers‑image, 59.8% en édition à référence unique et 63.6% en édition multi‑références par rapport aux autres modèles ouverts cités. BFL a également présenté un graphique ELO vs. coût par image situant les variantes de FLUX.2 dans la bande ~1030–1050 ELO pour des coûts par image dans la plage de 2–6 cent.

Limitations de FLUX.2 Flex

Évolution des coûts avec les références / la résolution : Flex utilise une tarification au mégapixel. Ajouter plusieurs images de référence ou augmenter la résolution de sortie accroît le coût de manière linéaire selon le modèle au mégapixel annoncé. Pour des workflows itératifs avec de nombreuses références, le coût peut s’accumuler rapidement.
Modes d’échec liés au prompt / à la cohérence : Bien que FLUX.2 améliore la cohérence des personnages, des prompts complexes à multiples attributs peuvent encore produire des échecs (artéfacts, mélanges inattendus ou dérive de pose/d’identité) selon la conception du prompt et le nombre de références.
Contenu et sécurité : Bien que BFL rapporte une forte résilience lors des tests de modération/d’entrées violant les règles, les modèles d’image ne sont pas parfaits ; des risques subsistent de générer du contenu protégé par droits d’auteur, d’usurpation d’identité ou inapproprié.

Cas d’usage typiques / recommandés

Variantes d’images publicitaires et marketing où le même mannequin/acteur/produit doit rester cohérent à travers de nombreuses scènes ou arrière‑plans (cohérence multi‑références).
Photographie produit et essayage virtuel (préserver les détails du produit à travers différents arrière‑plans).
Éditorial/mode nécessitant la même identité sur de nombreuses prises de vue.
Prototypage rapide et recherche (le checkpoint Dev permet l’expérimentation, le fine‑tuning et des workflows LoRA/adapter).

Comment accéder à l’API Flux.2 Flex

Étape 1 : S’inscrire pour obtenir une clé API

Connectez‑vous à cometapi.com. Si vous n’êtes pas encore utilisateur, veuillez d’abord vous inscrire. Connectez‑vous à votre CometAPI console. Obtenez la clé API d’authentification de l’interface. Cliquez sur « Add Token » dans la section des jetons API du centre personnel, récupérez la clé de jeton : sk-xxxxx et validez.

Étape 2 : Envoyer des requêtes à l’API Flux.2 Flex

Sélectionnez l’endpoint « black-forest-labs/flux-2-flex » pour envoyer la requête API et définir le corps de la requête. La méthode et le corps de la requête sont fournis dans la documentation API de notre site Web. Notre site propose également des tests Apifox pour votre commodité. Remplacez <YOUR_API_KEY> par votre véritable clé CometAPI de votre compte.

Insérez votre question ou demande dans le champ content — c’est à cela que le modèle répondra. Traitez la réponse de l’API pour obtenir le résultat généré.

Étape 3 : Récupérer et vérifier les résultats

Traitez la réponse de l’API pour obtenir la sortie générée. Après traitement, l’API renvoie le statut de la tâche et les données de sortie.

CometAPI prend désormais en charge les modèles au format Replicate : 🔹 black-forest-labs/flux-2-pro 🔹 black-forest-labs/flux-2-dev 🔹 black-forest-labs/flux-2-flex

Promotion limitée dans le temps : des prix inférieurs aux tarifs officiels de Replicate !

👇 Commencez à construire maintenant Créer des prédictions – Doc API

⚡ Sélection flexible :

Pro : Conçu pour une production à haute efficacité et une livraison rapide.
Flex : Optimise la qualité d’image avec des paramètres ajustables.
Dev : Optimisation adaptée aux développeurs.

Tarification pour Black Forest Labs/FLUX 2 FLEX

Découvrez des tarifs compétitifs pour Black Forest Labs/FLUX 2 FLEX, conçus pour s'adapter à différents budgets et besoins d'utilisation. Nos formules flexibles garantissent que vous ne payez que ce que vous utilisez, ce qui facilite l'adaptation à mesure que vos besoins évoluent. Découvrez comment Black Forest Labs/FLUX 2 FLEX peut améliorer vos projets tout en maîtrisant les coûts.

Prix de Comet (USD / M Tokens)	Prix officiel (USD / M Tokens)	Remise
Par requête:$0.192	Par requête:$0.24	-20%

Exemple de code et API pour Black Forest Labs/FLUX 2 FLEX

Accédez à des exemples de code complets et aux ressources API pour Black Forest Labs/FLUX 2 FLEX afin de simplifier votre processus d'intégration. Notre documentation détaillée fournit des instructions étape par étape pour vous aider à exploiter tout le potentiel de Black Forest Labs/FLUX 2 FLEX dans vos projets.

import os
import requests

COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"

url = "https://api.cometapi.com/replicate/v1/models/black-forest-labs/flux-2-flex/predictions"

headers = {
    "Authorization": f"Bearer {COMETAPI_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "input": {
        "prompt": "Fluffy cotton candy sculpted into voluminous 3D letters spelling 'FLEX' in swirls of bubblegum pink, baby blue, and soft lavender, held on a wooden stick in front of a vintage pastel cotton candy cart. Shot on Kodak Portra 160, bright midday summer sunlight, the spun sugar texture catching light with wispy translucent edges",
        "input_images": [
            "https://replicate.delivery/xezq/Q9jOVfT4nmT6YaUGe7fwMe85kYPNziFq18j850Sg6YvPlk0WB/tmpzq6ncmxa.jpg"
        ],
        "aspect_ratio": "16:9",
        "resolution": "2 MP",
        "steps": 30,
        "guidance": 4.5,
        "prompt_upsampling": True,
        "output_format": "jpg",
        "output_quality": 90,
        "safety_tolerance": 2,
        "seed": 42
    }
}

response = requests.post(url, headers=headers, json=payload)
result = response.json()

print(f"Status Code: {response.status_code}")
print(f"Task ID: {result.get('id')}")
print(f"Status: {result.get('status')}")
print(f"Model: {result.get('model')}")

Python Code Example

import os
import requests

COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"

url = "https://api.cometapi.com/replicate/v1/models/black-forest-labs/flux-2-flex/predictions"

headers = {
    "Authorization": f"Bearer {COMETAPI_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "input": {
        "prompt": "Fluffy cotton candy sculpted into voluminous 3D letters spelling 'FLEX' in swirls of bubblegum pink, baby blue, and soft lavender, held on a wooden stick in front of a vintage pastel cotton candy cart. Shot on Kodak Portra 160, bright midday summer sunlight, the spun sugar texture catching light with wispy translucent edges",
        "input_images": [
            "https://replicate.delivery/xezq/Q9jOVfT4nmT6YaUGe7fwMe85kYPNziFq18j850Sg6YvPlk0WB/tmpzq6ncmxa.jpg"
        ],
        "aspect_ratio": "16:9",
        "resolution": "2 MP",
        "steps": 30,
        "guidance": 4.5,
        "prompt_upsampling": True,
        "output_format": "jpg",
        "output_quality": 90,
        "safety_tolerance": 2,
        "seed": 42
    }
}

response = requests.post(url, headers=headers, json=payload)
result = response.json()

print(f"Status Code: {response.status_code}")
print(f"Task ID: {result.get('id')}")
print(f"Status: {result.get('status')}")
print(f"Model: {result.get('model')}")

JavaScript Code Example

const COMETAPI_KEY = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";

const url = "https://api.cometapi.com/replicate/v1/models/black-forest-labs/flux-2-flex/predictions";

const payload = {
    input: {
        prompt: "Fluffy cotton candy sculpted into voluminous 3D letters spelling 'FLEX' in swirls of bubblegum pink, baby blue, and soft lavender, held on a wooden stick in front of a vintage pastel cotton candy cart. Shot on Kodak Portra 160, bright midday summer sunlight, the spun sugar texture catching light with wispy translucent edges",
        input_images: [
            "https://replicate.delivery/xezq/Q9jOVfT4nmT6YaUGe7fwMe85kYPNziFq18j850Sg6YvPlk0WB/tmpzq6ncmxa.jpg"
        ],
        aspect_ratio: "16:9",
        resolution: "2 MP",
        steps: 30,
        guidance: 4.5,
        prompt_upsampling: true,
        output_format: "jpg",
        output_quality: 90,
        safety_tolerance: 2,
        seed: 42
    }
};

const response = await fetch(url, {
    method: "POST",
    headers: {
        "Authorization": `Bearer ${COMETAPI_KEY}`,
        "Content-Type": "application/json"
    },
    body: JSON.stringify(payload)
});

const result = await response.json();

console.log(`Status Code: ${response.status}`);
console.log(`Task ID: ${result.id}`);
console.log(`Status: ${result.status}`);
console.log(`Model: ${result.model}`);

Curl Code Example

#!/bin/bash
# Get your CometAPI key from https://api.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

curl --location --request POST 'https://api.cometapi.com/replicate/v1/models/black-forest-labs/flux-2-flex/predictions' \
--header "Authorization: Bearer $COMETAPI_KEY" \
--header 'Content-Type: application/json' \
--data-raw '{
    "input": {
        "prompt": "Fluffy cotton candy sculpted into voluminous 3D letters spelling FLEX in swirls of bubblegum pink, baby blue, and soft lavender, held on a wooden stick in front of a vintage pastel cotton candy cart. Shot on Kodak Portra 160, bright midday summer sunlight, the spun sugar texture catching light with wispy translucent edges",
        "input_images": [
            "https://replicate.delivery/xezq/Q9jOVfT4nmT6YaUGe7fwMe85kYPNziFq18j850Sg6YvPlk0WB/tmpzq6ncmxa.jpg"
        ],
        "aspect_ratio": "16:9",
        "resolution": "2 MP",
        "steps": 30,
        "guidance": 4.5,
        "prompt_upsampling": true,
        "output_format": "jpg",
        "output_quality": 90,
        "safety_tolerance": 2,
        "seed": 42
    }
}'