diff --git a/client-vue/src/components/vod/VodItem.vue b/client-vue/src/components/vod/VodItem.vue
index 792ac1ee..f14cd1bf 100644
--- a/client-vue/src/components/vod/VodItem.vue
+++ b/client-vue/src/components/vod/VodItem.vue
@@ -451,13 +451,22 @@ function openPlayer(): void {
         hash += `&video_path=${props.vod.webpath}/${props.vod.basename}_vod.mp4`;
     }
 
+    // stream pauses are cut out of the captured video, chat and chapters need to be synced to it
+    const syncToVideo = playerSettings.value.vodSource == "captured" && props.vod.needs_video_sync;
+
     if (playerSettings.value.chatSource == "captured") {
-        hash += `&chatfile=${props.vod.webpath}/${props.vod.basename}.chatdump`;
+        if (syncToVideo) {
+            hash += `&chatfile=${store.cfg<string>("basepath", "")}/api/v0/vod/${props.vod.uuid}/synced.chatdump`;
+        } else {
+            hash += `&chatfile=${props.vod.webpath}/${props.vod.basename}.chatdump`;
+        }
     } else {
         hash += `&chatfile=${props.vod.webpath}/${props.vod.basename}_chat.json`;
     }
 
-    hash += `&chapters=${props.vod.chapters?.map((c) => `${c.offset}:${encodeURIComponent(c.title.replaceAll(":", "").replaceAll(";", ""))}`).join(";")}`;
+    hash += `&chapters=${props.vod.chapters
+        ?.map((c) => `${syncToVideo ? c.video_offset : c.offset}:${encodeURIComponent(c.title.replaceAll(":", "").replaceAll(";", ""))}`)
+        .join(";")}`;
 
     // url.searchParams.set("offset", this.playerSettings.offset.toString());
     // window.open(url.toString(), "_blank");
diff --git a/client-vue/src/components/vod/VodItemChapters.vue b/client-vue/src/components/vod/VodItemChapters.vue
index e6e5b38c..deea1d0f 100644
--- a/client-vue/src/components/vod/VodItemChapters.vue
+++ b/client-vue/src/components/vod/VodItemChapters.vue
@@ -42,8 +42,8 @@
                             }"
                         >
                             <!-- start timestamp -->
-                            <td data-contents="offset" :title="formatDate(chapter.started_at)">
-                                {{ chapter.offset !== undefined ? humanDuration(chapter.offset) : "Unknown" }}
+                            <td data-contents="offset" :title="chapterOffsetTitle(chapter)">
+                                {{ chapter.video_offset !== undefined ? humanDuration(chapter.video_offset) : "Unknown" }}
                             </td>
 
                             <!-- start time -->
@@ -58,15 +58,15 @@
 
                             <!-- end time -->
                             <td v-if="showAdvanced" data-contents="ended_at">
-                                <template v-if="chapter.offset !== undefined && chapter.duration !== undefined">
-                                    {{ humanDuration(chapter.offset + chapter.duration) }}
+                                <template v-if="chapter.video_offset !== undefined && chapter.video_duration !== undefined">
+                                    {{ humanDuration(chapter.video_offset + chapter.video_duration) }}
                                 </template>
                             </td>
 
                             <!-- duration -->
                             <td data-contents="duration">
-                                <template v-if="chapter.duration">
-                                    {{ niceDuration(chapter.duration) }}
+                                <template v-if="chapter.video_duration">
+                                    {{ niceDuration(chapter.video_duration) }}
                                 </template>
                                 <template v-else>
                                     <duration-display :start-date="chapter.started_at.toISOString()" output-style="human" />
@@ -89,7 +89,7 @@
                                         <a
                                             class="px-1"
                                             target="_blank"
-                                            :href="playerLink(chapter.offset)"
+                                            :href="playerLink(chapter.video_offset)"
                                             title="Open in player"
                                             :class="{ 'is-spoiler': store.clientCfg('hideChapterTitlesAndGames') }"
                                         >
@@ -104,7 +104,11 @@
                                             :to="{
                                                 name: 'Editor',
                                                 params: { uuid: vod.uuid },
-                                                query: { start: chapter.offset, end: (chapter.offset || 0) + (chapter.duration || 0), chapter: chapterIndex },
+                                                query: {
+                                                    start: chapter.video_offset,
+                                                    end: (chapter.video_offset || 0) + (chapter.video_duration || 0),
+                                                    chapter: chapterIndex,
+                                                },
                                             }"
                                         >
                                             <span class="icon"><font-awesome-icon icon="cut" /></span>
@@ -233,8 +237,20 @@ const hasViewerCount = computed(() => {
 function playerLink(offset = 0, chatdownload = false): string {
     if (!props.vod || !store.config) return "#";
     const video_path = `${props.vod.webpath}/${props.vod.basename}.mp4`;
-    const chat_path = `${props.vod.webpath}/${props.vod.basename}.${chatdownload ? "chat" : "chatdump"}`;
-    return `${store.cfg<string>("basepath", "")}/vodplayer#source=file_http&video_path=${video_path}&chatfile=${chat_path}&offset=${offset}`;
+    let chat_path = `${props.vod.webpath}/${props.vod.basename}.${chatdownload ? "chat" : "chatdump"}`;
+    if (!chatdownload && props.vod.needs_video_sync) {
+        // stream pauses were cut out of the video, use the chat dump synced to it
+        chat_path = `${store.cfg<string>("basepath", "")}/api/v0/vod/${props.vod.uuid}/synced.chatdump`;
+    }
+    return `${store.cfg<string>("basepath", "")}/vodplayer#source=file_http&video_path=${video_path}&chatfile=${chat_path}&t=${Math.floor(offset)}`;
+}
+
+function chapterOffsetTitle(chapter: ChapterTypes): string {
+    let title = formatDate(chapter.started_at);
+    if (chapter.offset !== undefined && chapter.video_offset !== undefined && Math.round(chapter.offset) !== Math.round(chapter.video_offset)) {
+        title += ` (${humanDuration(chapter.offset)} into the stream, ad breaks are cut out of the video)`;
+    }
+    return title;
 }
 
 function twitchVideoLink(video_id: string): string {
diff --git a/client-vue/src/core/Providers/Base/BaseVOD.ts b/client-vue/src/core/Providers/Base/BaseVOD.ts
index b76703fe..59bb9572 100644
--- a/client-vue/src/core/Providers/Base/BaseVOD.ts
+++ b/client-vue/src/core/Providers/Base/BaseVOD.ts
@@ -69,6 +69,10 @@ export default class BaseVOD {
 
     viewers: VodViewerEntry[] = [];
     stream_pauses: StreamPause[] = [];
+    /** The stream pauses were filled with black video during conversion */
+    stream_pauses_padded = false;
+    /** Chat and chapter times need to be mapped to the captured video because of stream pauses */
+    needs_video_sync = false;
 
     get current_chapter(): BaseVODChapter | undefined {
         if (this.chapters.length > 0) {
@@ -145,6 +149,8 @@ export default class BaseVOD {
         vod.stream_pauses = apiResponse.stream_pauses
             ? apiResponse.stream_pauses.map((entry) => ({ start: new Date(entry.start), end: new Date(entry.end) }))
             : [];
+        vod.stream_pauses_padded = apiResponse.stream_pauses_padded ?? false;
+        vod.needs_video_sync = apiResponse.needs_video_sync ?? false;
 
         return vod;
 
diff --git a/client-vue/src/core/Providers/Base/BaseVODChapter.ts b/client-vue/src/core/Providers/Base/BaseVODChapter.ts
index 0396a6b2..0703cb68 100644
--- a/client-vue/src/core/Providers/Base/BaseVODChapter.ts
+++ b/client-vue/src/core/Providers/Base/BaseVODChapter.ts
@@ -8,9 +8,15 @@ export class BaseVODChapter {
      */
     public started_at!: Date;
 
+    /** Seconds since the stream started */
     public offset?: number;
     public duration?: number;
 
+    /** Position in the captured video, corrected for stream pauses (ad breaks) */
+    public video_offset?: number;
+    /** Duration in the captured video, corrected for stream pauses (ad breaks) */
+    public video_duration?: number;
+
     // public game_id?: string;
     // public game?: TwitchGame;
 
@@ -34,6 +40,8 @@ export class BaseVODChapter {
         chapter.started_at = new Date(apiResponse.started_at);
         chapter.offset = apiResponse.offset;
         chapter.duration = apiResponse.duration;
+        chapter.video_offset = apiResponse.video_offset ?? apiResponse.offset;
+        chapter.video_duration = apiResponse.video_duration ?? apiResponse.duration;
         // chapter.strings = apiResponse.strings;
         // chapter.game_id = apiResponse.game_id;
         chapter.title = apiResponse.title;
diff --git a/client-vue/src/core/Providers/Twitch/TwitchVODChapter.ts b/client-vue/src/core/Providers/Twitch/TwitchVODChapter.ts
index dc502ad8..d0d5bb76 100644
--- a/client-vue/src/core/Providers/Twitch/TwitchVODChapter.ts
+++ b/client-vue/src/core/Providers/Twitch/TwitchVODChapter.ts
@@ -19,6 +19,8 @@ export class TwitchVODChapter extends BaseVODChapter {
         chapter.started_at = new Date(apiResponse.started_at);
         chapter.offset = apiResponse.offset;
         chapter.duration = apiResponse.duration;
+        chapter.video_offset = apiResponse.video_offset ?? apiResponse.offset;
+        chapter.video_duration = apiResponse.video_duration ?? apiResponse.duration;
         // chapter.strings = apiResponse.strings;
         chapter.game_id = apiResponse.game_id;
         chapter.title = apiResponse.title;
diff --git a/client-vue/src/views/EditorView.vue b/client-vue/src/views/EditorView.vue
index 6457bde2..fe5d9480 100644
--- a/client-vue/src/views/EditorView.vue
+++ b/client-vue/src/views/EditorView.vue
@@ -156,12 +156,12 @@
                 <ul class="list">
                     <li v-for="(chapter, i) in vodData.chapters" :key="i">
                         <a
-                            v-if="chapter.offset !== undefined && chapter.duration !== undefined"
-                            @click="setCutpoints(chapter.offset || 0, chapter.duration || 0)"
+                            v-if="chapter.video_offset !== undefined && chapter.video_duration !== undefined"
+                            @click="setCutpoints(chapter.video_offset || 0, chapter.video_duration || 0)"
                         >
                             <div class="chapter-time">
-                                {{ humanDuration(chapter.offset) }} - {{ humanDuration(chapter.offset + chapter.duration) }} ({{
-                                    humanDuration(chapter.duration)
+                                {{ humanDuration(chapter.video_offset) }} - {{ humanDuration(chapter.video_offset + chapter.video_duration) }} ({{
+                                    humanDuration(chapter.video_duration)
                                 }})
                             </div>
                             <div class="chapter-game">
@@ -479,8 +479,8 @@ function timelineMouseMove(event: MouseEvent): void {
 
     if (vodData.value) {
         const idx = vodData.value.chapters.findIndex((chapter, i) => {
-            const o = i == 0 ? 0 : chapter.offset || 0;
-            return chapter.offset && chapter.duration && seconds >= o && seconds < o + chapter.duration;
+            const o = i == 0 ? 0 : chapter.video_offset || 0;
+            return chapter.video_offset && chapter.video_duration && seconds >= o && seconds < o + chapter.video_duration;
         });
         if (idx !== -1) {
             currentChapterHoverIndex.value = idx;
@@ -619,7 +619,7 @@ function submitForm(event: Event): void {
 
 function chapterWidth(chapter: BaseVODChapter): number {
     // const chapterOffset = chapter.offset || 0;
-    const chapterDuration = chapter.duration || 0;
+    const chapterDuration = chapter.video_duration || 0;
     const width = (chapterDuration / videoDuration.value) * 100;
     return width;
 }
@@ -697,8 +697,8 @@ watch(
 );
 
 function chapterStyle(index: number, chapter: BaseVODChapter): HTMLAttributes["style"] {
-    const chapterOffset = index == 0 ? 0 : chapter.offset || 0;
-    const chapterDuration = chapter.duration || 0;
+    const chapterOffset = index == 0 ? 0 : chapter.video_offset || 0;
+    const chapterDuration = chapter.video_duration || 0;
     const left = (chapterOffset / videoDuration.value) * 100;
     // cap width at duration
     const width = Math.min((chapterDuration / videoDuration.value) * 100, 100 - left);
diff --git a/client-vue/test/mockdata.ts b/client-vue/test/mockdata.ts
index 31c20e89..0b8d5b69 100644
--- a/client-vue/test/mockdata.ts
+++ b/client-vue/test/mockdata.ts
@@ -138,6 +138,8 @@ export const MockApiVODData: ApiTwitchVod = {
     channel_uuid: "",
     viewers: [],
     stream_pauses: [],
+    stream_pauses_padded: false,
+    needs_video_sync: false,
 };
 
 export const MockApiChapterData: ApiVodTwitchChapter = {
@@ -146,6 +148,8 @@ export const MockApiChapterData: ApiVodTwitchChapter = {
     duration: 0,
     started_at: "",
     offset: 0,
+    video_offset: 0,
+    video_duration: 0,
     is_mature: false,
     game_id: undefined,
     game_name: undefined,
diff --git a/common/Api/Client.ts b/common/Api/Client.ts
index 5893f5f0..f5113d3e 100644
--- a/common/Api/Client.ts
+++ b/common/Api/Client.ts
@@ -23,7 +23,12 @@ export interface ApiVodBaseChapter {
     duration: number;
     started_at: string;
     // datetime: PHPDateTimeJSON;
+    /** Seconds since the stream started */
     offset: number;
+    /** Position in the captured video, corrected for stream pauses (ad breaks) */
+    video_offset: number;
+    /** Duration in the captured video, corrected for stream pauses (ad breaks) */
+    video_duration: number;
 }
 
 export interface ApiVodTwitchChapter extends ApiVodBaseChapter {
@@ -120,6 +125,10 @@ export interface ApiBaseVod {
 
     viewers: { amount: number; timestamp: string }[];
     stream_pauses: { start: string; end: string }[];
+    /** The stream pauses were filled with black video during conversion */
+    stream_pauses_padded: boolean;
+    /** Chat and chapter times need to be mapped to the captured video because of stream pauses */
+    needs_video_sync: boolean;
 
     bookmarks: VODBookmark[];
 }
diff --git a/common/ServerConfig.ts b/common/ServerConfig.ts
index 1c6fa385..fa607a81 100644
--- a/common/ServerConfig.ts
+++ b/common/ServerConfig.ts
@@ -704,6 +704,13 @@ export const settingsFields = createSettingsFields({
         type: "boolean",
         default: false,
     },
+    "video.pad_stream_pauses": {
+        group: "Video",
+        text: "Fill ad breaks with black video",
+        type: "boolean",
+        default: false,
+        help: "When converting a capture, insert black, silent video where streamlink filtered out ad breaks, so the video is as long as the stream and chat and chapters stay in sync. Only a short black clip is encoded, the capture itself is still copied. Falls back to a normal conversion if it fails.",
+    },
     create_video_chapters: {
         group: "Video",
         text: "Create video chapters",
diff --git a/server/src/Controllers/Vod.ts b/server/src/Controllers/Vod.ts
index 0167c735..600c6fdc 100644
--- a/server/src/Controllers/Vod.ts
+++ b/server/src/Controllers/Vod.ts
@@ -392,7 +392,8 @@ export async function RenderWizard(
                 chat_font,
                 chat_font_size,
                 chat_source == "downloaded",
-                true
+                true,
+                vod_source != "downloaded"
             );
         } catch (error) {
             res.api(400, {
@@ -700,9 +701,10 @@ export async function CutVod(
     }
 
     if (vod.is_chat_downloaded || vod.is_chatdump_captured) {
+        // the clip is cut from the captured video, so use the chat dump synced to it
         const chat_file_in = vod.is_chat_downloaded
             ? vod.path_chat
-            : vod.path_chatdump;
+            : await vod.getChatdumpForVideo();
         const chat_file_out = path.join(
             BaseConfigDataFolder.saved_clips,
             `${vod.basename}_${time_in}-${time_out}_${segment_name}_chat.json`
@@ -896,6 +898,40 @@ export async function GetSync(
     */
 }
 
+/**
+ * Send the captured chat dump timed to the captured video.
+ * Stream pauses (ad breaks) are cut out of the video, so the chat is synced to match.
+ * Sends the original chat dump if no sync is needed.
+ */
+export async function GetVideoChatdump(
+    req: express.Request,
+    res: express.Response
+): Promise<void> {
+    const vod = LiveStreamDVR.getInstance().getVodByUUID(req.params.uuid);
+
+    if (!vod) {
+        res.api(400, {
+            status: "ERROR",
+            message: "Vod not found",
+        } as ApiErrorResponse);
+        return;
+    }
+
+    if (!vod.is_chatdump_captured) {
+        res.api(404, {
+            status: "ERROR",
+            message: "No chat dump captured for this vod",
+        } as ApiErrorResponse);
+        return;
+    }
+
+    const chatdump = await vod.getChatdumpForVideo();
+
+    res.sendFile(chatdump, {
+        headers: { "Content-Type": "application/json" },
+    });
+}
+
 export async function RenameVod(
     req: express.Request,
     res: express.Response
diff --git a/server/src/Core/Helper.ts b/server/src/Core/Helper.ts
index e0df1240..330734bc 100644
--- a/server/src/Core/Helper.ts
+++ b/server/src/Core/Helper.ts
@@ -276,7 +276,11 @@ export class Helper {
     public static path_ffprobe(): string | false {
         const f = this.path_ffmpeg();
         if (!f) return false;
-        return f.replace("ffmpeg.exe", "ffprobe.exe");
+        // ffprobe is next to ffmpeg, replace only the file name (ffmpeg or ffmpeg.exe)
+        return path.join(
+            path.dirname(f),
+            path.basename(f).replace(/^ffmpeg/i, "ffprobe")
+        );
     }
 
     public static python_scripts_dir_name(): string {
diff --git a/server/src/Core/Providers/Base/BaseAutomator.ts b/server/src/Core/Providers/Base/BaseAutomator.ts
index 6581c5fd..fe708ed4 100644
--- a/server/src/Core/Providers/Base/BaseAutomator.ts
+++ b/server/src/Core/Providers/Base/BaseAutomator.ts
@@ -7,7 +7,8 @@ import { Sleep } from "@/Helpers/Sleep";
 import { xClearInterval, xInterval } from "@/Helpers/Timeout";
 import { isTwitchVOD, isTwitchVODChapter } from "@/Helpers/Types";
 import type { RemuxReturn } from "@/Helpers/Video";
-import { remuxFile } from "@/Helpers/Video";
+import { pausesToIntervals, totalPauseDuration } from "@/Helpers/StreamPauses";
+import { remuxFile, remuxFileWithPadding } from "@/Helpers/Video";
 import type { TwitchVODChapterJSON } from "@/Storage/JSON";
 import type { VideoQuality } from "@common/Config";
 import type { NotificationCategory } from "@common/Defs";
@@ -1957,7 +1958,8 @@ export class BaseAutomator {
                 settings.chatFont,
                 settings.chatFontSize,
                 settings.chatSource == "downloaded",
-                true
+                true,
+                settings.vodSource != "downloaded"
             );
         } catch (error) {
             log(LOGLEVEL.ERROR, "automator.burnChat", (error as Error).message);
@@ -2252,6 +2254,21 @@ export class BaseAutomator {
         return false;
     }
 
+    /**
+     * Save the chapters for embedding in the converted video.
+     * @returns path to the chapters metadata file, if enabled
+     */
+    private async saveChaptersForConvert(): Promise<string | undefined> {
+        if (!this.vod) return undefined;
+        if (
+            Config.getInstance().cfg("create_video_chapters") &&
+            (await this.vod.saveFFMPEGChapters())
+        ) {
+            return this.vod.path_ffmpegchapters;
+        }
+        return undefined;
+    }
+
     private async convertVideo(): Promise<boolean> {
         if (!this.vod) throw new Error("VOD not set");
 
@@ -2259,23 +2276,68 @@ export class BaseAutomator {
             vod: await this.vod.toAPI(),
         } as VodUpdated);
 
-        let mf;
-        if (
-            Config.getInstance().cfg("create_video_chapters") &&
-            (await this.vod.saveFFMPEGChapters())
-        ) {
-            mf = this.vod.path_ffmpegchapters;
-        }
+        let result: RemuxReturn | undefined;
 
-        let result: RemuxReturn;
+        // fill stream pauses (ad breaks) with black video so chat and chapters stay in sync
+        const pauseIntervals =
+            this.vod.started_at &&
+            Config.getInstance().cfg<boolean>("video.pad_stream_pauses", false)
+                ? pausesToIntervals(this.vod.stream_pauses, this.vod.started_at)
+                : [];
 
-        try {
-            result = await remuxFile(
-                this.capture_filename,
-                this.converted_filename,
-                false,
-                mf
+        if (pauseIntervals.length > 0) {
+            log(
+                LOGLEVEL.INFO,
+                "automator.convertVideo",
+                `Filling ${pauseIntervals.length} stream pauses (${Math.round(
+                    totalPauseDuration(pauseIntervals)
+                )}s) of ${this.vod.basename} with black video`
             );
+
+            // chapters in the padded video are at their stream time
+            this.vod.stream_pauses_padded = true;
+            this.vod.calculateChapters();
+
+            try {
+                result = await remuxFileWithPadding(
+                    this.capture_filename,
+                    this.converted_filename,
+                    pauseIntervals,
+                    await this.saveChaptersForConvert()
+                );
+            } catch (err) {
+                log(
+                    LOGLEVEL.ERROR,
+                    "automator.convertVideo",
+                    `Failed to fill stream pauses, converting normally: ${
+                        (err as Error).message
+                    }`,
+                    err
+                );
+                result = undefined;
+            }
+
+            if (!result || !result.success) {
+                this.vod.stream_pauses_padded = false;
+                this.vod.calculateChapters();
+                if (fs.existsSync(this.converted_filename)) {
+                    fs.unlinkSync(this.converted_filename);
+                }
+                result = undefined;
+            }
+
+            await this.vod.saveJSON("stream pauses padded");
+        }
+
+        try {
+            if (!result) {
+                result = await remuxFile(
+                    this.capture_filename,
+                    this.converted_filename,
+                    false,
+                    await this.saveChaptersForConvert()
+                );
+            }
         } catch (err) {
             log(
                 LOGLEVEL.ERROR,
diff --git a/server/src/Core/Providers/Base/BaseVOD.ts b/server/src/Core/Providers/Base/BaseVOD.ts
index e84b7997..fbc3d7d8 100644
--- a/server/src/Core/Providers/Base/BaseVOD.ts
+++ b/server/src/Core/Providers/Base/BaseVOD.ts
@@ -1,6 +1,13 @@
 import { debugLog } from "@/Helpers/Console";
 import { exec, isExecError, startJob } from "@/Helpers/Execute";
 import { formatBytes } from "@/Helpers/Format";
+import type { PauseInterval } from "@/Helpers/StreamPauses";
+import {
+    pausesToIntervals,
+    streamTimeToVideoTime,
+    syncChatDumpToVideo,
+    totalPauseDuration,
+} from "@/Helpers/StreamPauses";
 import { xClearTimeout, xTimeout } from "@/Helpers/Timeout";
 import { isTwitchVOD, isTwitchVODChapter } from "@/Helpers/Types";
 import {
@@ -11,6 +18,7 @@ import {
 } from "@/Helpers/Video";
 import type { BaseVODChapterJSON, VODJSON } from "@/Storage/JSON";
 import type { ApiBaseVod } from "@common/Api/Client";
+import type { TwitchCommentDumpTD } from "@common/Comments";
 import type { VODBookmark } from "@common/Bookmark";
 import type { VideoQuality } from "@common/Config";
 import type { Providers } from "@common/Defs";
@@ -124,6 +132,8 @@ export class BaseVOD {
     public path_chatmask = "";
     public path_chatburn = "";
     public path_chatdump = "";
+    /** Chat dump with offsets mapped to the captured video, see {@link syncChatdumpToVideo} */
+    public path_chatdump_synced = "";
     // path_adbreak = "";
     public path_playlist = "";
     public path_ffmpegchapters = "";
@@ -157,6 +167,12 @@ export class BaseVOD {
 
     public stream_pauses: StreamPause[] = [];
 
+    /**
+     * The stream pauses were filled with black video during conversion,
+     * so the captured video already matches the stream time.
+     */
+    public stream_pauses_padded = false;
+
     public bookmarks: Array<VODBookmark> = [];
 
     public is_capture_paused = false; // no longer a file, just a flag
@@ -195,6 +211,9 @@ export class BaseVOD {
             /** Live chat dump */
             `${this.basename}.chatdump`,
 
+            /** Live chat dump synced to the captured video */
+            `${this.basename}.synced.chatdump`,
+
             /** in-progress chat dump */
             `${this.basename}.chatdump.txt`,
 
@@ -253,6 +272,112 @@ export class BaseVOD {
         return this.path_chatdump !== "" && fs.existsSync(this.path_chatdump);
     }
 
+    /**
+     * Stream pauses (ad breaks) that were cut out of the captured video,
+     * as intervals in seconds since the stream started.
+     *
+     * Empty if there were no pauses or they were padded during conversion,
+     * meaning chat and chapter times already match the captured video.
+     */
+    public get pauseIntervals(): PauseInterval[] {
+        if (this.stream_pauses_padded || !this.started_at) return [];
+        return pausesToIntervals(this.stream_pauses, this.started_at);
+    }
+
+    /**
+     * Chat and chapter times need to be mapped to the captured video.
+     */
+    public get needs_video_sync(): boolean {
+        return this.pauseIntervals.length > 0;
+    }
+
+    /**
+     * Map seconds since the stream started to seconds in the captured video.
+     */
+    public streamTimeToVideoTime(seconds: number): number {
+        return streamTimeToVideoTime(seconds, this.pauseIntervals);
+    }
+
+    /**
+     * Write a copy of the chat dump with offsets mapped to the captured video.
+     * Does nothing if no sync is needed or the synced file is up to date, unless forced.
+     * @returns path to the synced chat dump, or false if no sync is needed or possible
+     */
+    public async syncChatdumpToVideo(force = false): Promise<string | false> {
+        if (!this.is_chatdump_captured || !this.path_chatdump_synced) {
+            return false;
+        }
+
+        const intervals = this.pauseIntervals;
+
+        if (intervals.length == 0) {
+            // remove a synced file left over from before the vod was padded
+            if (fs.existsSync(this.path_chatdump_synced)) {
+                fs.unlinkSync(this.path_chatdump_synced);
+            }
+            return false;
+        }
+
+        if (
+            !force &&
+            fs.existsSync(this.path_chatdump_synced) &&
+            fs.statSync(this.path_chatdump_synced).mtimeMs >=
+                fs.statSync(this.path_chatdump).mtimeMs
+        ) {
+            return this.path_chatdump_synced;
+        }
+
+        log(
+            LOGLEVEL.INFO,
+            "vod.syncChatdumpToVideo",
+            `Syncing chat dump of ${this.basename} to video, removing ${
+                intervals.length
+            } stream pauses (${Math.round(totalPauseDuration(intervals))}s)`
+        );
+
+        const dump: TwitchCommentDumpTD = JSON.parse(
+            await fs.promises.readFile(this.path_chatdump, "utf8")
+        );
+
+        if (!dump || !Array.isArray(dump.comments)) {
+            log(
+                LOGLEVEL.ERROR,
+                "vod.syncChatdumpToVideo",
+                `Chat dump of ${this.basename} has no comments array`
+            );
+            return false;
+        }
+
+        const synced = syncChatDumpToVideo(dump, intervals);
+
+        // write to a temp file first so a half-written file is never served
+        const tempPath = `${this.path_chatdump_synced}.tmp`;
+        await fs.promises.writeFile(tempPath, JSON.stringify(synced));
+        await fs.promises.rename(tempPath, this.path_chatdump_synced);
+
+        return this.path_chatdump_synced;
+    }
+
+    /**
+     * The chat dump to use together with the captured video,
+     * synced to the video if needed.
+     */
+    public async getChatdumpForVideo(): Promise<string> {
+        try {
+            const synced = await this.syncChatdumpToVideo();
+            if (synced) return synced;
+        } catch (error) {
+            log(
+                LOGLEVEL.ERROR,
+                "vod.getChatdumpForVideo",
+                `Failed to sync chat dump of ${
+                    this.basename
+                } to video, using the original: ${(error as Error).message}`
+            );
+        }
+        return this.path_chatdump;
+    }
+
     public get is_chat_rendered(): boolean {
         return (
             this.path_chatrender !== "" && fs.existsSync(this.path_chatrender)
@@ -626,6 +751,8 @@ export class BaseVOD {
                     end: v.end.toISOString(),
                 };
             }),
+            stream_pauses_padded: this.stream_pauses_padded,
+            needs_video_sync: this.needs_video_sync,
 
             api_getDuration: await this.getDuration(true),
             api_getRecordingSize: this.getRecordingSize(),
@@ -696,6 +823,7 @@ export class BaseVOD {
                 ? [{ start: pause.start.toJSON(), end: pause.end.toJSON() }]
                 : [];
         });
+        generated.stream_pauses_padded = this.stream_pauses_padded;
 
         generated.external_vod_exists = this.external_vod_exists;
         generated.external_vod_id = this.external_vod_id;
@@ -836,7 +964,9 @@ export class BaseVOD {
         font: string,
         font_size: number,
         use_downloaded: boolean,
-        overwrite: boolean
+        overwrite: boolean,
+        /** Sync the captured chat to the captured video, disable when burning onto the downloaded vod */
+        sync_to_video = true
     ): Promise<boolean> {
         if (use_downloaded && !this.is_chat_downloaded) {
             console.error(chalk.redBright("No chat downloaded"));
@@ -892,10 +1022,14 @@ export class BaseVOD {
         args.push("chatrender");
         args.push("--temp-path", BaseConfigCacheFolder.cache);
         args.push("--ffmpeg-path", ffmpegBin);
-        args.push(
-            "--input",
-            path.normalize(use_downloaded ? this.path_chat : this.path_chatdump)
-        );
+        let chatInput = this.path_chat;
+        if (!use_downloaded) {
+            chatInput = sync_to_video
+                ? await this.getChatdumpForVideo()
+                : this.path_chatdump;
+        }
+
+        args.push("--input", path.normalize(chatInput));
         args.push(
             "--chat-height",
             (chat_height ? chat_height : this.video_metadata.height).toString()
@@ -1465,6 +1599,8 @@ export class BaseVOD {
 
         // console.debug(`Calculating chapters for ${this.basename}, ${this.chapters.length} chapters`);
 
+        const pauseIntervals = this.pauseIntervals;
+
         this.chapters.forEach((chapter, index) => {
             if (!this.started_at) return; // thanks scoping
 
@@ -1475,7 +1611,8 @@ export class BaseVOD {
             chapter.calculateDurationAndOffset(
                 this.started_at,
                 this.ended_at,
-                nextChapter ? nextChapter.started_at : undefined
+                nextChapter ? nextChapter.started_at : undefined,
+                pauseIntervals
             );
         });
 
@@ -1518,8 +1655,9 @@ export class BaseVOD {
         const titleConfig = Config.getInstance().cfg("video.chapters.title");
 
         this.chapters.forEach((chapter) => {
-            const offset = chapter.offset || 0;
-            const duration = chapter.duration || 0;
+            // position in the captured video, corrected for stream pauses
+            const offset = chapter.video_offset ?? chapter.offset ?? 0;
+            const duration = chapter.video_duration ?? chapter.duration ?? 0;
             const start = Math.floor(offset * 1000);
             const end = Math.floor((offset + duration) * 1000);
             // const title = isTwitchVODChapter(chapter)
@@ -1855,6 +1993,9 @@ export class BaseVOD {
         this.path_chatdump = this.realpath(
             path.join(this.directory, `${this.basename}.chatdump`)
         );
+        this.path_chatdump_synced = this.realpath(
+            path.join(this.directory, `${this.basename}.synced.chatdump`)
+        );
         // this.path_adbreak = this.realpath(path.join(this.directory, `${this.basename}.adbreak`));
         this.path_playlist = this.realpath(
             path.join(this.directory, `${this.basename}.m3u8`)
@@ -1924,16 +2065,21 @@ export class BaseVOD {
         let data = "";
 
         this.chapters.forEach((chapter, i) => {
-            let offset = chapter.offset;
+            // position in the captured video, corrected for stream pauses
+            let offset = chapter.video_offset ?? chapter.offset;
             if (offset === undefined) return;
 
-            offset -= this.chapters[0].offset || 0;
+            offset -=
+                this.chapters[0].video_offset ?? this.chapters[0].offset ?? 0;
 
             data += offset + ","; // offset
 
             if (i < this.chapters.length - 1) {
                 // not last chapter
-                data += offset + (chapter.duration || 0) + ",";
+                data +=
+                    offset +
+                    (chapter.video_duration ?? chapter.duration ?? 0) +
+                    ",";
             } else {
                 // last chapter
                 data += ",";
@@ -2307,6 +2453,8 @@ export class BaseVOD {
                 });
         }
 
+        this.stream_pauses_padded = this.json.stream_pauses_padded ?? false;
+
         this.external_vod_id = this.json.external_vod_id;
         this.external_vod_title = this.json.external_vod_title;
         this.external_vod_date = this.json.external_vod_date
diff --git a/server/src/Core/Providers/Base/BaseVODChapter.ts b/server/src/Core/Providers/Base/BaseVODChapter.ts
index 2cdc226e..0b877767 100644
--- a/server/src/Core/Providers/Base/BaseVODChapter.ts
+++ b/server/src/Core/Providers/Base/BaseVODChapter.ts
@@ -1,6 +1,8 @@
 import type { VODTypes } from "@/Core/LiveStreamDVR";
 import { LiveStreamDVR } from "@/Core/LiveStreamDVR";
 import { LOGLEVEL, log } from "@/Core/Log";
+import type { PauseInterval } from "@/Helpers/StreamPauses";
+import { streamTimeToVideoTime } from "@/Helpers/StreamPauses";
 import type { BaseVODChapterJSON } from "@/Storage/JSON";
 import type { ApiVodBaseChapter } from "@common/Api/Client";
 import type { Providers } from "@common/Defs";
@@ -13,9 +15,15 @@ export class BaseVODChapter {
      */
     public started_at!: Date;
 
+    /** Seconds since the stream started */
     public offset?: number;
     public duration?: number;
 
+    /** Position in the captured video, corrected for stream pauses (ad breaks) */
+    public video_offset?: number;
+    /** Duration in the captured video, corrected for stream pauses (ad breaks) */
+    public video_duration?: number;
+
     public title = "";
 
     /**
@@ -28,7 +36,8 @@ export class BaseVODChapter {
     public calculateDurationAndOffset(
         vod_started_at: Date,
         vod_ended_at: Date | undefined,
-        next_chapter_started_at: Date | undefined
+        next_chapter_started_at: Date | undefined,
+        pause_intervals: PauseInterval[] = []
     ): void {
         if (vod_started_at.getTime() > this.started_at.getTime()) {
             // this chapter started before the vod started
@@ -76,6 +85,20 @@ export class BaseVODChapter {
                 (this.started_at.getTime() - vod_started_at.getTime()) / 1000;
         }
 
+        if (this.offset !== undefined) {
+            this.video_offset = streamTimeToVideoTime(
+                this.offset,
+                pause_intervals
+            );
+            this.video_duration =
+                this.duration !== undefined
+                    ? streamTimeToVideoTime(
+                          this.offset + this.duration,
+                          pause_intervals
+                      ) - this.video_offset
+                    : undefined;
+        }
+
         // console.debug(`Calculated duration and offset for chapter: ${this.title}`, this.offset, this.duration);
     }
 
@@ -91,6 +114,8 @@ export class BaseVODChapter {
 
             offset: this.offset || 0,
             duration: this.duration || 0,
+            video_offset: this.video_offset ?? this.offset ?? 0,
+            video_duration: this.video_duration ?? this.duration ?? 0,
 
             started_at: this.started_at.toISOString(),
 
diff --git a/server/src/Core/Providers/Twitch/TwitchVOD.ts b/server/src/Core/Providers/Twitch/TwitchVOD.ts
index d8ea6a82..b4f6f08d 100644
--- a/server/src/Core/Providers/Twitch/TwitchVOD.ts
+++ b/server/src/Core/Providers/Twitch/TwitchVOD.ts
@@ -2011,10 +2011,14 @@ export class TwitchVOD extends BaseVOD {
                 );
             }
 
+            // position in the captured video, corrected for stream pauses
+            const videoOffset = chapter.video_offset ?? chapter.offset;
+            const videoDuration = chapter.video_duration ?? chapter.duration;
+
             if (
-                chapter.offset < 0 ||
-                chapter.duration < 0 ||
-                chapter.offset > this.duration
+                videoOffset < 0 ||
+                videoDuration < 0 ||
+                videoOffset > this.duration
             ) {
                 log(
                     LOGLEVEL.ERROR,
@@ -2027,7 +2031,7 @@ export class TwitchVOD extends BaseVOD {
             }
 
             if (
-                chapter.offset + chapter.duration > this.duration &&
+                videoOffset + videoDuration > this.duration &&
                 chapterIndex != this.chapters.length
             ) {
                 log(
@@ -2040,8 +2044,8 @@ export class TwitchVOD extends BaseVOD {
                 );
             }
 
-            const chapterStart = chapter.offset || 0;
-            const chapterEnd = chapter.offset + chapter.duration;
+            const chapterStart = videoOffset || 0;
+            const chapterEnd = videoOffset + videoDuration;
 
             let basepath = this.directory;
 
@@ -2364,8 +2368,9 @@ export class TwitchVOD extends BaseVOD {
         let data = `WEBVTT - Generated by ${AppName}\n\n`;
 
         this.chapters.forEach((chapter, i) => {
-            const offset = chapter.offset || 0;
-            const duration = chapter.duration || 0;
+            // position in the captured video, corrected for stream pauses
+            const offset = chapter.video_offset ?? chapter.offset ?? 0;
+            const duration = chapter.video_duration ?? chapter.duration ?? 0;
 
             const start = offset;
             const end = offset + duration;
diff --git a/server/src/Core/Providers/Twitch/TwitchVODChapter.ts b/server/src/Core/Providers/Twitch/TwitchVODChapter.ts
index 0e51cab3..0de26612 100644
--- a/server/src/Core/Providers/Twitch/TwitchVODChapter.ts
+++ b/server/src/Core/Providers/Twitch/TwitchVODChapter.ts
@@ -93,6 +93,8 @@ export class TwitchVODChapter extends BaseVODChapter {
 
             offset: this.offset || 0,
             duration: this.duration || 0,
+            video_offset: this.video_offset ?? this.offset ?? 0,
+            video_duration: this.video_duration ?? this.duration ?? 0,
 
             started_at: this.started_at.toISOString(),
 
diff --git a/server/src/Helpers/PadVideo.test.ts b/server/src/Helpers/PadVideo.test.ts
new file mode 100644
index 00000000..e9af99f3
--- /dev/null
+++ b/server/src/Helpers/PadVideo.test.ts
@@ -0,0 +1,211 @@
+import type { PacketScan } from "./PadVideo";
+import {
+    PacketScanner,
+    buildConcatList,
+    fillerUnitFrames,
+    planPadding,
+} from "./PadVideo";
+
+const fps = 60;
+const fd = 1 / fps;
+
+/**
+ * Scan of a capture starting at 1.4s with a keyframe every 2 seconds,
+ * with the given seconds of capture time removed (timestamp gaps), like streamlink does with ads.
+ */
+function makeScan(
+    length: number,
+    gaps: { at: number; length: number }[]
+): PacketScan {
+    const scanner = new PacketScanner(fd);
+    let shift = 0;
+    const sortedGaps = [...gaps].sort((a, b) => a.at - b.at);
+    for (let frame = 0; frame < length * fps; frame++) {
+        const t = frame / fps;
+        const gap = sortedGaps.find((g) => Math.abs(g.at - t) < fd / 2);
+        if (gap) shift += gap.length;
+        const dts = 1.4 + t + shift;
+        const keyframe = frame % (2 * fps) == 0;
+        scanner.addLine(
+            `${(dts + 2 * fd).toFixed(6)},${dts.toFixed(6)},${
+                keyframe ? "K__" : "___"
+            }`
+        );
+    }
+    const scan = scanner.result();
+    if (!scan) throw new Error("no scan");
+    return scan;
+}
+
+describe("PacketScanner", () => {
+    it("finds timestamp gaps and keyframes", () => {
+        const scan = makeScan(60, [{ at: 20, length: 16 }]);
+        expect(scan.start).toBeCloseTo(1.4 + 2 * fd);
+        expect(scan.gaps).toHaveLength(1);
+        expect(scan.gaps[0].length).toBeCloseTo(16);
+        expect(scan.keyframes).toHaveLength(30);
+    });
+
+    it("estimates the frame duration if not given", () => {
+        const scanner = new PacketScanner();
+        for (let i = 0; i < 100; i++)
+            scanner.addLine(`${i / 30},${i / 30},___`);
+        const scan = scanner.result();
+        expect(scan && scan.frameDuration).toBeCloseTo(1 / 30);
+    });
+
+    it("ignores invalid lines", () => {
+        const scanner = new PacketScanner(fd);
+        scanner.addLine("N/A,N/A,K__");
+        scanner.addLine("");
+        expect(scanner.result()).toBe(false);
+    });
+});
+
+describe("planPadding", () => {
+    it("places filler exactly at matching timestamp gaps", () => {
+        const scan = makeScan(54, [
+            { at: 20, length: 16 },
+            { at: 44, length: 20 },
+        ]);
+        // pauses as recorded by streamlink logs, a bit off
+        const plan = planPadding(scan, [
+            { start: 20.4, end: 36.3 },
+            { start: 60.3, end: 80.5 },
+        ]);
+        expect(plan.matchedPauses).toBe(2);
+        expect(plan.estimatedPauses).toBe(0);
+        expect(plan.collapsedGaps).toBe(0);
+        expect(plan.totalFiller).toBeCloseTo(36);
+        expect(plan.parts.map((p) => p.type)).toEqual([
+            "source",
+            "filler",
+            "source",
+            "filler",
+            "source",
+        ]);
+
+        const [first, , second, , third] = plan.parts;
+        expect(first.type == "source" && first.inpoint).toBe(undefined);
+        expect(first.type == "source" && first.outpoint).toBeCloseTo(1.4 + 20);
+        // continues at the keyframe dts after the gap
+        expect(second.type == "source" && second.inpoint).toBeCloseTo(1.4 + 36);
+        expect(third.type == "source" && third.inpoint).toBeCloseTo(
+            1.4 + 44 + 36
+        );
+    });
+
+    it("estimates the position when there are no timestamp gaps", () => {
+        const scan = makeScan(54, []);
+        const plan = planPadding(scan, [
+            { start: 20.4, end: 36.3 },
+            { start: 60.3, end: 80.5 },
+        ]);
+        expect(plan.matchedPauses).toBe(0);
+        expect(plan.estimatedPauses).toBe(2);
+        expect(plan.totalFiller).toBeCloseTo(15.9 + 20.2);
+        const sources = plan.parts.filter((p) => p.type == "source");
+        // snapped to the nearest keyframes, at 20s and 44s of the collapsed video
+        expect(sources[0].type == "source" && sources[0].outpoint).toBeCloseTo(
+            1.4 + 20
+        );
+        expect(sources[1].type == "source" && sources[1].inpoint).toBeCloseTo(
+            1.4 + 20
+        );
+        expect(sources[1].type == "source" && sources[1].outpoint).toBeCloseTo(
+            1.4 + 44
+        );
+    });
+
+    it("collapses gaps without a matching pause like a normal conversion", () => {
+        const scan = makeScan(54, [{ at: 30, length: 12 }]);
+        const plan = planPadding(scan, []);
+        expect(plan.collapsedGaps).toBe(1);
+        expect(plan.totalFiller).toBe(0);
+        expect(plan.parts.map((p) => p.type)).toEqual(["source", "source"]);
+    });
+
+    it("does not match a gap of a very different length", () => {
+        const scan = makeScan(54, [{ at: 20, length: 60 }]);
+        const plan = planPadding(scan, [{ start: 20, end: 36 }]);
+        expect(plan.matchedPauses).toBe(0);
+        expect(plan.estimatedPauses).toBe(1);
+        expect(plan.collapsedGaps).toBe(1);
+    });
+
+    it("puts filler for a pause at the start before the first frame", () => {
+        const scan = makeScan(30, []);
+        const plan = planPadding(scan, [{ start: 0, end: 15 }]);
+        expect(plan.parts[0]).toEqual({ type: "filler", duration: 15 });
+        expect(plan.parts[1]).toEqual({ type: "source", inpoint: undefined });
+    });
+
+    it("merges pauses that snap to the same keyframe", () => {
+        const scan = makeScan(30, []);
+        const plan = planPadding(scan, [
+            { start: 10, end: 11 },
+            { start: 11.2, end: 12 },
+        ]);
+        expect(plan.parts.filter((p) => p.type == "filler")).toHaveLength(1);
+        expect(plan.totalFiller).toBeCloseTo(1.8);
+    });
+});
+
+describe("fillerUnitFrames", () => {
+    it("is a whole number of video and aac frames", () => {
+        for (const [rate, sampleRate] of [
+            [60, 48000],
+            [30, 48000],
+            [30000 / 1001, 48000],
+            [60, 44100],
+        ]) {
+            const frames = fillerUnitFrames(rate, sampleRate);
+            const seconds = frames / rate;
+            const aacFrames = (seconds * sampleRate) / 1024;
+            expect(Math.abs(aacFrames - Math.round(aacFrames))).toBeLessThan(
+                1e-6
+            );
+            expect(seconds).toBeGreaterThanOrEqual(4);
+        }
+    });
+});
+
+describe("buildConcatList", () => {
+    it("repeats the filler unit and trims the last one", () => {
+        const list = buildConcatList(
+            {
+                parts: [
+                    { type: "source", outpoint: 21.4 },
+                    { type: "filler", duration: 10 },
+                    { type: "source", inpoint: 37.4 },
+                ],
+                matchedPauses: 1,
+                estimatedPauses: 0,
+                collapsedGaps: 0,
+                totalFiller: 10,
+                messages: [],
+            },
+            "/data/it's.ts",
+            "/cache/filler.ts",
+            1.4,
+            4
+        );
+        expect(list).toBe(
+            [
+                "ffconcat version 1.0",
+                "file '/data/it'\\''s.ts'",
+                "outpoint 21.400000",
+                "file '/cache/filler.ts'",
+                "duration 4.000000",
+                "file '/cache/filler.ts'",
+                "duration 4.000000",
+                "file '/cache/filler.ts'",
+                "outpoint 3.400000",
+                "duration 2.000000",
+                "file '/data/it'\\''s.ts'",
+                "inpoint 37.400000",
+                "",
+            ].join("\n")
+        );
+    });
+});
diff --git a/server/src/Helpers/PadVideo.ts b/server/src/Helpers/PadVideo.ts
new file mode 100644
index 00000000..ac0d017f
--- /dev/null
+++ b/server/src/Helpers/PadVideo.ts
@@ -0,0 +1,421 @@
+import type { PauseInterval } from "./StreamPauses";
+import { streamTimeToVideoTime } from "./StreamPauses";
+
+/**
+ * Filling stream pauses (ad breaks) with black video when converting a capture.
+ *
+ * Streamlink drops the ad segments, so the captured video is shorter than the stream
+ * and everything timed against the stream (chat, chapters) drifts after every ad break.
+ * Here the capture is cut at each pause and a black, silent filler of the pause length
+ * is inserted, using only stream copy for the capture itself.
+ *
+ * The cut points are taken from timestamp jumps in the capture when they match a recorded
+ * pause, otherwise they are estimated from the recorded pause times and snapped to a keyframe.
+ */
+
+/** Timestamp jumps shorter than this are not considered gaps */
+export const GAP_MIN_SECONDS = 5;
+
+/** How far (in seconds) a timestamp gap may be from the expected pause position to match it */
+export const GAP_MATCH_POSITION_TOLERANCE = 60;
+
+export interface Keyframe {
+    pts: number;
+    dts: number;
+}
+
+export interface TimestampGap {
+    /** dts of the last video packet before the gap */
+    before: number;
+    /** dts of the first video packet after the gap */
+    after: number;
+    /** missing time in seconds */
+    length: number;
+}
+
+/** Result of scanning the video packets of a capture */
+export interface PacketScan {
+    /** pts of the first video packet */
+    start: number;
+    /** dts of the last video packet */
+    end: number;
+    frameDuration: number;
+    /** sorted by pts */
+    keyframes: Keyframe[];
+    /** sorted by position */
+    gaps: TimestampGap[];
+}
+
+export type PadPart =
+    | {
+          type: "source";
+          /**
+           * timestamp in the capture to start at, the dts of a keyframe.
+           * using the pts makes the concat demuxer start after the keyframe and break decoding
+           */
+          inpoint?: number;
+          /** dts in the capture to stop at */
+          outpoint?: number;
+      }
+    | {
+          type: "filler";
+          duration: number;
+      };
+
+export interface PadPlan {
+    parts: PadPart[];
+    /** pauses placed exactly at a timestamp gap */
+    matchedPauses: number;
+    /** pauses placed at an estimated position */
+    estimatedPauses: number;
+    /** timestamp gaps without a matching pause, collapsed like a normal conversion */
+    collapsedGaps: number;
+    totalFiller: number;
+    messages: string[];
+}
+
+interface Cut {
+    /** sort key, position in the capture */
+    position: number;
+    /** dts to stop the previous source part at, undefined to insert before the first frame */
+    outpoint?: number;
+    /** keyframe dts to continue at, undefined if the capture ends here */
+    inpoint?: number;
+    filler: number;
+}
+
+/**
+ * Scan ffprobe packet output lines (`pts_time,dts_time,flags`) of a video stream.
+ */
+export class PacketScanner {
+    private start?: number;
+    private lastDts?: number;
+    private keyframes: Keyframe[] = [];
+    private gaps: { before: number; after: number }[] = [];
+    private deltas: number[] = [];
+
+    public constructor(private frameDuration?: number) {}
+
+    public addLine(line: string): void {
+        const [ptsText, dtsText, flags] = line.trim().split(",");
+        const pts = parseFloat(ptsText);
+        const dts = parseFloat(dtsText);
+        if (isNaN(dts)) return;
+
+        if (this.start === undefined && !isNaN(pts)) this.start = pts;
+
+        if (flags && flags.includes("K") && !isNaN(pts)) {
+            this.keyframes.push({ pts, dts });
+        }
+
+        if (this.lastDts !== undefined) {
+            const delta = dts - this.lastDts;
+            if (delta >= GAP_MIN_SECONDS) {
+                this.gaps.push({ before: this.lastDts, after: dts });
+            } else if (this.deltas.length < 500 && delta > 0) {
+                this.deltas.push(delta);
+            }
+        }
+
+        this.lastDts = dts;
+    }
+
+    public result(): PacketScan | false {
+        if (this.start === undefined || this.lastDts === undefined) {
+            return false;
+        }
+
+        let frameDuration = this.frameDuration;
+        if (!frameDuration) {
+            if (this.deltas.length == 0) return false;
+            const sorted = [...this.deltas].sort((a, b) => a - b);
+            frameDuration = sorted[Math.floor(sorted.length / 2)];
+        }
+
+        return {
+            start: this.start,
+            end: this.lastDts,
+            frameDuration,
+            keyframes: [...this.keyframes].sort((a, b) => a.pts - b.pts),
+            gaps: this.gaps.map((g) => ({
+                ...g,
+                length: g.after - g.before - (frameDuration as number),
+            })),
+        };
+    }
+}
+
+function firstKeyframeAtOrAfter(
+    keyframes: Keyframe[],
+    time: number
+): Keyframe | undefined {
+    return keyframes.find((k) => k.pts >= time - 0.001);
+}
+
+function nearestKeyframe(
+    keyframes: Keyframe[],
+    time: number
+): Keyframe | undefined {
+    let best: Keyframe | undefined;
+    for (const k of keyframes) {
+        if (!best || Math.abs(k.pts - time) < Math.abs(best.pts - time)) {
+            best = k;
+        }
+    }
+    return best;
+}
+
+/**
+ * Plan where to cut the capture and how much filler to insert.
+ *
+ * @param scan video packet scan of the capture
+ * @param intervals stream pauses in seconds since the stream started
+ */
+export function planPadding(
+    scan: PacketScan,
+    intervals: PauseInterval[]
+): PadPlan {
+    const messages: string[] = [];
+
+    // position of each gap in the collapsed timeline (all gaps removed), like a normal conversion
+    let removedBefore = 0;
+    const gaps = scan.gaps.map((gap) => {
+        const collapsed =
+            gap.before + scan.frameDuration - scan.start - removedBefore;
+        removedBefore += gap.length;
+        return { ...gap, collapsed, matched: false };
+    });
+
+    const cuts: Cut[] = [];
+    let matchedPauses = 0;
+    let estimatedPauses = 0;
+
+    for (const pause of intervals) {
+        const duration = pause.end - pause.start;
+        // where the pause is in the collapsed video, assuming the video starts when the stream started
+        const expected = streamTimeToVideoTime(pause.start, intervals);
+
+        let match: (typeof gaps)[number] | undefined;
+        for (const gap of gaps) {
+            if (gap.matched) continue;
+            if (
+                Math.abs(gap.collapsed - expected) >
+                GAP_MATCH_POSITION_TOLERANCE
+            )
+                continue;
+            if (Math.abs(gap.length - duration) > Math.max(10, duration * 0.25))
+                continue;
+            if (
+                !match ||
+                Math.abs(gap.collapsed - expected) <
+                    Math.abs(match.collapsed - expected)
+            ) {
+                match = gap;
+            }
+        }
+
+        if (match) {
+            match.matched = true;
+            matchedPauses++;
+            const resume = firstKeyframeAtOrAfter(scan.keyframes, match.after);
+            cuts.push({
+                position: match.before,
+                outpoint: match.before + scan.frameDuration,
+                inpoint: resume?.dts,
+                filler: match.length,
+            });
+            messages.push(
+                `Pause at ${expected.toFixed(1)}s (${duration.toFixed(
+                    1
+                )}s) matched timestamp gap at ${match.collapsed.toFixed(
+                    1
+                )}s (${match.length.toFixed(1)}s)`
+            );
+            continue;
+        }
+
+        // no gap, estimate the position in the capture and snap it to a keyframe
+        estimatedPauses++;
+        const gapsBefore = gaps
+            .filter((g) => g.collapsed <= expected)
+            .reduce((acc, g) => acc + g.length, 0);
+        const target = scan.start + expected + gapsBefore;
+
+        if (target <= scan.start + scan.frameDuration) {
+            cuts.push({ position: scan.start, filler: duration });
+        } else if (target >= scan.end) {
+            cuts.push({
+                position: scan.end,
+                outpoint: scan.end + scan.frameDuration,
+                filler: duration,
+            });
+        } else {
+            const keyframe = nearestKeyframe(scan.keyframes, target);
+            if (!keyframe || keyframe.pts <= scan.start) {
+                cuts.push({ position: scan.start, filler: duration });
+            } else {
+                cuts.push({
+                    position: keyframe.pts,
+                    outpoint: keyframe.dts,
+                    inpoint: keyframe.dts,
+                    filler: duration,
+                });
+            }
+        }
+        messages.push(
+            `Pause at ${expected.toFixed(1)}s (${duration.toFixed(
+                1
+            )}s) has no timestamp gap, placed at the nearest keyframe`
+        );
+    }
+
+    // gaps without a pause (e.g. network issues) are collapsed, like a normal conversion
+    let collapsedGaps = 0;
+    for (const gap of gaps) {
+        if (gap.matched) continue;
+        collapsedGaps++;
+        const resume = firstKeyframeAtOrAfter(scan.keyframes, gap.after);
+        cuts.push({
+            position: gap.before,
+            outpoint: gap.before + scan.frameDuration,
+            inpoint: resume?.dts,
+            filler: 0,
+        });
+        messages.push(
+            `Timestamp gap at ${gap.collapsed.toFixed(
+                1
+            )}s (${gap.length.toFixed(1)}s) has no matching pause, collapsed`
+        );
+    }
+
+    cuts.sort((a, b) => a.position - b.position);
+
+    const parts: PadPart[] = [];
+    let inpoint: number | undefined = undefined;
+    let ended = false;
+
+    for (const cut of cuts) {
+        if (ended) {
+            // capture already ended, only filler can follow
+            if (cut.filler > 0)
+                parts.push({ type: "filler", duration: cut.filler });
+            continue;
+        }
+
+        if (cut.outpoint !== undefined) {
+            if (inpoint === undefined || cut.outpoint > inpoint) {
+                parts.push({ type: "source", inpoint, outpoint: cut.outpoint });
+            }
+        }
+
+        if (cut.filler > 0) {
+            parts.push({ type: "filler", duration: cut.filler });
+        }
+
+        if (cut.outpoint === undefined) {
+            // filler before the first frame, the capture continues from where it was
+            continue;
+        }
+
+        if (cut.inpoint === undefined) {
+            ended = true;
+        } else {
+            inpoint = cut.inpoint;
+        }
+    }
+
+    if (!ended) {
+        parts.push({ type: "source", inpoint });
+    }
+
+    // merge adjacent fillers
+    const merged: PadPart[] = [];
+    for (const part of parts) {
+        const last = merged[merged.length - 1];
+        if (part.type == "filler" && last && last.type == "filler") {
+            last.duration += part.duration;
+        } else {
+            merged.push({ ...part });
+        }
+    }
+
+    const totalFiller = merged.reduce(
+        (acc, p) => acc + (p.type == "filler" ? p.duration : 0),
+        0
+    );
+
+    return {
+        parts: merged,
+        matchedPauses,
+        estimatedPauses,
+        collapsedGaps,
+        totalFiller,
+        messages,
+    };
+}
+
+/**
+ * Number of video frames in one filler unit, chosen so that the unit is a whole number
+ * of both video frames and AAC frames (1024 samples), so repeated units don't drift.
+ */
+export function fillerUnitFrames(
+    fps: number,
+    sampleRate: number,
+    minSeconds = 4
+): number {
+    let base = Math.max(1, Math.round(fps));
+    for (let n = 1; n <= 1024; n++) {
+        const aacFrames = (n / fps) * (sampleRate / 1024);
+        if (Math.abs(aacFrames - Math.round(aacFrames)) < 1e-6) {
+            base = n;
+            break;
+        }
+    }
+    const baseSeconds = base / fps;
+    return base * Math.max(1, Math.ceil(minSeconds / baseSeconds));
+}
+
+function escapeConcatPath(file: string): string {
+    return `'${file.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * Write an ffconcat list for the plan.
+ *
+ * @param source capture file
+ * @param filler filler unit file
+ * @param fillerStart start_time of the filler file
+ * @param fillerUnit duration of the filler unit
+ */
+export function buildConcatList(
+    plan: PadPlan,
+    source: string,
+    filler: string,
+    fillerStart: number,
+    fillerUnit: number
+): string {
+    const lines = ["ffconcat version 1.0"];
+
+    for (const part of plan.parts) {
+        if (part.type == "source") {
+            lines.push(`file ${escapeConcatPath(source)}`);
+            if (part.inpoint !== undefined)
+                lines.push(`inpoint ${part.inpoint.toFixed(6)}`);
+            if (part.outpoint !== undefined)
+                lines.push(`outpoint ${part.outpoint.toFixed(6)}`);
+        } else {
+            let remaining = part.duration;
+            while (remaining > 0.001) {
+                const length = Math.min(fillerUnit, remaining);
+                lines.push(`file ${escapeConcatPath(filler)}`);
+                if (length < fillerUnit - 0.001) {
+                    lines.push(`outpoint ${(fillerStart + length).toFixed(6)}`);
+                }
+                lines.push(`duration ${length.toFixed(6)}`);
+                remaining -= length;
+            }
+        }
+    }
+
+    return lines.join("\n") + "\n";
+}
diff --git a/server/src/Helpers/StreamPauses.test.ts b/server/src/Helpers/StreamPauses.test.ts
new file mode 100644
index 00000000..f6b45253
--- /dev/null
+++ b/server/src/Helpers/StreamPauses.test.ts
@@ -0,0 +1,187 @@
+import type { TwitchComment, TwitchCommentDumpTD } from "@common/Comments";
+import {
+    pausesToIntervals,
+    streamTimeToVideoTime,
+    syncChatDumpToVideo,
+    totalPauseDuration,
+} from "./StreamPauses";
+
+// capture 43333681128, a real stream with 8 ad breaks
+const started_at = new Date("2024-12-08T13:47:21.000Z");
+const pauses = [
+    ["2024-12-08T13:47:37.022Z", "2024-12-08T13:47:52.090Z"],
+    ["2024-12-08T14:49:27.406Z", "2024-12-08T14:51:02.077Z"],
+    ["2024-12-08T15:47:47.205Z", "2024-12-08T15:49:52.073Z"],
+    ["2024-12-08T16:09:47.309Z", "2024-12-08T16:11:52.038Z"],
+    ["2024-12-08T16:34:52.405Z", "2024-12-08T16:35:57.090Z"],
+    ["2024-12-08T16:48:49.121Z", "2024-12-08T16:50:52.053Z"],
+    ["2024-12-08T16:57:29.045Z", "2024-12-08T16:58:32.088Z"],
+    ["2024-12-08T17:22:07.156Z", "2024-12-08T17:24:12.100Z"],
+].map(([start, end]) => ({ start: new Date(start), end: new Date(end) }));
+
+const secondsSinceStart = (iso: string) =>
+    (new Date(iso).getTime() - started_at.getTime()) / 1000;
+
+describe("pausesToIntervals", () => {
+    it("converts the example stream pauses", () => {
+        const intervals = pausesToIntervals(pauses, started_at);
+        expect(intervals).toHaveLength(8);
+        expect(intervals[0].start).toBeCloseTo(16.022);
+        expect(intervals[0].end).toBeCloseTo(31.09);
+        expect(totalPauseDuration(intervals)).toBeCloseTo(734.94, 1);
+    });
+
+    it("returns nothing without pauses", () => {
+        expect(pausesToIntervals([], started_at)).toEqual([]);
+    });
+
+    it("ignores negligible pauses", () => {
+        expect(
+            pausesToIntervals(
+                [
+                    {
+                        start: new Date("2024-12-08T14:00:00.000Z"),
+                        end: new Date("2024-12-08T14:00:00.500Z"),
+                    },
+                ],
+                started_at
+            )
+        ).toEqual([]);
+    });
+
+    it("drops invalid pauses and merges overlapping ones", () => {
+        const intervals = pausesToIntervals(
+            [
+                {
+                    start: new Date("2024-12-08T14:00:30.000Z"),
+                    end: new Date("2024-12-08T14:01:30.000Z"),
+                },
+                {
+                    start: new Date("2024-12-08T14:00:00.000Z"),
+                    end: new Date("2024-12-08T14:01:00.000Z"),
+                },
+                {
+                    start: new Date("2024-12-08T15:00:00.000Z"),
+                    end: new Date("2024-12-08T14:59:00.000Z"),
+                },
+                { start: new Date("2024-12-08T15:00:00.000Z") },
+                {
+                    start: new Date("invalid"),
+                    end: new Date("2024-12-08T15:00:00.000Z"),
+                },
+            ],
+            started_at
+        );
+        expect(intervals).toHaveLength(1);
+        expect(intervals[0].end - intervals[0].start).toBeCloseTo(90);
+    });
+});
+
+describe("streamTimeToVideoTime", () => {
+    const intervals = pausesToIntervals(pauses, started_at);
+
+    it("does not change anything without pauses", () => {
+        expect(streamTimeToVideoTime(1234.5, [])).toBe(1234.5);
+    });
+
+    it("does not move times before the first pause", () => {
+        expect(streamTimeToVideoTime(10, intervals)).toBe(10);
+    });
+
+    it("moves times after a pause back by the pause duration", () => {
+        // 1:00:00 into the stream, only the pre-roll has passed
+        expect(streamTimeToVideoTime(3600, intervals)).toBeCloseTo(
+            3600 - 15.068
+        );
+        // 2:00:00, pre-roll and first mid-roll
+        expect(streamTimeToVideoTime(7200, intervals)).toBeCloseTo(
+            7200 - 15.068 - 94.671
+        );
+    });
+
+    it("moves times after the last pause back by all pauses", () => {
+        const end = secondsSinceStart("2024-12-08T18:25:32.134Z");
+        expect(end - streamTimeToVideoTime(end, intervals)).toBeCloseTo(
+            734.94,
+            1
+        );
+    });
+
+    it("maps times inside a pause to the cut point", () => {
+        const pauseStart = secondsSinceStart("2024-12-08T14:49:27.406Z");
+        const cut = streamTimeToVideoTime(pauseStart, intervals);
+        expect(streamTimeToVideoTime(pauseStart + 30, intervals)).toBeCloseTo(
+            cut
+        );
+        expect(streamTimeToVideoTime(pauseStart + 94, intervals)).toBeCloseTo(
+            cut
+        );
+    });
+
+    it("is monotonic", () => {
+        let last = -1;
+        for (let t = 0; t < 17000; t += 7) {
+            const v = streamTimeToVideoTime(t, intervals);
+            expect(v).toBeGreaterThanOrEqual(last);
+            last = v;
+        }
+    });
+
+    it("maps the second chapter of the example stream", () => {
+        const chapter = secondsSinceStart("2024-12-08T15:47:34.092Z");
+        expect(chapter).toBeCloseTo(7213.092);
+        expect(streamTimeToVideoTime(chapter, intervals)).toBeCloseTo(
+            7213.092 - 109.739
+        );
+    });
+});
+
+describe("syncChatDumpToVideo", () => {
+    const comment = (id: string, offset: number) =>
+        ({
+            _id: id,
+            content_offset_seconds: offset,
+        }) as unknown as TwitchComment;
+
+    const dump = {
+        comments: [
+            comment("a", 10),
+            comment("b", 50),
+            comment("c", 40),
+            comment("d", 100),
+        ],
+        video: {
+            title: "Chat Dump",
+            description: "",
+            id: "",
+            created_at: "",
+            start: 0,
+            end: 100,
+            length: 100,
+            viewCount: 0,
+            game: "",
+            chapters: [],
+        },
+        embeddedData: null,
+    } as TwitchCommentDumpTD;
+
+    it("maps offsets, collapses comments during pauses and keeps order", () => {
+        const result = syncChatDumpToVideo(dump, [{ start: 20, end: 60 }]);
+        expect(
+            result.comments.map((c) => [c._id, c.content_offset_seconds])
+        ).toEqual([
+            ["a", 10],
+            ["b", 20],
+            ["c", 20],
+            ["d", 60],
+        ]);
+        expect(result.video.length).toBe(60);
+        expect(result.video.end).toBe(60);
+    });
+
+    it("does not modify the original dump", () => {
+        syncChatDumpToVideo(dump, [{ start: 20, end: 60 }]);
+        expect(dump.comments[1].content_offset_seconds).toBe(50);
+        expect(dump.video.length).toBe(100);
+    });
+});
diff --git a/server/src/Helpers/StreamPauses.ts b/server/src/Helpers/StreamPauses.ts
new file mode 100644
index 00000000..bd272e9e
--- /dev/null
+++ b/server/src/Helpers/StreamPauses.ts
@@ -0,0 +1,131 @@
+import type { TwitchComment, TwitchCommentDumpTD } from "@common/Comments";
+
+/**
+ * A stream pause (usually an ad break filtered out by streamlink) as an
+ * interval in seconds relative to the stream start (started_at).
+ */
+export interface PauseInterval {
+    start: number;
+    end: number;
+}
+
+/**
+ * Pauses shorter than this in total are ignored, the video and chat are
+ * considered to be in sync already.
+ */
+export const MIN_TOTAL_PAUSE_SECONDS = 1;
+
+export function totalPauseDuration(intervals: PauseInterval[]): number {
+    return intervals.reduce((acc, p) => acc + (p.end - p.start), 0);
+}
+
+/**
+ * Convert stream pauses (wall-clock dates) to sorted, non-overlapping
+ * intervals in seconds relative to the stream start.
+ *
+ * Invalid pauses (missing dates, end before start) are dropped,
+ * pauses before the stream start are clipped to 0.
+ *
+ * Returns an empty array if the total pause duration is negligible,
+ * meaning no correction should be applied.
+ */
+export function pausesToIntervals(
+    pauses: { start?: Date; end?: Date }[],
+    started_at: Date
+): PauseInterval[] {
+    const base = started_at.getTime();
+
+    const intervals = pauses
+        .filter(
+            (p): p is { start: Date; end: Date } =>
+                p.start instanceof Date &&
+                p.end instanceof Date &&
+                !isNaN(p.start.getTime()) &&
+                !isNaN(p.end.getTime())
+        )
+        .map((p) => ({
+            start: Math.max(0, (p.start.getTime() - base) / 1000),
+            end: Math.max(0, (p.end.getTime() - base) / 1000),
+        }))
+        .filter((p) => p.end > p.start)
+        .sort((a, b) => a.start - b.start);
+
+    // merge overlapping intervals
+    const merged: PauseInterval[] = [];
+    for (const interval of intervals) {
+        const last = merged[merged.length - 1];
+        if (last && interval.start <= last.end) {
+            last.end = Math.max(last.end, interval.end);
+        } else {
+            merged.push({ ...interval });
+        }
+    }
+
+    if (totalPauseDuration(merged) < MIN_TOTAL_PAUSE_SECONDS) return [];
+
+    return merged;
+}
+
+/**
+ * Map a time in the stream (seconds since started_at, how chat and chapters are timed)
+ * to a time in the captured video, where the paused sections have been cut out.
+ *
+ * Times inside a pause are mapped to the point where the pause was cut.
+ */
+export function streamTimeToVideoTime(
+    seconds: number,
+    intervals: PauseInterval[]
+): number {
+    let removed = 0;
+    for (const pause of intervals) {
+        if (seconds >= pause.end) {
+            removed += pause.end - pause.start;
+        } else if (seconds > pause.start) {
+            removed += seconds - pause.start;
+            break;
+        } else {
+            break;
+        }
+    }
+    return seconds - removed;
+}
+
+/**
+ * Return a copy of a chat dump with all comment offsets mapped to video time.
+ * Comments are sorted by their new offset, the original order is kept for equal offsets.
+ */
+export function syncChatDumpToVideo(
+    dump: TwitchCommentDumpTD,
+    intervals: PauseInterval[]
+): TwitchCommentDumpTD {
+    const comments: TwitchComment[] = dump.comments
+        .map((comment, index) => ({
+            comment: {
+                ...comment,
+                content_offset_seconds: streamTimeToVideoTime(
+                    comment.content_offset_seconds,
+                    intervals
+                ),
+            },
+            index,
+        }))
+        .sort(
+            (a, b) =>
+                a.comment.content_offset_seconds -
+                    b.comment.content_offset_seconds || a.index - b.index
+        )
+        .map((c) => c.comment);
+
+    const result: TwitchCommentDumpTD = { ...dump, comments };
+
+    if (dump.video) {
+        result.video = {
+            ...dump.video,
+            start: streamTimeToVideoTime(dump.video.start || 0, intervals),
+            end: streamTimeToVideoTime(dump.video.end || 0, intervals),
+            length: streamTimeToVideoTime(dump.video.length || 0, intervals),
+        };
+    }
+
+    return result;
+}
diff --git a/server/src/Helpers/Video.ts b/server/src/Helpers/Video.ts
index 2f175294..4a2522a1 100644
--- a/server/src/Helpers/Video.ts
+++ b/server/src/Helpers/Video.ts
@@ -15,6 +15,16 @@ import path from "node:path";
 import { progressOutput } from "./Console";
 import { exec, execSimple, isExecError, startJob } from "./Execute";
 import { formatDuration } from "./Format";
+import type { PadPlan } from "./PadVideo";
+import {
+    PacketScanner,
+    buildConcatList,
+    fillerUnitFrames,
+    planPadding,
+} from "./PadVideo";
+import type { PauseInterval } from "./StreamPauses";
+import { spawn } from "node:child_process";
+import readline from "node:readline";
 
 export interface RemuxReturn {
     stdout: string[];
@@ -36,7 +46,9 @@ export async function remuxFile(
     input: string,
     output: string,
     overwrite = false,
-    metadata_file?: string
+    metadata_file?: string,
+    /** options placed before the input, e.g. the input format */
+    input_options: string[] = []
 ): Promise<RemuxReturn> {
     const ffmpegPath = Helper.path_ffmpeg();
 
@@ -64,6 +76,7 @@ export async function remuxFile(
     const opts: string[] = [];
     // "-r", parseInt(info.video.FrameRate).toString(),
     // "-vsync", "cfr",
+    opts.push(...input_options);
     opts.push("-i", input);
 
     // write metadata to file
@@ -620,6 +633,216 @@ export async function ffprobe(filename: string): Promise<FFProbe> {
     }
 }
 
+function parseFrameRate(rate?: string): number | undefined {
+    if (!rate) return undefined;
+    const [num, den] = rate.split("/").map((v) => parseFloat(v));
+    const fps = den ? num / den : num;
+    return fps > 0 && isFinite(fps) ? fps : undefined;
+}
+
+/**
+ * Scan the timestamps of all video packets in a file, streaming the ffprobe output.
+ */
+function scanVideoPackets(
+    ffprobePath: string,
+    input: string,
+    frameDuration?: number
+): Promise<ReturnType<PacketScanner["result"]>> {
+    return new Promise((resolve, reject) => {
+        const scanner = new PacketScanner(frameDuration);
+        const proc = spawn(ffprobePath, [
+            "-v",
+            "error",
+            "-select_streams",
+            "v:0",
+            "-show_entries",
+            "packet=pts_time,dts_time,flags",
+            "-of",
+            "csv=p=0",
+            input,
+        ]);
+        const stderr: string[] = [];
+        proc.stderr.on("data", (data: Buffer) => stderr.push(data.toString()));
+        const lines = readline.createInterface({ input: proc.stdout });
+        lines.on("line", (line) => scanner.addLine(line));
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                reject(
+                    new Error(
+                        `ffprobe packet scan failed (${code}): ${stderr
+                            .join("")
+                            .slice(0, 500)}`
+                    )
+                );
+                return;
+            }
+            resolve(scanner.result());
+        });
+    });
+}
+
+/**
+ * Remux a capture, filling the stream pauses (ad breaks) with black, silent video
+ * so the video length matches the stream and chat/chapters stay in sync.
+ *
+ * The capture itself is only stream copied, just the short filler unit is encoded.
+ * Throws if the capture can't be padded, the caller should fall back to {@link remuxFile}.
+ *
+ * @param intervals stream pauses in seconds since the stream started
+ */
+export async function remuxFileWithPadding(
+    input: string,
+    output: string,
+    intervals: PauseInterval[],
+    metadata_file?: string
+): Promise<RemuxReturn & { plan: PadPlan }> {
+    const ffmpegPath = Helper.path_ffmpeg();
+    const ffprobePath = Helper.path_ffprobe();
+    if (!ffmpegPath) throw new Error("Failed to find ffmpeg");
+    if (!ffprobePath || !fs.existsSync(ffprobePath)) {
+        throw new Error("Failed to find ffprobe");
+    }
+
+    const probe = await ffprobe(input);
+    const video = probe.streams.find((s) => s.codec_type == "video");
+    const audio = probe.streams.find((s) => s.codec_type == "audio");
+    if (!video || video.codec_type != "video" || video.codec_name != "h264") {
+        throw new Error("Padding needs an h264 video stream");
+    }
+    if (!audio || audio.codec_type != "audio" || audio.codec_name != "aac") {
+        throw new Error("Padding needs an aac audio stream");
+    }
+
+    const fps =
+        parseFrameRate(video.r_frame_rate) ||
+        parseFrameRate(video.avg_frame_rate);
+    const sampleRate = Number(audio.sample_rate);
+    if (!fps || !sampleRate || !video.width || !video.height) {
+        throw new Error(
+            "Could not determine video/audio parameters for padding"
+        );
+    }
+
+    log(
+        LOGLEVEL.INFO,
+        "video.remuxPadded",
+        `Scanning video timestamps of ${input}`
+    );
+    progressOutput(`🎞 Scanning ${path.basename(input)} for ad breaks`);
+
+    const scan = await scanVideoPackets(ffprobePath, input, 1 / fps);
+    if (!scan) throw new Error("No video packets found");
+
+    const plan = planPadding(scan, intervals);
+    for (const message of plan.messages) {
+        log(LOGLEVEL.INFO, "video.remuxPadded", message);
+    }
+    log(
+        LOGLEVEL.INFO,
+        "video.remuxPadded",
+        `Padding plan for ${path.basename(input)}: ${
+            plan.matchedPauses
+        } pauses at timestamp gaps, ` +
+            `${plan.estimatedPauses} estimated, ${plan.collapsedGaps} gaps collapsed, ` +
+            `${plan.totalFiller.toFixed(1)}s filler in ${
+                plan.parts.length
+            } parts`
+    );
+
+    if (plan.totalFiller < 1) throw new Error("Nothing to pad");
+
+    // encode one filler unit matching the capture, it's repeated for the whole pause
+    const unitFrames = fillerUnitFrames(fps, sampleRate);
+    const unitSeconds = unitFrames / fps;
+    const workBase = path.join(
+        BaseConfigCacheFolder.cache,
+        `pad_${path.basename(input, path.extname(input))}`
+    );
+    const fillerFile = `${workBase}_filler.ts`;
+    const listFile = `${workBase}.ffconcat`;
+
+    const profile = (video.profile || "").toLowerCase();
+    const x264Profile = profile.includes("baseline")
+        ? "baseline"
+        : profile == "main"
+        ? "main"
+        : "high";
+
+    try {
+        await execSimple(
+            ffmpegPath,
+            [
+                "-y",
+                "-f",
+                "lavfi",
+                "-i",
+                `color=c=black:s=${video.width}x${video.height}:r=${
+                    video.r_frame_rate || fps
+                }`,
+                "-f",
+                "lavfi",
+                "-i",
+                `anullsrc=r=${sampleRate}:cl=${
+                    audio.channel_layout ||
+                    (audio.channels == 1 ? "mono" : "stereo")
+                }`,
+                "-frames:v",
+                unitFrames.toString(),
+                "-t",
+                unitSeconds.toFixed(6),
+                "-c:v",
+                "libx264",
+                "-preset",
+                "ultrafast",
+                "-profile:v",
+                x264Profile,
+                "-pix_fmt",
+                video.pix_fmt || "yuv420p",
+                "-bf",
+                "0",
+                "-g",
+                unitFrames.toString(),
+                "-c:a",
+                "aac",
+                "-ar",
+                sampleRate.toString(),
+                "-ac",
+                (audio.channels || 2).toString(),
+                "-f",
+                "mpegts",
+                fillerFile,
+            ],
+            "pad filler"
+        );
+
+        if (!fs.existsSync(fillerFile) || fs.statSync(fillerFile).size == 0) {
+            throw new Error("Failed to encode filler");
+        }
+
+        const fillerProbe = await ffprobe(fillerFile);
+        const fillerStart = parseFloat(fillerProbe.format.start_time) || 0;
+
+        fs.writeFileSync(
+            listFile,
+            buildConcatList(plan, input, fillerFile, fillerStart, unitSeconds)
+        );
+
+        const result = await remuxFile(listFile, output, false, metadata_file, [
+            "-f",
+            "concat",
+            "-safe",
+            "0",
+        ]);
+
+        return { ...result, plan };
+    } finally {
+        for (const file of [fillerFile, listFile]) {
+            if (fs.existsSync(file)) fs.unlinkSync(file);
+        }
+    }
+}
+
 export async function videometadata(
     filename: string,
     force = false
diff --git a/server/src/Routes/Api.ts b/server/src/Routes/Api.ts
index 2ad5ec42..cbdbae9c 100644
--- a/server/src/Routes/Api.ts
+++ b/server/src/Routes/Api.ts
@@ -107,6 +107,7 @@ router.post("/vod/:uuid/save", AuthAdmin, Vod.ArchiveVod);
 router.post("/vod/:uuid/bookmark", AuthAdmin, Vod.AddBookmark);
 router.delete("/vod/:uuid/bookmark", AuthAdmin, Vod.RemoveBookmark);
 router.get("/vod/:uuid/sync", AuthAdmin, Vod.GetSync);
+router.get("/vod/:uuid/synced.chatdump", AuthGuest, Vod.GetVideoChatdump);
 router.post("/vod/:uuid/rename", AuthAdmin, Vod.RenameVod);
 router.post("/vod/:uuid/fix_issues", AuthAdmin, Vod.FixIssues);
 router.post("/vod/:uuid/refresh_metadata", AuthAdmin, Vod.RefreshVodMetadata);
diff --git a/server/src/Storage/JSON.ts b/server/src/Storage/JSON.ts
index 1b8d2044..94ae6390 100644
--- a/server/src/Storage/JSON.ts
+++ b/server/src/Storage/JSON.ts
@@ -58,6 +58,8 @@ export interface VODJSON {
     viewers?: { timestamp: string; amount: number }[];
     // stream_pauses?: StreamPause[];
     stream_pauses?: { start?: string; end?: string }[];
+    /** The stream pauses were filled with black video during conversion */
+    stream_pauses_padded?: boolean;
 
     bookmarks: VODBookmark[];
 
diff --git a/twitch-vod-chat b/twitch-vod-chat
index 39251925..823d4a9c 160000
--- a/twitch-vod-chat
+++ b/twitch-vod-chat
@@ -1 +1 @@
-Subproject commit 39251925ac72860b973cff0c8c93f4691e7cd951
+Subproject commit 823d4a9caf5335aeddd3c021c7291e6b4e12622d