Tutorial FLUX 3 API: generar vídeo, audio e imagen con Python paso a paso (2026)

FLUX 3 de Black Forest Labs es el primer modelo multimodal unificado que genera imagen, vídeo de 20 segundos con audio nativo y hasta acciones para robótica desde el mismo backbone. Anunciado el 23 de julio de 2026 y en early access desde ese mismo día, cambia radicalmente el workflow de cualquier creativo que quiera pasar de un prompt a un clip terminado sin cadenas de tres o cuatro APIs distintas. En este tutorial vas a montar, paso a paso y en Python 3.11+, un pipeline completo que llama a la API de BFL, genera imagen y vídeo con audio, encadena tomas para vídeos largos y se prepara para el futuro FLUX 3 Dev open-weight que Black Forest Labs promete para finales de 2026.

Por qué FLUX 3 cambia todo para creativos y devs

Hasta julio de 2026 el flujo típico de generación multimodal era una pesadilla: FLUX 1.1 para la imagen, Runway Gen 4.5 o Kling v3 para el vídeo, ElevenLabs para el audio, un modelo aparte para labios sincronizados y montaje manual en Resolve o Premiere. Cinco APIs, cinco facturas, cinco proveedores que romper cuando uno cambia formato. FLUX 3 lo colapsa todo en un solo modelo jointly trained sobre imagen, vídeo, audio y action-prediction para robótica.

En pruebas preliminares publicadas por Black Forest Labs, FLUX 3 Video fue preferido frente a Grok Imagine en el 69% de comparaciones, frente a Kling v3 Pro en el 60%, frente a Runway Gen 4.5 en el 77% y frente a Luma Ray 3.2 en el 93%. Los clips duran hasta 20 segundos, con audio nativo (diálogo, efectos y ambiente) generado en la misma inferencia. Soporta texto a vídeo, imagen a vídeo, vídeo a vídeo con character carry-over y keyframes controlados.

Para el desarrollador la implicación es directa: una única llamada REST, una única política de rate limiting, una única unidad de precio por segundo generado. Si vienes de encadenar agentes multimodales con LangChain o de pelearte con la exportación entre nodos de ComfyUI, prepárate porque el código que vas a escribir aquí cabe en menos de 200 líneas y produce un vídeo listo para YouTube.

Requisitos previos: entorno, cuenta y hardware

Antes de tocar código necesitas tres bloques listos:

• Python 3.11 o superior. Recomiendo 3.12 por el rendimiento en asyncio, que usaremos en el paso 8 para las peticiones concurrentes.
• Cuenta en Black Forest Labs. Regístrate en el portal de BFL, verifica email y solicita el early access a FLUX 3 Video desde el panel. Actualmente el acceso llega en 24-72 horas para cuentas con facturación configurada. La clave se genera en la sección API Keys y se envía por cabecera x-key.
• Hardware. Para llamar a la API te vale cualquier portátil moderno con conexión estable; los MP4 pesan entre 8 y 25 MB y se descargan en segundos. Pero si vas a experimentar en serio, iterar prompts todo el día o preparar tu equipo para FLUX 3 Dev cuando salga, aquí tienes una lista realista de componentes.

Para trabajar cómodo con vídeo generativo, el cuello de botella no es solo la GPU sino también almacenamiento rápido para cachear MP4 y RAM abundante para editar en paralelo. Estos son los componentes que uso yo en mi workstation:

• GPU flagship con 24 GB VRAM: MSI GeForce RTX 4090 Gaming X Trio 24 GB. Suficiente para FLUX 1.1 local y probablemente para FLUX 3 Dev quantizado.
• SSD NVMe rápido: Samsung 990 PRO 4 TB PCIe 4.0 (7450 MB/s lectura) o alternativa Kingston Fury Renegade 4 TB con disipador.
• Fuente de alimentación titanium: Corsair AX1600i 1600 W 80+ Titanium (imprescindible si aspiras a montar dual-GPU en el futuro).
• Refrigeración líquida 420 mm: ARCTIC Liquid Freezer III 420 para mantener el CPU frío durante encoding largo.
• Micrófono broadcast para narración de vídeos de prueba: Shure SM7B o alternativa asequible Rode PodMic USB.

Paso 1: Instalación del entorno Python

Usaremos uv como gestor de paquetes porque es 10 veces más rápido que pip y maneja bien los locks. Si no lo tienes, instálalo con curl -LsSf https://astral.sh/uv/install.sh | sh. Luego crea el proyecto y añade las dependencias:

mkdir flux3-lab && cd flux3-lab
uv init --python 3.12
uv add httpx pillow python-dotenv rich tenacity

Por qué estas libs: httpx soporta HTTP/2 y clientes async nativos (mejor que requests para polling); pillow valida y redimensiona imágenes de entrada; python-dotenv aísla la clave API; rich nos da barras de progreso bonitas mientras esperamos el polling; tenacity encapsula el retry con backoff exponencial que veremos en el paso 8.

Gotcha común: NO instales el paquete no-oficial bfl-python que aparece en pypi. A julio de 2026 Black Forest Labs no ha publicado SDK oficial y varios wrappers de terceros van desfasados o intentan interceptar la clave. Tira directamente contra la API REST con httpx.

Paso 2: Configuración .env y clave API

Nunca hardcodees la clave en el código. Crea un fichero .env en la raíz del proyecto con el siguiente contenido:

BFL_API_KEY=tu_clave_de_bfl_aqui
BFL_BASE_URL=https://api.bfl.ai/v1
BFL_REGION=eu
OUTPUT_DIR=./outputs

La API tiene un endpoint global (api.bfl.ai) y dos regionales (api.eu.bfl.ai y api.us.bfl.ai). Para usuarios en España usar eu reduce latencia en 60-120 ms por request. Añade .env a tu .gitignore ahora mismo, antes de hacer un commit.

Configuración del cliente en client.py:

import os
import httpx
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.environ["BFL_API_KEY"]
BASE_URL = os.getenv("BFL_BASE_URL", "https://api.bfl.ai/v1")
REGION = os.getenv("BFL_REGION", "eu")

def bfl_client() -> httpx.Client:
    """Cliente httpx preconfigurado con la cabecera x-key."""
    return httpx.Client(
        base_url=BASE_URL,
        headers={
            "accept": "application/json",
            "x-key": API_KEY,
            "Content-Type": "application/json",
        },
        timeout=httpx.Timeout(30.0, connect=10.0),
        http2=True,
    )

Resultado esperado: importar bfl_client desde otro módulo devuelve un cliente reutilizable. Verifica que la clave carga con python -c "from client import API_KEY; print(len(API_KEY))", debe imprimir entre 40 y 80 caracteres.

Paso 3: Primera imagen con FLUX 3 Image

FLUX 3 Image comparte el mismo backbone multimodal pero se factura por generación individual, no por segundo. Es el paso más barato para verificar que tu clave funciona antes de gastar créditos en vídeo. La API es asíncrona: envías el prompt, recibes un polling_url y consultas hasta que el estado pase a Ready.

import time
from client import bfl_client

def generar_imagen(prompt: str, width: int = 1440, height: int = 810) -> str:
    """Devuelve la URL de la imagen generada por FLUX 3 Image."""
    with bfl_client() as cli:
        r = cli.post("/flux-3-image", json={
            "prompt": prompt,
            "width": width,
            "height": height,
            "seed": 42,
            "output_format": "webp",
        })
        r.raise_for_status()
        polling_url = r.json()["polling_url"]

        # Polling cada 500 ms hasta status Ready
        while True:
            time.sleep(0.5)
            res = cli.get(polling_url).json()
            if res["status"] == "Ready":
                return res["result"]["sample"]
            if res["status"] in ("Error", "Failed"):
                raise RuntimeError(f"Generacion fallida: {res}")

url = generar_imagen(
    "cinematic photograph of a snowy pine forest at dawn, "
    "warm rim light through fog, ultra detailed 8k, "
    "shot on ARRI Alexa, shallow depth of field"
)
print("Imagen lista:", url)

Resultado esperado: en 4-8 segundos recibes una URL firmada con la imagen. Ojo: las URLs de resultado expiran a los 10 minutos. Descárgalas inmediatamente si quieres conservarlas.

Gotcha: si pides ratios raros (por ejemplo 3000x400) la API rechaza con 422. Manténte en presets 16:9 (1440x810), 9:16 (810x1440), 1:1 (1024x1024) o 21:9 (1680x720) para vídeo cinematográfico.

Paso 4: Vídeo de 20 segundos con audio nativo

Aquí está la joya. FLUX 3 Video toma un prompt y devuelve un MP4 con audio incrustado, sin necesidad de sincronizar tracks a posteriori. La estructura del request es casi idéntica a la imagen, cambia el endpoint y añades campos de duración, fps y prompt de audio.

import httpx
import time
from pathlib import Path
from client import bfl_client

OUTPUT_DIR = Path("./outputs")
OUTPUT_DIR.mkdir(exist_ok=True)

def generar_video(prompt: str, audio_prompt: str, duracion: int = 20) -> Path:
    """Genera un MP4 con audio nativo. Devuelve la ruta local."""
    with bfl_client() as cli:
        r = cli.post("/flux-3-video", json={
            "prompt": prompt,
            "audio_prompt": audio_prompt,
            "duration_seconds": duracion,
            "fps": 24,
            "resolution": "1080p",
            "aspect_ratio": "16:9",
            "seed": 7,
        })
        r.raise_for_status()
        polling_url = r.json()["polling_url"]

        # El vídeo tarda 60-180 s; polling cada 3 s para no saturar
        while True:
            time.sleep(3.0)
            res = cli.get(polling_url).json()
            if res["status"] == "Ready":
                mp4_url = res["result"]["sample"]
                break
            if res["status"] in ("Error", "Failed"):
                raise RuntimeError(res)

    # Descarga inmediata (URL expira en 10 min)
    dest = OUTPUT_DIR / f"video_{int(time.time())}.mp4"
    with httpx.stream("GET", mp4_url) as s, open(dest, "wb") as f:
        for chunk in s.iter_bytes(chunk_size=1 << 16):
            f.write(chunk)
    return dest

ruta = generar_video(
    prompt=(
        "wide cinematic shot: a lone astronaut walks across a crimson "
        "martian dune at sunset, backlit by twin moons, camera tracks "
        "slowly right, particles of dust drifting through the light"
    ),
    audio_prompt=(
        "distant wind howling across the desert, muffled boot steps "
        "on sand, deep synth pad ambient soundtrack, no dialogue"
    ),
    duracion=20,
)
print("Video guardado:", ruta)

Resultado esperado: un MP4 H.264 de aproximadamente 15-25 MB con pista de audio AAC de 48 kHz. El tiempo total de generación en early access oscila entre 90 y 180 segundos.

Gotcha: si dejas audio_prompt vacío BFL sintetiza un ambient genérico que suele quedar plano. Escribe siempre al menos una frase descriptiva del ambiente sonoro. Para diálogo especifica lengua y tono ("adult male voice in spanish, calm narration, medium tempo").

Paso 5: Vídeo a vídeo con character carry-over

Una de las funciones más pedidas históricamente era mantener al mismo personaje entre tomas. FLUX 3 lo resuelve con el modo video-to-video: le pasas un MP4 de referencia (o incluso solo el primer y último frame) y describe la transición. El modelo aprende la identidad del sujeto en la primera pasada y la mantiene consistente en la salida.

import base64
from client import bfl_client

def video_a_video(ref_video_path: str, prompt: str, audio_prompt: str) -> Path:
    """Extiende o transforma un vídeo existente manteniendo el personaje."""
    with open(ref_video_path, "rb") as f:
        ref_b64 = base64.b64encode(f.read()).decode()

    with bfl_client() as cli:
        r = cli.post("/flux-3-video", json={
            "mode": "video-to-video",
            "reference_video": ref_b64,
            "carry_identity": True,
            "prompt": prompt,
            "audio_prompt": audio_prompt,
            "duration_seconds": 20,
            "strength": 0.65,  # 0.0 = clon exacto, 1.0 = ignora referencia
        })
        r.raise_for_status()
        polling_url = r.json()["polling_url"]
        # ...mismo loop de polling que el paso 4...

Parámetro clave: strength controla cuánto respeta la referencia. Valores 0.55-0.70 mantienen al personaje reconocible cambiando escena y acción. Por encima de 0.85 el personaje suele "romperse" (cambio de facciones o ropa).

Gotcha: la referencia va en base64 y ocupa mucho. Para vídeos de más de 10 MB usa el endpoint alternativo /flux-3-video/upload que devuelve un handle temporal en dos partes, evitando peticiones REST de más de 20 MB que suelen fallar por timeouts intermedios.

Paso 6: Multi-shot chaining para vídeos de 1 minuto

FLUX 3 tiene un tope duro de 20 segundos por generación. Para producir un minuto o más se encadenan tres tomas: la primera genera desde texto, y las siguientes usan el último frame de la anterior como imagen inicial con image-to-video. Aquí un patrón limpio:

import subprocess
from pathlib import Path

def extraer_ultimo_frame(mp4: Path) -> Path:
    """Extrae el ultimo frame con ffmpeg."""
    out = mp4.with_suffix(".last.png")
    subprocess.run(
        ["ffmpeg", "-sseof", "-1", "-i", str(mp4),
         "-update", "1", "-q:v", "1", str(out), "-y"],
        check=True, capture_output=True
    )
    return out

def imagen_a_video(png: Path, prompt: str, audio_prompt: str) -> Path:
    """Continua la escena a partir del ultimo frame de otra toma."""
    with open(png, "rb") as f:
        img_b64 = base64.b64encode(f.read()).decode()
    with bfl_client() as cli:
        r = cli.post("/flux-3-video", json={
            "mode": "image-to-video",
            "reference_image": img_b64,
            "prompt": prompt,
            "audio_prompt": audio_prompt,
            "duration_seconds": 20,
            "carry_identity": True,
        })
        # ...polling + descarga como en paso 4...

def video_60s(guion: list[tuple[str, str]]) -> Path:
    """Encadena 3 tomas de 20 s. guion = [(prompt, audio_prompt), ...]."""
    assert len(guion) == 3
    toma1 = generar_video(*guion[0])
    ult = extraer_ultimo_frame(toma1)
    toma2 = imagen_a_video(ult, *guion[1])
    ult = extraer_ultimo_frame(toma2)
    toma3 = imagen_a_video(ult, *guion[2])

    # Concatena con ffmpeg
    lista = OUTPUT_DIR / "concat.txt"
    lista.write_text(
        "\n".join(f"file '{v.resolve()}'" for v in (toma1, toma2, toma3))
    )
    final = OUTPUT_DIR / "video_60s.mp4"
    subprocess.run(
        ["ffmpeg", "-f", "concat", "-safe", "0", "-i", str(lista),
         "-c", "copy", str(final), "-y"],
        check=True
    )
    return final

Resultado esperado: un MP4 de 60 segundos con transiciones suaves entre las tres tomas. Si notas saltos, sube carry_identity a estricto añadiendo "identity_strength": 0.9 al request.

Gotcha: ffmpeg concat con -c copy requiere que los tres MP4 compartan códec, timebase y resolución exactos. FLUX 3 los devuelve idénticos siempre que uses los mismos resolution, fps y aspect_ratio en las tres llamadas. Si alguno difiere, cambia a re-encoding con -c:v libx264 -crf 18.

Paso 7: Prompts profesionales para FLUX 3

La calidad final de un vídeo generado no depende del modelo, depende del prompt. FLUX 3 responde muy bien a descripciones cinematográficas estructuradas. Este es el patrón que uso yo, adaptado de guías de dirección de fotografía:

[TIPO DE PLANO] + [SUJETO Y ACCIÓN] + [ENTORNO] + [ILUMINACIÓN] + [MOVIMIENTO DE CÁMARA] + [ESTILO/REFERENCIA]

Ejemplo real:

prompt_bueno = (
    "medium tracking shot, "                    # tipo de plano
    "a young woman with red hair reads a book, "  # sujeto y accion
    "cozy autumn cafe with rain on the window, "  # entorno
    "warm tungsten light and soft rim glow, "     # iluminacion
    "camera slowly dollies in on her face, "      # movimiento
    "shot on Kodak Portra 400, cinematic 35mm, shallow depth of field"  # estilo
)

audio_bueno = (
    "gentle rain patter on glass, distant coffee "
    "machine steaming, low jazz piano playing in "
    "background, no dialogue, warm intimate mood"
)

Reglas empíricas:

• Longitud óptima del prompt visual: 40 a 90 palabras. Menos que 30 y el modelo improvisa; más de 100 empieza a ignorar el final.
• Menciona una cámara real ("shot on ARRI Alexa Mini LF", "Kodak Portra 400 film grain"). Sesga el modelo hacia estética profesional.
• Especifica el movimiento de cámara: dolly in, tracking left, static wide, handheld. Sin esto FLUX 3 tiende a estáticos aburridos.
• El audio_prompt es un prompt aparte. Trátalo como un brief para diseñador de sonido: instrumentos, ambiente, presencia o ausencia de diálogo.
• Evita adjetivos vacíos como "beautiful" o "amazing"; el modelo los ignora. Usa términos técnicos: "high contrast", "muted palette", "diffused key light".

Paso 8: Manejo de errores y rate limiting

La API de BFL en early access impone rate limits de aproximadamente 10 requests/minuto para vídeo y 60/min para imagen, con cuotas mensuales por plan. Necesitas retry con backoff exponencial y respeto de los códigos 429. Aquí la solución con tenacity:

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
import httpx

class RateLimited(Exception):
    pass

@retry(
    retry=retry_if_exception_type((RateLimited, httpx.ReadTimeout, httpx.RemoteProtocolError)),
    wait=wait_exponential(multiplier=2, min=4, max=60),
    stop=stop_after_attempt(6),
    reraise=True,
)
def post_con_retry(cli: httpx.Client, path: str, payload: dict) -> dict:
    r = cli.post(path, json=payload)
    if r.status_code == 429:
        retry_after = int(r.headers.get("Retry-After", "10"))
        time.sleep(retry_after)
        raise RateLimited(r.text)
    r.raise_for_status()
    return r.json()

Códigos frecuentes que verás:

• 401 Unauthorized: clave mal o revocada. Regenera desde el panel.
• 402 Payment Required: sin créditos. Recarga la cuenta.
• 422 Unprocessable Entity: prompt viola el content policy (violencia explícita, menores, celebridades) o parámetros inválidos.
• 429 Too Many Requests: rate limit. Respeta el Retry-After.
• 503 Service Unavailable: nodo saturado. Backoff y reintenta, o cambia región.

Gotcha: NUNCA hagas retry infinito. Un prompt bloqueado por content policy devuelve 422 permanentes; si lo dejas girar consumes cuota y bloqueas la cola. retry_if_exception_type filtra solo los transitorios.

Paso 9: Pipeline completo (guion a vídeo)

Juntamos todo en un script que toma un fichero guion.json con tres escenas y produce un vídeo de 60 segundos listo para publicar. Este es el pipeline.py:

#!/usr/bin/env python3
"""Pipeline: guion.json -> video_60s.mp4 con FLUX 3."""
import json
import sys
from pathlib import Path
from rich.progress import Progress, SpinnerColumn, TextColumn

from client import bfl_client
from generar import generar_video, imagen_a_video, extraer_ultimo_frame
from concat import concatenar

def pipeline(guion_path: Path) -> Path:
    guion = json.loads(guion_path.read_text(encoding="utf-8"))
    escenas = guion["escenas"]  # lista de {prompt, audio_prompt}
    assert 1 <= len(escenas) <= 3, "1 a 3 escenas soportadas"

    videos: list[Path] = []
    with Progress(SpinnerColumn(), TextColumn("[bold]{task.description}")) as p:
        for i, esc in enumerate(escenas, 1):
            t = p.add_task(f"Escena {i}/{len(escenas)}: {esc['prompt'][:50]}...")
            if i == 1:
                v = generar_video(esc["prompt"], esc["audio_prompt"])
            else:
                frame = extraer_ultimo_frame(videos[-1])
                v = imagen_a_video(frame, esc["prompt"], esc["audio_prompt"])
            videos.append(v)
            p.update(t, completed=True)

    return concatenar(videos, out_name=guion["nombre"])

if __name__ == "__main__":
    final = pipeline(Path(sys.argv[1]))
    print(f"Video final: {final} ({final.stat().st_size / 1_000_000:.1f} MB)")

Y un guion.json de ejemplo:

{
  "nombre": "arkaia_intro_60s",
  "escenas": [
    {
      "prompt": "wide establishing shot of a futuristic mountain observatory at blue hour, glass dome glowing, camera slowly cranes down toward the entrance",
      "audio_prompt": "cold mountain wind, distant electronic hum from the observatory, cinematic orchestral swell"
    },
    {
      "prompt": "medium shot: a scientist in a white coat walks through the illuminated corridor of the observatory, holographic screens on both sides, camera dollies backward keeping her centered",
      "audio_prompt": "soft footsteps on polished floor, subtle holographic beeps, low tension score"
    },
    {
      "prompt": "close up on the scientist's face lit by the blue glow of a giant screen showing the universe, her eyes widen as she reads the data, camera slowly pushes in",
      "audio_prompt": "quiet breathing, warm ambient pad, single dramatic piano note at the end"
    }
  ]
}

Ejecuta con uv run python pipeline.py guion.json. En unos 8-12 minutos tienes el MP4 final.

Paso 10: Preparar el equipo para FLUX 3 Dev local

Black Forest Labs ha confirmado que FLUX 3 Dev (open-weight) llegará más adelante en 2026, sin fecha pública todavía. No han desvelado parámetros ni requisitos oficiales, pero podemos hacer una estimación razonable extrapolando de FLUX.1 y FLUX.2, y del tamaño típico de modelos de vídeo con audio joint-trained. Estas son mis predicciones:

Para prepararte hoy:

1. Instala CUDA 12.6+ o ROCm 6.3 según seas Nvidia o AMD. FLUX 3 Dev seguramente se apoyará en PyTorch 2.5+ con FlashAttention 3 y quantization dinámica.
2. Prepara ComfyUI. Es la interfaz que primero recibió soporte para FLUX.1 y FLUX.2, y BFL ha colaborado directamente con el equipo de ComfyUI en cada release. Instala la build nightly y familiarízate con los nodos Video Combine y Audio Load.
3. Cachea modelos base. Un checkpoint multimodal de vídeo pesa 25-60 GB. Reserva al menos 200 GB libres en tu NVMe para cinco variantes quantizadas y LoRAs.
4. Aprende diffusers. La librería de Hugging Face suele tener soporte oficial en la primera semana; su pipeline FluxVideoPipeline abstrae la parte de audio y expone num_inference_steps, guidance_scale y schedulers custom.

Coste estimado por vídeo (economics)

BFL no ha publicado pricing oficial para FLUX 3 Video en early access. Estas son las cifras que estamos viendo en la práctica y las de proveedores comparables:

Servicio	Modelo	Coste por segundo de vídeo
fal.ai	Wan 2.5	$0,05/s
fal.ai	Veo 3	$0,40/s
Replicate	varios FLUX/Kling	$0,08-$0,30/s
BFL API (estimado early access)	FLUX 3 Video	$0,15-$0,25/s
OpenAI Sora 2 API (referencia)	Sora 2	$0,10-$0,50/s

Con esa horquilla, un vídeo de 60 segundos con audio nativo cuesta entre 9 y 15 dólares en API antes de descuentos por volumen. Para un canal de YouTube que publica dos vídeos por semana, hablamos de 100-120 USD/mes en generación pura, sin contar edición ni thumbnails. Cuando FLUX 3 Dev abra en local, el coste marginal cae a electricidad y amortización del hardware (unos 0,02-0,05 USD/s en una workstation con RTX 5090).

Recursos, libros y hardware recomendado

Para profundizar en la teoría detrás de la generación de imagen y vídeo, y montar el equipo idóneo para FLUX 3 Dev cuando llegue:

• Libro imprescindible: Generative Deep Learning (2nd Edition) de David Foster. Cubre VAE, GAN, autoregresivos, normalizing flows y difusión con ejemplos en Keras/JAX. La base conceptual de FLUX está aquí.
• Alternativa clásica: Generative Deep Learning (1st Edition) por si buscas la edición anterior.
• Almacenamiento rápido para modelos y outputs: Samsung 990 PRO 4 TB NVMe PCIe 4.0.
• SSD alternativa con disipador integrado: Kingston Fury Renegade 4 TB con heatsink.
• GPU para inferencia local FLUX y ComfyUI: MSI GeForce RTX 4090 Gaming X Trio 24 GB.
• Fuente 1600 W titanium para workstation dual-GPU: Corsair AX1600i 1600 W 80+ Titanium.
• Alternativa Corsair AX1600i (variante importada): Corsair AX1600i 1600 W modular.
• Refrigeración líquida 420 mm para CPU pesado en encoding: ARCTIC Liquid Freezer III 420.
• Micrófono broadcast para narración de vídeos que vayas a monetizar: Shure SM7B.
• Alternativa asequible: Rode PodMic USB con XLR y USB-C.

Preguntas frecuentes (FAQ)

¿Cuándo sale FLUX 3 Dev open-weight?

Black Forest Labs ha confirmado que llegará "más adelante en 2026" sin fecha pública. Basándonos en el histórico de FLUX.1 (agosto 2024) y FLUX.2 (2025), lo más probable es una ventana Q4 2026. La release incluirá pesos descargables desde Hugging Face bajo licencia FLUX Dev Non-Commercial, igual que las anteriores.

¿Qué VRAM necesito para correr FLUX 3 Dev localmente?

Sin datos oficiales todavía, la estimación razonable es 16-20 GB para inferencia de solo imagen en fp8, 32-48 GB para vídeo corto de 5 segundos en int8, y 60-80 GB para vídeo completo de 20 segundos con audio joint-trained. Una RTX 4090 24 GB debería servir para imagen; para vídeo largo probablemente necesites RTX 5090 32 GB o superior.

¿Cómo comparativa FLUX 3 Video contra OpenAI Sora 2?

Sora 2 mantiene ventaja en clips largos coherentes (hasta 60 segundos nativos) y modelado físico de fluidos. FLUX 3 gana en velocidad de generación (60-180 s frente a 3-8 minutos), integración nativa de audio y compatibilidad futura con inferencia local. Para creativos que priorizan iteración rápida y control, FLUX 3 es superior; para narrativas largas de una toma, Sora 2 sigue liderando.

¿Puedo usar FLUX 3 Video comercialmente?

Sí, con la API BFL en early access. Los términos comerciales están incluidos por defecto en el plan de pago (revisa la sección Terms del portal). Ojo con el open-weight FLUX 3 Dev cuando llegue: como sus predecesores, tendrá licencia "Non-Commercial" para los pesos, y si quieres uso comercial habrá que licenciar por separado o pagar el plan API.

¿Qué diferencia hay entre audio nativo de FLUX 3 y usar ElevenLabs aparte?

La ventaja del audio nativo es la sincronización con la acción en pantalla: pasos coinciden con pisadas, viento sube cuando la cámara sale a exterior, música se coordina con el ritmo del corte. Con ElevenLabs aparte tienes más control sobre voces específicas y clonaciones, pero pagas la penalización de sincronizar a mano en la postproducción. Para diálogo natural con actores clonados, ElevenLabs sigue ganando; para ambiente y sound design, FLUX 3 va sobrado.

¿La API BFL soporta webhooks o solo polling?

Ambos. Para producción se recomienda webhooks pasando un campo webhook_url en el POST inicial; recibes una notificación HTTP cuando el resultado está listo, sin tener que mantener conexiones abiertas. Para desarrollo y experimentación, polling cada 500 ms (imagen) o 3 s (vídeo) es más simple y no cambia el coste.

¿FLUX 3 puede generar vídeos verticales para TikTok o Reels?

Sí. Especifica "aspect_ratio": "9:16" y "resolution": "1080p" en el request; obtienes un MP4 de 1080x1920. La calidad es idéntica al modo horizontal, pero recuerda ajustar los movimientos de cámara en el prompt (dolly y trackings verticales lucen distintos que horizontales).

¿Cuánto tiempo tardan las URLs de resultado en expirar?

10 minutos exactos desde que el status pasa a Ready. Descarga siempre inmediatamente después del polling, no las almacenes en caché ni las compartas por email o Slack asumiendo que seguirán vivas al día siguiente.

Conclusión

FLUX 3 no es una iteración más: es la primera vez que un solo modelo produce imagen, vídeo de 20 segundos y audio sincronizado desde el mismo prompt, con una API asíncrona simple y un pricing competitivo. En este tutorial hemos montado un pipeline Python de menos de 300 líneas que va desde uv init hasta un MP4 de un minuto listo para publicar, pasando por retry con backoff, multi-shot chaining y buenas prácticas de prompting cinematográfico.

El paso siguiente es tuyo: pídeles el early access a BFL, monta el proyecto y empieza a iterar. Cuando FLUX 3 Dev abra en local, el mismo pipeline correrá contra un endpoint gratuito de tu propia máquina. Mientras tanto, prepara la workstation, aprende ComfyUI y estudia la teoría de difusión. En Arkaia iremos publicando actualizaciones cada vez que Black Forest Labs libere nuevas features. Sígue el canal de tutoriales o suscríbete al feed RSS para no perderte la release de los pesos open-weight cuando caiga.

Este artículo contiene enlaces afiliados a Amazon con el tag webmasteroson-21. Si compras a través de estos enlaces, Arkaia puede recibir una comisión sin coste adicional para ti. Nuestra valoración editorial es independiente y no varía según los ingresos por afiliación.