¿Cómo usar la API de Flux.2? Todo lo que necesitas saber

FLUX.2 es la segunda generación de la familia de modelos de generación y edición de imágenes de Black Forest Labs (lanzado el 25 de noviembre de 2025). Ofrece fotorrealismo de nivel producción, edición multirreferencia hasta 4MP, prompting estructurado/JSON y una elección entre endpoints gestionados (Pro, Flex) y opciones de pesos abiertos (Dev).

La buena noticia es que CometAPI ha integrado la API de Flux.2. Esta guía explica qué es FLUX.2, cómo llamar a la API y flujos de trabajo avanzados (texto→imagen, control flexible, edición multirreferencia), con ejemplos de código y mejores prácticas.

¿Qué es FLUX.2 y por qué importa?

FLUX.2 es la continuación de la familia de modelos FLUX — diseñado para generación de imágenes a partir de texto de alta fidelidad y edición de imágenes con múltiples referencias a resoluciones de producción (hasta ~4 megapíxeles). FLUX.2 está pensado para flujos creativos reales (activos seguros para marca, personajes y estilos consistentes entre referencias, mejor tipografía y detalles pequeños) en lugar de demos, y busca cerrar la brecha entre las imágenes generadas y las reales.

Resultados clave que FLUX.2 está diseñado para ofrecer

Resultados fotorrealistas adecuados para publicidad, imágenes de producto y maquetas de UI.
Edición nativa multirreferencia: combinar, intercambiar o componer elementos de varias imágenes de entrada en una única edición.
Variantes para diferentes casos de uso: modelos para desarrolladores de disponibilidad abierta, un endpoint Pro optimizado para producción y un endpoint Flex para control de bajo nivel.

A alto nivel, FLUX.2 combina una columna generativa latente (arquitectura de flujo/transformer) con un modelo visión–lenguaje para anclaje semántico, y un VAE recién entrenado para proporcionar un espacio latente compartido entre variantes. Este diseño permite al modelo tanto generar como reconstruir (editar) con mayor fidelidad, manteniendo a la vez una representación aprendible para entrenamiento y ajuste fino. El VAE abierto es especialmente notable porque estandariza el espacio latente para flujos de trabajo alojados y autoalojados.

Por qué importa: acoplar lenguaje y emparejamiento de flujo latente produce un seguimiento de prompts más sólido (de modo que instrucciones multipartes y composicionales se comporten de forma predecible), mejor tipografía y una única arquitectura que admite tanto generación como edición con múltiples referencias. Para los creadores, eso significa resultados más fiables para instrucciones complejas y entradas mixtas (texto + imágenes).

¿Cómo accedo a la API de FLUX.2?

Preparar el entorno

Regístrate e inicia sesión en CometAPI y obtén tu clave de API desde tu panel de perfil. Idealmente, deberías tener ciertos conocimientos de API como desarrollador (te proporcionaremos asistencia en este sentido, así que no te preocupes).

También necesitarás seleccionar tu método de solicitud deseado y el modelo Flux.2 apropiado.

¿Qué endpoints y autenticación se requieren?

La Replicate Predictions API proporciona acceso para generar imágenes de alta calidad usando varios modelos FLUX de Black Forest Labs a través del formato estándar de Replicate. Esta API admite una gama completa de variantes del modelo FLUX, cada una optimizada para diferentes casos de uso, desde prototipado rápido hasta generación de imágenes de grado profesional. Los usuarios pueden cambiar sin problemas entre diferentes modelos simplemente cambiando el nombre del modelo en la ruta URL (https://api.cometapi.com/replicate/v1/models/{models}/predictions), lo que la hace flexible para diversas aplicaciones creativas y comerciales.

CometAPI expone endpoints gestionados bajo https://api.cometapi.com/flux/v1/{model} y nombra endpoints como flux-2-pro, flux-2-flex y flux-2-flex para creación y edición de imágenes. Las solicitudes requieren una clave de API en el encabezado x-key.

Familia de modelos y compensaciones de cómputo

FLUX.2 (open weights) — Usa esta opción cuando necesites control local, experimentos de investigación o ejecutar inferencia en tu propia infraestructura. Dev es de pesos abiertos (32B) y excelente para investigación exploratoria y ajuste fino. Es más configurable, pero tú eres responsable de la infraestructura y la optimización.
FLUX.2 pro — La mejor combinación de velocidad, calidad y costo para producción. Pro está ajustado para latencia predecible, cumplimiento de prompt consistente, alto rendimiento y admite hasta 8 imágenes de referencia por API (9MP en total vía API). Úsalo para edición de alto volumen y cuando necesites fiabilidad y precios predecibles.
FLUX.2 (managed + controllability) — Expone controles de generación de bajo nivel (p. ej., steps, guidance) y admite más referencias (hasta 10) y una calidad/detalle ligeramente mayores cuando aceptas mayor latencia y costo. Usa Flex cuando necesites el control creativo final — fidelidad tipográfica, colores exactos o ajustes de composición altamente detallados.

Prototipa en Dev o con un plan Pro de bajo costo, luego migra a Pro para escalar o a Flex para renders finales altamente controlados.

¿Cómo uso la API de FLUX.2?

Ciclo de solicitud (tarea + modelo de sondeo)

Las respuestas a solicitudes de edición/generación son objetos de tarea que incluyen un polling_url e id; creas una solicitud y luego haces sondeo (o usas webhooks) para recuperar la URL firmada del resultado. Las URLs firmadas son de corta duración (típicamente ~10 minutos), así que obtén las salidas con prontitud.

La API alojada sigue un modelo de tareas asíncronas:

POST de una solicitud de generación → devuelve un task id y polling_url más el cost estimado.
Haz sondeo al polling_url hasta que status == "Ready", luego recupera el resultado de la imagen (a menudo base64 o una URL alojada).

Ejemplo: Python (requests) — enviar y sondear

import time, requests, os

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

payload = {
    "prompt": "Una foto de producto de alta gama de una taza de cerámica sobre un escritorio de madera, luz suave de ventana.",
    "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("URL del resultado:", status)
        break
    elif status in ("Error", "Failed"):
        print("La generación falló:", status)
        break

Este patrón (enviar → sondeo o webhook) es el flujo sincrónico/asíncrono principal para los endpoints gestionados.

Edición de imagen — ejemplo mínimo (curl con URL de entrada)

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": "Sustituye el fondo por un paseo marítimo soleado, mantiene a la persona intacta y empareja la iluminación",
    "input_image": "![image](https://example.com/my-photo.jpg)",
    "width": 2048,
    "height": 1536
  }'

Para edición multirreferencia, usa input_image, input_image_2, input_image_3, … (Pro admite hasta 8 referencias vía API; Flex hasta 10; Dev recomienda un máximo de ~6 según la memoria).

¿Qué parámetros básicos debo enviar?

Campos importantes del cuerpo de la solicitud (edición/generación de imágenes) incluyen:

guidance y steps — permiten control de grano fino.
prompt (string) — hasta 32K tokens; lenguaje natural detallado o JSON estructurado.
input_image (string) — obligatorio para ediciones (URL o base64).
input_image_2 … input_image_9 — imágenes multirreferencia.
width / height — múltiplos de 16; salida máxima 4MP.
seed — entero para reproducibilidad.
safety_tolerance — nivel de moderación.

¿Cómo puedo aprovechar FLUX.2 Pro para generación de texto a imagen profesional?

FLUX.2 Pro está ajustado para resultados fiables y de alta calidad. Úsalo cuando necesites resultados al nivel de marca, tiempos de respuesta rápidos y SLAs empresariales.

Receta de flujo de trabajo — imágenes de producción

Preprocesa los prompts: conserva una línea corta de “intención” más una sección de atributos estructurada (iluminación, lente, estado de ánimo, códigos de color hex para colores de marca). FLUX.2 admite dirección por color hex para ayudar a preservar paletas de marca.
Comienza con valores conservadores: steps 30–50 y guidance scale 6–9.0; aumenta steps para más detalle, aumenta guidance para que los resultados se adhieran más estrictamente al prompt.
Usa seeds + muestreo determinista para reproducibilidad en pruebas A/B.
Usa el endpoint Pro para muestreo multiintento: solicita N variaciones en paralelo y elige la mejor — más barato y rápido que ajustar hiperparámetros manualmente.
Posprocesa: desruido, mapeado de tonos menor o retoques de estilo vectorial en una canalización determinista. Considera una pequeña GAN o un paso de super-resolución si necesitas más que la salida nativa.

Por qué estos pasos ayudan: Pro equilibra velocidad y fidelidad y normalmente aplica filtros de seguridad/contenido post-generación, por lo que es la opción sensata para activos de cara al cliente.

Mejores consejos para generar imágenes

El prompting estructurado gana en producción. Organiza los prompts por prioridad: sujeto → acción → estilo → contexto. Usa prompting en JSON (scene, subjects, camera, lighting, color_palette) cuando necesites composición determinista en muchas imágenes. Uso de esquema JSON (pseudo):

{
  "scene": "toma de producto",
  "subjects": [
    {"type":"mug","pose":"center","style":"cerámica, mate"},
    {"type":"background","style":"escritorio de madera, luz de ventana"}
  ],
  "camera": {"focal_length":"85mm","aperture":"f2.8","angle":"ligeramente por encima"}
}

Reproducibilidad: Pasa seed para reproducir después. Conserva un catálogo que mapee prompt + seed → imagen para trazabilidad.
Lotes y orquestación: Para grandes ejecuciones de producción, envía muchas solicitudes en paralelo a Pro, pero limita la tasa para evitar throttling; prefiere el endpoint Pro para latencia predecible. Usa colas de trabajos y grupos de workers para descargar resultados firmados rápidamente una vez listos.
Moderación y seguridad: Usa safety_tolerance para controlar el rigor de moderación. Los endpoints Pro incluyen políticas de uso y ganchos de moderación de contenido; integra comprobaciones en el servidor antes de publicar.
Posprocesado: Las salidas de Pro son de alta calidad pero ocasionalmente necesitan pequeños retoques. Construye un paso automatizado de posprocesado (recorte, gradación de color, composición) en tu canalización y mantén revisión humana para activos sensibles a la marca.

¿Cómo puedo personalizar salidas con el endpoint FLUX.2 Flex?

Flex es la variante “quirúrgica”: ajusta steps, guidance, prompts negativos, tamaños de mosaico y conteo de referencias para modelar la salida con precisión.

Cuándo elegir Flex

Necesitas renderizado tipográfico preciso (maquetas de UI, etiquetas).
Debes componer múltiples referencias con control sobre pose e iluminación.
Estás experimentando con técnicas avanzadas de prompting (prompts estructurados, cadenas de restricciones).

Ejemplo — Claves de control de Flex y sus efectos

steps — más pasos = más detalle (a costa de latencia).
guidance_scale — mayor = más cercano al prompt de texto, menor = más creatividad.
negative_prompt — elimina explícitamente elementos (p. ej., “sin marca de agua, sin dedos extra”).
tile_size / tiled_inference — para generación de muy alta resolución, divide la inferencia en mosaicos para intercambiar memoria por velocidad.
reference_weights — algunos endpoints permiten ponderar referencias para sesgar qué imagen dirige la pose frente al estilo.

Consejo práctico: Para composiciones complejas, ejecuta una vista previa corta de baja guidance para verificar la composición, luego escala con más steps y mayor guidance. Esta técnica de dos pasadas reduce el costo y brinda resultados finales precisos.

Ejemplo: solicitud Flex con steps y 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": "Póster de película cinematográfico, tipografía en negrita en la parte superior, personaje principal centrado, luz de contorno dramática",
    "width": 1536, "height": 2048,
    "steps": 50,
    "guidance": 7.5,
    "seed": 99999
  }'

Consejo: Usa Flex durante las aprobaciones creativas finales y Pro para canalizaciones a gran escala y más rápidas. Flex es notablemente más controlable para tareas de tipografía y microdetalle.

Mejores prácticas para uso en producción

A continuación, patrones probados y consejos pragmáticos para integrar FLUX.2 a escala.

1) Controla el costo rastreando megapíxeles y usando caché

La facturación de FLUX.2 se basa en los megapíxeles de entrada + salida. Para generación de alto volumen, prefiere renders de vista previa más pequeños (baja resolución, pocos pasos) y solo escala a renders finales de mayor MP. Cachea los activos renderizados (o almacena diffs) para no volver a renderizar trabajos idénticos. Siempre muestra cost en las respuestas y regístralo por solicitud.

2) Usa los niveles con inteligencia: división vista previa vs render final

Ejecuta renders Pro rápidos y de pocos pasos para prototipado o muchas variantes.
Usa Flex o ejecuciones Pro de alta MP para salidas finales aprobadas donde la fidelidad importa. Este enfoque híbrido equilibra rendimiento y calidad de imagen final.

3) Ingeniería de prompts → prompts estructurados y JSON

Aprovecha el prompting JSON estructurado de FLUX.2 cuando necesites composición determinista (objetos de escena, cámara, poses, muestras de color hex). Esto reduce ciclos iterativos de prompting y conduce a lotes más reproducibles. Ejemplos de Cloudflare muestran prompts JSON incrustados en formularios multipart.

4) Seed + versionado para reproducibilidad

Cuando necesites resultados reproducibles, pasa un seed y registra la versión del modelo/marca de tiempo en metadatos. Para canalizaciones de activos deterministas, conserva un manifiesto: prompt, seed, variante del modelo, resolución, hashes de imágenes de referencia. Esto mejora la trazabilidad y las opciones de reversión.

Conclusión

FLUX.2 apunta directamente a cerrar la brecha entre “demo impresionante” y “herramienta creativa de producción”. Con edición multirreferencia, salidas de alta resolución y un conjunto de endpoints alojados (además de código de inferencia abierto y compilaciones cuantizadas para consumidores), ofrece a los equipos muchas opciones prácticas: ejecuta localmente para investigación y personalización, o utiliza los endpoints Pro/Flex alojados para canalizaciones de producción estables.

Los desarrolladores pueden acceder a la Flux.2 Dev API, Flux.2 Flex API y Flux.2 Pro API a través de CometAPI. Para comenzar, explora las capacidades del modelo de CometAPI en el Playground y consulta la guía de la API para instrucciones detalladas. Antes de acceder, asegúrate de haber iniciado sesión en CometAPI y obtenido la clave de API. CometAPI ofrece un precio muy inferior al oficial para ayudarte a integrar.

¿Listo para empezar?→ ¡Regístrate en CometAPI hoy!

Si quieres conocer más consejos, guías y noticias sobre IA, síguenos en VK, X y Discord!