Videos UGC con IA: Automatiza Creación de Contenido con n8n y Stable Diffusion (Guía Completa 2025)

¿Necesitas crear cientos de videos UGC (User Generated Content) para tu marca pero no tienes tiempo ni presupuesto para grabarlos manualmente? La solución está en automatizar todo el proceso con IA: Stable Diffusion genera las imágenes, n8n orquesta el workflow, y FFmpeg crea los videos automáticamente. Sin necesidad de grabar nada. Sin depender de creadores humanos. Sin límites de escalabilidad.

En esta guía completa te enseño a montar un pipeline completo de automatización de videos UGC usando herramientas open source en tu homelab. Aprenderás a integrar ComfyUI (o AUTOMATIC1111) con n8n, procesar imágenes con FFmpeg, y crear workflows reutilizables que generan videos listos para publicar en minutos. Todo con ejemplos prácticos, código copy-paste, y soluciones a los problemas más comunes.

Después de seguir esta guía, tendrás un sistema automatizado que genera videos UGC de forma masiva: unboxings, reviews, tutoriales, y contenido lifestyle. Perfecto para e-commerce, marketing en redes sociales, o canales de YouTube que necesitan publicar contenido diario.

—

📋 TL;DR

¿Qué es esto? Un pipeline automatizado que genera videos UGC usando IA: Stable Diffusion crea imágenes → n8n automatiza el proceso → FFmpeg genera videos.

¿Qué necesitas? Docker-2025/), GPU NVIDIA (mínimo 4GB VRAM), y 30 minutos de configuración.

¿Resultado? Sistema que genera videos UGC automáticamente, escalable a cientos de videos por día.

⏱️ Tiempo de lectura: 20 minutos

—

📚 Tabla de Contenidos

1. ¿Qué son los videos UGC y por qué automatizarlos?
2. Arquitectura del pipeline
3. Requisitos y preparación
4. Instalación del stack completo
5. Configuración de Stable Diffusion
6. Crear workflow n8n para automatización
7. Procesamiento de imágenes a video con FFmpeg
8. Ejemplos prácticos: diferentes tipos de videos UGC
9. Optimización y mejores prácticas
10. Comparativa: ComfyUI vs AUTOMATIC1111
11. Troubleshooting común
12. Descargar ejemplos
13. Preguntas frecuentes
14. Conclusión

—

¿Qué son los videos UGC y por qué automatizarlos? {#que-son-videos-ugc}

UGC (User Generated Content) son videos creados por usuarios que muestran productos o servicios de manera auténtica. Incluyen unboxings, tutoriales, testimonios, reviews, y vlogs de experiencias. Su principal ventaja es que no se perciben como publicidad tradicional, sino como recomendaciones genuinas de otros consumidores.

Problemas del UGC tradicional

1. Coste elevado:

• Pagar a creadores por cada video (50-500€ por video)
• Producción profesional (cámaras, iluminación, edición)
• Tiempo de coordinación y revisión

2. Escalabilidad limitada:

• Difícil generar cientos de videos
• Dependes de disponibilidad de creadores
• Proceso manual lento y tedioso

3. Consistencia:

• Cada creador tiene su estilo
• Difícil mantener coherencia de marca
• Calidad variable entre videos

Solución: Automatización con IA

Ventajas de automatizar con IA:

✅ Escalabilidad ilimitada: Genera cientos de videos automáticamente

✅ Coste reducido: Solo hardware/infraestructura (sin pagar creadores)

✅ Consistencia: Mismo estilo y calidad en todos los videos

✅ Personalización masiva: Diferentes variaciones automáticamente

✅ Velocidad: Videos listos en minutos, no días

Casos de uso ideales:

• E-commerce: Videos de productos para catálogo (100+ productos)
• Marketing: Campañas en redes sociales (TikTok, Instagram Reels)
• YouTube: Contenido diario automatizado (shorts, reviews)
• A/B Testing: Múltiples variaciones del mismo producto

—

Arquitectura del pipeline {#arquitectura}

El pipeline completo consta de tres componentes principales que trabajan juntos:

┌─────────────────┐
│  n8n Workflow   │  ← Orquesta todo el proceso
│  (Orquestador)  │
└────────┬────────┘
         │
         ├──────────────────────┐
         │                      │
         ▼                      ▼
┌──────────────────┐   ┌──────────────────┐
│ Stable Diffusion │   │     FFmpeg       │
│  (Genera Imágenes)│   │  (Crea Videos)   │
│  :7860 o :8188   │   │  (Local/Remote)  │
└──────────────────┘   └──────────────────┘
         │                      │
         │                      │
         └──────────┬───────────┘
                    │
                    ▼
         ┌──────────────────┐
         │  Videos UGC      │
         │  Listos          │
         └──────────────────┘

Flujo de trabajo paso a paso

1. Trigger inicial:

• n8n recibe trigger (schedule, webhook, o manual)
• Genera lista de prompts según tipo de video

2. Generación de imágenes:

• n8n llama a Stable Diffusion API (ComfyUI o AUTOMATIC1111)
• Genera múltiples imágenes (4-8 por video)
• Descarga imágenes generadas

3. Procesamiento de video:

• n8n ejecuta FFmpeg (local o remoto)
• FFmpeg crea video desde imágenes (slideshow, animación)
• Opcional: añade audio de fondo, transiciones, efectos

4. Post-procesamiento:

• n8n guarda video en storage local
• Opcional: sube a YouTube, S3, o plataforma de hosting
• Notifica cuando está listo

—

Requisitos y preparación {#requisitos}

Hardware

Nota: Si no tienes GPU, puedes usar servicios cloud (RunPod, Vast.ai) o CPU (mucho más lento).

Software

• Docker y Docker Compose (última versión)
• NVIDIA Docker runtime (si usas GPU)
• FFmpeg (o contenedor Docker)
• Git (para clonar ejemplos)

Verificar GPU

# Verificar que NVIDIA driver está instalado
nvidia-smi

# Verificar que Docker puede usar GPU
docker run --rm --gpus all nvidia/cuda:11.0.3-base-ubuntu20.04 nvidia-smi

Si ambos comandos funcionan, estás listo para continuar.

—

Instalación del stack completo {#instalacion}

Vamos a instalar todo el stack con Docker Compose. Esto incluye ComfyUI, n8n, y FFmpeg en contenedores separados.

1. Crear estructura de directorios

mkdir -p videos-ugc-automation/{comfyui_models,comfyui_output,video_output,n8n_workflows}
cd videos-ugc-automation

2. Docker Compose completo

Crea docker-compose.yml:

version: '3.8'

services:
  # Stable Diffusion (ComfyUI)
  comfyui:
    image: yanwk/comfyui-boot:cu126
    container_name: comfyui
    ports:
      - "8188:8188"
    volumes:
      - ./comfyui_models:/comfyui/models
      - ./comfyui_output:/comfyui/output
    environment:
      - CLI_ARGS=--listen 0.0.0.0
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

  # n8n
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
      - ./n8n_workflows:/data/workflows
      - ./video_output:/data/videos
      - ./comfyui_output:/data/images
    environment:
      - N8N_HOST=0.0.0.0
      - WEBHOOK_URL=http://localhost:5678/
    depends_on:
      - comfyui
    restart: unless-stopped

  # FFmpeg (para procesamiento de video)
  ffmpeg:
    image: jrottenberg/ffmpeg:latest
    container_name: ffmpeg
    volumes:
      - ./video_output:/data/videos
      - ./comfyui_output:/data/images
    command: tail -f /dev/null  # Mantener contenedor corriendo
    restart: unless-stopped

volumes:
  n8n_data:

3. Levantar servicios

docker-compose up -d

Verificar que todo funciona:

# ComfyUI debería estar en http://localhost:8188
curl http://localhost:8188/queue

# n8n debería estar en http://localhost:5678
curl http://localhost:5678/healthz

# FFmpeg debería estar corriendo
docker exec ffmpeg ffmpeg -version

4. Descargar modelo Stable Diffusion

ComfyUI necesita un modelo para generar imágenes. Descarga uno desde Civitai o Hugging Face:

# Crear directorio para modelos
mkdir -p comfyui_models/Stable-diffusion

# Descargar modelo (ejemplo: Realistic Vision v5)
cd comfyui_models/Stable-diffusion
wget https://huggingface.co/SG161222/Realistic_Vision_V5.1_noVAE/resolve/main/Realistic_Vision_V5.1_fp16-no-ema.safetensors

Modelos recomendados para UGC:

• Realistic Vision v5: Excelente para personas y productos realistas
• DreamShaper XL: Versátil, buena calidad general
• Juggernaut XL: Alta calidad, requiere más VRAM

—

Configuración de Stable Diffusion {#configuracion-stable-diffusion}

Tienes dos opciones: ComfyUI (recomendado para automatización) o AUTOMATIC1111 (más fácil de usar).

Opción A: ComfyUI (Recomendado)

Ventajas:

• ✅ API REST completa y bien documentada
• ✅ Batch generation fácil
• ✅ Workflows reutilizables (JSON exportable)
• ✅ Optimizado para VRAM
• ✅ Más rápido

Desventajas:

• ❌ Curva de aprendizaje más alta
• ❌ Interfaz menos intuitiva

Verificar que funciona:

# Acceder a la interfaz web
# http://localhost:8188

# Probar API
curl -X POST http://localhost:8188/prompt \
  -H "Content-Type: application/json" \
  -d '{"prompt": {"1": {"inputs": {"text": "test"}, "class_type": "CLIPTextEncode"}}}'

Opción B: AUTOMATIC1111

Ventajas:

• ✅ Interfaz más intuitiva
• ✅ Más plugins disponibles
• ✅ Curva de aprendizaje más baja

Desventajas:

• ❌ API menos completa
• ❌ Batch generation más complejo
• ❌ Menos optimizado para VRAM

Si prefieres AUTOMATIC1111, cambia el servicio en docker-compose.yml:

comfyui:
  image: atinoda/stable-diffusion-webui:latest
  ports:
    - "7860:7860"
  # ... resto de configuración igual

Verificar que funciona:

# Acceder a la interfaz web
# http://localhost:7860

# Probar API
curl http://localhost:7860/sdapi/v1/options

Recomendación: Para automatización de video, ComfyUI es superior por su mejor API y batch generation.

—

Crear workflow n8n para automatización {#workflow-n8n}

Vamos a crear un workflow n8n que automatiza todo el proceso: desde generar prompts hasta crear el video final.

1. Acceder a n8n

Abre http://localhost:5678 en tu navegador. Si es la primera vez, crea una cuenta.

2. Workflow básico: Generar Video UGC

Estructura del workflow:

Schedule Trigger → Generate Prompts → Generate Images → Wait → Download Images → Create Video → Notify

Paso 1: Schedule Trigger

• Añade nodo Schedule Trigger
• Configura para ejecutarse cada 6 horas (o según necesites)

Paso 2: Code Node (Generar Prompts)

Añade nodo Code con este código:

const prompts = [
  "a person unboxing a product, authentic UGC style, smartphone video, natural lighting, vertical format",
  "a person reviewing a product, showing features, tutorial style, clear demonstration, natural lighting, vertical format",
  "a person using a product in daily life, casual setting, authentic moment, natural lighting, lifestyle content, vertical format"
];

return prompts.map((prompt, index) => ({
  prompt: prompt,
  seed: Math.floor(Math.random() * 1000000),
  index: index
}));

Paso 3: HTTP Request (Generar Imágenes con ComfyUI)

Añade nodo HTTP Request:

• Method: POST
• URL: http://comfyui:8188/prompt
• Body: (JSON)

{
  "prompt": {
    "1": {
      "inputs": {"text": "={{ $json.prompt }}", "clip": ["4", 0]},
      "class_type": "CLIPTextEncode"
    },
    "2": {
      "inputs": {"text": "blurry, low quality, distorted", "clip": ["4", 0]},
      "class_type": "CLIPTextEncode"
    },
    "3": {
      "inputs": {"ckpt_name": "realistic_vision_v5.safetensors"},
      "class_type": "CheckpointLoaderSimple"
    },
    "4": {
      "inputs": {"width": 512, "height": 512, "batch_size": 4},
      "class_type": "EmptyLatentImage"
    },
    "5": {
      "inputs": {
        "seed": "={{ $json.seed }}",
        "steps": 20,
        "cfg": 7.0,
        "sampler_name": "euler",
        "scheduler": "normal",
        "denoise": 1.0,
        "model": ["3", 0],
        "positive": ["1", 0],
        "negative": ["2", 0],
        "latent_image": ["4", 0]
      },
      "class_type": "KSampler"
    },
    "6": {
      "inputs": {"samples": ["5", 0], "vae": ["3", 2]},
      "class_type": "VAEDecode"
    },
    "7": {
      "inputs": {"filename_prefix": "ugc_video", "images": ["6", 0]},
      "class_type": "SaveImage"
    }
  }
}

Paso 4: Wait Node (Esperar Generación)

Añade nodo Wait:

• Resume: After Time Interval
• Amount: 60 (segundos)
• Unit: Seconds

Paso 5: Execute Command (Crear Video con FFmpeg)

Añade nodo Execute Command:

• Command:

docker exec ffmpeg ffmpeg -framerate 1/3 \
  -pattern_type glob \
  -i '/data/images/ugc_video_*.png' \
  -vf 'scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2' \
  -c:v libx264 \
  -pix_fmt yuv420p \
  -r 30 \
  /data/videos/ugc_$(date +%s).mp4

Paso 6: Telegram/Email (Notificar)

Añade nodo Telegram o Email para notificar cuando el video esté listo.

3. Activar workflow

Haz clic en Activate en la esquina superior derecha. El workflow se ejecutará automáticamente según el schedule configurado.

—

Procesamiento de imágenes a video con FFmpeg {#ffmpeg}

FFmpeg es la herramienta que convierte las imágenes generadas en videos. Vamos a ver diferentes técnicas según el tipo de video que quieras crear.

1. Slideshow básico

Script: scripts/create-video.sh

#!/bin/bash
INPUT_DIR="${1:-./comfyui_output}"
OUTPUT_FILE="${2:-./video_output/video_ugc.mp4}"
FPS="${3:-1}"  # 1 frame cada segundo (slideshow lento)

ffmpeg -framerate $FPS \
  -pattern_type glob \
  -i "${INPUT_DIR}/ugc_video_*.png" \
  -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" \
  -c:v libx264 \
  -pix_fmt yuv420p \
  -r 30 \
  "$OUTPUT_FILE"

Uso:

chmod +x scripts/create-video.sh
./scripts/create-video.sh ./comfyui_output ./video_output/unboxing.mp4 1

2. Video con transiciones suaves

Script: scripts/create-video-advanced.sh

#!/bin/bash
INPUT_DIR="${1:-./comfyui_output}"
OUTPUT_FILE="${2:-./video_output/video_ugc_advanced.mp4}"

ffmpeg -framerate 0.5 \
  -pattern_type glob \
  -i "${INPUT_DIR}/ugc_video_*.png" \
  -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,fps=30,scale=1920:1080" \
  -c:v libx264 \
  -preset slow \
  -crf 18 \
  -pix_fmt yuv420p \
  -r 30 \
  "$OUTPUT_FILE"

Parámetros importantes:

• -framerate 0.5: 1 frame cada 2 segundos (transiciones más lentas)
• -preset slow: Mejor calidad, más lento
• -crf 18: Alta calidad (18-23 es rango recomendado)

3. Video con audio de fondo

# Crear video sin audio
ffmpeg -framerate 1/3 \
  -pattern_type glob \
  -i "images/*.png" \
  -vf "scale=1920:1080" \
  -c:v libx264 \
  -pix_fmt yuv420p \
  -r 30 \
  video_no_audio.mp4

# Añadir audio
ffmpeg -i video_no_audio.mp4 -i background_music.mp3 \
  -c:v copy \
  -c:a aac \
  -shortest \
  video_with_audio.mp4

4. Video con zoom Ken Burns

Efecto de zoom suave que hace el video más dinámico:

ffmpeg -framerate 1/2 \
  -pattern_type glob \
  -i "images/*.png" \
  -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,zoompan=z='zoom+0.002':d=60:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)'" \
  -c:v libx264 \
  -pix_fmt yuv420p \
  -r 30 \
  output.mp4

5. Video con texto overlay

Añadir texto sobre el video (título, marca, etc.):

ffmpeg -framerate 1/3 \
  -pattern_type glob \
  -i "images/*.png" \
  -vf "scale=1920:1080,drawtext=text='Product Review':fontcolor=white:fontsize=48:x=(w-text_w)/2:y=h-th-40" \
  -c:v libx264 \
  -pix_fmt yuv420p \
  -r 30 \
  output.mp4

—

Ejemplos prácticos: diferentes tipos de videos UGC {#ejemplos-practicos}

Vamos a ver ejemplos específicos para diferentes tipos de videos UGC.

1. Unboxing Videos

Características:

• Muestra producto siendo desembalado
• Reacción auténtica
• Iluminación natural
• Estilo smartphone/casual

Prompt Stable Diffusion:

"a person unboxing a [product], authentic UGC style, smartphone video, natural lighting, genuine reaction, casual setting, vertical format"

Duración: 15-30 segundos

Imágenes necesarias: 5-8 frames

Ejemplo de workflow n8n:

// Code Node: Generar prompt
const product = "smartphone";
const prompt = `a person unboxing a ${product}, authentic UGC style, smartphone video, natural lighting, genuine reaction, vertical format`;

return [{ prompt: prompt, seed: Math.floor(Math.random() * 1000000) }];

2. Product Review Videos

Características:

• Muestra producto en uso
• Explicación de características
• Comparación con alternativas
• Testimonio honesto

Prompt Stable Diffusion:

"a person reviewing a [product], showing features, tutorial style, clear demonstration, natural lighting, authentic review, vertical format"

Duración: 30-60 segundos

Imágenes necesarias: 10-15 frames

3. Tutorial/How-to Videos

Características:

• Paso a paso
• Instrucciones claras
• Producto en acción
• Estilo educativo

Prompt Stable Diffusion:

"a person demonstrating how to use [product], step by step tutorial, clear instructions, educational style, natural lighting, vertical format"

Duración: 60-120 segundos

Imágenes necesarias: 15-25 frames

4. Lifestyle/Usage Videos

Características:

• Producto en contexto real
• Uso diario
• Ambiente casual
• Autenticidad

Prompt Stable Diffusion:

"a person using [product] in daily life, casual setting, authentic moment, natural lighting, lifestyle content, vertical format"

Duración: 15-30 segundos

Imágenes necesarias: 5-10 frames

—

Optimización y mejores prácticas {#optimizacion}

1. Optimización de Prompts

Tips para mejores resultados:

• ✅ Especificar estilo UGC: «authentic UGC style», «smartphone video»
• ✅ Formato vertical: «vertical format» (para TikTok, Instagram Reels)
• ✅ Iluminación natural: «natural lighting», «casual setting»
• ✅ Variaciones: Cambiar seeds para diferentes variaciones

Ejemplo de prompt optimizado:

"a person unboxing a smartphone, authentic UGC style, smartphone video, natural lighting, genuine reaction, casual setting, vertical format, high quality, detailed"

2. Gestión de Recursos

Batch size óptimo:

• Generar 4-8 imágenes por video (balance calidad/velocidad)
• Más imágenes = video más largo pero más lento

Resolución:

• 512×512 o 768×768 (balance calidad/velocidad)
• 1024×1024 solo si tienes GPU potente (16GB+ VRAM)

GPU sharing:

• Si usas Ollama también, limitar VRAM de cada servicio
• Usar --gpu-memory-limit en ComfyUI

3. Calidad de Video

Configuración recomendada:

• FPS: 30 fps para videos suaves
• Bitrate: 5-10 Mbps para buena calidad
• Codec: H.264 (compatible universalmente)
• Formato: MP4 (más compatible)

Ejemplo de FFmpeg optimizado:

ffmpeg -framerate 1/3 \
  -pattern_type glob \
  -i "images/*.png" \
  -vf "scale=1920:1080" \
  -c:v libx264 \
  -preset medium \
  -crf 20 \
  -b:v 5M \
  -pix_fmt yuv420p \
  -r 30 \
  output.mp4

4. Escalabilidad

Procesamiento paralelo:

• Múltiples workflows n8n ejecutándose simultáneamente
• Limitar trabajos simultáneos para no saturar GPU

Queue management:

• Usar cola en n8n para gestionar trabajos
• Priorizar videos urgentes

Storage:

• Usar S3 o storage externo para videos grandes
• Limpiar imágenes antiguas periódicamente

—

Comparativa: ComfyUI vs AUTOMATIC1111 {#comparativa}

Recomendación:

• Para automatización: ComfyUI (mejor API, batch generation, workflows reutilizables)
• Para uso manual: AUTOMATIC1111 (interfaz más intuitiva)

—

Troubleshooting común {#troubleshooting}

1. FFmpeg no encuentra imágenes

Síntoma: Error «No such file or directory» al ejecutar FFmpeg

Soluciones:

# Verificar que las imágenes existen
ls -la comfyui_output/ugc_video_*.png

# Verificar permisos
chmod 644 comfyui_output/*.png

# Usar rutas absolutas en lugar de relativas
ffmpeg -framerate 1/3 \
  -pattern_type glob \
  -i "/ruta/absoluta/comfyui_output/ugc_video_*.png" \
  ...

2. Video sin audio o con problemas de sincronización

Síntoma: Video se ve pero sin audio o audio desincronizado

Soluciones:

# Verificar duración del video
ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 video.mp4

# Ajustar audio al video
ffmpeg -i video.mp4 -i audio.mp3 \
  -c:v copy \
  -c:a aac \
  -shortest \
  output.mp4

3. Imágenes generadas no se descargan

Síntoma: ComfyUI genera imágenes pero n8n no las encuentra

Soluciones:

• Verificar que el workflow de ComfyUI guarda con filename_prefix correcto
• Usar volumen compartido entre ComfyUI y n8n (ya configurado en docker-compose.yml)
• Verificar permisos de escritura en comfyui_output/
• Esperar suficiente tiempo antes de descargar (verificar queue status en ComfyUI)

4. Video de baja calidad

Síntoma: Video pixelado o borroso

Soluciones:

# Aumentar bitrate
ffmpeg -i input.mp4 -b:v 5M -b:a 192k output.mp4

# Usar preset slower (mejor calidad)
ffmpeg -i input.mp4 -preset slow -crf 18 output.mp4

# Aumentar resolución de imágenes fuente (en Stable Diffusion)
# Usar 768x768 o 1024x1024 en lugar de 512x512

5. Proceso muy lento

Síntoma: Generar un video tarda demasiado tiempo

Soluciones:

• Reducir número de imágenes por video (4 en lugar de 8)
• Usar modelo más rápido (SD1.5 en lugar de SDXL)
• Optimizar FFmpeg (usar hardware acceleration si disponible)
• Procesar en paralelo (múltiples workflows n8n)

—

Descargar ejemplos {#descargar}

Todos los ejemplos de código, scripts, y workflows están disponibles en GitHub:

🔗 Descargar ejemplos completos

Incluye:

• ✅ docker-compose.yml – Stack completo Docker
• ✅ scripts/create-video.sh – Script básico FFmpeg
• ✅ scripts/create-video-advanced.sh – Script avanzado con transiciones
• ✅ scripts/generate-ugc-batch.py – Script Python para batch
• ✅ n8n-workflows/ugc-video-generator.json – Workflow n8n completo
• ✅ README.md – Instrucciones de uso

—

Preguntas frecuentes {#faqs}

¿Puedo usar esto sin GPU?

Sí, pero será mucho más lento. Puedes usar:

• CPU: Muy lento (10-30 minutos por imagen)
• Cloud GPU: RunPod, Vast.ai, Lambda Labs (pago por uso)
• Google Colab: Gratis pero limitado

¿Qué modelos de Stable Diffusion funcionan mejor para UGC?

Recomendados:

• Realistic Vision v5: Excelente para personas y productos realistas
• DreamShaper XL: Versátil, buena calidad general
• Juggernaut XL: Alta calidad, requiere más VRAM

¿Puedo generar videos con audio de voz?

Sí, puedes:

1. Generar imágenes con Stable Diffusion
2. Generar audio con TTS (ElevenLabs, OpenAI TTS)
3. Combinar con FFmpeg

Ejemplo:

# Añadir audio de voz
ffmpeg -i video.mp4 -i voice_audio.mp3 \
  -c:v copy \
  -c:a aac \
  -shortest \
  video_with_voice.mp4

¿Cuántos videos puedo generar por día?

Depende de tu hardware:

• GPU 4GB: ~10-20 videos/día
• GPU 8GB: ~50-100 videos/día
• GPU 16GB+: ~200+ videos/día

¿Puedo personalizar el estilo de los videos?

Sí, puedes:

• Cambiar prompts en n8n
• Ajustar parámetros de FFmpeg (velocidad, transiciones)
• Añadir efectos (zoom, texto, audio)

¿Funciona con otros modelos de IA?

Sí, puedes adaptar el pipeline para:

• Midjourney: Usar API (si tienes acceso)
• DALL-E: Usar API de OpenAI
• Stable Diffusion XL: Cambiar modelo en ComfyUI

¿Puedo subir videos automáticamente a YouTube?

Sí, puedes añadir un nodo YouTube en n8n después de crear el video:

1. Crear video con FFmpeg
2. Añadir nodo YouTube Upload en n8n
3. Configurar credenciales OAuth
4. Subir automáticamente

¿Qué formato de video es mejor para redes sociales?

Recomendaciones:

• TikTok/Instagram Reels: Vertical (9:16), 30 fps, MP4
• YouTube Shorts: Vertical (9:16), 30 fps, MP4
• YouTube normal: Horizontal (16:9), 30 fps, MP4

¿Puedo generar videos en diferentes idiomas?

Sí, puedes:

• Cambiar prompts en el idioma deseado
• Añadir subtítulos con FFmpeg
• Generar audio de voz en diferentes idiomas

¿Cómo optimizo el uso de VRAM?

Tips:

• Usar modelos más pequeños (SD1.5 en lugar de SDXL)
• Reducir resolución (512×512 en lugar de 1024×1024)
• Limitar batch size (4 en lugar de 8)
• Cerrar otros procesos que usen GPU

¿Puedo usar esto comercialmente?

Sí, pero verifica:

• Licencia del modelo: Algunos modelos tienen restricciones comerciales
• Licencia de Stable Diffusion: Generalmente permite uso comercial
• Derechos de imagen: Las imágenes generadas son tuyas, pero verifica términos de servicio

¿Qué pasa si el proceso falla a mitad?

n8n tiene retry automático configurable:

• Configura retry en nodos HTTP Request
• Usa Error Trigger para notificar fallos
• Guarda estado intermedio para recuperar

¿Puedo generar videos de productos específicos?

Sí, puedes:

• Personalizar prompts con nombre del producto
• Usar ControlNet para mantener consistencia
• Fine-tune modelo con imágenes del producto

—

Conclusión {#conclusion}

Has aprendido a crear un pipeline completo de automatización de videos UGC usando IA. Con Stable Diffusion generando imágenes, n8n orquestando el proceso, y FFmpeg creando videos, puedes generar cientos de videos automáticamente sin necesidad de grabar nada manualmente.

Próximos pasos:

1. Personaliza los prompts según tus productos o necesidades
2. Optimiza la calidad ajustando parámetros de FFmpeg
3. Escala el proceso creando múltiples workflows para diferentes tipos de videos
4. Integra con plataformas (YouTube, S3, etc.) para automatizar la publicación

¿Necesitas ayuda? Consulta los ejemplos en GitHub o revisa la documentación de n8n, ComfyUI, y FFmpeg.

Artículos relacionados:

• n8n Playwright: Automatización Web Nativa sin Browserless
• ComfyUI vs Stable Diffusion WebUI: ¿Cuál Elegir para tu Homelab?
• Automatización con n8n: 20 Workflows Listos para Usar

—

➜ ¿Listo para automatizar tus videos UGC? Descarga los ejemplos completos y empieza a generar contenido automáticamente.