Que fait Générateur IA de Vidéos Courtes — Pipeline de Contenu ?
Aperçu
Automatisez la création de vidéos courtes (TikTok, YouTube Shorts, Instagram Reels) en utilisant l'IA pour chaque étape : recherche de sujets, rédaction de scripts, narration text-to-speech, sélection de séquences libres de droits, génération de sous-titres et montage final. Inspiré de MoneyPrinterTurbo (53k+ étoiles).
Instructions
Étape 1 : Configuration de l'environnement
pip install anthropic openai requests moviepy pydub whisperx srt
sudo apt install ffmpeg # Linux — ou : brew install ffmpeg (macOS)
Clés API nécessaires : Anthropic ou OpenAI (scripts), ElevenLabs ou OpenAI TTS (voix), Pexels (séquences libres de droits).
Étape 2 : Rédaction IA du script
import anthropic
def generate_script(topic, duration_seconds=45):
"""Génère un script vidéo optimisé pour les courts-métrages."""
client = anthropic.Anthropic()
prompt = f"""Écris un script vidéo de {duration_seconds} secondes sur : {topic}
Format :
ACCROCHE (3 premières secondes) : Une affirmation choquante ou une question qui arrête le défilement
CORPS (contenu principal) : 3 à 5 faits ou points percutants, chacun en 1 à 2 phrases
APPEL À L'ACTION (5 dernières secondes) : Appel à l'action — suivre, aimer, commenter
Règles :
- Conversationnel, pas de phrases complexes
- Chaque phrase sur sa propre ligne
- ~{duration_seconds * 2.5:.0f} mots ({duration_seconds}s à 150 mpm)
- Utilise des mots puissants : secret, choquant, personne ne te dit, en fait
- Pas d'émojis ni de hashtags — c'est un script de voix off
"""
response = client.messages.create(
model="claude-sonnet-4-20250514", max_tokens=500,
messages=[{"role": "user", "content": prompt}]
)
return response.content[0].text
Étape 3 : Narration Text-to-Speech
import requests, os
def generate_voice_elevenlabs(text, output_path='narration.mp3'):
"""Génère la voix off avec 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'):
"""Génère la voix off avec OpenAI TTS (alternative moins chère)."""
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
Étape 4 : Sélection des séquences libres de droits
def search_pexels_videos(query, count=5):
"""Recherche des clips vidéo libres de droits en orientation portrait sur Pexels."""
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
Étape 5 : Génération des sous-titres
def generate_subtitles(audio_path, output_srt='subtitles.srt'):
"""Génère des sous-titres mot par mot avec 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
Étape 6 : Montage vidéo avec FFmpeg
import subprocess
def assemble_video(clips, narration, subtitles, output='final.mp4'):
"""Assemble la vidéo finale : concaténation des clips, ajout de la narration et des sous-titres."""
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
Étape 7 : Pipeline complet
def generate_video(topic, output_dir='./output'):
"""Pipeline complet : du sujet à la vidéo finie."""
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) # téléchargement du clip
clips.append(path)
subs = generate_subtitles(narration, f'{output_dir}/subs.srt')
return assemble_video(clips, narration, subs, f'{output_dir}/final.mp4')
Exemples
Exemple 1 : Générer un lot de vidéos tech
Un créateur produit 5 vidéos courtes sur la technologie pour TikTok en une seule exécution :
topics = [
"Outils IA dont personne ne parle",
"Apps qui semblent illégales à utiliser gratuitement",
"Sites web qui vont vous épater",
"Outils IA gratuits dont chaque étudiant a besoin",
"Gadgets tech à moins de 50 € qui ont changé ma vie"
]
for topic in topics:
output = generate_video(topic, output_dir=f'./output/{topic[:30]}')
print(f"Vidéo prête : {output}")
# Chaque vidéo : ~45 secondes, portrait 1080x1920, avec sous-titres et narration
# Coût total : ~0,25 € (5 x 0,05 € par vidéo) avec ElevenLabs + Claude Sonnet
Exemple 2 : Vidéos financières quotidiennes pour YouTube
Une chaîne finance automatise les Shorts quotidiens avec des sujets d'argent tendance :
import schedule
def daily_finance_video():
topic = "3 idées de revenus passifs qui marchent vraiment en 2025"
script = generate_script(topic, duration_seconds=55)
# Sortie du script :
# ACCROCHE : "Vous perdez de l'argent chaque jour sans le savoir."
# CORPS : 1. Boutiques print-on-demand (500-2000 €/mois)
# 2. Licence de contenu généré par IA (300-1000 €/mois)
# 3. Cumul d'ETF à dividendes (200-800 €/mois passif)
# APPEL À L'ACTION : "Suivez pour plus d'astuces d'argent que personne ne vous dit."
narration = generate_voice_openai(script, './daily/narration.mp3')
videos = search_pexels_videos("money finance investing", count=4)
# Télécharge 4 clips portrait de séquences argent/finances/lifestyle
# Assemble avec des sous-titres blancs en gras, produit un Short de 55 secondes
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)
Conseils
- Respectez les droits d'auteur — utilisez uniquement des séquences libres de droits (Pexels, Pixabay) ou votre propre contenu
- Divulguez l'utilisation de l'IA — YouTube et TikTok exigent la divulgation du contenu généré par IA
- Révisez avant de publier — regardez toujours la vidéo finale ; les scripts IA peuvent contenir des inexactitudes
- Optimisez les 3 premières secondes — l'accroche détermine si les spectateurs restent ou défilent
- Testez plusieurs voix — ElevenLabs propose des dizaines de voix ; trouvez celle qui correspond à votre niche
- Suivez les performances — suivez les vues, la rétention et le taux de clic pour itérer sur le style de contenu
Références
- MoneyPrinterTurbo — inspiration originale (53k étoiles)
- API Pexels — vidéos libres de droits
- ElevenLabs — text-to-speech réaliste
- WhisperX — alignement de sous-titres mot par mot