What makes FLUX.2 [flex] different from other FLUX.2 models?

FLUX.2 [flex] est spécialisé dans la typographie et le rendu de texte, ce qui en fait le meilleur choix pour préserver les petits détails et générer du contenu riche en texte.

Does FLUX.2 [flex] support adjustable generation steps?

Oui, FLUX.2 [flex] offre une 'Qualité avec contrôle' en permettant d'ajuster le nombre d'étapes et le niveau de guidage, contrairement aux paramètres standard de [pro] et [max].

How many reference images can FLUX.2 [flex] handle?

Comme les autres modèles FLUX.2, [flex] prend en charge jusqu'à 8 images de référence via l'API (10 dans Playground) pour la génération à références multiples.

What is the pricing for FLUX.2 [flex]?

FLUX.2 [flex] est facturé $0.06 par mégapixel (MP), ce qui le positionne entre les modèles [pro] et [max].

Is FLUX.2 [flex] suitable for photo editing?

Oui, FLUX.2 [flex] combine de puissantes capacités d'édition avec sa spécialisation dans le texte, permettant de modifier des objets, des couleurs et d'ajouter des incrustations de texte de manière séquentielle.

What resolution does FLUX.2 [flex] support?

FLUX.2 [flex] prend en charge une sortie haute résolution jusqu'à 4 mégapixels (4MP) pour n'importe quel format d'image, adaptée aux travaux créatifs professionnels.

When should I choose [flex] over [pro]?

Choisissez FLUX.2 [flex] lorsque votre projet implique des éléments textuels importants, de la typographie, ou nécessite un contrôle fin des étapes de génération que [pro] ne propose pas.

API FLUX 2 FLEX Abordable | text-to-image

Playground pour FLUX 2 FLEX

Explorez le Playground de FLUX 2 FLEX — un environnement interactif pour tester les modèles et exécuter des requêtes en temps réel. Essayez des invites, ajustez les paramètres et itérez instantanément pour accélérer le développement et valider les cas d'utilisation.

Qu’est-ce que FLUX.2 [flex]

FLUX.2 [flex] est la variante « flexible-control » de la famille FLUX.2 de Black Forest Labs : un modèle texte→image et d’édition d’images orienté production qui expose des paramètres d’inférence réglables (steps, guidance scale, seed) pour permettre aux développeurs d’échanger vitesse contre fidélité et d’ajuster avec précision le comportement de la typographie et des détails fins. Flex prend en charge l’édition multi‑références (jusqu’à 10 images de référence dans l’offre Flex) et permet des éditions jusqu’à ~4 mégapixels.

Ce pour quoi FLUX.2 [flex] est performant

Contrôle précis du compromis qualité/vitesse (l’utilisateur sélectionne les étapes d’inférence et l’échelle de guidage).
Rendu texte/typographie supérieur par rapport à de nombreux contemporains — recommandé pour les affiches, maquettes d’UI, infographies.
Édition multi‑références : combiner et préserver les éléments d’identité/de marque sur jusqu’à 10 images d’entrée (Flex), avec des éclairages et matériaux cohérents.
Haute résolution native et édition : jusqu’à 4MP en sortie ; enveloppe opérationnelle recommandée ≤2MP pour la plupart des workflows.
Prompts structurés pris en charge : prompts JSON ou en langage naturel ; le « suréchantillonnage du prompt » peut enrichir automatiquement les prompts courts.

Comparaison de FLUX.2 [flex] avec ses pairs

Tableau court (résumé) :

Nano Banana Pro (Google / noms internes ; concurrent haute fidélité) : fidélité brute similaire aux hautes résolutions ; Nano Banana cible des sorties plus grandes dans certaines versions fournisseur ; les comparaisons d’utilisateurs montrent un photoréalisme comparable mais des forces différentes dans le comportement aux prompts et la constance des éditions.
Qwen-Image / Hunyuan Image : FLUX.2 a affiché des taux de préférence subjectifs plus élevés dans les comparaisons de lancement sur les tâches texte→image et d’édition multi‑références (voir la couverture du lancement).
Midjourney / SaaS commercial : Midjourney utilise souvent des pipelines de suréchantillonnage pour rivaliser sur le nombre final de pixels ; FLUX.2 met l’accent sur une sortie native haute résolution et une édition multi‑références plus stricte. Des évaluateurs indépendants observent des compromis en style compositionnel et détail de pixel natif.

Conclusion pratique : Les atouts de FLUX.2 sont l’édition multi‑références, une typographie robuste et une famille de points de terminaison permettant aux équipes de choisir un compromis débit/qualité/coût. Des testeurs indépendants le trouvent compétitif face aux meilleurs modèles de la même fenêtre de sortie.

Paramètres propres à [flex] :

Paramètre	Type	Par défaut	Description
steps	entier	50	[flex uniquement] Nombre d’étapes d’inférence. Maximum : 50, par défaut : 50. Plus élevé = plus de détails, plus lent.
guidance	flottant	4.5	[flex uniquement] Échelle de guidage. Contrôle la fidélité de la sortie au prompt. Minimum : 1.5, maximum : 10, par défaut : 4.5. Plus élevé = adhérence plus stricte au prompt.

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 console CometAPI. Obtenez la clé API d’identification d’accès de l’interface. Cliquez sur « Add Token » dans la section API token du centre personnel, obtenez la clé de jeton : sk-xxxxx et soumettez.

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

Sélectionnez le point de terminaison « flux-2-flex » pour envoyer la requête API et définissez le corps de la requête. La méthode et le corps de la requête sont obtenus à partir de la documentation API de notre site Web. Notre site propose également des tests Apifox pour votre commodité. Remplacez <YOUR_API_KEY> par votre clé CometAPI réelle depuis votre compte. l’URL de base est flux generate image(https://api.cometapi.com/flux/v1/flux-2-flex)

Insérez votre question ou votre 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

Après la génération, vous pouvez utiliser le point de terminaison /flux/v1/get_result pour interroger les images générées ou surveiller l’état du processus. Après traitement, l’API répond avec l’état de la tâche et les données de sortie.

👇 Commencez dès maintenant Génération d’images Flux – Documentation API

FAQ

Tarification pour FLUX 2 FLEX

Découvrez des tarifs compétitifs pour 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 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.008	Par requête:$0.01	-20%

Exemple de code et API pour FLUX 2 FLEX

FLUX.2 Flex est la version intermédiaire, orientée développeurs, de la famille de génération d’images FLUX.2 de Black Forest Labs. Elle expose des paramètres de génération (notamment le nombre de pas d’échantillonnage et l’échelle de guidage) afin que les développeurs puissent mettre en balance la latence avec la fidélité du texte et de la typographie ainsi que le niveau de détail de l’image.

POST

/flux/v1/{model}

import os
import requests

# Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"

# API endpoint for FLUX.2 [flex]
url = "https://api.cometapi.com/flux/v1/flux-2-flex"

# Request headers
headers = {
    "Authorization": COMETAPI_KEY,
    "Content-Type": "application/json",
    "Accept": "*/*",
}

# Request payload with all available parameters
# See: https://docs.bfl.ml/api-reference/models/generate-or-edit-an-image-with-flux2-[flex]
payload = {
    # Required: Text prompt for image generation
    "prompt": "A futuristic cyberpunk cityscape at sunset, neon signs with readable text 'WELCOME TO 2077', flying cars, ultra detailed, 8k",
    # Optional: Enable prompt upsampling for enhanced details (default: true)
    "prompt_upsampling": True,
    # Output dimensions (multiple of 16, min 64, max 4MP total)
    "width": 1920,
    "height": 1080,
    # FLEX-specific: Number of inference steps (1-50, default: 50)
    # Higher values produce more detailed images but take longer
    "steps": 50,
    # FLEX-specific: Guidance scale (1.5-10, default: 5)
    # Higher values improve prompt adherence at cost of reduced realism
    "guidance": 5.0,
    # Seed for reproducible results (optional)
    "seed": 42,
    # Moderation level: 0 (strict) to 5 (permissive), default: 2
    "safety_tolerance": 2,
    # Output format: "jpeg" or "png"
    "output_format": "jpeg",
}

# Submit the generation task
print("Submitting FLUX.2 [flex] image generation task...")
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"Cost: {result.get('cost')} credits")
print(f"Output Megapixels: {result.get('output_mp')}")

Python Code Example

import os
import requests

# Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"

# API endpoint for FLUX.2 [flex]
url = "https://api.cometapi.com/flux/v1/flux-2-flex"

# Request headers
headers = {
    "Authorization": COMETAPI_KEY,
    "Content-Type": "application/json",
    "Accept": "*/*",
}

# Request payload with all available parameters
# See: https://docs.bfl.ml/api-reference/models/generate-or-edit-an-image-with-flux2-[flex]
payload = {
    # Required: Text prompt for image generation
    "prompt": "A futuristic cyberpunk cityscape at sunset, neon signs with readable text 'WELCOME TO 2077', flying cars, ultra detailed, 8k",
    # Optional: Enable prompt upsampling for enhanced details (default: true)
    "prompt_upsampling": True,
    # Output dimensions (multiple of 16, min 64, max 4MP total)
    "width": 1920,
    "height": 1080,
    # FLEX-specific: Number of inference steps (1-50, default: 50)
    # Higher values produce more detailed images but take longer
    "steps": 50,
    # FLEX-specific: Guidance scale (1.5-10, default: 5)
    # Higher values improve prompt adherence at cost of reduced realism
    "guidance": 5.0,
    # Seed for reproducible results (optional)
    "seed": 42,
    # Moderation level: 0 (strict) to 5 (permissive), default: 2
    "safety_tolerance": 2,
    # Output format: "jpeg" or "png"
    "output_format": "jpeg",
}

# Submit the generation task
print("Submitting FLUX.2 [flex] image generation task...")
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"Cost: {result.get('cost')} credits")
print(f"Output Megapixels: {result.get('output_mp')}")

JavaScript Code Example

// Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
const COMETAPI_KEY = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";

// API endpoint for FLUX.2 [flex]
const url = "https://api.cometapi.com/flux/v1/flux-2-flex";

// Request payload with all available parameters
// See: https://docs.bfl.ml/api-reference/models/generate-or-edit-an-image-with-flux2-[flex]
const payload = {
    // Required: Text prompt for image generation
    prompt: "A futuristic cyberpunk cityscape at sunset, neon signs with readable text 'WELCOME TO 2077', flying cars, ultra detailed, 8k",
    
    // Optional: Enable prompt upsampling for enhanced details (default: true)
    prompt_upsampling: true,
    
    // Output dimensions (multiple of 16, min 64, max 4MP total)
    width: 1920,
    height: 1080,
    
    // FLEX-specific: Number of inference steps (1-50, default: 50)
    // Higher values produce more detailed images but take longer
    steps: 50,
    
    // FLEX-specific: Guidance scale (1.5-10, default: 5)
    // Higher values improve prompt adherence at cost of reduced realism
    guidance: 5.0,
    
    // Seed for reproducible results (optional)
    seed: 42,
    
    // Moderation level: 0 (strict) to 5 (permissive), default: 2
    safety_tolerance: 2,
    
    // Output format: "jpeg" or "png"
    output_format: "jpeg"
};

// Submit the generation task
console.log("Submitting FLUX.2 [flex] image generation task...");

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

const result = await response.json();

console.log(`Status Code: ${response.status}`);
console.log(`Task ID: ${result.id}`);
console.log(`Cost: ${result.cost} credits`);
console.log(`Output Megapixels: ${result.output_mp}`);

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/flux/v1/flux-2-flex' \
--header "Authorization: $COMETAPI_KEY" \
--header 'Content-Type: application/json' \
--header 'Accept: */*' \
--data-raw '{
    "prompt": "A futuristic cyberpunk cityscape at sunset, neon signs with readable text WELCOME TO 2077, flying cars, ultra detailed, 8k",
    "prompt_upsampling": true,
    "width": 1920,
    "height": 1080,
    "steps": 50,
    "guidance": 5.0,
    "seed": 42,
    "safety_tolerance": 2,
    "output_format": "jpeg"
}'