KI-Videogenerator – Kurzvideo-Content-Pipeline
Überblick
Automatisiere die Erstellung von Kurzvideos (TikTok, YouTube Shorts, Instagram Reels) mit KI für jeden Schritt: Themenrecherche, Skripterstellung, Text-to-Speech-Vertonung, Stock-Fotografie-Anpassung, Untertitelgenerierung und finaler Videoschnitt. Inspiriert von MoneyPrinterTurbo (53k+ Sterne).
Anleitung
Schritt 1: Umgebung einrichten
pip install anthropic openai requests moviepy pydub whisperx srt
sudo apt install ffmpeg # Linux – or: brew install ffmpeg (macOS)
Benötigte API-Keys: Anthropic oder OpenAI (Skripte), ElevenLabs oder OpenAI TTS (Sprache), Pexels (kostenloses Stock-Footage).
Schritt 2: KI-Skripterstellung
import anthropic
def generate_script(topic, duration_seconds=45):
"""Erstelle ein Videoskript, optimiert für Kurzformate."""
client = anthropic.Anthropic()
prompt = f"""Schreibe ein {duration_seconds}-Sekunden-Videoskript über: {topic}
Format:
HOOK (erste 3 Sekunden): Eine schockierende Aussage oder Frage, die das Scrollen stoppt
BODY (Hauptinhalt): 3-5 knackige Fakten oder Punkte, jeweils 1-2 Sätze
CTA (letzte 5 Sekunden): Handlungsaufforderung – Folgen, Liken, Kommentieren
Regeln:
- Konversationell, keine komplexen Sätze
- Jeder Satz in einer eigenen Zeile
- ~{duration_seconds * 2.5:.0f} Wörter ({duration_seconds}s bei 150 Wörtern/min)
- Verwende Power-Wörter: Geheimnis, schockierend, niemand sagt dir, eigentlich
- Keine Emojis oder Hashtags – dies ist ein Voiceover-Skript
"""
response = client.messages.create(
model="claude-sonnet-4-20250514", max_tokens=500,
messages=[{"role": "user", "content": prompt}]
)
return response.content[0].text
Schritt 3: Text-to-Speech-Vertonung
import requests, os
def generate_voice_elevenlabs(text, output_path='narration.mp3'):
"""Erzeuge Sprachausgabe mit 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'):
"""Erzeuge Sprachausgabe mit OpenAI TTS (günstigere Alternative)."""
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
Schritt 4: Stock-Fotografie-Auswahl
def search_pexels_videos(query, count=5):
"""Suche auf Pexels nach Hochformat-Stock-Videoclips."""
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
Schritt 5: Untertitelgenerierung
def generate_subtitles(audio_path, output_srt='subtitles.srt'):
"""Erzeuge Wort-für-Wort-Untertitel mit 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
Schritt 6: Videoschnitt mit FFmpeg
import subprocess
def assemble_video(clips, narration, subtitles, output='final.mp4'):
"""Erstelle finales Video: Clips zusammenfügen, Vertonung und Untertitel hinzufügen."""
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
Schritt 7: Vollständige Pipeline
def generate_video(topic, output_dir='./output'):
"""Komplette Pipeline: Thema -> fertiges Video."""
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) # Download des Clips
clips.append(path)
subs = generate_subtitles(narration, f'{output_dir}/subs.srt')
return assemble_video(clips, narration, subs, f'{output_dir}/final.mp4')
Beispiele
Beispiel 1: Batch-Erstellung von Tech-Fact-Videos
Ein Creator produziert 5 technologiebezogene Kurzvideos für TikTok in einem Durchlauf:
topics = [
"KI-Tools, über die niemand spricht",
"Apps, die sich illegal anfühlen, sie kostenlos zu nutzen",
"Websites, die dich umhauen werden",
"Kostenlose KI-Tools, die jeder Student braucht",
"Tech-Gadgets unter 50€, die mein Leben verändert haben"
]
for topic in topics:
output = generate_video(topic, output_dir=f'./output/{topic[:30]}')
print(f"Video fertig: {output}")
# Jedes Video: ~45 Sekunden, Hochformat 1080x1920, mit Untertiteln und Vertonung
# Gesamtkosten: ~0,25€ (5 x 0,05€ pro Video) mit ElevenLabs + Claude Sonnet
Beispiel 2: Tägliche Finanz-Shorts für YouTube
Ein Finanzkanal automatisiert tägliche Shorts-Uploads mit aktuellen Geldthemen:
import schedule
def daily_finance_video():
topic = "3 passive Einkommensideen, die 2025 wirklich funktionieren"
script = generate_script(topic, duration_seconds=55)
# Script-Ausgabe:
# HOOK: „Du verlierst jeden Tag Geld, nur weil du das nicht kennst.“
# BODY: 1. Print-on-Demand-Shops (500-2000€/Monat)
# 2. KI-generierte Content-Lizenzen (300-1000€/Monat)
# 3. Dividenden-ETF-Stacking (200-800€/Monat passiv)
# CTA: „Folge mir für mehr Geldtipps, die dir niemand verrät.“
narration = generate_voice_openai(script, './daily/narration.mp3')
videos = search_pexels_videos("money finance investing", count=4)
# Lädt 4 Hochformat-Clips mit Geld/Charts/Lifestyle-Material
# Fügt fette weiße Untertitel hinzu, erzeugt 55-Sekunden-Short
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)
Richtlinien
- Urheberrecht beachten – nur lizenzfreies Stock-Material (Pexels, Pixabay) oder eigene Inhalte verwenden
- KI-Nutzung offenlegen – YouTube und TikTok verlangen die Offenlegung von KI-generierten Inhalten
- Vor Veröffentlichung prüfen – immer das finale Video ansehen; KI-Skripte können Ungenauigkeiten enthalten
- Erste 3 Sekunden optimieren – der Hook entscheidet, ob Zuschauer bleiben oder weiterscrollen
- Mehrere Stimmen testen – ElevenLabs bietet Dutzende Stimmen; finde eine, die zu deiner Nische passt
- Leistung überwachen – Aufrufe, Verweildauer und Klickrate verfolgen, um den Content-Stil zu iterieren
Referenzen
- MoneyPrinterTurbo – ursprüngliche Inspiration (53k Sterne)
- Pexels API – kostenlose Stock-Videos
- ElevenLabs – realistische Text-to-Speech
- WhisperX – Wortgenaue Untertitelausrichtung