Cómo crear vídeos animados sin mostrar tu cara con Claude y Python, paso a paso

Aprende a generar vídeos animados sin rostro utilizando Python y la IA de Claude para automatizar la creación de contenido masivo sin costes.

Crea un vídeo vertical desde cero, comprueba cómo se ve en el móvil y convierte el diseño en una plantilla para Reels, TikTok o Shorts. Incluye el guion, los prompts para Claude y el código necesario para exportar tus propios MP4.

¿Cómo explicarías qué es un eco en once segundos y sin hablar? Un punto luminoso avanza hacia una pared, la toca y regresa más pequeño. Cuando vuelve al origen, aparece una frase: «El sonido vuelve». El espectador ha visto la idea antes de leer la explicación.

Vamos a producir ese clip. Claude te ayudará a diseñar la escena y a modificar el programa. Python dibujará los fotogramas en tu ordenador y FFmpeg los reunirá en un vídeo. Al terminar tendrás dos archivos que podrás reutilizar: uno controla la animación y el otro guarda los textos, los colores y la duración de cada pieza.

El punto de partida es un tutorial de Postiz sobre animaciones breves sin rostro. La cifra de 265 millones de reproducciones que aparece en su titular corresponde a 42 reels de neuronvisuals, la cuenta que el autor estudió como referencia. La parte que puedes reproducir en casa es el método de producción. La audiencia tendrás que medirla en tu propio canal.

1. Elige una idea que se pueda dibujar

Para un primer vídeo, busca algo que cambie delante del espectador. Una onda rebota. Una cola avanza. Dos barras que parecían iguales se separan al cambiar la escala. Si el guion empieza con «este vídeo trata sobre la importancia de…», todavía te falta decidir qué verá la persona que está al otro lado de la pantalla.

Así queda el guion de nuestro ejemplo. La animación es una representación esquemática: el punto permite seguir el recorrido del sonido y su menor tamaño indica que el eco regresa con menos intensidad.

TiempoQué se veQué debe entenderse
0 a 4,5 s«¿Qué es un eco?». Un pulso avanza hacia una pared visible.El sonido sale de un punto y recorre una distancia.
4,5 a 9 sEl pulso toca la pared, cambia de dirección y vuelve más pequeño.El sonido se refleja y regresa con menos intensidad.
9 a 11 sEl pulso se detiene en el origen. Aparece «El sonido vuelve».El espectador tiene tiempo de asociar el movimiento con la explicación.

Prompt para preparar tu propio guion en Claude

Quiero explicar [concepto] en un vídeo vertical de 11 segundos que se entienda sin audio. Mi público es [audiencia]. Propón tres acciones que se puedan dibujar con círculos, líneas o barras. Para cada una, dime qué cambia en pantalla y qué podría interpretar mal el espectador. Elige la más clara y escribe su guion con tiempos, movimiento y texto exacto. Reserva los últimos dos segundos para leer el cierre.

2. Prepara el ordenador

Necesitas Python 3.10 o posterior, la biblioteca de dibujo Pillow y FFmpeg con el codificador H.264. Claude interviene al escribir o adaptar el código. Después puedes volver a generar tus vídeos en local con los archivos guardados.

Crea una carpeta llamada animaciones y abre una terminal dentro. En Windows puedes abrir la carpeta en el Explorador, escribir powershell en su barra de direcciones y pulsar Intro. Comprueba qué herramientas tienes disponibles:

# Windows
py --version
ffmpeg -version

# macOS o Linux
python3 --version
ffmpeg -version

Si aparece un número de versión para cada programa, continúa. Si te falta alguno, instala Python desde su web oficial y elige en la página de descargas de FFmpeg la opción correspondiente a tu sistema. En Windows, el directorio que contiene ffmpeg.exe debe estar en el PATH para poder invocarlo desde cualquier carpeta. Cierra y vuelve a abrir la terminal después de instalarlo.

Ahora crea un entorno para este proyecto e instala Pillow. Los comandos utilizan directamente el Python del entorno, así que puedes ejecutarlos sin activar nada.

# Windows
py -m venv .venv
.\.venv\Scripts\python.exe -m pip install "Pillow>=10.1"

# macOS o Linux
python3 -m venv .venv
.venv/bin/python -m pip install "Pillow>=10.1"

3. Guarda los primeros dos guiones en escenas.json

Abre un editor de texto, copia el bloque siguiente y guárdalo como escenas.json en la carpeta del proyecto. Usa texto plano y codificación UTF-8 para conservar las tildes. Si usas el Bloc de notas, comprueba que el nombre no haya quedado como escenas.json.txt.

[
  {
    "id": "eco",
    "segundos": 11,
    "color": "#E0AAFF",
    "inicio": "¿Qué es un eco?",
    "cierre": "El sonido vuelve"
  },
  {
    "id": "rebote",
    "segundos": 8,
    "color": "#FFCF70",
    "inicio": "Sigue el pulso",
    "cierre": "Vuelve más débil"
  }
]

id se convertirá en el nombre del MP4. segundos controla la duración total. El programa reserva los dos últimos segundos para el cierre y reparte el tiempo restante entre la ida y la vuelta. Por eso el mismo movimiento se percibe más rápido en la segunda versión. Generar ambas te permitirá decidir el ritmo viendo el resultado en el móvil.

4. Crea el programa que dibuja y exporta el vídeo

Guarda este segundo bloque como animar.py, junto a escenas.json. Puedes utilizarlo tal cual. Cada fotograma pasa directamente de Pillow a FFmpeg, de modo que el proyecto evita llenar la carpeta con cientos de imágenes intermedias. El MP4 definitivo aparece cuando termina la exportación.

import argparse
import json
import subprocess
from pathlib import Path
from tempfile import TemporaryDirectory

from PIL import Image, ImageDraw, ImageFont

parser = argparse.ArgumentParser()
parser.add_argument("archivo", type=Path)
parser.add_argument("--previa", action="store_true")
args = parser.parse_args()

ancho = 540 if args.previa else 1080
alto = ancho * 16 // 9
fps = 15 if args.previa else 30
fuente = ImageFont.load_default(size=round(ancho * 0.062))
salida = Path("videos")
salida.mkdir(exist_ok=True)

for escena in json.loads(args.archivo.read_text(encoding="utf-8")):
    nombre = escena["id"]
    if not nombre.isidentifier():
        raise ValueError("Usa un id sin espacios ni signos.")

    duracion = float(escena["segundos"])
    if duracion < 4:
        raise ValueError("Usa al menos cuatro segundos.")

    sufijo = "_previa" if args.previa else ""
    destino = salida / f"{nombre}{sufijo}.mp4"
    if destino.exists():
        raise SystemExit(f"Ya existe {destino}. Cambia el id para guardar otra versión.")

    with TemporaryDirectory(dir=salida) as carpeta:
        temporal = Path(carpeta) / "clip.mp4"
        comando = [
            "ffmpeg", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24",
            "-s", f"{ancho}x{alto}", "-r", str(fps), "-i", "pipe:0",
            "-c:v", "libx264", "-pix_fmt", "yuv420p",
            "-movflags", "+faststart", str(temporal)
        ]
        with subprocess.Popen(comando, stdin=subprocess.PIPE) as proceso:
            try:
                for i in range(round(duracion * fps)):
                    t = i / fps
                    fase = min(2.0, 2 * t / (duracion - 2))
                    avance = 1 - abs(1 - fase)
                    x = ancho * (0.15 + 0.70 * avance)
                    y = alto * 0.5
                    radio = ancho * (0.065 if fase < 1 else 0.04)

                    imagen = Image.new("RGB", (ancho, alto), "#231839")
                    dibujo = ImageDraw.Draw(imagen)
                    pared = round(ancho * 0.85)
                    dibujo.line(
                        (pared, y - alto * 0.12, pared, y + alto * 0.12),
                        fill="white", width=max(2, ancho // 100)
                    )
                    dibujo.ellipse(
                        (x - 2 * radio, y - radio, x, y + radio),
                        fill=escena["color"]
                    )
                    texto = escena["inicio"] if fase < 2 else escena["cierre"]
                    dibujo.text(
                        (ancho / 2, alto * 0.31), texto, anchor="mm",
                        font=fuente, fill="white"
                    )
                    proceso.stdin.write(imagen.tobytes())
            finally:
                proceso.stdin.close()

            if proceso.wait():
                raise RuntimeError("FFmpeg no pudo terminar el vídeo.")

        temporal.replace(destino)
    print(destino)

5. Exporta una vista previa y mírala en el móvil

Ejecuta el comando de tu sistema. La opción --previa genera una copia más ligera de cada escena, a 540 × 960 y 15 fotogramas por segundo.

# Windows
.\.venv\Scripts\python.exe animar.py escenas.json --previa

# macOS o Linux
.venv/bin/python animar.py escenas.json --previa

Dentro de videos aparecerán eco_previa.mp4 y rebote_previa.mp4. Ábrelos a pantalla completa en el teléfono y reproduce cada uno una sola vez. Si tienes que repetir el vídeo para leer el cierre, acorta la frase o amplía el tiempo reservado para ella. Si entiendes el rebote en ocho segundos y en la versión larga acabas esperando a que ocurra, ya tienes una razón editorial para elegir el clip corto.

Una segunda persona puede detectar algo que tú ya das por hecho. Enséñale la animación sin explicarle el tema y pregúntale qué representa el punto pequeño en el camino de vuelta. Si responde «otra pelota», quizá convenga cambiar el dibujo, aunque la exportación sea técnicamente perfecta.

6. Pide a Claude una mejora que puedas comprobar

Adjunta o pega el contenido de animar.py y escenas.json. Pide un cambio concreto e indica qué resultado esperas ver. Así podrás evaluar la nueva versión antes de tocar el resto del diseño.

Si el punto parece una pelota:

Modifica la animación para representar el pulso con tres arcos que viajen juntos hacia la pared. Al reflejarse, los arcos deben orientarse hacia el origen y perder intensidad. Conserva la duración, el texto final y los comandos de exportación. Dame el archivo animar.py completo y dime qué debería observar justo antes y después del rebote.

Si los titulares largos se salen de la pantalla:

Añade ajuste de texto al programa con Pillow. Mide el ancho real de las palabras usando la fuente elegida. Permite hasta dos líneas centradas dentro del 80 % del ancho del vídeo. Si una frase sigue sin caber, indica qué escena tengo que corregir. Comprueba el diseño con «¿Por qué oímos nuestra voz dos veces?».

Si quieres una serie para tu medio:

Estoy preparando una serie de vídeos breves sobre sonido para un público general. La plantilla actual solo sabe animar un pulso que va hasta una pared y regresa. Propón cinco guiones. Para cada uno, indica si cabe en el movimiento existente o qué dibujo nuevo necesita. Escribe el JSON únicamente para los que la plantilla ya puede representar con rigor.

Esta última instrucción evita un fallo frecuente al trabajar por lotes. Cambiar el título a «Qué es la latencia» seguirá produciendo un pulso que rebota en una pared. Para explicar la latencia tendría más sentido mostrar una petición, la espera y la llegada de la respuesta. Ese episodio necesita su propio movimiento.

7. Genera los MP4 finales y prepara el lote

Cuando el ritmo y los textos funcionen, ejecuta el programa sin --previa. Obtendrás videos/eco.mp4 y videos/rebote.mp4 en vertical, a 1080 × 1920 y 30 fotogramas por segundo. El ejemplo se exporta en silencio.

# Windows
.\.venv\Scripts\python.exe animar.py escenas.json

# macOS o Linux
.venv/bin/python animar.py escenas.json

Para una segunda tanda, copia escenas.json como lote_02.json, conserva solo las entradas nuevas y asigna un id distinto a cada clip. Por ejemplo, eco_arcos_v2 identifica mejor una revisión que final_final. Pasa el nuevo nombre de archivo al mismo comando. El programa procesa las entradas en orden y se detiene si su destino ya existe, para conservar las versiones anteriores.

Para programar las publicaciones, usa el id como referencia compartida entre el vídeo, el pie de publicación y tu calendario. En el caso del eco, el texto que acompaña al reel puede aportar lo que el dibujo simplifica: «El sonido se refleja al encontrar una superficie. Si el regreso tarda lo suficiente, lo oímos separado del sonido original». Así el pie de publicación añade información a la pieza.

8. Qué hacer si algo falla

Qué vesCómo resolverlo
No module named 'PIL'Instala Pillow con el mismo ejecutable de Python que usas para lanzar animar.py. Copia el comando del paso 2 correspondiente a tu sistema.
La terminal indica que no encuentra ffmpeg.Ejecuta ffmpeg -version en esa misma terminal. Si falla, revisa la instalación y el PATH. Instalar un paquete Python con nombre parecido no instala necesariamente el ejecutable.
FFmpeg muestra Unknown encoder 'libx264'.La instalación disponible carece del codificador que usa la plantilla. Elige una distribución de FFmpeg que incluya libx264 y repite la vista previa.
Aparece JSONDecodeError.Revisa la línea que señala el error. Los textos necesitan comillas dobles rectas y el último elemento de una lista debe quedar sin coma final.
El programa avisa de que el MP4 ya existe.Si estás probando un cambio, usa un id nuevo, como eco_v2. Para reanudar un lote interrumpido, prepara un JSON con las escenas pendientes.
El texto se corta en los laterales.La plantilla básica usa una sola línea. Acorta el rótulo o aplica el prompt de ajuste de texto del paso 6 y vuelve a generar la vista previa.

9. Decide si merece la pena producir más episodios

Antes de preparar treinta vídeos, publica unas pocas piezas y anota qué querías comprobar en cada una. Si ensayas dos ritmos, conserva el mismo dibujo y cambia la duración. Si pruebas otra manera de explicar la reflexión, mantén un ritmo parecido. Las publicaciones llegarán a audiencias distintas, pero cambiar una sola variable hará más fácil interpretar las diferencias.

Para una pieza de once segundos como esta, mira la curva de retención, si tu plataforma la ofrece. Una caída antes del segundo 4,5 significa que parte del público se marchó antes de ver el rebote. Eso te da una siguiente prueba concreta: acercar la pared, adelantar el giro o mostrar el fenómeno ya en el primer segundo. Si la gente llega al final y en los comentarios pregunta por qué el punto se hace pequeño, quizá el ajuste que necesita tu próximo vídeo sea una explicación visual más clara.

Renderizar en local evita pagar a un servicio por cada exportación. El equipo, la electricidad, el acceso a Claude y el trabajo de edición siguen formando parte del coste. Para saber qué te ahorra la plantilla, cronometra cuánto tardas en pasar de un guion aprobado a un MP4 listo para publicar. Esa es la cifra que te permitirá planificar tu propia serie.

Fuentes y descargas

Sombra Radio · Apoyo de lectores

Ayuda a mantener viva Sombra Radio

Tu aportación voluntaria nos ayuda a seguir publicando sobre IA. Puedes apoyarnos desde 1 € al mes.

Subrosa
SubRosa

Estructurado y publicado por SubRosa, la arquitecta invisible de SombraRadio.

Nadie la ve, pero todo pasa por ella. SubRosa organiza, etiqueta y optimiza sin levantar la voz. La estructura editorial le pertenece.

Artículos: 630

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *