ElevenLabs-gestützte Demovideos
Ein wiederholbares Rezept, um aus einer laufenden Web-App ein poliertes, vertontes Demo-mp4 zu erstellen. Ein in sich geschlossenes Node-Skript pro Demo macht alles: Sprachaufnahme synthetisieren, eine choreografierte Tour der App aufzeichnen und Stimme + Musik unter das Filmmaterial mischen. Kein Videobearbeitungsprogramm, keine manuelle Zeitabstimmung.
Die Pipeline
ElevenLabs TTS ──► Erzählung .wav pro Zeile (zwischengespeichert)
│
Playwright ──► nimmt eine skriptgesteuerte Scroll-/Klick-Tour der live App auf (.webm)
│
ffmpeg ──► kürzt den Ladevorspann, platziert jede Erzählungszeile an ihrem Szenen-
Stichwort, erzeugt einen Hintergrundmusikteppich, senkt die Musik unter der
Stimme ab (Sidechain-Kompression), codiert das finale .mp4
Die Kernidee: Jede Szene hält exakt so lange wie ihre Erzählungszeile, sodass die Stimme immer auf dem richtigen Bild landet – ohne manuelle Synchronisation.
Voraussetzungen
- Node 18+ und
npm i -D playwright(verwendet das installierte Chrome viachannel: "chrome"oder wechsle zu gebündeltem Chromium). ffmpegundffprobeimPATH.- Ein ElevenLabs-API-Key mit Text-to-Speech-Berechtigung (die günstigeren Keys haben oft nicht
user_read, verlasse dich also nicht auf den Quota-Endpunkt – versuche einfach TTS). - Die App läuft lokal (z.B.
npm run devauf:3000); übergibBASE_URLzum Überschreiben.
Speichere den Key außerhalb von Git (z.B. in einer gitignorierten Datei demo/.eleven.key). Die gerenderten .mp4-Dateien sind groß – ignoriere sie in Git und verteile sie über eine Freigabe (Drive usw.), nicht über das Repository.
Verwendung
- Ein Skript pro Demo. Kopiere die Vorlage unten nach
demo/build-<name>.mjs. Jedes Skript ist unabhängig und schreibt seine temporären Dateien indemo/<name>-work/. - Schreibe die Erzählung als
LINES-Array – wortwörtlich, ein Eintrag pro Szene. Ziel: ~2,3 Wörter/Sekunde bei der Zeitplanung. - Choreografiere die Szenen in
actions– ein Eintrag pro Zeile, in derselben Reihenfolge. Eine einfache async-Funktion erstellt ein Standbild; ein{action, hold}-Objekt erstellt das Bild (action) und führt dann eine Schwenk-/Klickbewegung während die Erzählung läuft (hold) aus. - Führe es im VORDERGRUND aus für jedes Demo, das die App steuert (Klicks, Formulareingaben, Identitäts-/Routenwechsel):
node demo/build-<name>.mjs. Statische Scroll-Touren können im Hintergrund laufen, aber interaktive Touren können oft nicht auf den Dev-Server zugreifen oder gesteuerte Eingaben aus einer Hintergrund-Sandbox steuern – führe es daher im Zweifelsfall im Vordergrund aus. - Nehme nach UI-Änderungen neu auf. Selektoren sind an das DOM gekoppelt; ein Redesign wird sie brechen. Führe das betroffene Skript erneut aus und überprüfe einen Frame stichprobenartig (
ffmpeg -ss <t> -i out.mp4 -frames:v 1 frame.jpg).
Lektionen, die Stunden sparen
- Erzählung nach Index zwischenspeichern. Jede Zeile ist
l<i>.wav; verwende sie wieder, falls vorhanden, sodass Neuaufnahmen keine Credits verbrauchen. Um eine Zeile zu ändern, bearbeiteLINES[i]und lösche die entsprechendel<i>.wav. Wenn du eine Zeile in der Mitte der Liste einfügst, verschiebe die zwischengespeicherten WAVs um eine Position nach oben (mv l7.wav l8.wav; mv l6.wav l7.wav; …), sodass nur die neue Zeile synthetisiert wird – die Schleife speichert nach Index zwischen und prüft nicht den Text. - Ausfallsicherheit bei Quota. Wenn ein TTS-Aufruf fehlschlägt, falle auf Filmmaterial + Musik ohne Erzählung zurück und schätze die Dauer jeder Zeile anhand der Wortanzahl, sodass der Build immer ein mp4 erzeugt.
- Kürze den Ladevorspann. Nimm das GoTo/Seed/Hydrate auf, markiere
contentStart, sobald die erste Aufnahme stabil ist, und schneide mit-ss contentStartden Anfang ab, sodass das Video mit einem ruhigen Bild beginnt. Die Erzählungsstichworte werden beim Mischen umcontentStartverschoben. - Halten = max(Erzählung, Schwenk). Bei aktiven Haltevorgängen verlängere auf mindestens die Zeilenlänge, damit die Stimme nie abgeschnitten wird; wenn die Interaktion länger dauert, lass sie laufen.
- Scharf aufnehmen. Verwende ein großes Viewport (z.B. 1920×1200) und setze
document.documentElement.style.zoom(z.B. 1.5) über ein Init-Skript, sodass das logische Layout auf der gewünschten Größe bleibt, der Frame aber schärfer rendert. - Abgehacktes Scrollen vermeiden. Feste, vollbilddeckende Overlays mit
mix-blend-*(Filmkörnung, Verläufe) erzwingen bei jedem Scroll-Frame eine vollständige Neuberechnung des Bildes. Verstecke sie während der Aufnahme:page.addStyleTag({content: ".grain{display:none!important}"}). Verstecke auch immer sichtbare CTAs/Footer, die du nicht im Bild haben möchtest. - Steuere kontrollierte Eingaben robust. Ein React-gesteuertes
<select>ignoriert ein einfachesselectOption. Setze es mit dem nativen Setter + einemchange-Event, das bubbelt, und wiederhole, bis ein Bestätigungslocator erscheint:const setter = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "value").set; setter.call(el, value); el.dispatchEvent(new Event("change", { bubbles: true })); - Verwende typografische Anführungszeichen in Selektoren. Wenn Überschriften geschweifte Anführungszeichen (
',',") rendern, passt ein Regex mit einem geraden'nicht. Verwende.für den Apostroph:/Tell us who you.re looking for/i. - Lokalisiere Fragen/Felder anhand ihrer Bezeichnung und handle dann innerhalb des Blocks. Robust gegenüber Layoutänderungen:
page.locator("label", { hasText: q }).first().locator("xpath=..")dann.getByRole("radio"/"checkbox", { name })darin. - Musikbett + Ducking. Synthetisiere einen loopenden Ambient-Pad aus Sinuswellen-Akkorden mit ffmpeg
aevalsrc, dannsidechaincompressdie Musik unter der Erzählung, sodass die Stimme immer klar zu hören ist. Halte die Musik bei ca. 0,4 und lasse den Kompressor sie absenken.
Vorlage (demo/build-<name>.mjs)
import { chromium } from "playwright";
import fs from "node:fs";
import path from "node:path";
import { execFileSync } from "node:child_process";
const DIR = path.resolve("demo");
const WORK = path.join(DIR, "name-work");
fs.mkdirSync(WORK, { recursive: true });
const KEY = fs.readFileSync(path.join(DIR, ".eleven.key"), "utf8").trim();
const BASE = process.env.BASE_URL || "http://localhost:3000";
const OUT = path.join(DIR, "name.mp4");
const W = 1920, H = 1200, ZOOM = 1.5;
const sh = (c, a) => execFileSync(c, a, { stdio: ["ignore", "pipe", "pipe"] }).toString();
const probe = (f) => parseFloat(sh("ffprobe", ["-v","error","-show_entries","format=duration","-of","default=noprint_wrappers=1:nokey=1", f]).trim());
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
// 1 Zeile pro Szene, in Szenen-Reihenfolge.
const LINES = [
"Eröffnungszeile – der Aufhänger, gesprochen über das erste ruhige Bild.",
"Zweite Zeile – erzähle, während die Kamera durch den nächsten Abschnitt schwenkt.",
"Schlusszeile – ein ruhiger Abschluss.",
];
const TAILS = LINES.map(() => 1.4); // Puffer nach jeder Zeile
// ── ElevenLabs ──────────────────────────────────────────────────────────────
async function voiceId() {
const r = await fetch("https://api.elevenlabs.io/v1/voices", { headers: { "xi-api-key": KEY } });
const { voices } = await r.json();
return (voices.find((v) => v.name.toLowerCase().startsWith("jessica")) || voices[0]).voice_id;
}
async function tts(id, text, out) {
const r = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${id}?output_format=mp3_44100_128`, {
method: "POST", headers: { "xi-api-key": KEY, "content-type": "application/json" },
body: JSON.stringify({ text, model_id: "eleven_multilingual_v2",
voice_settings: { stability: 0.55, similarity_boost: 0.8, style: 0, use_speaker_boost: true } }),
});
if (!r.ok) throw new Error(`tts ${r.status} ${await r.text()}`);
fs.writeFileSync(out, Buffer.from(await r.arrayBuffer()));
}
// ── Ambient-Musikbett (Am–F–C–G Pad) ────────────────────────────────────────
function buildMusic(total, out) {
const chords = [[220,261.63,329.63],[174.61,220,261.63],[261.63,329.63,392],[196,246.94,293.66]];
const CH = 6;
const files = chords.map((freqs, i) => {
const expr = freqs.map((f) => `0.17*sin(2*PI*${f}*t)`).join("+");
const f = path.join(WORK, `chord${i}.wav`);
sh("ffmpeg", ["-y","-f","lavfi","-i",`aevalsrc=${expr}:duration=${CH}:sample_rate=44100`,
"-af", `afade=t=in:d=1.4,afade=t=out:st=${CH-1.4}:d=1.4`, f]);
return f;
});
const list = path.join(WORK, "chords.txt");
fs.writeFileSync(list, files.map((f) => `file '${f}'`).join("\n"));
const loop = path.join(WORK, "loop.wav");
sh("ffmpeg", ["-y","-f","concat","-safe","0","-i",list,"-c","copy", loop]);
const loops = Math.ceil(total / (chords.length * CH)) + 1;
sh("ffmpeg", ["-y","-stream_loop",String(loops),"-i",loop,"-af",
["aecho=0.8:0.88:70|130:0.25|0.18","lowpass=f=2200","tremolo=f=0.12:d=0.25",
"aformat=channel_layouts=stereo","afade=t=in:d=0.5",
`afade=t=out:st=${Math.max(0,total-3)}:d=3`,`atrim=0:${total}`].join(","), out]);
}
// ── Choreografie-Hilfsfunktionen ────────────────────────────────────────────
async function smoothTo(page, y, ms) {
await page.evaluate(({ y, ms }) => new Promise((res) => {
const s = window.scrollY, d = y - s, t0 = performance.now();
const e = (t) => (t < 0.5 ? 2*t*t : -1 + (4-2*t)*t);
const f = (n) => { const p = Math.min(1, (n-t0)/ms); window.scrollTo(0, s + d*e(p)); p < 1 ? requestAnimationFrame(f) : res(); };
requestAnimationFrame(f);
}), { y, ms });
}
async function scrollToText(page, text, ms = 1500, offset = 150) {
const y = await page.evaluate(({ text, offset }) => {
const all = [...document.querySelectorAll("h1,h2,h3,h4,p,span,button,a,li")].filter((e) => e.getClientRects().length);
let el = all.find((e) => (e.textContent || "").trim() === text)
|| all.filter((e) => (e.textContent || "").includes(text)).sort((a,b)=>a.textContent.length-b.textContent.length)[0];
return el ? el.getBoundingClientRect().top + window.scrollY - offset : null;
}, { text, offset });
if (y != null) await smoothTo(page, Math.max(0, y), ms);
}
// ── 1) Erzählung synthetisieren (zwischengespeichert), Dauer messen ─────────
const clips = []; let vid = null, narrationOk = true;
for (let i = 0; i < LINES.length; i++) {
const mp3 = path.join(WORK, `l${i}.mp3`), wav = path.join(WORK, `l${i}.wav`);
if (fs.existsSync(wav)) { clips.push({ wav, dur: probe(wav) }); continue; }
try {
if (!vid) vid = await voiceId();
await tts(vid, LINES[i], mp3);
sh("ffmpeg", ["-y","-i",mp3,"-ar","44100","-ac","2", wav]);
clips.push({ wav, dur: probe(wav) });
} catch (e) {
narrationOk = false;
clips.push({ wav: null, dur: LINES[i].trim().split(/\s+/).length / 2.3 });
}
}
// ── 2) Aufnehmen, jedes Bild für seine Zeile halten ─────────────────────────
const browser = await chromium.launch({ channel: "chrome", headless: true });
const context = await browser.newContext({ viewport: { width: W, height: H }, recordVideo: { dir: WORK, size: { width: W, height: H } } });
await context.addInitScript((z) => {
const apply = () => { try { document.documentElement.style.zoom = String(z); } catch {} };
apply(); document.addEventListener("DOMContentLoaded", apply);
}, ZOOM);
const page = await context.newPage();
page.setDefaultTimeout(20000);
const video = page.video();
const t0 = Date.now();
await page.goto(`${BASE}/`, { waitUntil: "domcontentloaded" });
await page.evaluate(() => (document.fonts ? document.fonts.ready : null));
await page.addStyleTag({ content: ".grain{display:none !important}" }); // Misch-Overlays ausblenden
await sleep(1500);
const contentStart = (Date.now() - t0) / 1000; // alles davor abschneiden
const actions = [
async () => { await sleep(300); }, // stiller Aufhänger
{ action: async () => { await scrollToText(page, "Eine Überschrift"); await sleep(300); },
hold: async () => { await smoothTo(page, 1600, Math.max(4000, clips[1].dur*1000)); } }, // Schwenk während der Zeile
async () => { await smoothTo(page, 0, 2500); await sleep(500); }, // Abschluss
];
const cues = [];
for (let i = 0; i < actions.length; i++) {
const sc = actions[i];
const act = typeof sc === "function" ? sc : sc.action;
const hold = typeof sc === "function" ? null : sc.hold;
await act();
cues.push((Date.now() - t0) / 1000);
if (hold) {
const start = Date.now();
await hold();
const min = clips[i].dur + TAILS[i], elapsed = (Date.now() - start) / 1000;
if (elapsed < min) await sleep((min - elapsed) * 1000);
} else {
await sleep((clips[i].dur + TAILS[i]) * 1000);
}
}
await sleep(400);
await context.close();
await browser.close();
// ── 3) Muxen: Vorspann kürzen, Erzählung an Stichworten platzieren, Musik ducken ──
const raw = await video.path();
const outDur = probe(raw) - contentStart;
const music = path.join(WORK, "music.wav");
buildMusic(outDur, music);
if (!narrationOk) {
sh("ffmpeg", ["-y","-ss",String(contentStart),"-i",raw,"-i",music,
"-filter_complex","[1:a]volume=0.7[a]","-map","0:v","-map","[a]",
"-c:v","libx264","-preset","medium","-crf","18","-pix_fmt","yuv420p",
"-c:a","aac","-b:a","192k","-movflags","+faststart","-t",String(outDur), OUT]);
} else {
const lead = 0.35, narr = path.join(WORK, "narration.wav");
const inputs = clips.flatMap((c) => ["-i", c.wav]);
const fc =
clips.map((c, i) => { const at = Math.max(0, Math.round((cues[i]-contentStart+lead)*1000)); return `[${i}:a]adelay=${at}|${at}[d${i}]`; }).join(";") +
";" + clips.map((_, i) => `[d${i}]`).join("") +
`amix=inputs=${clips.length}:normalize=0:dropout_transition=0[mix];[mix]apad=whole_dur=${outDur},volume=1.25[a]`;
sh("ffmpeg", ["-y", ...inputs, "-filter_complex", fc, "-map","[a]", narr]);
sh("ffmpeg", ["-y","-ss",String(contentStart),"-i",raw,"-i",music,"-i",narr,
"-filter_complex",[
"[1:a]volume=0.42[m]","[2:a]asplit=2[k][n]",
"[m][k]sidechaincompress=threshold=0.035:ratio=9:attack=15:release=350[md]",
"[md][n]amix=inputs=2:normalize=0:duration=longest[a]",
].join(";"),
"-map","0:v","-map","[a]",
"-c:v","libx264","-preset","medium","-crf","18","-pix_fmt","yuv420p",
"-c:a","aac","-b:a","192k","-movflags","+faststart","-t",String(outDur), OUT]);
}
console.log(`FERTIG: ${OUT} (${outDur.toFixed(1)}s)`);
Anpassung
- Neue Stimme: Ändere den Namensfilter in
voiceId()oder hinterlege einevoice_idfest. - Interaktive Touren: Füge Hilfsfunktionen wie
answerChoice/clickTabhinzu, die auf einen Block per Label eingrenzen und wiederholen, bis ein Bestätigungselement erscheint.