3 pasos para completar el acceso a la API de FLUX.2 Pro y Max: Guía práctica del modelo de generación de imágenes más potente de BFL

La serie FLUX.2 de Black Forest Labs se ha convertido en uno de los modelos de generación de imágenes más seguidos de 2025. ¿Cómo acceder rápidamente a las API de FLUX.2 Pro y FLUX.2 Max? Es una pregunta clave para muchos desarrolladores y creativos. Esta guía te proporcionará los pasos completos para realizar la integración en menos de 5 minutos.

Valor principal: Al terminar de leer, dominarás los métodos de llamada a la API de FLUX.2 Pro/Max, los trucos de configuración de parámetros y sabrás cómo elegir la versión del modelo adecuada para tu caso de uso.

Información rápida de la serie FLUX.2

Antes de comenzar con la integración, echemos un vistazo a la información clave de la serie FLUX.2:

Matriz de modelos FLUX.2

🎯 Sugerencia de acceso: Para la mayoría de los escenarios de producción, recomendamos acceder a FLUX.2 Pro a través de la plataforma APIYI (apiyi.com). Esta plataforma ofrece una interfaz unificada compatible con OpenAI, eliminando la necesidad de lidiar con los complejos procesos de autenticación de la API oficial.

Diferencias clave entre FLUX.2 Pro y Max

¿Elegir FLUX.2 Pro o Max? Esta es la pregunta que más se hacen los desarrolladores. La siguiente tabla compara detalladamente las diferencias entre ambos:

Sugerencias de selección

Escenarios para elegir FLUX.2 [pro]:

• Generación por lotes de fotos de productos para e-commerce.
• Creación de contenido para redes sociales.
• Producción a gran escala de materiales publicitarios.
• Proyectos con presupuesto ajustado.
• Necesidad de resultados estables y consistentes.

Escenarios para elegir FLUX.2 [max]:

• Creatividad publicitaria para marcas de lujo.
• Imágenes que requieran incluir información de actualidad reciente.
• Creación artística y diseño conceptual.
• Recreación precisa de escenas complejas.
• Uso profesional con exigencias de calidad extremadamente altas.

Integración rápida de la API de FLUX.2

Opción 1: Interfaz unificada a través de APIYI (Recomendado)

La plataforma APIYI ya tiene disponibles FLUX.2 Pro y FLUX.2 Max, permitiendo llamadas en formato compatible con OpenAI:

import requests

# Interfaz unificada de APIYI
base_url = "https://api.apiyi.com/v1"

def generate_image_flux2(prompt, model="flux.2-pro", width=1024, height=1024):
    """
    Genera imágenes usando FLUX.2 a través de APIYI

    Args:
        prompt: Descripción de la imagen
        model: flux.2-pro o flux.2-max
        width: Ancho de la imagen (múltiplo de 16, máx. 2048)
        height: Alto de la imagen (múltiplo de 16, máx. 2048)
    """
    headers = {
        "Authorization": "Bearer YOUR_APIYI_KEY",
        "Content-Type": "application/json"
    }

    data = {
        "model": model,
        "prompt": prompt,
        "size": f"{width}x{height}",
        "response_format": "url"
    }

    response = requests.post(
        f"{base_url}/images/generations",
        json=data,
        headers=headers
    )

    result = response.json()
    return result["data"][0]["url"]


# Ejemplo de uso
image_url = generate_image_flux2(
    prompt="A professional product photo of a modern smartphone on marble surface, soft studio lighting, ultra detailed",
    model="flux.2-pro",
    width=1024,
    height=1024
)
print(f"Imagen generada: {image_url}")

🚀 Inicio rápido: Se recomienda usar la plataforma APIYI (apiyi.com) para integrar FLUX.2 rápidamente. Esta plataforma ofrece una interfaz API lista para usar, sin configuraciones complejas, y soporta llamadas directas mediante el SDK de OpenAI.

Opción 2: API oficial de BFL

Si necesitas usar directamente la API oficial de Black Forest Labs:

import requests
import time

class FLUX2Client:
    """Cliente oficial de la API de FLUX.2"""

    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.bfl.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def generate(self, prompt, model="flux-2-pro", **kwargs):
        """
        Generar imagen

        Args:
            prompt: Descripción de la imagen
            model: flux-2-pro, flux-2-max, flux-2-flex
            **kwargs: width, height, seed, output_format, safety_tolerance
        """
        endpoint = f"{self.base_url}/{model}"

        data = {
            "prompt": prompt,
            "width": kwargs.get("width", 1024),
            "height": kwargs.get("height", 1024),
            "output_format": kwargs.get("output_format", "png")
        }

        # Añadir parámetros opcionales
        if "seed" in kwargs:
            data["seed"] = kwargs["seed"]
        if "safety_tolerance" in kwargs:
            data["safety_tolerance"] = kwargs["safety_tolerance"]

        response = requests.post(endpoint, json=data, headers=self.headers)
        return response.json()

    def generate_with_flex(self, prompt, steps=50, guidance=4.5, **kwargs):
        """
        Generar con FLUX.2 [flex] (soporta ajuste de parámetros)

        Args:
            prompt: Descripción de la imagen
            steps: Pasos de muestreo 1-50
            guidance: Factor de guía 1.5-10
        """
        data = {
            "prompt": prompt,
            "steps": steps,
            "guidance": guidance,
            "width": kwargs.get("width", 1024),
            "height": kwargs.get("height", 1024)
        }

        response = requests.post(
            f"{self.base_url}/flux-2-flex",
            json=data,
            headers=self.headers
        )
        return response.json()


# Ejemplo de uso
client = FLUX2Client("YOUR_BFL_API_KEY")

# Usar versión Pro
result = client.generate(
    prompt="A serene Japanese garden with cherry blossoms",
    model="flux-2-pro",
    width=1536,
    height=1024
)
print(f"Resultado de generación Pro: {result}")

# Usar versión Max (calidad máxima)
result_max = client.generate(
    prompt="A futuristic cityscape at night, neon lights, cyberpunk style, ultra detailed",
    model="flux-2-max",
    width=2048,
    height=2048
)
print(f"Resultado de generación Max: {result_max}")

import asyncio
import aiohttp
from typing import List, Dict

class AsyncFLUX2Client:
    """Cliente asíncrono de FLUX.2, soporta generación por lotes"""

    def __init__(self, api_key: str, base_url: str = "https://api.apiyi.com/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    async def generate_single(self, session: aiohttp.ClientSession,
                              prompt: str, model: str = "flux.2-pro",
                              width: int = 1024, height: int = 1024) -> Dict:
        """Generar una sola imagen de forma asíncrona"""
        data = {
            "model": model,
            "prompt": prompt,
            "size": f"{width}x{height}",
            "response_format": "url"
        }

        async with session.post(
            f"{self.base_url}/images/generations",
            json=data,
            headers=self.headers
        ) as response:
            return await response.json()

    async def generate_batch(self, prompts: List[str],
                             model: str = "flux.2-pro",
                             max_concurrent: int = 5) -> List[Dict]:
        """
        Generar imágenes por lotes

        Args:
            prompts: Lista de indicaciones
            model: Versión del modelo
            max_concurrent: Número máximo de concurrencia
        """
        semaphore = asyncio.Semaphore(max_concurrent)

        async def limited_generate(session, prompt):
            async with semaphore:
                return await self.generate_single(session, prompt, model)

        async with aiohttp.ClientSession() as session:
            tasks = [limited_generate(session, p) for p in prompts]
            results = await asyncio.gather(*tasks, return_exceptions=True)

        return results


async def main():
    client = AsyncFLUX2Client("YOUR_APIYI_KEY")

    prompts = [
        "A modern minimalist living room with natural lighting",
        "A vintage coffee shop interior with warm tones",
        "A futuristic office space with holographic displays",
        "A cozy bookstore with wooden shelves",
        "A high-tech laboratory with blue lighting"
    ]

    print("Iniciando generación por lotes...")
    results = await client.generate_batch(prompts, model="flux.2-pro")

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Error al generar la imagen {i+1}: {result}")
        else:
            print(f"Imagen {i+1}: {result['data'][0]['url']}")


if __name__ == "__main__":
    asyncio.run(main())

Detalle de los parámetros principales de la API FLUX.2

Parámetros generales

Sugerencias de configuración de resolución

💡 Optimización de costos: Para proyectos con presupuesto ajustado, puedes llamar a FLUX.2 Pro a través de la plataforma APIYI (apiyi.com) para obtener mejores precios, ideal para escenarios de generación por lotes.

Parámetros exclusivos de FLUX.2 [flex]

La versión FLUX.2 [flex] permite un control detallado de los parámetros:

Efecto del parámetro Steps:

Funciones avanzadas: Referencia de múltiples imágenes y edición de imagen

FLUX.2 admite la entrada de hasta 10 imágenes de referencia, lo que permite funciones avanzadas como la transferencia de estilo y la consistencia de personajes:

import base64
import requests

def generate_with_references(prompt, reference_images, model="flux.2-pro"):
    """
    Generar con imágenes de referencia

    Args:
        prompt: Descripción de la imagen
        reference_images: Lista de URLs o base64 de imágenes de referencia (máximo 10)
        model: Versión del modelo
    """
    headers = {
        "Authorization": "Bearer YOUR_APIYI_KEY",
        "Content-Type": "application/json"
    }

    # Procesar imágenes de referencia
    images = []
    for img in reference_images[:10]:  # Máximo 10 imágenes
        if img.startswith("http"):
            images.append({"type": "url", "url": img})
        else:
            images.append({"type": "base64", "data": img})

    data = {
        "model": model,
        "prompt": prompt,
        "reference_images": images,
        "size": "1024x1024"
    }

    response = requests.post(
        "https://api.apiyi.com/v1/images/generations",
        json=data,
        headers=headers
    )

    return response.json()


# Ejemplo de uso: Mantener la consistencia del personaje
result = generate_with_references(
    prompt="Same character in a coffee shop, reading a book, warm lighting",
    reference_images=[
        "https://example.com/character_ref1.jpg",
        "https://example.com/character_ref2.jpg"
    ],
    model="flux.2-max"
)

Funciones de edición de imagen

FLUX.2 permite la edición de imágenes basada en lenguaje natural:

def edit_image(source_image, edit_prompt, model="flux.2-pro"):
    """
    Editar una imagen existente

    Args:
        source_image: URL o base64 de la imagen de origen
        edit_prompt: Instrucción de edición
        model: Versión del modelo
    """
    headers = {
        "Authorization": "Bearer YOUR_APIYI_KEY",
        "Content-Type": "application/json"
    }

    data = {
        "model": model,
        "prompt": edit_prompt,
        "image": source_image,
        "mode": "edit"
    }

    response = requests.post(
        "https://api.apiyi.com/v1/images/edits",
        json=data,
        headers=headers
    )

    return response.json()


# Ejemplo de uso
result = edit_image(
    source_image="https://example.com/room.jpg",
    edit_prompt="Change the wall color to light blue, add plants near the window",
    model="flux.2-pro"
)

Mejores prácticas para indicaciones (prompts) en FLUX.2

El modelo de lenguaje visual Mistral-3 24B de FLUX.2 tiene una gran capacidad de comprensión de las indicaciones. Aquí tienes algunos trucos para optimizarlas:

Plantilla de estructura de la indicación

[Descripción del sujeto] + [Definición del estilo] + [Iluminación/Atmósfera] + [Requisitos de detalles] + [Modificadores de calidad]

Ejemplos de indicaciones excelentes

Técnicas de control de color

FLUX.2 admite un control preciso mediante códigos de color hexadecimales:

# Usar códigos de color hex para asegurar la precisión de los colores de marca
prompt = """
A modern tech company logo mockup on business card,
primary color: #FF6B35 (orange),
secondary color: #1A1A2E (dark navy),
clean minimalist design, professional presentation
"""

Optimización de costos y mejores prácticas

Ejemplo de cálculo de precios

Estrategias de optimización de costos

1. Optimización de resolución: Elige la resolución adecuada según el uso real para evitar un consumo excesivo de recursos.
2. Selección de modelo: Utiliza la versión Pro para contenido masivo y reserva la versión Max para piezas creativas premium.
3. Iteración de previsualización: Usa la versión Flex con pocos pasos (steps) para previsualizaciones rápidas y, una vez que estés satisfecho, genera la salida en alta calidad.
4. Procesamiento por lotes: Utiliza interfaces asíncronas por lotes para mejorar la eficiencia operativa.

💰 Comparación de costos: Al acceder a FLUX.2 a través de la plataforma APIYI (apiyi.com), puedes obtener métodos de facturación más flexibles. Para usuarios con un gran volumen de llamadas mensuales, la plataforma ofrece descuentos por niveles.

Preguntas frecuentes

result = generate_image(
    prompt="A red apple on wooden table",
    seed=12345  # Semilla fija
)

import time
from requests.exceptions import Timeout, RequestException

def generate_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            result = generate_image(prompt, timeout=60)
            return result
        except Timeout:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Retroceso exponencial
            continue
        except RequestException as e:
            print(f"请求错误: {e}")
            break
    return None

Resumen de integración de la API de FLUX.2

Ruta de acceso rápido a la API de FLUX.2 Complete la integración en 5 minutos a través de la plataforma APIYI

1 Registrar cuenta

<text x="60" y="140" text-anchor="middle" fill="#e2e8f0" font-size="11" font-family="Arial, sans-serif">Visita apiyi.com</text>
<text x="60" y="158" text-anchor="middle" fill="#94a3b8" font-size="10" font-family="Arial, sans-serif">Completado en 1 minuto</text>

2 Obtener Key

<text x="60" y="140" text-anchor="middle" fill="#e2e8f0" font-size="11" font-family="Arial, sans-serif">Crear API Key</text>
<text x="60" y="158" text-anchor="middle" fill="#94a3b8" font-size="10" font-family="Arial, sans-serif">Crédito de prueba gratuito</text>

3 Llamar a la API

<text x="60" y="140" text-anchor="middle" fill="#e2e8f0" font-size="11" font-family="Arial, sans-serif">Usar ejemplos de código</text>
<text x="60" y="158" text-anchor="middle" fill="#94a3b8" font-size="10" font-family="Arial, sans-serif">Formato compatible con OpenAI</text>

4 Obtener imagen

<text x="60" y="140" text-anchor="middle" fill="#e2e8f0" font-size="11" font-family="Arial, sans-serif">Generación completada</text>
<text x="60" y="158" text-anchor="middle" fill="#94a3b8" font-size="10" font-family="Arial, sans-serif">Salida de alta definición de 4MP</text>

Interfaz unificada Compatible con el SDK de OpenAI

Servicio estable 99.9% de disponibilidad

Facturación flexible Pago por uso / Suscripción mensual

Soporte técnico Respuesta del equipo profesional

La serie FLUX.2 representa la vanguardia actual en tecnología de generación de imágenes. Estos son los puntos clave presentados en este artículo:

Ruta de integración recomendada:

1. Visita apiyi.com y registra una cuenta
2. Obtén tu API Key
3. Usa los ejemplos de código de este artículo para una integración rápida
4. Ajusta las indicaciones y los parámetros según los resultados

A través de la plataforma APIYI, puedes integrar rápidamente FLUX.2 Pro y Max, disfrutando de las ventajas de una interfaz unificada, un servicio estable y una facturación flexible.

Lecturas adicionales:

• Documentación oficial de FLUX.2: docs.bfl.ai
• Presentación del modelo FLUX.2: bfl.ai/models/flux-2
• Blog oficial de FLUX.2: bfl.ai/blog/flux-2

Este artículo fue escrito por el equipo técnico de APIYI. Para conocer más soluciones de integración de APIs de modelos de IA, te invitamos a visitar apiyi.com