Saltar al contenido
Automatización y agentes

Crear un video vertical con Python y FFmpeg: Reels y Shorts sin editor de video

Actualizado el 9 min de lectura

Lo esencial

  • Escribes una frase por línea en un archivo de texto y un programa de unas cien líneas lo convierte en un video vertical de 1080 × 1920, con barra de avance y, si quieres, con voz o música.
  • Python dibuja cada escena con la biblioteca Pillow y FFmpeg las une en un MP4 con H.264 y sonido AAC, que es lo que piden las especificaciones de Reels de Meta.
  • Todo es gratis. En Windows, la vía sin instalar ejecutables de terceros es el subsistema de Linux de Microsoft (WSL).
  • Nivel: intermedio. Sin programar nada nuevo: copias el programa, cambias el texto y ejecutas una orden. Una hora la primera vez.

Este proyecto publica cada día Reels hechos sin abrir un editor de video: un programa dibuja cada fotograma, añade la voz y entrega el archivo listo. Aquí tienes una versión reducida de esa idea, que cabe en un solo archivo y que puedes adaptar a lo tuyo: frases de un curso, consejos, el resumen de un artículo o un anuncio de tu negocio.

El resultado es sencillo a propósito: texto grande sobre fondo oscuro, una escena por frase y una barra que avanza abajo. Lo importante es el método. Cuando funciona, cambiar el texto y volver a generar el video lleva segundos.

Qué necesitas

  • Un ordenador con Windows 10 (versión 2004 o posterior), Windows 11, Mac o Linux.
  • Python 3 y la biblioteca Pillow, que dibuja las imágenes. Gratis.
  • FFmpeg, el programa que une las imágenes y el sonido en un video. Gratis. Ojo: su web oficial dice que solo publica el código fuente y enlaza a compilaciones hechas por terceros (consultada el 14 de octubre de 2026). En Linux viene en los paquetes oficiales de cada distribución.
  • Nivel: intermedio. Hay que abrir una terminal y escribir órdenes, pero no programar.
  • Tiempo: una hora la primera vez; después, segundos por video.
  • Dinero: nada. No usa ninguna cuenta ni ninguna clave.

Cómo funciona

  1. Escribes un archivo escenas.txt, con una frase por línea.
  2. El programa dibuja cada frase en una imagen de 1080 × 1920 píxeles, el tamaño vertical de los Reels y los Shorts.
  3. FFmpeg muestra cada imagen el tiempo que le toca, les añade el sonido si lo hay y guarda un MP4.

Las especificaciones de Reels de la API de Instagram piden, entre otras cosas, video H.264 o HEVC con submuestreo 4:2:0, de 23 a 60 fotogramas por segundo, sonido AAC de 48 kHz como máximo, de 3 segundos a 15 minutos y la proporción 9:16 recomendada (consultadas el 14 de octubre de 2026). El programa entrega H.264 4:2:0 a 30 fotogramas por segundo y AAC a 48 kHz. YouTube, por su parte, trata como Short un video vertical o cuadrado de hasta tres minutos.

Paso 1 · Instalar Python, Pillow y FFmpeg

En Windows, la vía que no obliga a ejecutar programas de terceros sin firma es el subsistema de Windows para Linux (WSL), de Microsoft. Según su guía de instalación (consultada el 14 de octubre de 2026):

  1. Abre PowerShell como administrador (clic derecho → “Ejecutar como administrador”).
  2. Escribe wsl --install y reinicia el equipo. Instala Ubuntu.
  3. Abre “Ubuntu” desde el menú Inicio y crea tu usuario de Linux.

Si Windows bloquea algún programa por Smart App Control, no desactives esa protección: es justo lo que esta vía evita.

En Ubuntu (también dentro de WSL), instala todo con una orden:

sudo apt update
sudo apt install -y ffmpeg python3-pil fonts-dejavu-core

fonts-dejavu-core trae la tipografía DejaVu, que tiene tildes y eñes. Comprueba que FFmpeg responde con ffmpeg -version.

En Mac, ffmpeg.org enlaza una compilación de terceros; nadie de Ctrl+IA la comprobó, y por eso esta guía no da los pasos.

Paso 2 · El programa

Guarda esto como video_vertical.py:

"""Hace un video vertical (1080 x 1920) a partir de un archivo de texto.

Cada línea del archivo es una escena. Si la línea termina en "| 4", la escena
dura 4 segundos; si no, 3. Uso:

    python video_vertical.py escenas.txt
    python video_vertical.py escenas.txt --audio voz.mp3 --salida reel.mp4
    python video_vertical.py escenas.txt --solo-imagenes
"""
import argparse
import shutil
import subprocess
import sys
import textwrap
from pathlib import Path

from PIL import Image, ImageDraw, ImageFont

ANCHO, ALTO = 1080, 1920
FONDO = "#0F1012"
TEXTO = "#F4F4EF"
ACENTO = "#C8F53C"

# Tipografías que suelen venir con Windows, Mac y Linux. La que trae Pillow
# por defecto no tiene tildes ni eñes, así que no sirve para un texto en español.
FUENTES = [
    "C:/Windows/Fonts/arialbd.ttf",
    "/mnt/c/Windows/Fonts/arialbd.ttf",
    "/System/Library/Fonts/Supplemental/Arial Bold.ttf",
    "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
]


def leer_escenas(ruta):
    escenas = []
    for linea in Path(ruta).read_text(encoding="utf-8").splitlines():
        linea = linea.strip()
        if not linea:
            continue
        texto, _, segundos = linea.partition("|")
        escenas.append((texto.strip(), float(segundos) if segundos.strip() else 3.0))
    if not escenas:
        sys.exit("El archivo no tiene ninguna escena.")
    return escenas


def dibujar(texto, numero, total, fuente, ruta):
    imagen = Image.new("RGB", (ANCHO, ALTO), FONDO)
    dibujo = ImageDraw.Draw(imagen)
    lineas = textwrap.wrap(texto, width=16)
    alto_linea = fuente.size + 24
    y = (ALTO - alto_linea * len(lineas)) // 2
    for linea in lineas:
        dibujo.text((ANCHO // 2, y), linea, font=fuente, fill=TEXTO, anchor="ma")
        y += alto_linea
    # Barra de avance abajo: crece con cada escena.
    dibujo.rectangle((0, ALTO - 24, ANCHO * numero // total, ALTO), fill=ACENTO)
    imagen.save(ruta)


def montar(imagenes, escenas, audio, salida):
    orden = ["ffmpeg", "-y", "-loglevel", "error"]
    for imagen, (_, segundos) in zip(imagenes, escenas):
        orden += ["-loop", "1", "-framerate", "30", "-t", str(segundos), "-i", str(imagen)]
    n = len(imagenes)
    if audio:
        orden += ["-i", str(audio)]
    filtro = "".join(f"[{i}:v]" for i in range(n)) + f"concat=n={n}:v=1:a=0,format=yuv420p[v]"
    orden += ["-filter_complex", filtro, "-map", "[v]"]
    if audio:
        # El sonido, en AAC a 48 kHz; el video se corta donde acabe lo más corto.
        orden += ["-map", f"{n}:a", "-c:a", "aac", "-b:a", "128k", "-ar", "48000", "-shortest"]
    orden += ["-c:v", "libx264", "-r", "30", "-movflags", "+faststart", str(salida)]
    subprocess.run(orden, check=True)


def main():
    parser = argparse.ArgumentParser(description="Video vertical a partir de un texto.")
    parser.add_argument("escenas", help="archivo de texto, una escena por línea")
    parser.add_argument("--audio", help="voz o música (mp3, wav o m4a)")
    parser.add_argument("--salida", default="video.mp4")
    parser.add_argument("--fuente", help="archivo .ttf de la tipografía")
    parser.add_argument("--solo-imagenes", action="store_true", help="dibuja las escenas y no monta el video")
    args = parser.parse_args()

    escenas = leer_escenas(args.escenas)
    ruta_fuente = args.fuente or next((f for f in FUENTES if Path(f).exists()), None)
    if not ruta_fuente or not Path(ruta_fuente).exists():
        sys.exit("No encuentro la tipografía. Indica un archivo .ttf con --fuente.")
    fuente = ImageFont.truetype(ruta_fuente, 96)
    carpeta = Path("escenas")
    carpeta.mkdir(exist_ok=True)
    imagenes = []
    for i, (texto, _) in enumerate(escenas, start=1):
        ruta = carpeta / f"{i:02d}.png"
        dibujar(texto, i, len(escenas), fuente, ruta)
        imagenes.append(ruta)
    print(f"{len(imagenes)} escenas dibujadas en {carpeta}/")
    if args.solo_imagenes:
        return
    if not shutil.which("ffmpeg"):
        sys.exit("No encuentro FFmpeg. Instálalo y vuelve a intentarlo.")
    montar(imagenes, escenas, args.audio, args.salida)
    print(f"Video listo: {args.salida}")


if __name__ == "__main__":
    main()

Lo que hace cada parte:

  • leer_escenas lee el archivo. Si una línea termina en | 4, esa escena dura 4 segundos; si no, 3.
  • dibujar pinta el texto centrado, partido en líneas de 16 letras, y la barra de avance abajo. Los colores son los de la marca de este proyecto: cámbialos arriba del todo.
  • montar prepara la orden de FFmpeg: cada imagen entra como una entrada que se repite el tiempo de su escena, el filtro concat las pone en fila y el resultado sale en H.264 con +faststart, que pone el índice del archivo al principio, como pide Meta.

Paso 3 · Probarlo

Crea escenas.txt en la misma carpeta:

Haz en minutos lo que te toma horas | 2.5
Paso 1: escribe tus frases | 3
Paso 2: Python dibuja cada escena | 3
Paso 3: FFmpeg las une en un video | 3.5

Primero, solo las imágenes, para ver cómo queda el texto sin esperar al video:

python3 video_vertical.py escenas.txt --solo-imagenes

Las encontrarás en la carpeta escenas/. Si se leen bien, genera el video:

python3 video_vertical.py escenas.txt --salida reel.mp4

Y con sonido:

python3 video_vertical.py escenas.txt --audio voz.mp3 --salida reel.mp4

Con --audio, el video dura lo que dure lo más corto: si la voz es más corta que las escenas, el final se corta. Ajusta los segundos de cada línea a lo que dura cada frase de la voz.

Para comprobar el resultado, ffprobe -v error -show_entries stream=codec_name,width,height reel.mp4 tiene que decir h264, 1080 y 1920, y aac si lleva sonido.

Qué se comprobó

  • El programa se ejecutó el 14 de octubre de 2026 en Linux, con Python 3.11, Pillow 12.3 y FFmpeg 6.1.1: las cuatro escenas de ejemplo dieron un video de 12 segundos, H.264 de 1080 × 1920 a 30 fotogramas por segundo con 4:2:0; con un sonido de prueba de 10 segundos, el video salió de 10 segundos con AAC a 48 kHz y el índice al principio del archivo.
  • Se volvió a ejecutar el 5 de noviembre de 2026, en Linux con Python 3.11, Pillow 13.0 y FFmpeg: el mismo resultado, 12 segundos sin sonido y 10 con un sonido de prueba de 10 segundos, H.264 4:2:0 de 1080 × 1920 a 30 fotogramas por segundo y AAC a 48 kHz.
  • Un fallo que salió al probarlo: la tipografía que Pillow trae por defecto no tiene tildes ni eñes, y “Así” salía con un cuadrado en lugar de la í. Por eso el programa busca una tipografía del sistema y, si no encuentra ninguna, se para y lo dice.
  • No se probó en Windows ni en Mac. Las rutas de Arial de Windows y Mac del programa no se ejecutaron; los pasos de WSL salen de la guía de Microsoft.
  • Este video concreto no se subió a Instagram ni a YouTube. Sí se suben a diario los del motor completo de este proyecto, que usa el mismo método (Pillow y FFmpeg) con más escenas y animación.

Errores comunes

  • Cuadrados en lugar de letras. La tipografía no tiene esos caracteres. Indica otra con --fuente ruta/al/archivo.ttf.
  • “No encuentro FFmpeg”. No está instalado o la terminal no lo ve. Prueba ffmpeg -version.
  • Un texto que no cabe. Más de cinco o seis líneas por escena se sale de la pantalla. Parte la frase en dos escenas: un Reel se lee mejor con frases cortas.
  • Mezclar rutas de Windows y de WSL. Dentro de Ubuntu, tu disco C está en /mnt/c/. Trabaja en una carpeta de Linux (~/videos) y copia ahí el audio.

Para seguir

Recibe los prompts nuevos por correo

Al confirmar te llevas de regalo un PDF con los 62 prompts del sitio, listos para copiar. Sin spam, y te das de baja cuando quieras.

Te pediremos confirmar por correo. Al suscribirte aceptas la política de privacidad. Los envíos se gestionan con Kit.

Sigue con