O que Gerador de Vídeos com IA — Pipeline de Conteúdo Curto faz?
Visão Geral
Automatize a criação de vídeos curtos (TikTok, YouTube Shorts, Instagram Reels) usando IA em cada etapa: pesquisa de tópicos, escrita de roteiro, narração por texto-para-fala, correspondência de imagens de arquivo, geração de legendas e montagem final. Inspirado pelo MoneyPrinterTurbo (mais de 53 mil estrelas).
Instruções
Passo 1: Configure o Ambiente
pip install anthropic openai requests moviepy pydub whisperx srt
sudo apt install ffmpeg # Linux — ou: brew install ffmpeg (macOS)
Chaves de API necessárias: Anthropic ou OpenAI (roteiros), ElevenLabs ou OpenAI TTS (voz), Pexels (imagens de arquivo gratuitas).
Passo 2: Escrita de Roteiro com IA
import anthropic
def generate_script(topic, duration_seconds=45):
"""Gera um roteiro de vídeo otimizado para conteúdo curto."""
client = anthropic.Anthropic()
prompt = f"""Escreva um roteiro de vídeo de {duration_seconds} segundos sobre: {topic}
Formato:
GANCHO (primeiros 3 segundos): Uma declaração chocante ou pergunta que faz parar a rolagem
CORPO (conteúdo principal): 3-5 fatos ou pontos impactantes, cada um com 1-2 frases
CTA (últimos 5 segundos): Chamada para ação — siga, curta, comente
Regras:
- Conversacional, sem frases complexas
- Cada frase em sua própria linha
- ~{duration_seconds * 2.5:.0f} palavras ({duration_seconds}s a 150 ppm)
- Use palavras de poder: segredo, chocante, ninguém te conta, na verdade
- Sem emojis ou hashtags — este é um roteiro para narração
"""
response = client.messages.create(
model="claude-sonnet-4-20250514", max_tokens=500,
messages=[{"role": "user", "content": prompt}]
)
return response.content[0].text
Passo 3: Narração por Texto-para-Fala
import requests, os
def generate_voice_elevenlabs(text, output_path='narration.mp3'):
"""Gera narração usando ElevenLabs."""
url = "https://api.elevenlabs.io/v1/text-to-speech/21m00Tcm4TlvDq8ikWAM"
headers = {"xi-api-key": os.environ["ELEVENLABS_API_KEY"], "Content-Type": "application/json"}
data = {"text": text, "model_id": "eleven_turbo_v2_5",
"voice_settings": {"stability": 0.5, "similarity_boost": 0.75}}
response = requests.post(url, json=data, headers=headers)
with open(output_path, 'wb') as f:
f.write(response.content)
return output_path
def generate_voice_openai(text, output_path='narration.mp3'):
"""Gera narração usando OpenAI TTS (alternativa mais barata)."""
from openai import OpenAI
client = OpenAI()
response = client.audio.speech.create(model="tts-1-hd", voice="onyx", input=text)
response.stream_to_file(output_path)
return output_path
Passo 4: Seleção de Imagens de Arquivo
def search_pexels_videos(query, count=5):
"""Pesquisa no Pexels clipes de vídeo em orientação retrato."""
url = "https://api.pexels.com/videos/search"
headers = {"Authorization": os.environ["PEXELS_API_KEY"]}
params = {"query": query, "per_page": count, "orientation": "portrait", "size": "medium"}
response = requests.get(url, headers=headers, params=params)
videos = response.json().get('videos', [])
results = []
for v in videos:
files = sorted(v['video_files'], key=lambda x: x.get('height', 0), reverse=True)
hd = next((f for f in files if f.get('height', 0) >= 720), files[0])
results.append({'id': v['id'], 'url': hd['link'], 'duration': v['duration']})
return results
Passo 5: Geração de Legendas
def generate_subtitles(audio_path, output_srt='subtitles.srt'):
"""Gera legendas no nível da palavra usando WhisperX."""
import whisperx, srt
from datetime import timedelta
model = whisperx.load_model("base", device="cpu")
audio = whisperx.load_audio(audio_path)
result = model.transcribe(audio)
align_model, metadata = whisperx.load_align_model(language_code="en")
aligned = whisperx.align(result["segments"], align_model, metadata, audio)
subs = []
words = [w for seg in aligned["segments"] for w in seg.get("words", [])]
for i in range(0, len(words), 4):
group = words[i:i + 4]
if not group: continue
start = timedelta(seconds=group[0].get('start', 0))
end = timedelta(seconds=group[-1].get('end', 0))
text = ' '.join(w['word'] for w in group)
subs.append(srt.Subtitle(index=len(subs)+1, start=start, end=end, content=text))
with open(output_srt, 'w') as f:
f.write(srt.compose(subs))
return output_srt
Passo 6: Montagem do Vídeo com FFmpeg
import subprocess
def assemble_video(clips, narration, subtitles, output='final.mp4'):
"""Monta o vídeo final: concatena clipes, adiciona narração e legendas."""
concat_list = 'concat_list.txt'
with open(concat_list, 'w') as f:
for clip in clips:
f.write(f"file '{clip}'\n")
subprocess.run([
'ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', concat_list,
'-vf', 'scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920',
'-c:v', 'libx264', '-preset', 'fast', '-an', 'temp_video.mp4'
], check=True)
subtitle_filter = (f"subtitles={subtitles}:force_style='"
"FontName=Arial,FontSize=18,PrimaryColour=&H00FFFFFF,"
"OutlineColour=&H00000000,Outline=2,Bold=1,Alignment=2'")
subprocess.run([
'ffmpeg', '-y', '-i', 'temp_video.mp4', '-i', narration,
'-vf', subtitle_filter, '-c:v', 'libx264', '-c:a', 'aac',
'-shortest', output
], check=True)
return output
Passo 7: Pipeline Completo
def generate_video(topic, output_dir='./output'):
"""Pipeline completo: tópico -> vídeo finalizado."""
import os
os.makedirs(output_dir, exist_ok=True)
script = generate_script(topic)
narration = generate_voice_elevenlabs(script, f'{output_dir}/narration.mp3')
keywords = topic.split()[:3]
videos = search_pexels_videos(' '.join(keywords), count=3)
clips = []
for i, v in enumerate(videos):
path = f'{output_dir}/clip_{i}.mp4'
requests.get(v['url'], stream=True) # baixar clipe
clips.append(path)
subs = generate_subtitles(narration, f'{output_dir}/subs.srt')
return assemble_video(clips, narration, subs, f'{output_dir}/final.mp4')
Exemplos
Exemplo 1: Gere um Lote de Vídeos de Fatos Tecnológicos
Um criador produz 5 vídeos curtos com tema de tecnologia para o TikTok em uma única execução:
topics = [
"Ferramentas de IA que ninguém fala",
"Aplicativos que parecem ilegais de usar de graça",
"Sites que vão explodir sua mente",
"Ferramentas de IA gratuitas que todo estudante precisa",
"Gadgets de tecnologia abaixo de $50 que mudaram minha vida"
]
for topic in topics:
output = generate_video(topic, output_dir=f'./output/{topic[:30]}')
print(f"Vídeo pronto: {output}")
# Cada vídeo: ~45 segundos, retrato 1080x1920, com legendas e narração
# Custo total: ~$0,25 (5 x $0,05 por vídeo) usando ElevenLabs + Claude Sonnet
Exemplo 2: Shorts Financeiros Diários para o YouTube
Um canal de finanças automatiza o upload diário de Shorts com tópicos de dinheiro em alta:
import schedule
def daily_finance_video():
topic = "3 ideias de renda passiva que realmente funcionam em 2025"
script = generate_script(topic, duration_seconds=55)
# Saída do roteiro:
# GANCHO: "Você está perdendo dinheiro todos os dias por não saber disso."
# CORPO: 1. Lojas print-on-demand ($500-2k/mês)
# 2. Licenciamento de conteúdo gerado por IA ($300-1k/mês)
# 3. Acumulação de ETFs de dividendos ($200-800/mês passivo)
# CTA: "Siga para mais dicas de dinheiro que ninguém te conta."
narration = generate_voice_openai(script, './daily/narration.mp3')
videos = search_pexels_videos("money finance investing", count=4)
# Baixa 4 clipes retrato de dinheiro/gráficos/estilo de vida
# Monta com legendas brancas em negrito, gera Short de 55 segundos
final = assemble_video(['./daily/clip_0.mp4', './daily/clip_1.mp4'],
narration, './daily/subs.srt', './daily/final.mp4')
schedule.every().day.at("08:00").do(daily_finance_video)
Diretrizes
- Respeite os direitos autorais — use apenas imagens de arquivo isentas de royalties (Pexels, Pixabay) ou seu próprio conteúdo
- Divulgue o uso de IA — YouTube e TikTok exigem divulgação de conteúdo gerado por IA
- Revise antes de publicar — sempre assista ao vídeo final; roteiros de IA podem conter imprecisões
- Otimize os primeiros 3 segundos — o gancho determina se os espectadores ficam ou rolam para frente
- Teste várias vozes — ElevenLabs oferece dezenas de vozes; encontre uma que se encaixe no seu nicho
- Monitore o desempenho — acompanhe visualizações, retenção e taxa de cliques para iterar no estilo do conteúdo
Referências
- MoneyPrinterTurbo — inspiração original (53 mil estrelas)
- Pexels API — vídeos de arquivo gratuitos
- ElevenLabs — texto-para-fala realista
- WhisperX — alinhamento de legendas no nível da palavra