FLUX 2 FLEX

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

FLUX.2 [flex] is specialized for typography and text rendering, making it the best choice for preserving small details and generating text-heavy content.

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

Yes, FLUX.2 [flex] offers 'Quality with control' by allowing adjustable usage of steps and guidance, unlike the standard settings in [pro] and [max].

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

Like the other FLUX.2 models, [flex] supports up to 8 reference images via the API (10 in Playground) for multi-reference generation.

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

FLUX.2 [flex] is priced at $0.06 per megapixel (MP), positioning it between the [pro] and [max] models.

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

Yes, FLUX.2 [flex] combines powerful editing capabilities with its text specialization, allowing for changes to objects, colors, and adding text overlays sequentially.

Q: What resolution does FLUX.2 [flex] support?

FLUX.2 [flex] supports high-resolution output up to 4 megapixels (4MP) across any aspect ratio, suitable for professional creative work.

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

Choose FLUX.2 [flex] when your project involves significant text elements, typography, or requires fine-grained control over generation steps that [pro] does not offer.

Par requête:$0.008

FLUX 2 FLEX est un modèle polyvalent et adaptable, conçu pour un déploiement flexible dans divers cas d’usage et configurations matérielles. Il offre des performances évolutives avec des paramètres de qualité ajustables, ce qui le rend idéal pour les applications nécessitant une allocation dynamique des ressources. Ce modèle offre le meilleur équilibre entre qualité, vitesse et efficacité de l’utilisation des ressources.

Nouveau

Usage commercial

Playground

Aperçu

Fonctionnalités

Tarification

API

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 de production pour texte→image et édition d’images qui expose des paramètres d’inférence ajustables (steps, guidance scale, seed) afin que les développeurs puissent arbitrer vitesse vs fidélité et régler précisément le comportement en matière de typographie et de détails fins. Flex prend en charge l’édition multi-référence (jusqu’à 10 images de référence dans le niveau Flex), avec des éditions jusqu’à ~4 mégapixels.

Ce pour quoi FLUX.2 [flex] est performant

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

Comparaison de FLUX.2 [flex] avec ses pairs

Tableau succinct (résumé) :

Nano Banana Pro (Google / noms internes ; concurrent haute fidélité) : fidélité brute similaire à haute résolution ; Nano Banana cible des sorties plus grandes dans certaines versions de fournisseurs ; les comparaisons d’utilisateurs montrent un photoréalisme comparable mais des forces différentes dans le comportement vis-à-vis des prompts et la constance des éditions.
Qwen-Image / Hunyuan Image : FLUX.2 a rapporté des taux de gain subjectifs plus élevés dans les comparaisons de lancement sur les tâches texte→image et d’édition multi-référence (voir la couverture du lancement).
Midjourney / SaaS commercial : Midjourney utilise souvent des pipelines d’upscaling 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érence plus stricte. Des évaluateurs indépendants constatent des compromis sur le style compositionnel et le détail pixel natif.

À retenir en pratique : les points forts de FLUX.2 sont l’édition multi-référence, une typographie robuste et une famille d’endpoints permettant aux équipes de choisir un compromis débit/qualité/coût. Des testeurs indépendants le jugent compétitif avec les meilleurs modèles de la même fenêtre de sortie.

Paramètres uniquement pour [flex] :

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

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

Étape 1 : Inscrivez-vous 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é d’accès API 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 : Envoyez des requêtes à l’API Flux.2 Flex

Sélectionnez l’endpoint “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 disponibles 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 issue de votre compte. L’URL de base est génération d’images Flux(https://api.cometapi.com/flux/v1/flux-2-flex)

Insérez votre question ou votre requête 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érez et vérifiez les résultats

Après la génération, vous pouvez utiliser l’endpoint /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 le statut de la tâche et les données de sortie.

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

FAQ

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

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

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

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

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

What resolution does FLUX.2 [flex] support?

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

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	-

Exemple de code et API pour FLUX 2 FLEX

FLUX.2 Flex est le membre de milieu de gamme, axé sur les développeurs, de la famille FLUX.2 de génération d’images de Black Forest Labs. Il expose des paramètres de génération (notamment le nombre d’étapes d’échantillonnage et l’échelle de guidage) afin que les développeurs puissent ajuster le compromis entre latence, fidélité du texte/typographie et niveau de détail des images.

POST

/flux/v1/{model}

Python
JavaScript
Curl

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