Crear un video vertical con Python y FFmpeg: Reels y Shorts sin editor de video
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
- Escribes un archivo
escenas.txt, con una frase por línea. - El programa dibuja cada frase en una imagen de 1080 × 1920 píxeles, el tamaño vertical de los Reels y los Shorts.
- 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):
- Abre PowerShell como administrador (clic derecho → “Ejecutar como administrador”).
- Escribe
wsl --instally reinicia el equipo. Instala Ubuntu. - 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_escenaslee el archivo. Si una línea termina en| 4, esa escena dura 4 segundos; si no, 3.dibujarpinta 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.montarprepara la orden de FFmpeg: cada imagen entra como una entrada que se repite el tiempo de su escena, el filtroconcatlas 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
- Si te falta la voz, la voz con IA gratis para videos genera un archivo que puedes pasar con
--audio. - Para que el video salga solo en Instagram, mira cómo programar Reels con la API oficial, y para YouTube, cómo subir Shorts desde un programa.
- Si publicas el video en Instagram y pides comentar una palabra, puedes responder por mensaje directo a quien comenta, también con la API oficial.
- Para que algo se ejecute solo cada día en la nube, mira las rutinas de Claude Code.
- Si lo que quieres automatizar no es un video sino un formulario o una hoja de cálculo, empieza por tu primer flujo en n8n.