From b50f5a58b925d651be53ee9fe32edb090c371e1f Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 00:37:06 -0500
Subject: [PATCH 01/12] feat: staff takedown switch for Cap Infra videos

Stores the flag under a reserved key in developer_videos.metadata, wrapping
the developer's own metadata so a restore writes it back exactly. Status is
untouched, so storage billing reads the video as before. No migration.

A staff-only route and scripts/infra-video-takedown.ts flip it.
---
 .../fixtures/developer-video-takedown.ts      |  55 ++++++++
 .../admin/developer-video-takedown/route.ts   |  59 ++++++++
 .../web/lib/developer-video-takedown-store.ts | 130 ++++++++++++++++++
 apps/web/lib/developer-video-takedown.ts      |  69 ++++++++++
 apps/web/lib/infra-video-upload.ts            |   3 +-
 packages/database/developer-video-takedown.ts |  30 ++++
 packages/database/package.json                |   1 +
 packages/database/types/developer-video.ts    |   4 +
 scripts/infra-video-takedown.ts               |  99 +++++++++++++
 9 files changed, 449 insertions(+), 1 deletion(-)
 create mode 100644 apps/web/__tests__/fixtures/developer-video-takedown.ts
 create mode 100644 apps/web/app/api/admin/developer-video-takedown/route.ts
 create mode 100644 apps/web/lib/developer-video-takedown-store.ts
 create mode 100644 apps/web/lib/developer-video-takedown.ts
 create mode 100644 packages/database/developer-video-takedown.ts
 create mode 100644 scripts/infra-video-takedown.ts

diff --git a/apps/web/__tests__/fixtures/developer-video-takedown.ts b/apps/web/__tests__/fixtures/developer-video-takedown.ts
new file mode 100644
index 00000000000..b580466e24b
--- /dev/null
+++ b/apps/web/__tests__/fixtures/developer-video-takedown.ts
@@ -0,0 +1,55 @@
+import type { DeveloperVideoStore } from "./developer-video";
+
+// The takedown rewrites metadata in SQL. This applies the same two rewrites
+// to the fake's stored row, so a test can take a video down and restore it.
+// The SQL itself was run against MySQL 8 when it was written.
+export async function withTakedownSql(
+	store: DeveloperVideoStore,
+	database: Awaited<
+		ReturnType<typeof import("./developer-video").createDeveloperVideoDatabase>
+	>,
+) {
+	const { MySqlDialect } = await import("drizzle-orm/mysql-core");
+	const { SQL } = await import("drizzle-orm");
+	const dialect = new MySqlDialect();
+
+	const evaluate = (value: unknown, current: unknown): unknown => {
+		if (!(value instanceof SQL)) return value;
+		const query = dialect.sqlToQuery(value);
+		if (query.sql.startsWith("JSON_OBJECT(")) {
+			const [key, at] = query.params as [string, string];
+			return { [key]: { at, metadata: current } };
+		}
+		if (query.sql.startsWith("CASE WHEN JSON_TYPE(")) {
+			const marker = Object.values(
+				(current ?? {}) as Record<string, { metadata?: unknown }>,
+			)[0];
+			return marker?.metadata ?? null;
+		}
+		throw new Error(`The fake cannot evaluate ${query.sql}`);
+	};
+
+	const wrapped = {
+		...database,
+		update: () => ({
+			set: (updates: Record<string, unknown>) => ({
+				where: async () => {
+					const current = store.video;
+					const applied = Object.fromEntries(
+						Object.entries(updates).map(([column, value]) => [
+							column,
+							evaluate(
+								value,
+								current?.[column as keyof NonNullable<typeof current>],
+							),
+						]),
+					);
+					store.updates.push(updates);
+					if (current) store.video = { ...current, ...applied };
+				},
+			}),
+		}),
+		transaction: async (run: (tx: unknown) => Promise<unknown>) => run(wrapped),
+	};
+	return wrapped;
+}
diff --git a/apps/web/app/api/admin/developer-video-takedown/route.ts b/apps/web/app/api/admin/developer-video-takedown/route.ts
new file mode 100644
index 00000000000..93ce94c0c11
--- /dev/null
+++ b/apps/web/app/api/admin/developer-video-takedown/route.ts
@@ -0,0 +1,59 @@
+import { requireAdmin } from "@/lib/admin-access";
+import { setDeveloperVideoTakedown } from "@/lib/developer-video-takedown-store";
+
+const NO_STORE = { "Cache-Control": "no-store" };
+
+function answer(status: number, body: unknown) {
+	return Response.json(body, { status, headers: NO_STORE });
+}
+
+// The session cookie is SameSite=None, so a request is only taken as JSON
+// from no origin (the staff script) or this one. A cross-site form cannot
+// send JSON, and a cross-site fetch of it stops at the preflight.
+function fromThisSite(request: Request): boolean {
+	const type = request.headers.get("content-type") ?? "";
+	if (!type.toLowerCase().startsWith("application/json")) return false;
+	const origin = request.headers.get("origin");
+	return origin === null || origin === new URL(request.url).origin;
+}
+
+export async function POST(request: Request) {
+	if (!fromThisSite(request)) {
+		return answer(400, { error: "Send JSON from the staff script." });
+	}
+
+	let admin: Awaited<ReturnType<typeof requireAdmin>>;
+	try {
+		admin = await requireAdmin();
+	} catch {
+		return answer(403, { error: "Not allowed." });
+	}
+
+	let body: unknown;
+	try {
+		body = await request.json();
+	} catch {
+		return answer(400, { error: "The body is not JSON." });
+	}
+	const { video, takenDown } = (body ?? {}) as {
+		video?: unknown;
+		takenDown?: unknown;
+	};
+	if (typeof video !== "string" || typeof takenDown !== "boolean") {
+		return answer(400, {
+			error:
+				"Send { video, takenDown }: a playback id, video id or page URL, and true or false.",
+		});
+	}
+
+	const result = await setDeveloperVideoTakedown(video, takenDown);
+	if (!result) return answer(404, { error: "No video matches that." });
+
+	console.info("[developer-video] Takedown changed", {
+		by: admin.id,
+		videoId: result.videoId,
+		takenDown: result.takenDown,
+		changed: result.changed,
+	});
+	return answer(200, { data: result });
+}
diff --git a/apps/web/lib/developer-video-takedown-store.ts b/apps/web/lib/developer-video-takedown-store.ts
new file mode 100644
index 00000000000..c785400c2e7
--- /dev/null
+++ b/apps/web/lib/developer-video-takedown-store.ts
@@ -0,0 +1,130 @@
+import { db } from "@cap/database";
+import {
+	restoredMetadataSql,
+	takenDownMetadataSql,
+} from "@cap/database/developer-video-takedown";
+import { developerVideos } from "@cap/database/schema";
+import { and, eq, isNull } from "drizzle-orm";
+import {
+	DEVELOPER_VIDEO_UNAVAILABLE,
+	developerVideoIsTakenDown,
+	developerVideoReference,
+	developerVideoTakenDownAt,
+} from "./developer-video-takedown";
+
+export type DeveloperVideoTakedownResult = {
+	videoId: string;
+	appId: string;
+	playbackId: string | null;
+	takenDown: boolean;
+	takenDownAt: string | null;
+	changed: boolean;
+};
+
+type Executor = Pick<ReturnType<typeof db>, "select" | "update">;
+
+async function lockVideo(
+	tx: Executor,
+	column: "playbackId" | "id",
+	value: string,
+) {
+	const [video] = await tx
+		.select({
+			id: developerVideos.id,
+			appId: developerVideos.appId,
+			playbackId: developerVideos.playbackId,
+			metadata: developerVideos.metadata,
+		})
+		.from(developerVideos)
+		.where(
+			and(
+				eq(developerVideos[column], value),
+				isNull(developerVideos.deletedAt),
+			),
+		)
+		.for("update");
+	return video ?? null;
+}
+
+export async function setDeveloperVideoTakedown(
+	input: string,
+	takenDown: boolean,
+	now: Date = new Date(),
+): Promise<DeveloperVideoTakedownResult | null> {
+	const reference = developerVideoReference(input);
+	if (!reference) return null;
+	return db().transaction(async (tx) => {
+		const video =
+			(await lockVideo(tx, "playbackId", reference)) ??
+			(await lockVideo(tx, "id", reference));
+		if (!video) return null;
+
+		const wasTakenDown = developerVideoIsTakenDown(video);
+		const changed = wasTakenDown !== takenDown;
+		if (changed) {
+			await tx
+				.update(developerVideos)
+				.set({
+					metadata: takenDown
+						? takenDownMetadataSql(now)
+						: restoredMetadataSql(),
+				})
+				.where(eq(developerVideos.id, video.id));
+		}
+		return {
+			videoId: video.id,
+			appId: video.appId,
+			playbackId: video.playbackId,
+			takenDown,
+			takenDownAt: takenDown
+				? (developerVideoTakenDownAt(video.metadata) ?? now.toISOString())
+				: null,
+			changed,
+		};
+	});
+}
+
+export async function playbackIdIsTakenDown(
+	playbackId: string,
+): Promise<boolean> {
+	const [video] = await db()
+		.select({ metadata: developerVideos.metadata })
+		.from(developerVideos)
+		.where(
+			and(
+				eq(developerVideos.playbackId, playbackId),
+				isNull(developerVideos.deletedAt),
+			),
+		)
+		.limit(1);
+	return video ? developerVideoIsTakenDown(video) : false;
+}
+
+const PAGE_PATH = /^\/dev\/([A-Za-z0-9_-]{16,64})(?:\/embed)?\/?$/;
+
+const GONE_PAGE = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="robots" content="noindex"><title>Video not available</title><style>html,body{margin:0;height:100%;background:#050506;color:#E8ECF4;color-scheme:dark;font-family:system-ui,sans-serif}main{display:grid;min-height:100%;place-items:center;padding:16px 20px;box-sizing:border-box;text-align:center}h1{margin:0;font-size:15px;font-weight:500;line-height:1.3;letter-spacing:-0.01em}</style></head><body><main><h1>${DEVELOPER_VIDEO_UNAVAILABLE}</h1></main></body></html>`;
+
+// A page cannot choose a 410 status in the App Router, so the proxy answers
+// for a taken down video before the page renders.
+export async function developerVideoGonePage(
+	pathname: string,
+	method: string,
+): Promise<Response | null> {
+	if (method !== "GET" && method !== "HEAD") return null;
+	const playbackId = PAGE_PATH.exec(pathname)?.[1];
+	if (!playbackId) return null;
+	try {
+		if (!(await playbackIdIsTakenDown(playbackId))) return null;
+	} catch (error) {
+		console.error("[developer-video] Takedown check failed", error);
+		return null;
+	}
+	return new Response(method === "HEAD" ? null : GONE_PAGE, {
+		status: 410,
+		headers: {
+			"Cache-Control": "no-store",
+			"Content-Type": "text/html; charset=utf-8",
+			"X-Robots-Tag": "noindex",
+		},
+	});
+}
diff --git a/apps/web/lib/developer-video-takedown.ts b/apps/web/lib/developer-video-takedown.ts
new file mode 100644
index 00000000000..15f8c226555
--- /dev/null
+++ b/apps/web/lib/developer-video-takedown.ts
@@ -0,0 +1,69 @@
+import { DEVELOPER_VIDEO_TAKEDOWN_KEY } from "@cap/database/types";
+
+export const DEVELOPER_VIDEO_UNAVAILABLE = "This video is not available.";
+
+export const DEVELOPER_VIDEO_REPORT_EMAIL = "hello@cap.so";
+
+type Marker = { at: string; metadata: unknown };
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: null;
+}
+
+function markerOf(metadata: unknown): Marker | null {
+	const marker = asRecord(asRecord(metadata)?.[DEVELOPER_VIDEO_TAKEDOWN_KEY]);
+	if (!marker || typeof marker.at !== "string" || !("metadata" in marker)) {
+		return null;
+	}
+	return { at: marker.at, metadata: marker.metadata };
+}
+
+export function developerVideoTakenDownAt(metadata: unknown): string | null {
+	return markerOf(metadata)?.at ?? null;
+}
+
+export function developerVideoIsTakenDown(video: {
+	metadata: unknown;
+}): boolean {
+	return markerOf(video.metadata) !== null;
+}
+
+export function developerVideoPublicMetadata(metadata: unknown): unknown {
+	const marker = markerOf(metadata);
+	return marker ? marker.metadata : metadata;
+}
+
+export function withoutReservedMetadata<T extends Record<string, unknown>>(
+	metadata: T | undefined,
+): T | undefined {
+	if (!metadata || !(DEVELOPER_VIDEO_TAKEDOWN_KEY in metadata)) return metadata;
+	const { [DEVELOPER_VIDEO_TAKEDOWN_KEY]: _reserved, ...rest } = metadata;
+	return rest as T;
+}
+
+export function developerVideoReportHref(playbackId: string): string {
+	const subject = encodeURIComponent(`Report video ${playbackId}`);
+	return `mailto:${DEVELOPER_VIDEO_REPORT_EMAIL}?subject=${subject}`;
+}
+
+const REFERENCE_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+
+// Staff paste whatever the report gave them: a playback id, a video id, the
+// hosted or embed page, or a playback file URL.
+export function developerVideoReference(input: string): string | null {
+	const trimmed = input.trim();
+	let candidate = trimmed;
+	try {
+		const segments = new URL(trimmed).pathname.split("/").filter(Boolean);
+		const dev = segments.indexOf("dev");
+		const playback = segments.indexOf("playback");
+		candidate =
+			(dev >= 0 ? segments[dev + 1] : undefined) ??
+			(playback >= 0 ? segments[playback + 1] : undefined) ??
+			segments[0] ??
+			"";
+	} catch {}
+	return REFERENCE_PATTERN.test(candidate) ? candidate : null;
+}
diff --git a/apps/web/lib/infra-video-upload.ts b/apps/web/lib/infra-video-upload.ts
index 45bdf29ee00..a6180b36055 100644
--- a/apps/web/lib/infra-video-upload.ts
+++ b/apps/web/lib/infra-video-upload.ts
@@ -23,6 +23,7 @@ import {
 	releaseDeveloperVideoUpload,
 	startDeveloperVideoProcessing,
 } from "@/lib/developer-video-start";
+import { withoutReservedMetadata } from "@/lib/developer-video-takedown";
 import { canUseInfra } from "@/lib/infra-access";
 import { lockInfraAccount } from "@/lib/infra-balance";
 import {
@@ -357,7 +358,7 @@ export async function createInfraVideo({
 			externalUserId: userId?.trim() || null,
 			name: name ?? "Untitled",
 			s3Key,
-			metadata,
+			metadata: withoutReservedMetadata(metadata),
 			playbackId,
 			maxResolutionTier: maxResolutionTier ?? DEVELOPER_VIDEO_DEFAULT_TIER,
 		});
diff --git a/packages/database/developer-video-takedown.ts b/packages/database/developer-video-takedown.ts
new file mode 100644
index 00000000000..115b33b9908
--- /dev/null
+++ b/packages/database/developer-video-takedown.ts
@@ -0,0 +1,30 @@
+import { type SQL, sql } from "drizzle-orm";
+import { developerVideos } from "./schema";
+import { DEVELOPER_VIDEO_TAKEDOWN_KEY } from "./types/developer-video";
+
+// A takedown is stored in the metadata column so it needs no migration and
+// leaves status alone: storage billing groups by status, and the encoding
+// workflows rewrite processing, so neither can carry it. The developer's own
+// metadata is kept whole inside the marker and written back on restore.
+const MARKER_PATH = `$."${DEVELOPER_VIDEO_TAKEDOWN_KEY}"`;
+const AT_PATH = `${MARKER_PATH}.at`;
+const KEPT_PATH = `${MARKER_PATH}.metadata`;
+
+// Both rewrites run in SQL so the developer's metadata never passes through
+// JSON.parse, which would round integers past 2^53 on the way back. A video
+// with no metadata goes back to SQL NULL rather than a JSON null.
+export function takenDownMetadataSql(now: Date): SQL {
+	return sql`JSON_OBJECT(${DEVELOPER_VIDEO_TAKEDOWN_KEY}, JSON_OBJECT('at', ${now.toISOString()}, 'metadata', ${developerVideos.metadata}))`;
+}
+
+export function restoredMetadataSql(): SQL {
+	return sql`CASE WHEN JSON_TYPE(JSON_EXTRACT(${developerVideos.metadata}, ${KEPT_PATH})) = 'NULL' THEN NULL ELSE JSON_EXTRACT(${developerVideos.metadata}, ${KEPT_PATH}) END`;
+}
+
+// For queries that list videos without loading their metadata. It matches
+// developerVideoIsTakenDown in the web app.
+export function developerVideoTakenDownSql(): SQL<boolean> {
+	return sql<boolean>`(JSON_TYPE(JSON_EXTRACT(${developerVideos.metadata}, ${AT_PATH})) = 'STRING' AND JSON_CONTAINS_PATH(${developerVideos.metadata}, 'one', ${KEPT_PATH}))`.mapWith(
+		(value) => Number(value) === 1,
+	);
+}
diff --git a/packages/database/package.json b/packages/database/package.json
index caf5703f489..87e190b3122 100644
--- a/packages/database/package.json
+++ b/packages/database/package.json
@@ -76,6 +76,7 @@
 		"./emails/config": "./emails/config.ts",
 		"./emails/*": "./emails/*.tsx",
 		"./types": "./types/index.ts",
+		"./developer-video-takedown": "./developer-video-takedown.ts",
 		"./migrate": "./migrate.ts"
 	},
 	"publishConfig": {
diff --git a/packages/database/types/developer-video.ts b/packages/database/types/developer-video.ts
index 7efc8051b2d..646a741045a 100644
--- a/packages/database/types/developer-video.ts
+++ b/packages/database/types/developer-video.ts
@@ -66,3 +66,7 @@ export interface DeveloperVideoProcessingState {
 		poster: number;
 	};
 }
+
+// A video Cap staff took down keeps its own metadata under this key. See
+// developer-video-takedown.ts for why the flag lives in metadata.
+export const DEVELOPER_VIDEO_TAKEDOWN_KEY = "__capTakedown";
diff --git a/scripts/infra-video-takedown.ts b/scripts/infra-video-takedown.ts
new file mode 100644
index 00000000000..47988610a13
--- /dev/null
+++ b/scripts/infra-video-takedown.ts
@@ -0,0 +1,99 @@
+import { pathToFileURL } from "node:url";
+
+const USAGE = `Take a Cap Infra video down, or restore it.
+
+  bun scripts/infra-video-takedown.ts down <video>
+  bun scripts/infra-video-takedown.ts restore <video>
+
+<video> is a playback id, a video id, or the hosted, embed or playback URL.
+
+Environment:
+  CAP_SESSION_TOKEN  the next-auth.session-token cookie of a signed-in Cap staff account
+  CAP_URL            the Cap web app to call, https://cap.so by default`;
+
+type Fetch = (url: string, init: RequestInit) => Promise<Response>;
+
+type TakedownAnswer = {
+	data?: {
+		videoId: string;
+		appId: string;
+		playbackId: string | null;
+		takenDown: boolean;
+		changed: boolean;
+	};
+	error?: string;
+};
+
+export function parseTakedownArgs(
+	argv: readonly string[],
+): { video: string; takenDown: boolean } | null {
+	const [action, video, ...rest] = argv;
+	if (
+		rest.length > 0 ||
+		!video ||
+		(action !== "down" && action !== "restore")
+	) {
+		return null;
+	}
+	return { video, takenDown: action === "down" };
+}
+
+export async function runTakedown({
+	argv,
+	env,
+	fetchImpl = fetch,
+	log,
+	fail,
+}: {
+	argv: readonly string[];
+	env: Record<string, string | undefined>;
+	fetchImpl?: Fetch;
+	log: (line: string) => void;
+	fail: (line: string) => void;
+}): Promise<number> {
+	const parsed = parseTakedownArgs(argv);
+	if (!parsed) {
+		fail(USAGE);
+		return 2;
+	}
+	const token = env.CAP_SESSION_TOKEN;
+	if (!token) {
+		fail("Set CAP_SESSION_TOKEN to a staff session cookie.");
+		return 2;
+	}
+	const base = (env.CAP_URL || "https://cap.so").replace(/\/+$/, "");
+	const response = await fetchImpl(
+		`${base}/api/admin/developer-video-takedown`,
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Cookie: `next-auth.session-token=${token}`,
+			},
+			body: JSON.stringify(parsed),
+		},
+	);
+	const body = (await response
+		.json()
+		.catch(() => null)) as TakedownAnswer | null;
+	const data = body?.data;
+	if (!response.ok || !data) {
+		fail(`${response.status}: ${body?.error ?? "unexpected answer"}`);
+		return 1;
+	}
+	const state = data.takenDown ? "taken down" : "playing normally";
+	log(
+		`${data.videoId} (playback ${data.playbackId ?? "none"}, app ${data.appId}) is ${state}${data.changed ? "" : ", unchanged"}.`,
+	);
+	return 0;
+}
+
+const entry = process.argv[1];
+if (entry && import.meta.url === pathToFileURL(entry).href) {
+	process.exitCode = await runTakedown({
+		argv: process.argv.slice(2),
+		env: process.env,
+		log: (line) => console.log(line),
+		fail: (line) => console.error(line),
+	});
+}

From e5985008aff30c2a8ca11847ca71dd190cdcdd9d Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 00:37:06 -0500
Subject: [PATCH 02/12] feat: 410 for taken down Infra videos and a report link
 on the player

Every playback file of a taken down video answers a plain 410 with no-store,
and the hosted and embed pages answer a short 410 page from the proxy. The
hosted page gets a quiet Report link and the embed one in its top corner,
both opening an email to the support address with the playback id.
---
 .../unit/developer-video-page.test.ts         |  83 +++++-
 .../unit/developer-video-player.test.ts       |  25 ++
 .../developer-video-takedown-playback.test.ts | 258 ++++++++++++++++++
 .../proxy-developer-video-takedown.test.ts    |  95 +++++++
 .../unit/proxy-frame-headers.test.ts          |   4 +
 .../unit/proxy-referral-click.test.ts         |   4 +
 .../dev/_components/DeveloperVideoPage.tsx    |  59 +++-
 apps/web/lib/developer-video-playback.ts      |  17 ++
 apps/web/lib/developer-video-player.ts        |   5 +
 apps/web/proxy.ts                             |  11 +
 10 files changed, 553 insertions(+), 8 deletions(-)
 create mode 100644 apps/web/__tests__/unit/developer-video-takedown-playback.test.ts
 create mode 100644 apps/web/__tests__/unit/proxy-developer-video-takedown.test.ts

diff --git a/apps/web/__tests__/unit/developer-video-page.test.ts b/apps/web/__tests__/unit/developer-video-page.test.ts
index e3797926c09..3642fac505d 100644
--- a/apps/web/__tests__/unit/developer-video-page.test.ts
+++ b/apps/web/__tests__/unit/developer-video-page.test.ts
@@ -42,6 +42,11 @@ const processing: DeveloperVideoPlayer = {
 };
 const failed: DeveloperVideoPlayer = { ...frame, kind: "failed" };
 const paused: DeveloperVideoPlayer = { ...frame, kind: "paused" };
+const takenDown: DeveloperVideoPlayer = { ...frame, kind: "taken_down" };
+const REPORT_HREF = `mailto:hello@cap.so?subject=Report%20video%20${PLAYBACK_ID}`;
+
+const links = (html: string) =>
+	[...html.matchAll(/<a [^>]*>[^<]*<\/a>/g)].map((match) => match[0]);
 
 const render = (
 	player: DeveloperVideoPlayer,
@@ -49,7 +54,12 @@ const render = (
 	playback?: DeveloperVideoPlayback,
 ) =>
 	renderToStaticMarkup(
-		createElement(DeveloperVideoView, { player, variant, playback }),
+		createElement(DeveloperVideoView, {
+			playbackId: PLAYBACK_ID,
+			player,
+			variant,
+			playback,
+		}),
 	);
 
 const params = (query: DeveloperVideoQuery = {}, playbackId = PLAYBACK_ID) => ({
@@ -150,7 +160,8 @@ describe("developer video page states", () => {
 			expect(embed).not.toContain("Cap Infra");
 			expect(embed).not.toContain("<header");
 			expect(embed).toContain('<h1 class="sr-only">Launch demo</h1>');
-			expect(embed).not.toContain("<a ");
+			expect(embed.match(/<a /g)).toHaveLength(1);
+			expect(embed).toContain(`href="${REPORT_HREF}"`);
 		},
 	);
 
@@ -163,6 +174,74 @@ describe("developer video page states", () => {
 	});
 });
 
+describe("developer video report link", () => {
+	it.each([
+		["playing", playing],
+		["processing", processing],
+		["failed", failed],
+		["paused", paused],
+	])(
+		"offers a quiet Report link under the %s video that emails the support address with the playback id",
+		(_, player) => {
+			const [report, ...others] = links(render(player));
+
+			expect(others).toEqual([]);
+			expect(report).toContain(`href="${REPORT_HREF}"`);
+			expect(report).toContain('aria-label="Report this video"');
+			expect(report).toContain(">Report</a>");
+			expect(report).not.toContain("target=");
+			expect(report).not.toMatch(/uppercase|tracking-\[0\.|font-semibold/);
+		},
+	);
+
+	it("tucks the embed link into the top corner, hidden until the pointer is over a player with its controls showing", () => {
+		const html = render(playing, "embed");
+		const [report] = links(html);
+
+		expect(html).toContain('class="group fixed inset-0 bg-black"');
+		expect(report).toContain(`href="${REPORT_HREF}"`);
+		expect(report).toContain('target="_blank"');
+		expect(report).toContain('rel="noopener noreferrer"');
+		expect(report).toContain("absolute right-2 top-2");
+		expect(report).toContain("opacity-0");
+		expect(report).toContain("pointer-events-none");
+		expect(report).toContain(
+			"[.group:hover:not(:has([data-idle=true]))_&amp;]:opacity-100",
+		);
+		expect(report).toContain("focus-visible:opacity-100");
+	});
+});
+
+describe("a taken down video page", () => {
+	it.each(["share", "embed"] as const)(
+		"shows only that the video is not available on the %s page",
+		(variant) => {
+			const html = render(takenDown, variant);
+			const text = html
+				.replace(/<style>.*?<\/style>/g, "")
+				.replace(/<[^>]+>/g, " ");
+
+			expect(text).toContain("This video is not available.");
+			expect(html).not.toContain("Launch demo");
+			expect(html).not.toContain("<video");
+			expect(html).not.toContain(BASE);
+			expect(html).not.toContain("mailto:");
+			expect(html).not.toContain('role="status"');
+		},
+	);
+
+	it("previews as unavailable with no title or image from the video", async () => {
+		mocks.load.mockResolvedValue(takenDown);
+
+		expect(await developerVideoMetadata(PLAYBACK_ID)).toMatchObject({
+			title: "Video not available",
+			robots: { index: false, follow: false },
+			openGraph: { title: "Video not available", images: [] },
+			twitter: { card: "summary", title: "Video not available", images: [] },
+		});
+	});
+});
+
 describe("developer video page parameters", () => {
 	const embed = (query: DeveloperVideoQuery) =>
 		render(playing, "embed", developerVideoPlayback(query, "embed"));
diff --git a/apps/web/__tests__/unit/developer-video-player.test.ts b/apps/web/__tests__/unit/developer-video-player.test.ts
index 3d5c9707468..a6b406967eb 100644
--- a/apps/web/__tests__/unit/developer-video-player.test.ts
+++ b/apps/web/__tests__/unit/developer-video-player.test.ts
@@ -65,6 +65,31 @@ const uploadedLongAgo = () =>
 	});
 
 describe("developer video player data", () => {
+	it.each([
+		["a ready video", () => ready()],
+		["a paused app's video", () => ready()],
+		["a video still uploading", uploadedLongAgo],
+	])(
+		"shows %s that Cap took down as unavailable, without redriving it",
+		async (name, video) => {
+			if (name === "a paused app's video") {
+				mocks.standing.mockResolvedValue({ state: "paused", pausesAt: null });
+			}
+			mocks.store.video = {
+				...video(),
+				metadata: {
+					__capTakedown: { at: "2026-11-13T12:00:00.000Z", metadata: null },
+				},
+			};
+
+			expect(await loadDeveloperVideoPlayer(PLAYBACK_ID)).toMatchObject({
+				kind: "taken_down",
+			});
+			expect(mocks.standing).not.toHaveBeenCalled();
+			expect(mocks.redrive).not.toHaveBeenCalled();
+		},
+	);
+
 	it("plays the adaptive stream with the MP4 behind it and the poster", async () => {
 		expect(await loadDeveloperVideoPlayer(PLAYBACK_ID)).toEqual({
 			kind: "playing",
diff --git a/apps/web/__tests__/unit/developer-video-takedown-playback.test.ts b/apps/web/__tests__/unit/developer-video-takedown-playback.test.ts
new file mode 100644
index 00000000000..0c091fa6aa2
--- /dev/null
+++ b/apps/web/__tests__/unit/developer-video-takedown-playback.test.ts
@@ -0,0 +1,258 @@
+import type { NextRequest } from "next/server";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	type DeveloperVideoStore,
+	developerVideo,
+	processingState,
+} from "../fixtures/developer-video";
+
+const mocks = vi.hoisted(() => ({
+	store: { video: null, appDeleted: false, updates: [] } as DeveloperVideoStore,
+	readText: vi.fn(),
+	sign: vi.fn(),
+	answersAnyOrigin: vi.fn(),
+	standing: vi.fn(),
+}));
+
+vi.mock("@cap/database", async () => {
+	const { createDeveloperVideoDatabase } = await import(
+		"../fixtures/developer-video"
+	);
+	const { withTakedownSql } = await import(
+		"../fixtures/developer-video-takedown"
+	);
+	const database = await withTakedownSql(
+		mocks.store,
+		await createDeveloperVideoDatabase(mocks.store),
+	);
+	return { db: () => database };
+});
+vi.mock("@cap/env", () => ({
+	serverEnv: () => ({ WEB_URL: "https://web.example" }),
+}));
+vi.mock("@/lib/infra-standing", () => ({
+	getInfraAppStanding: mocks.standing,
+}));
+vi.mock("@/lib/developer-video-storage", () => ({
+	developerVideoUrlAnswersAnyOrigin: mocks.answersAnyOrigin,
+	readDeveloperVideoText: mocks.readText,
+	signedDeveloperVideoUrl: mocks.sign,
+}));
+
+const { GET, HEAD, OPTIONS } = await import(
+	"@/app/api/developer/playback/[playbackId]/[file]/route"
+);
+const { setDeveloperVideoTakedown } = await import(
+	"@/lib/developer-video-takedown-store"
+);
+
+const PLAYBACK_ID = "playback-id-0123456789ab";
+const HLS_PREFIX = "developer/app-1/video-1/encode-1/hls-out/hls/";
+const master = [
+	"#EXTM3U",
+	'#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud",NAME="audio",URI="audio.m3u8"',
+	"#EXT-X-STREAM-INF:BANDWIDTH=4000000",
+	"1080p.m3u8",
+].join("\n");
+const rendition = [
+	"#EXTM3U",
+	'#EXT-X-MAP:URI="1080p.m4s",BYTERANGE="800@0"',
+	"#EXTINF:4.000000,",
+	"#EXT-X-BYTERANGE:1000@800",
+	"1080p.m4s",
+	"#EXT-X-ENDLIST",
+].join("\n");
+
+const ready = (overrides = {}) =>
+	developerVideo({
+		status: "ready",
+		processing: processingState({
+			hls: { state: "complete", output: "hls-out" },
+			mp4: { state: "complete", output: "mp4-out" },
+			poster: { output: "mp4-out" },
+			bytes: { source: 1_000, hls: 5_000, mp4: 2_000, poster: 50 },
+		}),
+		...overrides,
+	});
+
+const FILES = [
+	"master.m3u8",
+	"master.m3u8?segments=short",
+	"1080p.m3u8",
+	"1080p.m3u8?segments=short",
+	"audio.m3u8",
+	"1080p.m4s",
+	"video.mp4",
+	"poster.jpg",
+	"missing.m3u8",
+	"anything.txt",
+];
+
+function call(handler: typeof GET, target: string) {
+	const [file, query] = target.split("?") as [string, string?];
+	const request = new Request(
+		`https://web.example/api/developer/playback/${PLAYBACK_ID}/${file}${query ? `?${query}` : ""}`,
+		{ method: handler === HEAD ? "HEAD" : "GET" },
+	) as NextRequest;
+	return handler(request, {
+		params: Promise.resolve({ playbackId: PLAYBACK_ID, file }),
+	});
+}
+
+async function snapshot(response: Response) {
+	return {
+		status: response.status,
+		headers: [...response.headers.entries()].sort(),
+		body: await response.text(),
+	};
+}
+
+async function answers(handler: typeof GET = GET) {
+	const result: Record<string, Awaited<ReturnType<typeof snapshot>>> = {};
+	for (const file of FILES)
+		result[file] = await snapshot(await call(handler, file));
+	return result;
+}
+
+afterEach(() => {
+	vi.useRealTimers();
+});
+
+beforeEach(() => {
+	vi.clearAllMocks();
+	vi.useFakeTimers({ toFake: ["Date"] });
+	vi.setSystemTime(Date.UTC(2026, 10, 13, 12));
+	mocks.store.video = ready();
+	mocks.store.updates = [];
+	mocks.store.appDeleted = false;
+	mocks.standing.mockResolvedValue({ state: "active", pausesAt: null });
+	mocks.answersAnyOrigin.mockReturnValue(true);
+	mocks.sign.mockImplementation(
+		async (key: string) => `https://cdn.example/${key}?sig=a`,
+	);
+	mocks.readText.mockImplementation(async (key: string) =>
+		key === `${HLS_PREFIX}master.m3u8`
+			? master
+			: key.endsWith(".m3u8") && key !== `${HLS_PREFIX}missing.m3u8`
+				? rendition
+				: null,
+	);
+	vi.spyOn(console, "error").mockImplementation(() => undefined);
+});
+
+describe("a taken down video on the playback route", () => {
+	it.each(FILES)(
+		"answers %s with a plain 410 that is never cached",
+		async (file) => {
+			await setDeveloperVideoTakedown(PLAYBACK_ID, true);
+			vi.clearAllMocks();
+
+			const response = await call(GET, file);
+
+			expect(response.status).toBe(410);
+			expect(await response.text()).toBe("This video is not available.");
+			expect(response.headers.get("cache-control")).toBe("no-store");
+			expect(response.headers.get("content-type")).toBe(
+				"text/plain; charset=utf-8",
+			);
+			expect(response.headers.get("access-control-allow-origin")).toBe("*");
+			expect(response.headers.get("location")).toBeNull();
+			expect(mocks.sign).not.toHaveBeenCalled();
+			expect(mocks.readText).not.toHaveBeenCalled();
+			expect(mocks.standing).not.toHaveBeenCalled();
+		},
+	);
+
+	it("answers HEAD with the same 410", async () => {
+		await setDeveloperVideoTakedown(PLAYBACK_ID, true);
+
+		for (const file of FILES) {
+			const response = await call(HEAD, file);
+			expect(response.status).toBe(410);
+			expect(response.headers.get("cache-control")).toBe("no-store");
+		}
+	});
+
+	it("answers 410 before the out of credit pause, and for a video still processing", async () => {
+		mocks.standing.mockResolvedValue({ state: "paused", pausesAt: null });
+		mocks.store.video = ready({ status: "processing" });
+		await setDeveloperVideoTakedown(PLAYBACK_ID, true);
+
+		expect((await call(GET, "master.m3u8")).status).toBe(410);
+		mocks.store.video = { ...mocks.store.video, processing: null };
+		expect((await call(GET, "video.mp4")).status).toBe(410);
+	});
+
+	it("leaves the preflight answer alone", async () => {
+		const before = await snapshot(OPTIONS());
+		await setDeveloperVideoTakedown(PLAYBACK_ID, true);
+
+		expect(await snapshot(OPTIONS())).toEqual(before);
+	});
+
+	it("still answers 404 for a deleted video", async () => {
+		await setDeveloperVideoTakedown(PLAYBACK_ID, true);
+		mocks.store.video = {
+			...(mocks.store.video ?? ready()),
+			deletedAt: new Date(),
+		};
+
+		expect((await call(GET, "master.m3u8")).status).toBe(404);
+	});
+});
+
+describe("restoring a taken down video", () => {
+	it.each([
+		{ name: "no metadata", metadata: null },
+		{
+			name: "the developer's metadata",
+			metadata: { orderId: 42, tags: ["a"] },
+		},
+	])(
+		"answers every file exactly as before, with $name",
+		async ({ metadata }) => {
+			mocks.store.video = ready({ metadata });
+			const before = await answers();
+			const beforeHead = await answers(HEAD);
+			expect(before["master.m3u8"]?.status).toBe(200);
+			expect(before["1080p.m4s"]?.status).toBe(302);
+
+			await setDeveloperVideoTakedown(PLAYBACK_ID, true);
+			const down = await answers();
+			for (const file of FILES) expect(down[file]?.status).toBe(410);
+
+			await setDeveloperVideoTakedown(PLAYBACK_ID, false);
+
+			expect(await answers()).toEqual(before);
+			expect(await answers(HEAD)).toEqual(beforeHead);
+			expect(mocks.store.video?.metadata).toEqual(metadata);
+		},
+	);
+});
+
+describe("videos that were never taken down", () => {
+	it("answer as they did before this change", async () => {
+		const response = await call(GET, "master.m3u8");
+
+		expect(response.status).toBe(200);
+		expect(response.headers.get("cache-control")).toBe(
+			"public, max-age=60, s-maxage=60",
+		);
+		const media = await call(GET, "1080p.m4s");
+		expect(media.status).toBe(302);
+		expect(media.headers.get("location")).toBe(
+			`https://cdn.example/${HLS_PREFIX}1080p.m4s?sig=a`,
+		);
+		expect(media.headers.get("cache-control")).toBe(
+			"public, max-age=60, s-maxage=60",
+		);
+	});
+
+	it("keep developer metadata that only looks like a marker playing", async () => {
+		mocks.store.video = ready({
+			metadata: { __capTakedown: "not a marker" },
+		});
+
+		expect((await call(GET, "master.m3u8")).status).toBe(200);
+	});
+});
diff --git a/apps/web/__tests__/unit/proxy-developer-video-takedown.test.ts b/apps/web/__tests__/unit/proxy-developer-video-takedown.test.ts
new file mode 100644
index 00000000000..959ee34f38e
--- /dev/null
+++ b/apps/web/__tests__/unit/proxy-developer-video-takedown.test.ts
@@ -0,0 +1,95 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ gonePage: vi.fn() }));
+
+vi.mock("@cap/database", () => ({
+	db: () => ({
+		select: () => ({ from: () => ({ where: async () => [] }) }),
+	}),
+}));
+vi.mock("@cap/database/schema", () => ({ organizations: {} }));
+vi.mock("@cap/env", () => ({
+	buildEnv: { NEXT_PUBLIC_IS_CAP: "true" },
+	serverEnv: () => ({
+		WEB_URL: "https://cap.so",
+		VERCEL_URL_HOST: undefined,
+		VERCEL_BRANCH_URL_HOST: undefined,
+		VERCEL_PROJECT_PRODUCTION_URL_HOST: undefined,
+	}),
+}));
+vi.mock("@/lib/developer-video-takedown-store", () => ({
+	developerVideoGonePage: mocks.gonePage,
+}));
+
+const { proxy } = await import("../../proxy");
+
+const PLAYBACK_ID = "playback-id-0123456789ab";
+const send = (path: string, method = "GET") =>
+	proxy(new NextRequest(`https://cap.so${path}`, { method }));
+
+beforeEach(() => {
+	mocks.gonePage.mockReset();
+	mocks.gonePage.mockResolvedValue(null);
+});
+
+describe("proxy takedown check", () => {
+	it.each([`/dev/${PLAYBACK_ID}`, `/dev/${PLAYBACK_ID}/embed`])(
+		"answers %s with the 410 page for a taken down video, with no cookies or frame headers",
+		async (path) => {
+			const gone = new Response("gone", {
+				status: 410,
+				headers: { "Cache-Control": "no-store" },
+			});
+			mocks.gonePage.mockResolvedValue(gone);
+
+			const response = await send(`${path}?dub_id=click`);
+
+			expect(response).toBe(gone);
+			expect(mocks.gonePage).toHaveBeenCalledWith(path, "GET");
+			expect(response.headers.get("set-cookie")).toBeNull();
+			expect(response.headers.get("x-frame-options")).toBeNull();
+		},
+	);
+
+	it("lets the page render when the video is not taken down", async () => {
+		const response = await send(`/dev/${PLAYBACK_ID}`);
+
+		expect(response.status).toBe(200);
+		expect(response.headers.get("x-middleware-next")).toBe("1");
+	});
+
+	it.each([
+		`/s/${PLAYBACK_ID}`,
+		`/s/${PLAYBACK_ID}/edit`,
+		`/embed/${PLAYBACK_ID}`,
+		"/c/collection",
+		"/dashboard/caps",
+		"/login",
+		"/",
+	])("never checks %s", async (path) => {
+		const response = await send(path);
+
+		expect(mocks.gonePage).not.toHaveBeenCalled();
+		expect(response.status).not.toBe(410);
+	});
+});
+
+describe("proxy takedown check on a self-hosted build", () => {
+	it("skips the lookup, since only Cap staff can take a video down", async () => {
+		vi.resetModules();
+		vi.doMock("@cap/env", () => ({
+			buildEnv: { NEXT_PUBLIC_IS_CAP: "false" },
+			serverEnv: () => ({ WEB_URL: "https://cap.example.com" }),
+		}));
+		const selfHosted = await import("../../proxy");
+
+		const response = await selfHosted.proxy(
+			new NextRequest(`https://cap.example.com/dev/${PLAYBACK_ID}`),
+		);
+
+		expect(response.status).toBe(200);
+		expect(mocks.gonePage).not.toHaveBeenCalled();
+		vi.doUnmock("@cap/env");
+	});
+});
diff --git a/apps/web/__tests__/unit/proxy-frame-headers.test.ts b/apps/web/__tests__/unit/proxy-frame-headers.test.ts
index e2050cffe0a..23723933625 100644
--- a/apps/web/__tests__/unit/proxy-frame-headers.test.ts
+++ b/apps/web/__tests__/unit/proxy-frame-headers.test.ts
@@ -10,6 +10,10 @@ vi.mock("@cap/database", () => ({
 
 vi.mock("@cap/database/schema", () => ({ organizations: {} }));
 
+vi.mock("@/lib/developer-video-takedown-store", () => ({
+	developerVideoGonePage: async () => null,
+}));
+
 vi.mock("@cap/env", () => ({
 	buildEnv: { NEXT_PUBLIC_IS_CAP: "true" },
 	serverEnv: () => ({
diff --git a/apps/web/__tests__/unit/proxy-referral-click.test.ts b/apps/web/__tests__/unit/proxy-referral-click.test.ts
index 945c85a9b16..0e8361e2225 100644
--- a/apps/web/__tests__/unit/proxy-referral-click.test.ts
+++ b/apps/web/__tests__/unit/proxy-referral-click.test.ts
@@ -12,6 +12,10 @@ vi.mock("@cap/database", () => ({
 
 vi.mock("@cap/database/schema", () => ({ organizations: {} }));
 
+vi.mock("@/lib/developer-video-takedown-store", () => ({
+	developerVideoGonePage: async () => null,
+}));
+
 vi.mock("@cap/env", () => ({
 	buildEnv: {
 		get NEXT_PUBLIC_IS_CAP() {
diff --git a/apps/web/app/dev/_components/DeveloperVideoPage.tsx b/apps/web/app/dev/_components/DeveloperVideoPage.tsx
index 5031c01e5cf..6f40eb31a12 100644
--- a/apps/web/app/dev/_components/DeveloperVideoPage.tsx
+++ b/apps/web/app/dev/_components/DeveloperVideoPage.tsx
@@ -13,6 +13,10 @@ import {
 	type DeveloperVideoPlayer,
 	loadDeveloperVideoPlayer,
 } from "@/lib/developer-video-player";
+import {
+	DEVELOPER_VIDEO_UNAVAILABLE,
+	developerVideoReportHref,
+} from "@/lib/developer-video-takedown";
 import { INFRA_VIDEO_PUBLIC_FAILURE } from "@/lib/infra-video-view";
 import { RefreshUntilReady } from "./RefreshUntilReady";
 
@@ -24,7 +28,10 @@ export async function developerVideoMetadata(
 	playbackId: string,
 ): Promise<Metadata> {
 	const player = await loadPlayer(playbackId);
-	const title = player?.name ?? "Video not found";
+	const title =
+		player?.kind === "taken_down"
+			? "Video not available"
+			: (player?.name ?? "Video not found");
 	const images =
 		player?.kind === "playing" && player.poster ? [player.poster] : [];
 	return {
@@ -111,6 +118,9 @@ function Stage({
 	if (player.kind === "failed") {
 		return <Notice title={INFRA_VIDEO_PUBLIC_FAILURE} />;
 	}
+	if (player.kind === "taken_down") {
+		return <Notice title={DEVELOPER_VIDEO_UNAVAILABLE} />;
+	}
 	return (
 		<>
 			<Notice
@@ -123,21 +133,44 @@ function Stage({
 	);
 }
 
+// The embed sits on someone else's page, so its link only shows while the
+// pointer is over a player whose controls are showing, or on keyboard focus.
+const EMBED_REPORT_CLASS =
+	"pointer-events-none absolute right-2 top-2 z-10 rounded-[6px] bg-[rgba(5,5,6,0.55)] px-2 py-1 text-[12px] leading-none text-[rgba(232,236,244,0.72)] opacity-0 outline-none transition-opacity duration-200 hover:text-[#E8ECF4] focus-visible:pointer-events-auto focus-visible:opacity-100 focus-visible:ring-1 focus-visible:ring-[rgba(232,236,244,0.6)] [.group:hover:not(:has([data-idle=true]))_&]:pointer-events-auto [.group:hover:not(:has([data-idle=true]))_&]:opacity-100";
+
 export function DeveloperVideoView({
+	playbackId,
 	player,
 	variant,
 	playback = developerVideoPlayback({}, variant),
 }: {
+	playbackId: string;
 	player: DeveloperVideoPlayer;
 	variant: DeveloperVideoPageVariant;
 	playback?: DeveloperVideoPlayback;
 }) {
+	const takenDown = player.kind === "taken_down";
+	const reportHref = developerVideoReportHref(playbackId);
+
 	if (variant === "embed") {
 		return (
-			<div className="fixed inset-0 bg-black">
+			<div className="group fixed inset-0 bg-black">
 				<style>{"html,body{background:#000}"}</style>
-				<h1 className="sr-only">{player.name}</h1>
+				<h1 className="sr-only">
+					{takenDown ? DEVELOPER_VIDEO_UNAVAILABLE : player.name}
+				</h1>
 				<Stage player={player} playback={playback} />
+				{!takenDown && (
+					<a
+						href={reportHref}
+						target="_blank"
+						rel="noopener noreferrer"
+						aria-label="Report this video"
+						className={EMBED_REPORT_CLASS}
+					>
+						Report
+					</a>
+				)}
 			</div>
 		);
 	}
@@ -160,9 +193,22 @@ export function DeveloperVideoView({
 					>
 						<Stage player={player} playback={playback} />
 					</div>
-					<h1 className="m-0 mt-5 text-[18px] font-medium leading-[1.3] tracking-[-0.01em] text-[#E8ECF4] [overflow-wrap:anywhere]">
-						{player.name}
-					</h1>
+					{takenDown ? (
+						<h1 className="sr-only">{DEVELOPER_VIDEO_UNAVAILABLE}</h1>
+					) : (
+						<div className="mt-5 flex items-baseline justify-between gap-4">
+							<h1 className="m-0 min-w-0 text-[18px] font-medium leading-[1.3] tracking-[-0.01em] text-[#E8ECF4] [overflow-wrap:anywhere]">
+								{player.name}
+							</h1>
+							<a
+								href={reportHref}
+								aria-label="Report this video"
+								className="shrink-0 rounded-[4px] text-[13px] leading-[1.3] text-[rgba(232,236,244,0.42)] outline-none transition-colors hover:text-[rgba(232,236,244,0.8)] focus-visible:text-[#E8ECF4] focus-visible:ring-1 focus-visible:ring-[rgba(232,236,244,0.6)]"
+							>
+								Report
+							</a>
+						</div>
+					)}
 				</div>
 			</div>
 		</div>
@@ -182,6 +228,7 @@ export async function DeveloperVideoPage({
 	if (!player) notFound();
 	return (
 		<DeveloperVideoView
+			playbackId={playbackId}
 			player={player}
 			variant={variant}
 			playback={developerVideoPlayback(query, variant)}
diff --git a/apps/web/lib/developer-video-playback.ts b/apps/web/lib/developer-video-playback.ts
index b987a9f5327..3591a88acfb 100644
--- a/apps/web/lib/developer-video-playback.ts
+++ b/apps/web/lib/developer-video-playback.ts
@@ -14,6 +14,10 @@ import {
 	readDeveloperVideoText,
 	signedDeveloperVideoUrl,
 } from "./developer-video-storage";
+import {
+	DEVELOPER_VIDEO_UNAVAILABLE,
+	developerVideoIsTakenDown,
+} from "./developer-video-takedown";
 import { getInfraAppStanding } from "./infra-standing";
 
 export const PLAYBACK_ID_PATTERN = /^[A-Za-z0-9_-]{16,64}$/;
@@ -49,6 +53,18 @@ function notFound(): Response {
 	});
 }
 
+// Never cached, so restoring a video brings it back on the next request.
+function gone(): Response {
+	return new Response(DEVELOPER_VIDEO_UNAVAILABLE, {
+		status: 410,
+		headers: {
+			...PLAYBACK_CORS_HEADERS,
+			"Cache-Control": "no-store",
+			"Content-Type": "text/plain; charset=utf-8",
+		},
+	});
+}
+
 function paused(): Response {
 	return new Response(
 		"Playback is paused because the account that hosts this video is out of credit.",
@@ -277,6 +293,7 @@ export async function developerPlaybackResponse(
 	if (!PLAYBACK_ID_PATTERN.test(playbackId)) return notFound();
 
 	const video = await findPlayableVideo(playbackId);
+	if (video && developerVideoIsTakenDown(video)) return gone();
 	if (!video?.processing) return notFound();
 	if ((await getInfraAppStanding(video.appId)).state === "paused") {
 		return paused();
diff --git a/apps/web/lib/developer-video-player.ts b/apps/web/lib/developer-video-player.ts
index 69b8c076ae2..306072940e0 100644
--- a/apps/web/lib/developer-video-player.ts
+++ b/apps/web/lib/developer-video-player.ts
@@ -5,6 +5,7 @@ import {
 } from "./developer-video-playback";
 import { redriveDeveloperVideoProcessing } from "./developer-video-start";
 import { developerVideoRedrive } from "./developer-video-state";
+import { developerVideoIsTakenDown } from "./developer-video-takedown";
 import { getInfraAppStanding } from "./infra-standing";
 
 const DEFAULT_WIDTH = 16;
@@ -26,6 +27,7 @@ export type DeveloperVideoPlayer = DeveloperVideoFrame &
 		| { kind: "processing"; uploading: boolean }
 		| { kind: "failed" }
 		| { kind: "paused" }
+		| { kind: "taken_down" }
 	);
 
 type PlayableVideo = NonNullable<Awaited<ReturnType<typeof findPlayableVideo>>>;
@@ -55,6 +57,9 @@ export async function loadDeveloperVideoPlayer(
 
 	const found = await findPlayableVideo(playbackId);
 	if (!found) return null;
+	if (developerVideoIsTakenDown(found)) {
+		return { ...frameOf(found), kind: "taken_down" };
+	}
 
 	const standing = await getInfraAppStanding(found.appId);
 	if (standing.state === "paused") return { ...frameOf(found), kind: "paused" };
diff --git a/apps/web/proxy.ts b/apps/web/proxy.ts
index 7a2382d7e68..58a20036106 100644
--- a/apps/web/proxy.ts
+++ b/apps/web/proxy.ts
@@ -12,6 +12,7 @@ import { eq } from "drizzle-orm";
 import { notFound } from "next/navigation";
 import { type NextRequest, NextResponse, userAgent } from "next/server";
 import { agentMarkdownResponse } from "@/lib/agent-markdown";
+import { developerVideoGonePage } from "@/lib/developer-video-takedown-store";
 import { INFRA_PATH_HEADER, isInfraPathname } from "@/lib/infra-routes";
 import { getShareIframeRedirectUrl } from "@/lib/share-iframe-navigation";
 
@@ -145,6 +146,16 @@ export async function proxy(request: NextRequest) {
 		return rememberReferralClick(request, setFrameHeaders(NextResponse.next()));
 	}
 
+	// Only Cap staff can take a video down, so a self-hosted build skips the
+	// lookup. The playback route and the page still read the flag themselves.
+	if (
+		buildEnv.NEXT_PUBLIC_IS_CAP === "true" &&
+		path.startsWith(DEVELOPER_VIDEO_PREFIX)
+	) {
+		const gone = await developerVideoGonePage(path, request.method);
+		if (gone) return gone;
+	}
+
 	const response = await route(request);
 	if (path.startsWith(DEVELOPER_VIDEO_PREFIX)) return response;
 	return rememberReferralClick(

From 6fe2bf7777872c0dc3ebb70e89f69e577a6893a1 Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 00:37:06 -0500
Subject: [PATCH 03/12] feat: report takedowns in the developer API and the
 Infra console

GET /videos/{id}, /videos/{id}/status and the agent API add takenDown and
null the playback URLs while a video is taken down. The console shows the
video as Taken down rather than failed.
---
 .../agent-developer-response-size.test.ts     |   1 +
 .../unit/agent-developer-routes.test.ts       |   2 +
 .../unit/developer-video-api.test.ts          |   2 +
 .../unit/developer-video-takedown.test.ts     | 524 ++++++++++++++++++
 .../__tests__/unit/infra-video-fields.test.ts |   1 +
 .../__tests__/unit/infra-video-view.test.ts   |   1 +
 .../[appId]/videos/[videoId]/video-client.tsx |  10 +-
 .../infra/_components/video-status.tsx        |   4 +-
 .../app/(infra)/dashboard/infra/infra-data.ts |  15 +-
 apps/web/components/pages/infra/content.ts    |   1 +
 apps/web/content/docs/api/rest-api.mdx        |   7 +
 apps/web/lib/developer-openapi.ts             |   5 +
 apps/web/lib/developer-video-api.ts           |  43 +-
 apps/web/lib/infra-video-view.ts              |  13 +-
 packages/web-backend/src/AgentManagement.ts   |   2 +
 packages/web-domain/src/Agent.ts              |   1 +
 16 files changed, 620 insertions(+), 12 deletions(-)
 create mode 100644 apps/web/__tests__/unit/developer-video-takedown.test.ts

diff --git a/apps/web/__tests__/unit/agent-developer-response-size.test.ts b/apps/web/__tests__/unit/agent-developer-response-size.test.ts
index 1156f7c0cf9..3c548515689 100644
--- a/apps/web/__tests__/unit/agent-developer-response-size.test.ts
+++ b/apps/web/__tests__/unit/agent-developer-response-size.test.ts
@@ -27,6 +27,7 @@ const row = (index: number): AgentDeveloperVideoRow => ({
 	height: 720,
 	fps: 30,
 	maxResolutionTier: "1080p",
+	takenDown: false,
 	renditions: [
 		{
 			name: "720p",
diff --git a/apps/web/__tests__/unit/agent-developer-routes.test.ts b/apps/web/__tests__/unit/agent-developer-routes.test.ts
index c658799349e..352a8a6ddf8 100644
--- a/apps/web/__tests__/unit/agent-developer-routes.test.ts
+++ b/apps/web/__tests__/unit/agent-developer-routes.test.ts
@@ -346,6 +346,7 @@ describe("developer routes of the agent API", () => {
 			},
 		],
 		transcriptionStatus: null,
+		takenDown: false,
 		processing: {
 			hls: { state: "complete" },
 			mp4: { state: "complete" },
@@ -380,6 +381,7 @@ describe("developer routes of the agent API", () => {
 			maxResolutionTier: "1080p",
 			renditions: videoRow().renditions,
 			transcriptionStatus: null,
+			takenDown: false,
 			hlsUrl:
 				"http://localhost/api/developer/playback/playback-id-000000000001/master.m3u8",
 			mp4Url:
diff --git a/apps/web/__tests__/unit/developer-video-api.test.ts b/apps/web/__tests__/unit/developer-video-api.test.ts
index ed081dba51a..3e5e589e7f9 100644
--- a/apps/web/__tests__/unit/developer-video-api.test.ts
+++ b/apps/web/__tests__/unit/developer-video-api.test.ts
@@ -146,6 +146,7 @@ describe("developer video API", () => {
 			deletedAt: null,
 			createdAt: "2026-11-01T00:00:00.000Z",
 			updatedAt: "2026-11-01T00:00:00.000Z",
+			takenDown: false,
 			hlsUrl: `${BASE}/master.m3u8`,
 			mp4Url: `${BASE}/video.mp4`,
 			posterUrl: `${BASE}/poster.jpg`,
@@ -711,6 +712,7 @@ describe("developer video API", () => {
 			errorReason: null,
 			playbackId: "playback-id-0123456789ab",
 			renditions: ready().renditions,
+			takenDown: false,
 			hlsUrl: `${BASE}/master.m3u8`,
 			mp4Url: `${BASE}/video.mp4`,
 			posterUrl: `${BASE}/poster.jpg`,
diff --git a/apps/web/__tests__/unit/developer-video-takedown.test.ts b/apps/web/__tests__/unit/developer-video-takedown.test.ts
new file mode 100644
index 00000000000..1967c34ff78
--- /dev/null
+++ b/apps/web/__tests__/unit/developer-video-takedown.test.ts
@@ -0,0 +1,524 @@
+import { MySqlDialect } from "drizzle-orm/mysql-core";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	type DeveloperVideoStore,
+	developerVideo,
+	processingState,
+} from "../fixtures/developer-video";
+
+const mocks = vi.hoisted(() => ({
+	store: { video: null, appDeleted: false, updates: [] } as DeveloperVideoStore,
+	user: null as { id: string; email: string } | null,
+	failSelect: false,
+}));
+
+vi.mock("@cap/database", async () => {
+	const { createDeveloperVideoDatabase } = await import(
+		"../fixtures/developer-video"
+	);
+	const { withTakedownSql } = await import(
+		"../fixtures/developer-video-takedown"
+	);
+	const database = await withTakedownSql(
+		mocks.store,
+		await createDeveloperVideoDatabase(mocks.store),
+	);
+	return {
+		db: () => ({
+			...database,
+			select: (...args: Parameters<typeof database.select>) => {
+				if (mocks.failSelect) throw new Error("database unavailable");
+				return database.select(...args);
+			},
+		}),
+	};
+});
+vi.mock("@cap/database/auth/session", () => ({
+	getCurrentUser: async () => mocks.user,
+}));
+vi.mock("@cap/env", () => ({
+	serverEnv: () => ({ WEB_URL: "https://web.example" }),
+}));
+
+const takedown = await import("@/lib/developer-video-takedown");
+const store = await import("@/lib/developer-video-takedown-store");
+const sqlHelpers = await import("@cap/database/developer-video-takedown");
+const api = await import("@/lib/developer-video-api");
+const view = await import("@/lib/infra-video-view");
+const { POST } = await import("@/app/api/admin/developer-video-takedown/route");
+const script = await import("../../../../scripts/infra-video-takedown");
+
+const PLAYBACK_ID = "playback-id-0123456789ab";
+const NOW = new Date("2026-11-13T12:00:00.000Z");
+const STAFF = { id: "staff-user", email: "richie@cap.so" };
+
+const ready = (overrides: Parameters<typeof developerVideo>[0] = {}) =>
+	developerVideo({
+		status: "ready",
+		processing: processingState({
+			hls: { state: "complete", output: "hls-out" },
+			mp4: { state: "complete", output: "mp4-out" },
+			poster: { output: "mp4-out" },
+		}),
+		...overrides,
+	});
+
+const admin = (body: unknown, headers: Record<string, string> = {}) =>
+	POST(
+		new Request("https://web.example/api/admin/developer-video-takedown", {
+			method: "POST",
+			headers: { "content-type": "application/json", ...headers },
+			body: typeof body === "string" ? body : JSON.stringify(body),
+		}),
+	);
+
+beforeEach(() => {
+	mocks.store.video = ready();
+	mocks.store.more = [];
+	mocks.store.updates = [];
+	mocks.store.appDeleted = false;
+	mocks.user = STAFF;
+	mocks.failSelect = false;
+	vi.spyOn(console, "error").mockImplementation(() => undefined);
+	vi.spyOn(console, "info").mockImplementation(() => undefined);
+});
+
+describe("takedown marker", () => {
+	it("keeps the developer's metadata whole and gives it back on restore", async () => {
+		const metadata = { orderId: 42, nested: { list: [1, "two"] } };
+		mocks.store.video = ready({ metadata });
+
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, true, NOW);
+		const stored = mocks.store.video?.metadata;
+
+		expect(stored).toEqual({
+			__capTakedown: { at: NOW.toISOString(), metadata },
+		});
+		expect(takedown.developerVideoIsTakenDown({ metadata: stored })).toBe(true);
+		expect(takedown.developerVideoTakenDownAt(stored)).toBe(NOW.toISOString());
+		expect(takedown.developerVideoPublicMetadata(stored)).toEqual(metadata);
+
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, false, NOW);
+		expect(mocks.store.video?.metadata).toEqual(metadata);
+	});
+
+	it.each([
+		null,
+		{},
+		{ __capTakedown: "a developer value" },
+		{ __capTakedown: { at: 5, metadata: null } },
+		{ __capTakedown: { at: "2026-11-13" } },
+		[1, 2],
+		"text",
+	])("does not read %j as taken down", (metadata) => {
+		expect(takedown.developerVideoIsTakenDown({ metadata })).toBe(false);
+		expect(takedown.developerVideoPublicMetadata(metadata)).toEqual(metadata);
+	});
+
+	it("drops the reserved key from metadata a developer sends, and leaves other metadata as sent", () => {
+		const own = { a: 1 };
+		expect(takedown.withoutReservedMetadata(own)).toBe(own);
+		expect(takedown.withoutReservedMetadata(undefined)).toBeUndefined();
+		expect(
+			takedown.withoutReservedMetadata({ a: 1, __capTakedown: { at: "x" } }),
+		).toEqual({ a: 1 });
+	});
+
+	it("rewrites metadata in SQL so large numbers in it are never parsed and written back", () => {
+		const dialect = new MySqlDialect();
+		const down = dialect.sqlToQuery(sqlHelpers.takenDownMetadataSql(NOW));
+		const restore = dialect.sqlToQuery(sqlHelpers.restoredMetadataSql());
+		const listed = dialect.sqlToQuery(sqlHelpers.developerVideoTakenDownSql());
+
+		expect(down.sql).toBe(
+			"JSON_OBJECT(?, JSON_OBJECT('at', ?, 'metadata', `developer_videos`.`metadata`))",
+		);
+		expect(down.params).toEqual(["__capTakedown", NOW.toISOString()]);
+		expect(restore.sql).toBe(
+			"CASE WHEN JSON_TYPE(JSON_EXTRACT(`developer_videos`.`metadata`, ?)) = 'NULL' THEN NULL ELSE JSON_EXTRACT(`developer_videos`.`metadata`, ?) END",
+		);
+		expect(restore.params).toEqual([
+			'$."__capTakedown".metadata',
+			'$."__capTakedown".metadata',
+		]);
+		expect(listed.params).toEqual([
+			'$."__capTakedown".at',
+			'$."__capTakedown".metadata',
+		]);
+	});
+});
+
+describe("the takedown switch", () => {
+	it.each([
+		["a playback id", PLAYBACK_ID],
+		["a video id", "video-1"],
+		["the hosted page", `https://cap.so/dev/${PLAYBACK_ID}`],
+		["the embed", `https://cap.so/dev/${PLAYBACK_ID}/embed?autoplay=1`],
+		[
+			"a playback file",
+			`https://cap.so/api/developer/playback/${PLAYBACK_ID}/master.m3u8`,
+		],
+		["a playback host", `https://play.example/${PLAYBACK_ID}/video.mp4`],
+	])("finds the video from %s", async (_, input) => {
+		const result = await store.setDeveloperVideoTakedown(input, true, NOW);
+
+		expect(result).toEqual({
+			videoId: "video-1",
+			appId: "app-1",
+			playbackId: PLAYBACK_ID,
+			takenDown: true,
+			takenDownAt: NOW.toISOString(),
+			changed: true,
+		});
+	});
+
+	it("only writes metadata, so status, duration and every billed column stay as they were", async () => {
+		const before = { ...mocks.store.video };
+
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, true, NOW);
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, false, NOW);
+
+		expect(mocks.store.updates.map((update) => Object.keys(update))).toEqual([
+			["metadata"],
+			["metadata"],
+		]);
+		expect(mocks.store.video).toEqual(before);
+	});
+
+	it("does nothing when the video is already in the asked state", async () => {
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, true, NOW);
+		const again = await store.setDeveloperVideoTakedown(
+			PLAYBACK_ID,
+			true,
+			new Date(NOW.getTime() + 60_000),
+		);
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, false, NOW);
+		const restoredAgain = await store.setDeveloperVideoTakedown(
+			PLAYBACK_ID,
+			false,
+			NOW,
+		);
+
+		expect(again).toMatchObject({
+			changed: false,
+			takenDownAt: NOW.toISOString(),
+		});
+		expect(restoredAgain).toMatchObject({ changed: false, takenDown: false });
+		expect(mocks.store.updates).toHaveLength(2);
+	});
+
+	it("finds no deleted video and nothing for input that is not an id", async () => {
+		expect(
+			await store.setDeveloperVideoTakedown("not an id!", true),
+		).toBeNull();
+		mocks.store.video = ready({ deletedAt: NOW });
+		expect(await store.setDeveloperVideoTakedown(PLAYBACK_ID, true)).toBeNull();
+		expect(mocks.store.updates).toEqual([]);
+	});
+});
+
+describe("the staff route", () => {
+	it("takes a video down and restores it for staff", async () => {
+		const down = await admin({ video: PLAYBACK_ID, takenDown: true });
+		expect(down.status).toBe(200);
+		expect(down.headers.get("cache-control")).toBe("no-store");
+		expect((await down.json()).data).toMatchObject({
+			videoId: "video-1",
+			takenDown: true,
+			changed: true,
+		});
+		expect(
+			takedown.developerVideoIsTakenDown({
+				metadata: mocks.store.video?.metadata,
+			}),
+		).toBe(true);
+
+		const restore = await admin({ video: PLAYBACK_ID, takenDown: false });
+		expect((await restore.json()).data).toMatchObject({
+			takenDown: false,
+			changed: true,
+		});
+		expect(mocks.store.video?.metadata).toBeNull();
+	});
+
+	it.each([
+		["signed out", null],
+		["any other account", { id: "user-2", email: "someone@example.com" }],
+	])("refuses %s and changes nothing", async (_, user) => {
+		mocks.user = user;
+
+		const response = await admin({ video: PLAYBACK_ID, takenDown: true });
+
+		expect(response.status).toBe(403);
+		expect(mocks.store.updates).toEqual([]);
+	});
+
+	it.each([
+		["a form post", { "content-type": "application/x-www-form-urlencoded" }],
+		["a text post", { "content-type": "text/plain" }],
+		[
+			"JSON from another site",
+			{ "content-type": "application/json", origin: "https://evil.example" },
+		],
+	])("refuses %s before reading the session", async (_, headers) => {
+		const response = await admin(
+			{ video: PLAYBACK_ID, takenDown: true },
+			headers,
+		);
+
+		expect(response.status).toBe(400);
+		expect(mocks.store.updates).toEqual([]);
+	});
+
+	it("accepts JSON from its own origin", async () => {
+		const response = await admin(
+			{ video: PLAYBACK_ID, takenDown: true },
+			{ origin: "https://web.example" },
+		);
+
+		expect(response.status).toBe(200);
+	});
+
+	it.each([
+		["not JSON", "{"],
+		["no video", { takenDown: true }],
+		["a string flag", { video: PLAYBACK_ID, takenDown: "true" }],
+	])("answers 400 for %s", async (_, body) => {
+		expect((await admin(body)).status).toBe(400);
+	});
+
+	it("answers 404 when no video matches", async () => {
+		mocks.store.video = null;
+
+		expect((await admin({ video: PLAYBACK_ID, takenDown: true })).status).toBe(
+			404,
+		);
+	});
+});
+
+describe("the staff script", () => {
+	const run = async (argv: string[], env: Record<string, string>) => {
+		const lines: string[] = [];
+		const calls: { url: string; init: RequestInit }[] = [];
+		const code = await script.runTakedown({
+			argv,
+			env,
+			fetchImpl: async (url: string, init: RequestInit) => {
+				calls.push({ url, init });
+				return admin(JSON.parse(String(init.body)));
+			},
+			log: (line: string) => lines.push(line),
+			fail: (line: string) => lines.push(`error: ${line}`),
+		});
+		return { code, lines, calls };
+	};
+
+	it("takes a video down and restores it through the staff route", async () => {
+		const down = await run(["down", PLAYBACK_ID], {
+			CAP_SESSION_TOKEN: "session",
+			CAP_URL: "https://web.example/",
+		});
+
+		expect(down.code).toBe(0);
+		expect(down.calls[0]?.url).toBe(
+			"https://web.example/api/admin/developer-video-takedown",
+		);
+		expect(down.calls[0]?.init.headers).toEqual({
+			"Content-Type": "application/json",
+			Cookie: "next-auth.session-token=session",
+		});
+		expect(down.lines).toEqual([
+			`video-1 (playback ${PLAYBACK_ID}, app app-1) is taken down.`,
+		]);
+
+		const restore = await run(["restore", PLAYBACK_ID], {
+			CAP_SESSION_TOKEN: "session",
+		});
+		expect(restore.calls[0]?.url).toBe(
+			"https://cap.so/api/admin/developer-video-takedown",
+		);
+		expect(restore.lines).toEqual([
+			`video-1 (playback ${PLAYBACK_ID}, app app-1) is playing normally.`,
+		]);
+		expect(mocks.store.video?.metadata).toBeNull();
+	});
+
+	it("explains its usage and needs a session", async () => {
+		expect((await run(["remove", PLAYBACK_ID], {})).code).toBe(2);
+		expect((await run(["down"], {})).code).toBe(2);
+		const missing = await run(["down", PLAYBACK_ID], {});
+		expect(missing.code).toBe(2);
+		expect(missing.calls).toEqual([]);
+	});
+
+	it("fails when the route refuses", async () => {
+		mocks.user = null;
+
+		const refused = await run(["down", PLAYBACK_ID], {
+			CAP_SESSION_TOKEN: "session",
+		});
+
+		expect(refused.code).toBe(1);
+		expect(refused.lines).toEqual(["error: 403: Not allowed."]);
+	});
+});
+
+describe("the hosted and embed pages for a taken down video", () => {
+	it.each([`/dev/${PLAYBACK_ID}`, `/dev/${PLAYBACK_ID}/embed`])(
+		"answer %s with a plain 410 page that is never cached",
+		async (path) => {
+			await store.setDeveloperVideoTakedown(PLAYBACK_ID, true, NOW);
+
+			const response = await store.developerVideoGonePage(path, "GET");
+
+			expect(response?.status).toBe(410);
+			expect(response?.headers.get("cache-control")).toBe("no-store");
+			expect(response?.headers.get("content-type")).toBe(
+				"text/html; charset=utf-8",
+			);
+			expect(response?.headers.get("x-robots-tag")).toBe("noindex");
+			const html = await response?.text();
+			expect(html).toContain("<h1>This video is not available.</h1>");
+			expect(html).not.toContain(PLAYBACK_ID);
+			expect(html).not.toContain("—");
+
+			const head = await store.developerVideoGonePage(path, "HEAD");
+			expect(head?.status).toBe(410);
+			expect(await head?.text()).toBe("");
+		},
+	);
+
+	it("leaves the page to render for a video that is not taken down, or once restored", async () => {
+		expect(
+			await store.developerVideoGonePage(`/dev/${PLAYBACK_ID}`, "GET"),
+		).toBeNull();
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, true, NOW);
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, false, NOW);
+		expect(
+			await store.developerVideoGonePage(`/dev/${PLAYBACK_ID}/embed`, "GET"),
+		).toBeNull();
+	});
+
+	it.each([
+		"/dev",
+		"/dev/short",
+		`/dev/${PLAYBACK_ID}/other`,
+		`/s/${PLAYBACK_ID}`,
+		`/embed/${PLAYBACK_ID}`,
+	])("does not look up %s", async (path) => {
+		mocks.failSelect = true;
+		await expect(store.developerVideoGonePage(path, "GET")).resolves.toBeNull();
+		expect(console.error).not.toHaveBeenCalled();
+	});
+
+	it("lets the page render when the check fails", async () => {
+		mocks.failSelect = true;
+
+		await expect(
+			store.developerVideoGonePage(`/dev/${PLAYBACK_ID}`, "GET"),
+		).resolves.toBeNull();
+		await expect(
+			store.developerVideoGonePage(`/dev/${PLAYBACK_ID}`, "POST"),
+		).resolves.toBeNull();
+	});
+});
+
+describe("the developer API", () => {
+	const withEnv = () => ready({ metadata: { orderId: 7 } });
+
+	it("reports a taken down video honestly and leaves every other field as it was", async () => {
+		mocks.store.video = withEnv();
+		const before = api.serializeDeveloperVideo(mocks.store.video);
+		const beforeStatus = api.serializeDeveloperVideoStatus(mocks.store.video);
+		const agentRow = (row: NonNullable<typeof mocks.store.video>) => ({
+			...row,
+			takenDown: takedown.developerVideoIsTakenDown(row),
+		});
+		const beforeAgent = api.toAgentDeveloperVideo(agentRow(mocks.store.video));
+
+		await store.setDeveloperVideoTakedown(PLAYBACK_ID, true, NOW);
+		const video = mocks.store.video;
+		if (!video) throw new Error("missing video");
+
+		const nulls = { hlsUrl: null, mp4Url: null, posterUrl: null };
+		expect(api.serializeDeveloperVideo(video)).toEqual({
+			...before,
+			...nulls,
+			takenDown: true,
+		});
+		expect(api.serializeDeveloperVideoStatus(video)).toEqual({
+			...beforeStatus,
+			...nulls,
+			takenDown: true,
+		});
+		expect(api.toAgentDeveloperVideo(agentRow(video))).toEqual({
+			...beforeAgent,
+			...nulls,
+			takenDown: true,
+		});
+		expect(api.serializeDeveloperVideo(video)).toMatchObject({
+			status: "ready",
+			metadata: { orderId: 7 },
+			shareUrl: `https://web.example/dev/${PLAYBACK_ID}`,
+		});
+	});
+
+	it("adds takenDown false to a regular video and changes nothing else", () => {
+		const video = withEnv();
+		const serialized = api.serializeDeveloperVideo(video);
+
+		expect(serialized.takenDown).toBe(false);
+		expect(serialized.metadata).toEqual({ orderId: 7 });
+		expect(serialized.hlsUrl).toBe(
+			`https://web.example/api/developer/playback/${PLAYBACK_ID}/master.m3u8`,
+		);
+		expect(api.serializeDeveloperVideoStatus(video)).toMatchObject({
+			ready: true,
+			status: "ready",
+			takenDown: false,
+		});
+	});
+});
+
+describe("the owner's console", () => {
+	const row = (
+		takenDown: boolean,
+		status: "ready" | "processing" = "ready",
+	) => {
+		const video = ready({ status });
+		return { ...video, legacy: false, takenDown };
+	};
+
+	it("shows a taken down video as taken down, not as failed", () => {
+		expect(view.infraVideoState(row(true))).toBe("taken_down");
+		expect(view.infraVideoState(row(true, "processing"))).toBe("taken_down");
+		expect(view.INFRA_VIDEO_DISPLAY_LABELS.taken_down).toBe("Taken down");
+		expect(view.infraVideoDisplayState("taken_down", null)).toBe("taken_down");
+		expect(
+			view.infraVideoIsChanging(
+				{ state: "taken_down", createdAt: NOW },
+				NOW.getTime(),
+			),
+		).toBe(false);
+	});
+
+	it("offers no page, embed code or failure for a taken down video", () => {
+		const detail = view.toInfraVideoDetail(
+			row(true),
+			{ hlsUrl: null, mp4Url: null, posterUrl: null },
+			{
+				shareUrl: "https://web.example/dev/x",
+				embedUrl: "https://web.example/dev/x/embed",
+			},
+		);
+
+		expect(detail).toMatchObject({
+			state: "taken_down",
+			failure: null,
+			shareUrl: null,
+			embedCode: null,
+			stillEncoding: false,
+		});
+		expect(view.infraVideoState(row(false))).toBe("ready");
+	});
+});
diff --git a/apps/web/__tests__/unit/infra-video-fields.test.ts b/apps/web/__tests__/unit/infra-video-fields.test.ts
index 8398eafb6e9..f334ee45a9d 100644
--- a/apps/web/__tests__/unit/infra-video-fields.test.ts
+++ b/apps/web/__tests__/unit/infra-video-fields.test.ts
@@ -100,6 +100,7 @@ describe("console video list", () => {
 			"legacy",
 			"name",
 			"status",
+			"takenDown",
 			"width",
 		]);
 		expect(query(selection?.legacy).sql).toMatch(
diff --git a/apps/web/__tests__/unit/infra-video-view.test.ts b/apps/web/__tests__/unit/infra-video-view.test.ts
index 295e0b7b119..e1bca97e9dc 100644
--- a/apps/web/__tests__/unit/infra-video-view.test.ts
+++ b/apps/web/__tests__/unit/infra-video-view.test.ts
@@ -35,6 +35,7 @@ const row = (overrides: Parameters<typeof developerVideo>[0] = {}) => {
 	return {
 		...video,
 		legacy: video.playbackId === null && video.processing === null,
+		takenDown: false,
 	};
 };
 
diff --git a/apps/web/app/(infra)/dashboard/infra/[appId]/videos/[videoId]/video-client.tsx b/apps/web/app/(infra)/dashboard/infra/[appId]/videos/[videoId]/video-client.tsx
index e6f53818d12..a778cc67824 100644
--- a/apps/web/app/(infra)/dashboard/infra/[appId]/videos/[videoId]/video-client.tsx
+++ b/apps/web/app/(infra)/dashboard/infra/[appId]/videos/[videoId]/video-client.tsx
@@ -9,6 +9,7 @@ import { toast } from "sonner";
 import { deleteDeveloperVideo } from "@/actions/developers/delete-video";
 import { renameDeveloperVideo } from "@/actions/developers/rename-video";
 import { CapPlayer } from "@/components/cap-player/CapPlayer";
+import { DEVELOPER_VIDEO_REPORT_EMAIL } from "@/lib/developer-video-takedown";
 import { useEffectMutation } from "@/lib/EffectRuntime";
 import { infraAppPath } from "@/lib/infra-routes";
 import { formatBytes, formatDuration } from "@/lib/infra-usage";
@@ -286,7 +287,14 @@ export function VideoClient({
 
 			<div className="grid items-start gap-x-16 gap-y-10 lg:grid-cols-[minmax(0,1.6fr)_minmax(0,1fr)]">
 				<div className="min-w-0">
-					{video.state === "ready" && playable && playbackPaused ? (
+					{video.state === "taken_down" ? (
+						<Notice title="Taken down">
+							Cap took this video down after a report, so it does not play here,
+							on its page or anywhere it is embedded. It is still stored and
+							billed like your other videos. If you think this is a mistake,
+							email {DEVELOPER_VIDEO_REPORT_EMAIL}.
+						</Notice>
+					) : video.state === "ready" && playable && playbackPaused ? (
 						<Notice
 							title="Playback is paused"
 							action={
diff --git a/apps/web/app/(infra)/dashboard/infra/_components/video-status.tsx b/apps/web/app/(infra)/dashboard/infra/_components/video-status.tsx
index 139703f820e..50d11afbe1a 100644
--- a/apps/web/app/(infra)/dashboard/infra/_components/video-status.tsx
+++ b/apps/web/app/(infra)/dashboard/infra/_components/video-status.tsx
@@ -13,13 +13,14 @@ export function VideoStatus({
 }) {
 	const working = state === "processing" || state === "uploading";
 	const unfinished = state === "unfinished";
+	const takenDown = state === "taken_down";
 	return (
 		<span
 			className={clsx(
 				"inline-flex items-center gap-1.5 whitespace-nowrap text-[13px] leading-none",
 				state === "ready" && "text-[#E8ECF4]",
 				state === "failed" && "text-[#F2A199]",
-				(working || unfinished) && "text-[rgba(232,236,244,0.58)]",
+				(working || unfinished || takenDown) && "text-[rgba(232,236,244,0.58)]",
 				className,
 			)}
 		>
@@ -33,6 +34,7 @@ export function VideoStatus({
 					working &&
 						"animate-pulse bg-[rgba(232,236,244,0.7)] motion-reduce:animate-none",
 					unfinished && "shadow-[inset_0_0_0_1px_rgba(232,236,244,0.5)]",
+					takenDown && "bg-[rgba(232,236,244,0.45)]",
 				)}
 			/>
 			{INFRA_VIDEO_DISPLAY_LABELS[state]}
diff --git a/apps/web/app/(infra)/dashboard/infra/infra-data.ts b/apps/web/app/(infra)/dashboard/infra/infra-data.ts
index 4d42ba3b691..8c5faf8e0a8 100644
--- a/apps/web/app/(infra)/dashboard/infra/infra-data.ts
+++ b/apps/web/app/(infra)/dashboard/infra/infra-data.ts
@@ -3,6 +3,7 @@ import {
 	getCurrentUser,
 	type userSelectProps,
 } from "@cap/database/auth/session";
+import { developerVideoTakenDownSql } from "@cap/database/developer-video-takedown";
 import {
 	developerApiKeys,
 	developerApps,
@@ -24,6 +25,7 @@ import {
 } from "@/lib/developer-video-api";
 import { redriveDeveloperVideoProcessing } from "@/lib/developer-video-start";
 import { developerVideoRedrive } from "@/lib/developer-video-state";
+import { developerVideoIsTakenDown } from "@/lib/developer-video-takedown";
 import { canUseInfra } from "@/lib/infra-access";
 import { hasClaimedProCredit, nextProCreditDate } from "@/lib/infra-pro-credit";
 import { proCreditEligibility } from "@/lib/infra-pro-credit-eligibility";
@@ -140,6 +142,7 @@ export async function getDeveloperAppVideos(
 			legacy: sql<
 				number | string
 			>`(${developerVideos.playbackId} IS NULL AND ${developerVideos.processing} IS NULL)`,
+			takenDown: developerVideoTakenDownSql(),
 		})
 		.from(developerVideos)
 		.where(and(...conditions))
@@ -148,7 +151,10 @@ export async function getDeveloperAppVideos(
 		.offset(options?.offset ?? 0);
 
 	return rows.map((row) =>
-		toInfraVideoListItem({ ...row, legacy: Number(row.legacy) === 1 }),
+		toInfraVideoListItem({
+			...row,
+			legacy: Number(row.legacy) === 1,
+		}),
 	);
 }
 
@@ -169,6 +175,7 @@ async function findDeveloperAppVideo(appId: string, videoId: string) {
 			renditions: developerVideos.renditions,
 			playbackId: developerVideos.playbackId,
 			processing: developerVideos.processing,
+			metadata: developerVideos.metadata,
 		})
 		.from(developerVideos)
 		.where(
@@ -196,7 +203,11 @@ export const getDeveloperAppVideo = cache(
 			row = (await findDeveloperAppVideo(appId, videoId)) ?? row;
 		}
 		return toInfraVideoDetail(
-			{ ...row, legacy: row.playbackId === null && row.processing === null },
+			{
+				...row,
+				legacy: row.playbackId === null && row.processing === null,
+				takenDown: developerVideoIsTakenDown(row),
+			},
 			developerVideoPlaybackUrls(row),
 			row.playbackId ? developerVideoPageUrls(row.playbackId) : null,
 		);
diff --git a/apps/web/components/pages/infra/content.ts b/apps/web/components/pages/infra/content.ts
index 0577807cb60..f0073157613 100644
--- a/apps/web/components/pages/infra/content.ts
+++ b/apps/web/components/pages/infra/content.ts
@@ -214,6 +214,7 @@ export const VIDEO_STATUS_RESPONSE = `{
       { "name": "720p", "width": 1280, "height": 720, "bitrate": 1161000, "bytes": 18070000, "codecs": "avc1.64001f,mp4a.40.2" },
       { "name": "360p", "width": 640, "height": 360, "bitrate": 261000, "bytes": 4060000, "codecs": "avc1.64001e,mp4a.40.2" }
     ],
+    "takenDown": false,
     "hlsUrl": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/master.m3u8",
     "mp4Url": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/video.mp4",
     "posterUrl": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/poster.jpg"
diff --git a/apps/web/content/docs/api/rest-api.mdx b/apps/web/content/docs/api/rest-api.mdx
index 62c801b629f..2e2b876a4fc 100644
--- a/apps/web/content/docs/api/rest-api.mdx
+++ b/apps/web/content/docs/api/rest-api.mdx
@@ -387,6 +387,7 @@ Each item is the full [video object](/docs/api/rest-api#video-object-reference),
       "deletedAt": null,
       "createdAt": "2025-06-15T10:30:00.000Z",
       "updatedAt": "2025-06-15T10:32:00.000Z",
+      "takenDown": false,
       "hlsUrl": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/master.m3u8",
       "mp4Url": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/video.mp4",
       "posterUrl": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/poster.jpg",
@@ -413,6 +414,7 @@ Each item is the full [video object](/docs/api/rest-api#video-object-reference),
       "deletedAt": null,
       "createdAt": "2025-06-15T10:20:00.000Z",
       "updatedAt": "2025-06-15T10:20:00.000Z",
+      "takenDown": false,
       "hlsUrl": null,
       "mp4Url": null,
       "posterUrl": null,
@@ -484,6 +486,7 @@ curl https://cap.so/api/developer/v1/videos/abc123def456 \
     "deletedAt": null,
     "createdAt": "2025-06-15T10:30:00.000Z",
     "updatedAt": "2025-06-15T10:32:00.000Z",
+    "takenDown": false,
     "hlsUrl": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/master.m3u8",
     "mp4Url": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/video.mp4",
     "posterUrl": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/poster.jpg",
@@ -543,6 +546,7 @@ curl https://cap.so/api/developer/v1/videos/abc123def456/status \
       { "name": "720p", "width": 1280, "height": 720, "bitrate": 1161000, "bytes": 18070000, "codecs": "avc1.64001f,mp4a.40.2" },
       { "name": "360p", "width": 640, "height": 360, "bitrate": 261000, "bytes": 4060000, "codecs": "avc1.64001e,mp4a.40.2" }
     ],
+    "takenDown": false,
     "hlsUrl": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/master.m3u8",
     "mp4Url": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/video.mp4",
     "posterUrl": "https://cap.so/api/developer/playback/Zk3vQ9s2Lm8Rt1Xy7Bc4Df6G/poster.jpg"
@@ -562,6 +566,8 @@ On a ready video, one of `hlsUrl` and `mp4Url` can still be `null` while that ou
 
 `externalUserId` is the `userId` the video was created with, so one call can confirm the owner and read the status.
 
+`takenDown` is `true` when Cap has taken the video down after a report. Its playback URLs are then `null`, and its page, embed and playback files answer `410 Gone`. `status` does not change, and the video is stored and billed as before. Email hello@cap.so about a takedown.
+
 `transcriptionStatus` is `null`. Uploaded videos are not transcribed automatically. To get text, send the file to [Transcripts](/docs/api/rest-api#transcripts).
 
 ### Delete Video
@@ -1496,6 +1502,7 @@ The full video object returned by list and get endpoints:
 | `hlsUrl` | string \| null | Adaptive HLS master playlist (null until it is encoded) |
 | `mp4Url` | string \| null | Progressive MP4 (null until it is encoded) |
 | `posterUrl` | string \| null | Poster image (null until ready) |
+| `takenDown` | boolean | `true` when Cap has taken the video down after a report. The playback URLs are then null, and the page, embed and playback files answer `410 Gone` |
 | `shareUrl` | string \| null | Hosted player page for the video (null only for a video with no `playbackId`) |
 | `embedUrl` | string \| null | The same player with nothing around it, for an iframe (null only for a video with no `playbackId`) |
 | `deletedAt` | string \| null | Deletion timestamp (null for active videos) |
diff --git a/apps/web/lib/developer-openapi.ts b/apps/web/lib/developer-openapi.ts
index bd61a1469bf..54d1540ae8d 100644
--- a/apps/web/lib/developer-openapi.ts
+++ b/apps/web/lib/developer-openapi.ts
@@ -321,6 +321,11 @@ const playbackProperties = {
 		format: "uri",
 		description: "Poster image. Null until ready.",
 	},
+	takenDown: {
+		type: "boolean",
+		description:
+			"True when Cap has taken the video down after a report. Its playback URLs are null, and its page, embed and playback files answer 410 Gone until Cap restores it. status is unchanged, and the video is stored and billed as before. Email hello@cap.so about a takedown.",
+	},
 };
 
 const developerVideoSchema = {
diff --git a/apps/web/lib/developer-video-api.ts b/apps/web/lib/developer-video-api.ts
index 5ecf2f0c9fb..6d01820a559 100644
--- a/apps/web/lib/developer-video-api.ts
+++ b/apps/web/lib/developer-video-api.ts
@@ -5,6 +5,10 @@ import {
 	DEVELOPER_VIDEO_MP4_FILE,
 	DEVELOPER_VIDEO_POSTER_FILE,
 } from "./developer-video-plan";
+import {
+	developerVideoIsTakenDown,
+	developerVideoPublicMetadata,
+} from "./developer-video-takedown";
 
 type DeveloperVideoRow = typeof developerVideos.$inferSelect;
 
@@ -14,11 +18,32 @@ export interface DeveloperVideoOutputs {
 	poster: boolean;
 }
 
+// A row read in full carries its metadata. A list that does not load
+// metadata selects the takedown flag on its own instead.
+type TakedownSource = { metadata: unknown } | { takenDown: boolean };
+
+type PlayableFields = Pick<
+	DeveloperVideoRow,
+	"status" | "playbackId" | "processing"
+> &
+	TakedownSource;
+
+export function developerVideoTakenDown(video: TakedownSource): boolean {
+	return "takenDown" in video
+		? video.takenDown
+		: developerVideoIsTakenDown(video);
+}
+
 export function developerVideoOutputs(
-	video: Pick<DeveloperVideoRow, "status" | "playbackId" | "processing">,
+	video: PlayableFields,
 ): DeveloperVideoOutputs {
 	const processing = video.processing;
-	if (video.status !== "ready" || !video.playbackId || !processing) {
+	if (
+		video.status !== "ready" ||
+		!video.playbackId ||
+		!processing ||
+		developerVideoTakenDown(video)
+	) {
 		return { hls: false, mp4: false, poster: false };
 	}
 	return {
@@ -34,9 +59,11 @@ export function developerPlaybackBaseUrl(): string {
 	return base.replace(/\/+$/, "");
 }
 
-export function developerVideoPlaybackUrls(
-	video: Pick<DeveloperVideoRow, "status" | "playbackId" | "processing">,
-): { hlsUrl: string | null; mp4Url: string | null; posterUrl: string | null } {
+export function developerVideoPlaybackUrls(video: PlayableFields): {
+	hlsUrl: string | null;
+	mp4Url: string | null;
+	posterUrl: string | null;
+} {
 	const outputs = developerVideoOutputs(video);
 	const base = `${developerPlaybackBaseUrl()}/${video.playbackId}`;
 	return {
@@ -73,7 +100,7 @@ export type AgentDeveloperVideoRow = Pick<
 	| "processing"
 	| "createdAt"
 	| "updatedAt"
->;
+> & { takenDown: boolean };
 
 export function toAgentDeveloperVideo(video: AgentDeveloperVideoRow) {
 	const status = developerVideoIsReady(video) ? "ready" : video.status;
@@ -92,6 +119,7 @@ export function toAgentDeveloperVideo(video: AgentDeveloperVideoRow) {
 		maxResolutionTier: video.maxResolutionTier,
 		renditions: video.renditions ?? [],
 		transcriptionStatus: video.transcriptionStatus,
+		takenDown: video.takenDown,
 		...developerVideoPlaybackUrls(video),
 		...(video.playbackId
 			? developerVideoPageUrls(video.playbackId)
@@ -110,7 +138,9 @@ export function serializeDeveloperVideo(video: DeveloperVideoRow) {
 	} = video;
 	return {
 		...fields,
+		metadata: developerVideoPublicMetadata(video.metadata),
 		renditions: video.renditions ?? [],
+		takenDown: developerVideoIsTakenDown(video),
 		...developerVideoPlaybackUrls(video),
 		...(video.playbackId
 			? developerVideoPageUrls(video.playbackId)
@@ -145,6 +175,7 @@ export function serializeDeveloperVideoStatus(video: DeveloperVideoRow) {
 		errorReason: video.errorReason,
 		playbackId: video.playbackId,
 		renditions: video.renditions ?? [],
+		takenDown: developerVideoIsTakenDown(video),
 		...developerVideoPlaybackUrls(video),
 	};
 }
diff --git a/apps/web/lib/infra-video-view.ts b/apps/web/lib/infra-video-view.ts
index 62220e56212..05b5eee0aba 100644
--- a/apps/web/lib/infra-video-view.ts
+++ b/apps/web/lib/infra-video-view.ts
@@ -1,10 +1,16 @@
-export type InfraVideoState = "uploading" | "processing" | "ready" | "failed";
+export type InfraVideoState =
+	| "uploading"
+	| "processing"
+	| "ready"
+	| "failed"
+	| "taken_down";
 
 export const INFRA_VIDEO_STATE_LABELS: Record<InfraVideoState, string> = {
 	uploading: "Uploading",
 	processing: "Processing",
 	ready: "Ready",
 	failed: "Failed",
+	taken_down: "Taken down",
 };
 
 export type InfraLocalUpload = "sending" | "sent" | null;
@@ -93,6 +99,7 @@ export type InfraVideoDetail = InfraVideoListItem & {
 type StateInput = {
 	status: string;
 	legacy: boolean;
+	takenDown: boolean;
 	duration: number | null;
 	width: number | null;
 };
@@ -100,6 +107,7 @@ type StateInput = {
 // Mirrors developerVideoIsReady: a video uploaded before encoding existed has
 // no playback id and no processing state, and is ready once it was measured.
 export function infraVideoState(video: StateInput): InfraVideoState {
+	if (video.takenDown) return "taken_down";
 	if (video.status === "ready") return "ready";
 	if (video.legacy && video.duration !== null && video.width !== null) {
 		return "ready";
@@ -194,7 +202,8 @@ export function toInfraVideoDetail(
 	page: { shareUrl: string; embedUrl: string } | null = null,
 ): InfraVideoDetail {
 	const item = toInfraVideoListItem(row);
-	const shared = page !== null && item.state !== "failed";
+	const shared =
+		page !== null && item.state !== "failed" && item.state !== "taken_down";
 	return {
 		...item,
 		width: row.width,
diff --git a/packages/web-backend/src/AgentManagement.ts b/packages/web-backend/src/AgentManagement.ts
index 8298434efad..04c535d791c 100644
--- a/packages/web-backend/src/AgentManagement.ts
+++ b/packages/web-backend/src/AgentManagement.ts
@@ -1,3 +1,4 @@
+import { developerVideoTakenDownSql } from "@cap/database/developer-video-takedown";
 import * as Db from "@cap/database/schema";
 import {
 	type Folder,
@@ -29,6 +30,7 @@ const developerVideoColumns = {
 	renditions: Db.developerVideos.renditions,
 	transcriptionStatus: Db.developerVideos.transcriptionStatus,
 	processing: Db.developerVideos.processing,
+	takenDown: developerVideoTakenDownSql(),
 	createdAt: Db.developerVideos.createdAt,
 	updatedAt: Db.developerVideos.updatedAt,
 };
diff --git a/packages/web-domain/src/Agent.ts b/packages/web-domain/src/Agent.ts
index 1d7452e556c..6692dc3d7c7 100644
--- a/packages/web-domain/src/Agent.ts
+++ b/packages/web-domain/src/Agent.ts
@@ -1115,6 +1115,7 @@ export const AgentDeveloperVideo = Schema.Struct({
 		}),
 	),
 	transcriptionStatus: Schema.NullOr(Schema.String),
+	takenDown: Schema.optional(Schema.Boolean),
 	hlsUrl: Schema.NullOr(Schema.String),
 	mp4Url: Schema.NullOr(Schema.String),
 	posterUrl: Schema.NullOr(Schema.String),

From 4d5a1900f8910740a94c0ee9360beca249436c78 Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 00:46:46 -0500
Subject: [PATCH 04/12] fix: read takedown as false for videos with no metadata

---
 apps/web/__tests__/unit/developer-video-takedown.test.ts | 7 +++++++
 apps/web/lib/developer-video-api.ts                      | 2 +-
 packages/database/developer-video-takedown.ts            | 5 +++--
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/apps/web/__tests__/unit/developer-video-takedown.test.ts b/apps/web/__tests__/unit/developer-video-takedown.test.ts
index 1967c34ff78..39d981771fb 100644
--- a/apps/web/__tests__/unit/developer-video-takedown.test.ts
+++ b/apps/web/__tests__/unit/developer-video-takedown.test.ts
@@ -141,6 +141,7 @@ describe("takedown marker", () => {
 			'$."__capTakedown".metadata',
 			'$."__capTakedown".metadata',
 		]);
+		expect(listed.sql).toMatch(/^COALESCE\(\(JSON_TYPE\(.*\), FALSE\)$/);
 		expect(listed.params).toEqual([
 			'$."__capTakedown".at',
 			'$."__capTakedown".metadata',
@@ -463,6 +464,12 @@ describe("the developer API", () => {
 		});
 	});
 
+	it("gives the agent API a boolean even when the database answers NULL", () => {
+		const row = { ...withEnv(), takenDown: null as unknown as boolean };
+
+		expect(api.toAgentDeveloperVideo(row).takenDown).toBe(false);
+	});
+
 	it("adds takenDown false to a regular video and changes nothing else", () => {
 		const video = withEnv();
 		const serialized = api.serializeDeveloperVideo(video);
diff --git a/apps/web/lib/developer-video-api.ts b/apps/web/lib/developer-video-api.ts
index 6d01820a559..bf3de15c118 100644
--- a/apps/web/lib/developer-video-api.ts
+++ b/apps/web/lib/developer-video-api.ts
@@ -119,7 +119,7 @@ export function toAgentDeveloperVideo(video: AgentDeveloperVideoRow) {
 		maxResolutionTier: video.maxResolutionTier,
 		renditions: video.renditions ?? [],
 		transcriptionStatus: video.transcriptionStatus,
-		takenDown: video.takenDown,
+		takenDown: video.takenDown === true,
 		...developerVideoPlaybackUrls(video),
 		...(video.playbackId
 			? developerVideoPageUrls(video.playbackId)
diff --git a/packages/database/developer-video-takedown.ts b/packages/database/developer-video-takedown.ts
index 115b33b9908..d0b7405b1db 100644
--- a/packages/database/developer-video-takedown.ts
+++ b/packages/database/developer-video-takedown.ts
@@ -22,9 +22,10 @@ export function restoredMetadataSql(): SQL {
 }
 
 // For queries that list videos without loading their metadata. It matches
-// developerVideoIsTakenDown in the web app.
+// developerVideoIsTakenDown in the web app. Without the COALESCE a row with no
+// metadata reads as NULL, which drizzle passes through without mapWith.
 export function developerVideoTakenDownSql(): SQL<boolean> {
-	return sql<boolean>`(JSON_TYPE(JSON_EXTRACT(${developerVideos.metadata}, ${AT_PATH})) = 'STRING' AND JSON_CONTAINS_PATH(${developerVideos.metadata}, 'one', ${KEPT_PATH}))`.mapWith(
+	return sql<boolean>`COALESCE((JSON_TYPE(JSON_EXTRACT(${developerVideos.metadata}, ${AT_PATH})) = 'STRING' AND JSON_CONTAINS_PATH(${developerVideos.metadata}, 'one', ${KEPT_PATH})), FALSE)`.mapWith(
 		(value) => Number(value) === 1,
 	);
 }

From 3e24de7f9236d098d542115c9f3e57a90b1d6c96 Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 00:46:46 -0500
Subject: [PATCH 05/12] docs: say how long already loaded media links last
 after a takedown

---
 apps/web/content/docs/api/rest-api.mdx | 2 +-
 apps/web/lib/developer-openapi.ts      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/apps/web/content/docs/api/rest-api.mdx b/apps/web/content/docs/api/rest-api.mdx
index 2e2b876a4fc..134cfce6d06 100644
--- a/apps/web/content/docs/api/rest-api.mdx
+++ b/apps/web/content/docs/api/rest-api.mdx
@@ -566,7 +566,7 @@ On a ready video, one of `hlsUrl` and `mp4Url` can still be `null` while that ou
 
 `externalUserId` is the `userId` the video was created with, so one call can confirm the owner and read the status.
 
-`takenDown` is `true` when Cap has taken the video down after a report. Its playback URLs are then `null`, and its page, embed and playback files answer `410 Gone`. `status` does not change, and the video is stored and billed as before. Email hello@cap.so about a takedown.
+`takenDown` is `true` when Cap has taken the video down after a report. Its playback URLs are then `null`, and its page, embed and playback files answer `410 Gone` to every new request. A player that already loaded the video holds signed media links that keep working until they expire, at most 18 hours later. `status` does not change, and the video is stored and billed as before. Email hello@cap.so about a takedown.
 
 `transcriptionStatus` is `null`. Uploaded videos are not transcribed automatically. To get text, send the file to [Transcripts](/docs/api/rest-api#transcripts).
 
diff --git a/apps/web/lib/developer-openapi.ts b/apps/web/lib/developer-openapi.ts
index 54d1540ae8d..77ead960385 100644
--- a/apps/web/lib/developer-openapi.ts
+++ b/apps/web/lib/developer-openapi.ts
@@ -324,7 +324,7 @@ const playbackProperties = {
 	takenDown: {
 		type: "boolean",
 		description:
-			"True when Cap has taken the video down after a report. Its playback URLs are null, and its page, embed and playback files answer 410 Gone until Cap restores it. status is unchanged, and the video is stored and billed as before. Email hello@cap.so about a takedown.",
+			"True when Cap has taken the video down after a report. Its playback URLs are null, and its page, embed and playback files answer 410 Gone to new requests until Cap restores it. Signed media links a player already loaded keep working until they expire, at most 18 hours later. status is unchanged, and the video is stored and billed as before. Email hello@cap.so about a takedown.",
 	},
 };
 

From 118773531c63048a39f0eefbd3e7da88de3ca9d5 Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 00:51:41 -0500
Subject: [PATCH 06/12] refactor: drop the takedown lookup from the proxy

---
 .../unit/developer-video-takedown.test.ts     | 72 +-------------
 .../proxy-developer-video-takedown.test.ts    | 95 -------------------
 .../unit/proxy-frame-headers.test.ts          |  4 -
 .../unit/proxy-referral-click.test.ts         |  4 -
 .../web/lib/developer-video-takedown-store.ts | 46 ---------
 apps/web/proxy.ts                             | 11 ---
 6 files changed, 1 insertion(+), 231 deletions(-)
 delete mode 100644 apps/web/__tests__/unit/proxy-developer-video-takedown.test.ts

diff --git a/apps/web/__tests__/unit/developer-video-takedown.test.ts b/apps/web/__tests__/unit/developer-video-takedown.test.ts
index 39d981771fb..4c437e7143a 100644
--- a/apps/web/__tests__/unit/developer-video-takedown.test.ts
+++ b/apps/web/__tests__/unit/developer-video-takedown.test.ts
@@ -9,7 +9,6 @@ import {
 const mocks = vi.hoisted(() => ({
 	store: { video: null, appDeleted: false, updates: [] } as DeveloperVideoStore,
 	user: null as { id: string; email: string } | null,
-	failSelect: false,
 }));
 
 vi.mock("@cap/database", async () => {
@@ -23,15 +22,7 @@ vi.mock("@cap/database", async () => {
 		mocks.store,
 		await createDeveloperVideoDatabase(mocks.store),
 	);
-	return {
-		db: () => ({
-			...database,
-			select: (...args: Parameters<typeof database.select>) => {
-				if (mocks.failSelect) throw new Error("database unavailable");
-				return database.select(...args);
-			},
-		}),
-	};
+	return { db: () => database };
 });
 vi.mock("@cap/database/auth/session", () => ({
 	getCurrentUser: async () => mocks.user,
@@ -78,7 +69,6 @@ beforeEach(() => {
 	mocks.store.updates = [];
 	mocks.store.appDeleted = false;
 	mocks.user = STAFF;
-	mocks.failSelect = false;
 	vi.spyOn(console, "error").mockImplementation(() => undefined);
 	vi.spyOn(console, "info").mockImplementation(() => undefined);
 });
@@ -364,66 +354,6 @@ describe("the staff script", () => {
 	});
 });
 
-describe("the hosted and embed pages for a taken down video", () => {
-	it.each([`/dev/${PLAYBACK_ID}`, `/dev/${PLAYBACK_ID}/embed`])(
-		"answer %s with a plain 410 page that is never cached",
-		async (path) => {
-			await store.setDeveloperVideoTakedown(PLAYBACK_ID, true, NOW);
-
-			const response = await store.developerVideoGonePage(path, "GET");
-
-			expect(response?.status).toBe(410);
-			expect(response?.headers.get("cache-control")).toBe("no-store");
-			expect(response?.headers.get("content-type")).toBe(
-				"text/html; charset=utf-8",
-			);
-			expect(response?.headers.get("x-robots-tag")).toBe("noindex");
-			const html = await response?.text();
-			expect(html).toContain("<h1>This video is not available.</h1>");
-			expect(html).not.toContain(PLAYBACK_ID);
-			expect(html).not.toContain("—");
-
-			const head = await store.developerVideoGonePage(path, "HEAD");
-			expect(head?.status).toBe(410);
-			expect(await head?.text()).toBe("");
-		},
-	);
-
-	it("leaves the page to render for a video that is not taken down, or once restored", async () => {
-		expect(
-			await store.developerVideoGonePage(`/dev/${PLAYBACK_ID}`, "GET"),
-		).toBeNull();
-		await store.setDeveloperVideoTakedown(PLAYBACK_ID, true, NOW);
-		await store.setDeveloperVideoTakedown(PLAYBACK_ID, false, NOW);
-		expect(
-			await store.developerVideoGonePage(`/dev/${PLAYBACK_ID}/embed`, "GET"),
-		).toBeNull();
-	});
-
-	it.each([
-		"/dev",
-		"/dev/short",
-		`/dev/${PLAYBACK_ID}/other`,
-		`/s/${PLAYBACK_ID}`,
-		`/embed/${PLAYBACK_ID}`,
-	])("does not look up %s", async (path) => {
-		mocks.failSelect = true;
-		await expect(store.developerVideoGonePage(path, "GET")).resolves.toBeNull();
-		expect(console.error).not.toHaveBeenCalled();
-	});
-
-	it("lets the page render when the check fails", async () => {
-		mocks.failSelect = true;
-
-		await expect(
-			store.developerVideoGonePage(`/dev/${PLAYBACK_ID}`, "GET"),
-		).resolves.toBeNull();
-		await expect(
-			store.developerVideoGonePage(`/dev/${PLAYBACK_ID}`, "POST"),
-		).resolves.toBeNull();
-	});
-});
-
 describe("the developer API", () => {
 	const withEnv = () => ready({ metadata: { orderId: 7 } });
 
diff --git a/apps/web/__tests__/unit/proxy-developer-video-takedown.test.ts b/apps/web/__tests__/unit/proxy-developer-video-takedown.test.ts
deleted file mode 100644
index 959ee34f38e..00000000000
--- a/apps/web/__tests__/unit/proxy-developer-video-takedown.test.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-import { NextRequest } from "next/server";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mocks = vi.hoisted(() => ({ gonePage: vi.fn() }));
-
-vi.mock("@cap/database", () => ({
-	db: () => ({
-		select: () => ({ from: () => ({ where: async () => [] }) }),
-	}),
-}));
-vi.mock("@cap/database/schema", () => ({ organizations: {} }));
-vi.mock("@cap/env", () => ({
-	buildEnv: { NEXT_PUBLIC_IS_CAP: "true" },
-	serverEnv: () => ({
-		WEB_URL: "https://cap.so",
-		VERCEL_URL_HOST: undefined,
-		VERCEL_BRANCH_URL_HOST: undefined,
-		VERCEL_PROJECT_PRODUCTION_URL_HOST: undefined,
-	}),
-}));
-vi.mock("@/lib/developer-video-takedown-store", () => ({
-	developerVideoGonePage: mocks.gonePage,
-}));
-
-const { proxy } = await import("../../proxy");
-
-const PLAYBACK_ID = "playback-id-0123456789ab";
-const send = (path: string, method = "GET") =>
-	proxy(new NextRequest(`https://cap.so${path}`, { method }));
-
-beforeEach(() => {
-	mocks.gonePage.mockReset();
-	mocks.gonePage.mockResolvedValue(null);
-});
-
-describe("proxy takedown check", () => {
-	it.each([`/dev/${PLAYBACK_ID}`, `/dev/${PLAYBACK_ID}/embed`])(
-		"answers %s with the 410 page for a taken down video, with no cookies or frame headers",
-		async (path) => {
-			const gone = new Response("gone", {
-				status: 410,
-				headers: { "Cache-Control": "no-store" },
-			});
-			mocks.gonePage.mockResolvedValue(gone);
-
-			const response = await send(`${path}?dub_id=click`);
-
-			expect(response).toBe(gone);
-			expect(mocks.gonePage).toHaveBeenCalledWith(path, "GET");
-			expect(response.headers.get("set-cookie")).toBeNull();
-			expect(response.headers.get("x-frame-options")).toBeNull();
-		},
-	);
-
-	it("lets the page render when the video is not taken down", async () => {
-		const response = await send(`/dev/${PLAYBACK_ID}`);
-
-		expect(response.status).toBe(200);
-		expect(response.headers.get("x-middleware-next")).toBe("1");
-	});
-
-	it.each([
-		`/s/${PLAYBACK_ID}`,
-		`/s/${PLAYBACK_ID}/edit`,
-		`/embed/${PLAYBACK_ID}`,
-		"/c/collection",
-		"/dashboard/caps",
-		"/login",
-		"/",
-	])("never checks %s", async (path) => {
-		const response = await send(path);
-
-		expect(mocks.gonePage).not.toHaveBeenCalled();
-		expect(response.status).not.toBe(410);
-	});
-});
-
-describe("proxy takedown check on a self-hosted build", () => {
-	it("skips the lookup, since only Cap staff can take a video down", async () => {
-		vi.resetModules();
-		vi.doMock("@cap/env", () => ({
-			buildEnv: { NEXT_PUBLIC_IS_CAP: "false" },
-			serverEnv: () => ({ WEB_URL: "https://cap.example.com" }),
-		}));
-		const selfHosted = await import("../../proxy");
-
-		const response = await selfHosted.proxy(
-			new NextRequest(`https://cap.example.com/dev/${PLAYBACK_ID}`),
-		);
-
-		expect(response.status).toBe(200);
-		expect(mocks.gonePage).not.toHaveBeenCalled();
-		vi.doUnmock("@cap/env");
-	});
-});
diff --git a/apps/web/__tests__/unit/proxy-frame-headers.test.ts b/apps/web/__tests__/unit/proxy-frame-headers.test.ts
index 23723933625..e2050cffe0a 100644
--- a/apps/web/__tests__/unit/proxy-frame-headers.test.ts
+++ b/apps/web/__tests__/unit/proxy-frame-headers.test.ts
@@ -10,10 +10,6 @@ vi.mock("@cap/database", () => ({
 
 vi.mock("@cap/database/schema", () => ({ organizations: {} }));
 
-vi.mock("@/lib/developer-video-takedown-store", () => ({
-	developerVideoGonePage: async () => null,
-}));
-
 vi.mock("@cap/env", () => ({
 	buildEnv: { NEXT_PUBLIC_IS_CAP: "true" },
 	serverEnv: () => ({
diff --git a/apps/web/__tests__/unit/proxy-referral-click.test.ts b/apps/web/__tests__/unit/proxy-referral-click.test.ts
index 0e8361e2225..945c85a9b16 100644
--- a/apps/web/__tests__/unit/proxy-referral-click.test.ts
+++ b/apps/web/__tests__/unit/proxy-referral-click.test.ts
@@ -12,10 +12,6 @@ vi.mock("@cap/database", () => ({
 
 vi.mock("@cap/database/schema", () => ({ organizations: {} }));
 
-vi.mock("@/lib/developer-video-takedown-store", () => ({
-	developerVideoGonePage: async () => null,
-}));
-
 vi.mock("@cap/env", () => ({
 	buildEnv: {
 		get NEXT_PUBLIC_IS_CAP() {
diff --git a/apps/web/lib/developer-video-takedown-store.ts b/apps/web/lib/developer-video-takedown-store.ts
index c785400c2e7..b670bfb7311 100644
--- a/apps/web/lib/developer-video-takedown-store.ts
+++ b/apps/web/lib/developer-video-takedown-store.ts
@@ -6,7 +6,6 @@ import {
 import { developerVideos } from "@cap/database/schema";
 import { and, eq, isNull } from "drizzle-orm";
 import {
-	DEVELOPER_VIDEO_UNAVAILABLE,
 	developerVideoIsTakenDown,
 	developerVideoReference,
 	developerVideoTakenDownAt,
@@ -83,48 +82,3 @@ export async function setDeveloperVideoTakedown(
 		};
 	});
 }
-
-export async function playbackIdIsTakenDown(
-	playbackId: string,
-): Promise<boolean> {
-	const [video] = await db()
-		.select({ metadata: developerVideos.metadata })
-		.from(developerVideos)
-		.where(
-			and(
-				eq(developerVideos.playbackId, playbackId),
-				isNull(developerVideos.deletedAt),
-			),
-		)
-		.limit(1);
-	return video ? developerVideoIsTakenDown(video) : false;
-}
-
-const PAGE_PATH = /^\/dev\/([A-Za-z0-9_-]{16,64})(?:\/embed)?\/?$/;
-
-const GONE_PAGE = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="robots" content="noindex"><title>Video not available</title><style>html,body{margin:0;height:100%;background:#050506;color:#E8ECF4;color-scheme:dark;font-family:system-ui,sans-serif}main{display:grid;min-height:100%;place-items:center;padding:16px 20px;box-sizing:border-box;text-align:center}h1{margin:0;font-size:15px;font-weight:500;line-height:1.3;letter-spacing:-0.01em}</style></head><body><main><h1>${DEVELOPER_VIDEO_UNAVAILABLE}</h1></main></body></html>`;
-
-// A page cannot choose a 410 status in the App Router, so the proxy answers
-// for a taken down video before the page renders.
-export async function developerVideoGonePage(
-	pathname: string,
-	method: string,
-): Promise<Response | null> {
-	if (method !== "GET" && method !== "HEAD") return null;
-	const playbackId = PAGE_PATH.exec(pathname)?.[1];
-	if (!playbackId) return null;
-	try {
-		if (!(await playbackIdIsTakenDown(playbackId))) return null;
-	} catch (error) {
-		console.error("[developer-video] Takedown check failed", error);
-		return null;
-	}
-	return new Response(method === "HEAD" ? null : GONE_PAGE, {
-		status: 410,
-		headers: {
-			"Cache-Control": "no-store",
-			"Content-Type": "text/html; charset=utf-8",
-			"X-Robots-Tag": "noindex",
-		},
-	});
-}
diff --git a/apps/web/proxy.ts b/apps/web/proxy.ts
index 58a20036106..7a2382d7e68 100644
--- a/apps/web/proxy.ts
+++ b/apps/web/proxy.ts
@@ -12,7 +12,6 @@ import { eq } from "drizzle-orm";
 import { notFound } from "next/navigation";
 import { type NextRequest, NextResponse, userAgent } from "next/server";
 import { agentMarkdownResponse } from "@/lib/agent-markdown";
-import { developerVideoGonePage } from "@/lib/developer-video-takedown-store";
 import { INFRA_PATH_HEADER, isInfraPathname } from "@/lib/infra-routes";
 import { getShareIframeRedirectUrl } from "@/lib/share-iframe-navigation";
 
@@ -146,16 +145,6 @@ export async function proxy(request: NextRequest) {
 		return rememberReferralClick(request, setFrameHeaders(NextResponse.next()));
 	}
 
-	// Only Cap staff can take a video down, so a self-hosted build skips the
-	// lookup. The playback route and the page still read the flag themselves.
-	if (
-		buildEnv.NEXT_PUBLIC_IS_CAP === "true" &&
-		path.startsWith(DEVELOPER_VIDEO_PREFIX)
-	) {
-		const gone = await developerVideoGonePage(path, request.method);
-		if (gone) return gone;
-	}
-
 	const response = await route(request);
 	if (path.startsWith(DEVELOPER_VIDEO_PREFIX)) return response;
 	return rememberReferralClick(

From 2ca50ab60ac5d04f198a56f9628b9da2b7e5360c Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 00:51:41 -0500
Subject: [PATCH 07/12] feat: plain unavailable page for a taken down video

---
 .../unit/developer-video-page.test.ts         | 83 ++++++++++++++-----
 .../unit/developer-video-player.test.ts       |  5 +-
 .../dev/_components/DeveloperVideoPage.tsx    | 72 +++++++++-------
 apps/web/lib/developer-video-player.ts        |  8 +-
 4 files changed, 116 insertions(+), 52 deletions(-)

diff --git a/apps/web/__tests__/unit/developer-video-page.test.ts b/apps/web/__tests__/unit/developer-video-page.test.ts
index 3642fac505d..532b7db4605 100644
--- a/apps/web/__tests__/unit/developer-video-page.test.ts
+++ b/apps/web/__tests__/unit/developer-video-page.test.ts
@@ -213,33 +213,78 @@ describe("developer video report link", () => {
 });
 
 describe("a taken down video page", () => {
+	const takenDownFromLoader: DeveloperVideoPlayer = {
+		name: "",
+		width: 16,
+		height: 9,
+		kind: "taken_down",
+	};
+
 	it.each(["share", "embed"] as const)(
-		"shows only that the video is not available on the %s page",
-		(variant) => {
-			const html = render(takenDown, variant);
+		"shows one plain sentence on the %s page and nothing from the video",
+		async (variant) => {
+			mocks.load.mockResolvedValue(takenDownFromLoader);
+			const page = variant === "share" ? sharePage : embedPage;
+			const route = await page.default(params());
+			expect(route.props).toMatchObject({ playbackId: PLAYBACK_ID, variant });
+
+			const html = renderToStaticMarkup(
+				await DeveloperVideoPage({
+					playbackId: PLAYBACK_ID,
+					variant,
+					query: {},
+				}),
+			);
 			const text = html
 				.replace(/<style>.*?<\/style>/g, "")
-				.replace(/<[^>]+>/g, " ");
-
-			expect(text).toContain("This video is not available.");
-			expect(html).not.toContain("Launch demo");
-			expect(html).not.toContain("<video");
-			expect(html).not.toContain(BASE);
-			expect(html).not.toContain("mailto:");
-			expect(html).not.toContain('role="status"');
+				.replace(/<[^>]+>/g, " ")
+				.trim();
+
+			expect(text).toBe("This video is not available.");
+			expect(html).toContain("<h1");
+			for (const absent of [
+				"<video",
+				"<img",
+				"<a ",
+				"poster",
+				"m3u8",
+				"video.mp4",
+				"/api/developer/playback",
+				PLAYBACK_ID,
+				"Launch demo",
+				"aspect-ratio",
+				'role="status"',
+				'aria-label="Cap Infra"',
+			]) {
+				expect(html).not.toContain(absent);
+			}
 		},
 	);
 
-	it("previews as unavailable with no title or image from the video", async () => {
-		mocks.load.mockResolvedValue(takenDown);
+	it("never renders the video's own name or size even if the loader passed them", () => {
+		const html = render(takenDown, "share");
 
-		expect(await developerVideoMetadata(PLAYBACK_ID)).toMatchObject({
-			title: "Video not available",
-			robots: { index: false, follow: false },
-			openGraph: { title: "Video not available", images: [] },
-			twitter: { card: "summary", title: "Video not available", images: [] },
-		});
+		expect(html).not.toContain("Launch demo");
+		expect(html).not.toContain("1920");
+		expect(html).not.toContain("mailto:");
 	});
+
+	it.each([
+		["share", sharePage],
+		["embed", embedPage],
+	])(
+		"keeps the %s page out of search and previews with no title or image from the video",
+		async (_, page) => {
+			mocks.load.mockResolvedValue(takenDownFromLoader);
+
+			expect(await page.generateMetadata(params())).toMatchObject({
+				title: "Video not available",
+				robots: { index: false, follow: false },
+				openGraph: { title: "Video not available", images: [] },
+				twitter: { card: "summary", title: "Video not available", images: [] },
+			});
+		},
+	);
 });
 
 describe("developer video page parameters", () => {
diff --git a/apps/web/__tests__/unit/developer-video-player.test.ts b/apps/web/__tests__/unit/developer-video-player.test.ts
index a6b406967eb..923f088e423 100644
--- a/apps/web/__tests__/unit/developer-video-player.test.ts
+++ b/apps/web/__tests__/unit/developer-video-player.test.ts
@@ -82,8 +82,11 @@ describe("developer video player data", () => {
 				},
 			};
 
-			expect(await loadDeveloperVideoPlayer(PLAYBACK_ID)).toMatchObject({
+			expect(await loadDeveloperVideoPlayer(PLAYBACK_ID)).toEqual({
 				kind: "taken_down",
+				name: "",
+				width: 16,
+				height: 9,
 			});
 			expect(mocks.standing).not.toHaveBeenCalled();
 			expect(mocks.redrive).not.toHaveBeenCalled();
diff --git a/apps/web/app/dev/_components/DeveloperVideoPage.tsx b/apps/web/app/dev/_components/DeveloperVideoPage.tsx
index 6f40eb31a12..79cea4c74c9 100644
--- a/apps/web/app/dev/_components/DeveloperVideoPage.tsx
+++ b/apps/web/app/dev/_components/DeveloperVideoPage.tsx
@@ -149,28 +149,42 @@ export function DeveloperVideoView({
 	variant: DeveloperVideoPageVariant;
 	playback?: DeveloperVideoPlayback;
 }) {
-	const takenDown = player.kind === "taken_down";
+	// A taken down video gets one plain sentence and nothing from the video:
+	// no player, poster, title or link. Every playback file answers 410.
+	if (player.kind === "taken_down") {
+		return (
+			<div
+				className={
+					variant === "embed"
+						? "fixed inset-0 grid place-items-center bg-black px-5 text-center"
+						: "grid min-h-dvh place-items-center px-5 text-center"
+				}
+			>
+				{variant === "embed" && <style>{"html,body{background:#000}"}</style>}
+				<h1 className="m-0 text-[15px] font-medium leading-[1.3] tracking-[-0.01em] text-[#E8ECF4]">
+					{DEVELOPER_VIDEO_UNAVAILABLE}
+				</h1>
+			</div>
+		);
+	}
+
 	const reportHref = developerVideoReportHref(playbackId);
 
 	if (variant === "embed") {
 		return (
 			<div className="group fixed inset-0 bg-black">
 				<style>{"html,body{background:#000}"}</style>
-				<h1 className="sr-only">
-					{takenDown ? DEVELOPER_VIDEO_UNAVAILABLE : player.name}
-				</h1>
+				<h1 className="sr-only">{player.name}</h1>
 				<Stage player={player} playback={playback} />
-				{!takenDown && (
-					<a
-						href={reportHref}
-						target="_blank"
-						rel="noopener noreferrer"
-						aria-label="Report this video"
-						className={EMBED_REPORT_CLASS}
-					>
-						Report
-					</a>
-				)}
+				<a
+					href={reportHref}
+					target="_blank"
+					rel="noopener noreferrer"
+					aria-label="Report this video"
+					className={EMBED_REPORT_CLASS}
+				>
+					Report
+				</a>
 			</div>
 		);
 	}
@@ -193,22 +207,18 @@ export function DeveloperVideoView({
 					>
 						<Stage player={player} playback={playback} />
 					</div>
-					{takenDown ? (
-						<h1 className="sr-only">{DEVELOPER_VIDEO_UNAVAILABLE}</h1>
-					) : (
-						<div className="mt-5 flex items-baseline justify-between gap-4">
-							<h1 className="m-0 min-w-0 text-[18px] font-medium leading-[1.3] tracking-[-0.01em] text-[#E8ECF4] [overflow-wrap:anywhere]">
-								{player.name}
-							</h1>
-							<a
-								href={reportHref}
-								aria-label="Report this video"
-								className="shrink-0 rounded-[4px] text-[13px] leading-[1.3] text-[rgba(232,236,244,0.42)] outline-none transition-colors hover:text-[rgba(232,236,244,0.8)] focus-visible:text-[#E8ECF4] focus-visible:ring-1 focus-visible:ring-[rgba(232,236,244,0.6)]"
-							>
-								Report
-							</a>
-						</div>
-					)}
+					<div className="mt-5 flex items-baseline justify-between gap-4">
+						<h1 className="m-0 min-w-0 text-[18px] font-medium leading-[1.3] tracking-[-0.01em] text-[#E8ECF4] [overflow-wrap:anywhere]">
+							{player.name}
+						</h1>
+						<a
+							href={reportHref}
+							aria-label="Report this video"
+							className="shrink-0 rounded-[4px] text-[13px] leading-[1.3] text-[rgba(232,236,244,0.42)] outline-none transition-colors hover:text-[rgba(232,236,244,0.8)] focus-visible:text-[#E8ECF4] focus-visible:ring-1 focus-visible:ring-[rgba(232,236,244,0.6)]"
+						>
+							Report
+						</a>
+					</div>
 				</div>
 			</div>
 		</div>
diff --git a/apps/web/lib/developer-video-player.ts b/apps/web/lib/developer-video-player.ts
index 306072940e0..14a18b980f8 100644
--- a/apps/web/lib/developer-video-player.ts
+++ b/apps/web/lib/developer-video-player.ts
@@ -57,8 +57,14 @@ export async function loadDeveloperVideoPlayer(
 
 	const found = await findPlayableVideo(playbackId);
 	if (!found) return null;
+	// Nothing about the video reaches a page that cannot play it.
 	if (developerVideoIsTakenDown(found)) {
-		return { ...frameOf(found), kind: "taken_down" };
+		return {
+			name: "",
+			width: DEFAULT_WIDTH,
+			height: DEFAULT_HEIGHT,
+			kind: "taken_down",
+		};
 	}
 
 	const standing = await getInfraAppStanding(found.appId);

From 04a034ac232afb17b82fb2e17c514b1cd126fe02 Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 00:57:05 -0500
Subject: [PATCH 08/12] docs: say only playback files answer 410 for a taken
 down video

---
 .../unit/developer-video-takedown.test.ts     | 24 +++++++++++++++++++
 apps/web/content/docs/api/rest-api.mdx        |  4 ++--
 apps/web/lib/developer-openapi.ts             |  2 +-
 3 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/apps/web/__tests__/unit/developer-video-takedown.test.ts b/apps/web/__tests__/unit/developer-video-takedown.test.ts
index 4c437e7143a..57f9283b456 100644
--- a/apps/web/__tests__/unit/developer-video-takedown.test.ts
+++ b/apps/web/__tests__/unit/developer-video-takedown.test.ts
@@ -354,6 +354,30 @@ describe("the staff script", () => {
 	});
 });
 
+describe("the takedown docs", () => {
+	it("promise 410 only for playback files, not for the page or embed", async () => {
+		const { readFileSync } = await import("node:fs");
+		const { join } = await import("node:path");
+		const { developerOpenApiSpec } = await import("@/lib/developer-openapi");
+		const docs = readFileSync(
+			join(process.cwd(), "content/docs/api/rest-api.mdx"),
+			"utf8",
+		);
+		const described = [
+			...docs.split("\n").filter((line) => line.includes("`takenDown`")),
+			String(
+				developerOpenApiSpec("https://cap.so").components.schemas.DeveloperVideo
+					.properties.takenDown.description,
+			),
+		];
+
+		expect(described.length).toBeGreaterThan(2);
+		for (const text of described) {
+			expect(text).not.toMatch(/page[^.]*410|embed[^.]*410/i);
+		}
+	});
+});
+
 describe("the developer API", () => {
 	const withEnv = () => ready({ metadata: { orderId: 7 } });
 
diff --git a/apps/web/content/docs/api/rest-api.mdx b/apps/web/content/docs/api/rest-api.mdx
index 134cfce6d06..157fd33c237 100644
--- a/apps/web/content/docs/api/rest-api.mdx
+++ b/apps/web/content/docs/api/rest-api.mdx
@@ -566,7 +566,7 @@ On a ready video, one of `hlsUrl` and `mp4Url` can still be `null` while that ou
 
 `externalUserId` is the `userId` the video was created with, so one call can confirm the owner and read the status.
 
-`takenDown` is `true` when Cap has taken the video down after a report. Its playback URLs are then `null`, and its page, embed and playback files answer `410 Gone` to every new request. A player that already loaded the video holds signed media links that keep working until they expire, at most 18 hours later. `status` does not change, and the video is stored and billed as before. Email hello@cap.so about a takedown.
+`takenDown` is `true` when Cap has taken the video down after a report. Its playback URLs are then `null`, its playback files answer `410 Gone` to every new request, and its page and embed show only "This video is not available." A player that already loaded the video holds signed media links that keep working until they expire, at most 18 hours later. `status` does not change, and the video is stored and billed as before. Email hello@cap.so about a takedown.
 
 `transcriptionStatus` is `null`. Uploaded videos are not transcribed automatically. To get text, send the file to [Transcripts](/docs/api/rest-api#transcripts).
 
@@ -1502,7 +1502,7 @@ The full video object returned by list and get endpoints:
 | `hlsUrl` | string \| null | Adaptive HLS master playlist (null until it is encoded) |
 | `mp4Url` | string \| null | Progressive MP4 (null until it is encoded) |
 | `posterUrl` | string \| null | Poster image (null until ready) |
-| `takenDown` | boolean | `true` when Cap has taken the video down after a report. The playback URLs are then null, and the page, embed and playback files answer `410 Gone` |
+| `takenDown` | boolean | `true` when Cap has taken the video down after a report. The playback URLs are then null, the playback files answer `410 Gone`, and the page and embed show that the video is not available |
 | `shareUrl` | string \| null | Hosted player page for the video (null only for a video with no `playbackId`) |
 | `embedUrl` | string \| null | The same player with nothing around it, for an iframe (null only for a video with no `playbackId`) |
 | `deletedAt` | string \| null | Deletion timestamp (null for active videos) |
diff --git a/apps/web/lib/developer-openapi.ts b/apps/web/lib/developer-openapi.ts
index 77ead960385..9b6c64cb084 100644
--- a/apps/web/lib/developer-openapi.ts
+++ b/apps/web/lib/developer-openapi.ts
@@ -324,7 +324,7 @@ const playbackProperties = {
 	takenDown: {
 		type: "boolean",
 		description:
-			"True when Cap has taken the video down after a report. Its playback URLs are null, and its page, embed and playback files answer 410 Gone to new requests until Cap restores it. Signed media links a player already loaded keep working until they expire, at most 18 hours later. status is unchanged, and the video is stored and billed as before. Email hello@cap.so about a takedown.",
+			"True when Cap has taken the video down after a report. Its playback URLs are null, its playback files answer 410 Gone to new requests, and its page and embed show only that the video is not available, until Cap restores it. Signed media links a player already loaded keep working until they expire, at most 18 hours later. status is unchanged, and the video is stored and billed as before. Email hello@cap.so about a takedown.",
 	},
 };
 

From 2b68d06d3ac5c4f9b8890714c08f1eef7f214372 Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 01:12:04 -0500
Subject: [PATCH 09/12] fix(infra): keep outputs describing the encodes on a
 taken down video

---
 apps/web/content/docs/api/rest-api.mdx |  2 +-
 apps/web/lib/developer-openapi.ts      |  2 +-
 apps/web/lib/developer-video-api.ts    | 11 +++++++----
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/apps/web/content/docs/api/rest-api.mdx b/apps/web/content/docs/api/rest-api.mdx
index f5c8e33d67f..8fde0e906ee 100644
--- a/apps/web/content/docs/api/rest-api.mdx
+++ b/apps/web/content/docs/api/rest-api.mdx
@@ -568,7 +568,7 @@ A video is `ready` as soon as its first output can be played, so playback can st
 
 On a ready video, one of `hlsUrl` and `mp4Url` can still be `null` while that output finishes encoding. It is filled in later without the video leaving `ready`, and `renditions` is filled in together with `hlsUrl`. Play whichever URL is present. A player that wants HLS should keep polling after `ready` until `hlsUrl` is set, and can play `mp4Url` in the meantime.
 
-`outputs` says whether a `null` URL is still coming. Each of `outputs.hls` and `outputs.mp4` is `ready` when its URL is set, `processing` while it is being encoded or will be retried, and `failed` when it will not be produced. A video can be `ready` with one output `failed`, so stop waiting for that URL and play the other. `none` only appears on videos uploaded before encoding existed.
+`outputs` says whether a `null` URL is still coming. Each of `outputs.hls` and `outputs.mp4` is `ready` when its URL is set, `processing` while it is being encoded or will be retried, and `failed` when it will not be produced. A video can be `ready` with one output `failed`, so stop waiting for that URL and play the other. `none` only appears on videos uploaded before encoding existed. While `takenDown` is `true` the playback URLs are `null` whatever `outputs` says, and `outputs` keeps describing what was encoded.
 
 `externalUserId` is the `userId` the video was created with, so one call can confirm the owner and read the status.
 
diff --git a/apps/web/lib/developer-openapi.ts b/apps/web/lib/developer-openapi.ts
index 3c3a0b9eeb3..4cf3a6944c2 100644
--- a/apps/web/lib/developer-openapi.ts
+++ b/apps/web/lib/developer-openapi.ts
@@ -330,7 +330,7 @@ const playbackProperties = {
 		type: "object",
 		required: ["hls", "mp4"],
 		description:
-			"Whether each output is still coming. ready means its URL is set. processing means it is being encoded, or will be retried, so check again later. failed means it will not be produced. none is only for videos uploaded before encoding existed.",
+			"Whether each output is still coming. ready means its URL is set, except while takenDown is true, when every URL is null. processing means it is being encoded, or will be retried, so check again later. failed means it will not be produced. none is only for videos uploaded before encoding existed.",
 		properties: {
 			hls: {
 				type: "string",
diff --git a/apps/web/lib/developer-video-api.ts b/apps/web/lib/developer-video-api.ts
index 0cddbc81444..a938008b1cb 100644
--- a/apps/web/lib/developer-video-api.ts
+++ b/apps/web/lib/developer-video-api.ts
@@ -65,16 +65,19 @@ export interface DeveloperVideoOutputStates {
 }
 
 // A null hlsUrl or mp4Url alone cannot say whether that output is still being
-// encoded or will never exist. "ready" matches a non-null URL exactly. A part
-// waiting for a busy encoder to retry is still "processing". "none" is only
-// for videos uploaded before encoding existed, which never get these outputs.
+// encoded or will never exist. "ready" matches a non-null URL exactly, except
+// on a video Cap took down: its URLs are null while takenDown is true, and its
+// outputs keep saying what was encoded, so a restore needs no new encode and a
+// client is not told to keep waiting. A part waiting for a busy encoder to
+// retry is still "processing". "none" is only for videos uploaded before
+// encoding existed, which never get these outputs.
 export function developerVideoOutputStates(
 	video: Pick<
 		DeveloperVideoRow,
 		"status" | "playbackId" | "processing" | "duration" | "width"
 	>,
 ): DeveloperVideoOutputStates {
-	const outputs = developerVideoOutputs(video);
+	const outputs = developerVideoOutputs({ ...video, takenDown: false });
 	const processing = video.processing;
 	const state = (part: "hls" | "mp4"): DeveloperVideoOutputState => {
 		if (outputs[part]) return "ready";

From 3cd05fde87406f1460b4f2e49bd86b7d114c66f4 Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 01:20:41 -0500
Subject: [PATCH 10/12] fix(infra): check the takedown flag again after a
 stalled video is retried

---
 .../unit/developer-video-player.test.ts       | 22 +++++++++++++++++++
 apps/web/lib/developer-video-player.ts        | 20 +++++++++--------
 2 files changed, 33 insertions(+), 9 deletions(-)

diff --git a/apps/web/__tests__/unit/developer-video-player.test.ts b/apps/web/__tests__/unit/developer-video-player.test.ts
index 923f088e423..cb8b7bb6df9 100644
--- a/apps/web/__tests__/unit/developer-video-player.test.ts
+++ b/apps/web/__tests__/unit/developer-video-player.test.ts
@@ -93,6 +93,28 @@ describe("developer video player data", () => {
 		},
 	);
 
+	it("shows a video taken down while its stalled processing was retried as unavailable", async () => {
+		mocks.store.video = uploadedLongAgo();
+		mocks.redrive.mockImplementation(async () => {
+			if (!mocks.store.video) throw new Error("missing video");
+			mocks.store.video = {
+				...mocks.store.video,
+				metadata: {
+					__capTakedown: { at: "2026-11-13T12:00:00.000Z", metadata: null },
+				},
+			};
+			return true;
+		});
+
+		expect(await loadDeveloperVideoPlayer(PLAYBACK_ID)).toEqual({
+			kind: "taken_down",
+			name: "",
+			width: 16,
+			height: 9,
+		});
+		expect(mocks.redrive).toHaveBeenCalledTimes(1);
+	});
+
 	it("plays the adaptive stream with the MP4 behind it and the poster", async () => {
 		expect(await loadDeveloperVideoPlayer(PLAYBACK_ID)).toEqual({
 			kind: "playing",
diff --git a/apps/web/lib/developer-video-player.ts b/apps/web/lib/developer-video-player.ts
index 14a18b980f8..2caeab88dc0 100644
--- a/apps/web/lib/developer-video-player.ts
+++ b/apps/web/lib/developer-video-player.ts
@@ -50,6 +50,14 @@ async function redriveStalled(video: PlayableVideo, playbackId: string) {
 	return started ? findPlayableVideo(playbackId) : video;
 }
 
+// Nothing about the video reaches a page that cannot play it.
+const TAKEN_DOWN: DeveloperVideoPlayer = {
+	name: "",
+	width: DEFAULT_WIDTH,
+	height: DEFAULT_HEIGHT,
+	kind: "taken_down",
+};
+
 export async function loadDeveloperVideoPlayer(
 	playbackId: string,
 ): Promise<DeveloperVideoPlayer | null> {
@@ -57,21 +65,15 @@ export async function loadDeveloperVideoPlayer(
 
 	const found = await findPlayableVideo(playbackId);
 	if (!found) return null;
-	// Nothing about the video reaches a page that cannot play it.
-	if (developerVideoIsTakenDown(found)) {
-		return {
-			name: "",
-			width: DEFAULT_WIDTH,
-			height: DEFAULT_HEIGHT,
-			kind: "taken_down",
-		};
-	}
+	if (developerVideoIsTakenDown(found)) return TAKEN_DOWN;
 
 	const standing = await getInfraAppStanding(found.appId);
 	if (standing.state === "paused") return { ...frameOf(found), kind: "paused" };
 
 	const video = await redriveStalled(found, playbackId);
 	if (!video) return null;
+	// The retry reads the row again, so a takedown made meanwhile counts too.
+	if (developerVideoIsTakenDown(video)) return TAKEN_DOWN;
 	const frame = frameOf(video);
 
 	if (video.status === "errored") return { ...frame, kind: "failed" };

From 49c81b61c6ca7a3d45a22bf261ee27543a67d6db Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 01:31:26 -0500
Subject: [PATCH 11/12] test(web): a client cannot store the takedown marker
 through create upload

---
 .../unit/infra-upload-idempotency.test.ts     | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/apps/web/__tests__/unit/infra-upload-idempotency.test.ts b/apps/web/__tests__/unit/infra-upload-idempotency.test.ts
index 62a865e2b1a..635b2a171dd 100644
--- a/apps/web/__tests__/unit/infra-upload-idempotency.test.ts
+++ b/apps/web/__tests__/unit/infra-upload-idempotency.test.ts
@@ -135,6 +135,27 @@ describe("create upload with an Idempotency-Key", () => {
 		expect(state.videos.size).toBe(1);
 	});
 
+	it("never stores Cap's takedown marker from a client's metadata, and replays the request", async () => {
+		const withMarker = {
+			...request,
+			metadata: {
+				project: "alpha",
+				tags: ["a", "b"],
+				__capTakedown: { at: "2026-11-13T12:00:00.000Z", metadata: null },
+			},
+		};
+		const first = await createInfraVideo(withMarker);
+		const id = developerVideoIdForIdempotencyKey("app-1", KEY);
+
+		expect(first.status).toBe(200);
+		expect(state.videos.get(id)?.metadata).toEqual({
+			project: "alpha",
+			tags: ["a", "b"],
+		});
+		expect(await createInfraVideo(withMarker)).toEqual(first);
+		expect(state.inserts).toBe(1);
+	});
+
 	it("makes one video when the same request races itself", async () => {
 		const results = await Promise.all(
 			Array.from({ length: 5 }, () => createInfraVideo(request)),

From 725705f10ec05232d836c9ddd209b2073c885a4b Mon Sep 17 00:00:00 2001
From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com>
Date: Fri, 13 Nov 2026 01:42:38 -0500
Subject: [PATCH 12/12] fix(infra): a takedown does not change which request an
 idempotency key belongs to

---
 .../unit/infra-upload-idempotency.test.ts        | 16 ++++++++++++++++
 apps/web/lib/infra-video-upload.ts               | 10 +++++++---
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/apps/web/__tests__/unit/infra-upload-idempotency.test.ts b/apps/web/__tests__/unit/infra-upload-idempotency.test.ts
index 635b2a171dd..74269ad01d1 100644
--- a/apps/web/__tests__/unit/infra-upload-idempotency.test.ts
+++ b/apps/web/__tests__/unit/infra-upload-idempotency.test.ts
@@ -156,6 +156,22 @@ describe("create upload with an Idempotency-Key", () => {
 		expect(state.inserts).toBe(1);
 	});
 
+	it("replays an unchanged request for a video Cap took down", async () => {
+		const first = await createInfraVideo(request);
+		const id = developerVideoIdForIdempotencyKey("app-1", KEY);
+		const stored = state.videos.get(id);
+		if (!stored) throw new Error("missing video");
+		stored.metadata = {
+			__capTakedown: {
+				at: "2026-11-13T12:00:00.000Z",
+				metadata: stored.metadata,
+			},
+		};
+
+		expect(await createInfraVideo(request)).toEqual(first);
+		expect(state.inserts).toBe(1);
+	});
+
 	it("makes one video when the same request races itself", async () => {
 		const results = await Promise.all(
 			Array.from({ length: 5 }, () => createInfraVideo(request)),
diff --git a/apps/web/lib/infra-video-upload.ts b/apps/web/lib/infra-video-upload.ts
index 22aaed0e004..0e0476a842e 100644
--- a/apps/web/lib/infra-video-upload.ts
+++ b/apps/web/lib/infra-video-upload.ts
@@ -24,7 +24,10 @@ import {
 	releaseDeveloperVideoUpload,
 	startDeveloperVideoProcessing,
 } from "@/lib/developer-video-start";
-import { withoutReservedMetadata } from "@/lib/developer-video-takedown";
+import {
+	developerVideoPublicMetadata,
+	withoutReservedMetadata,
+} from "@/lib/developer-video-takedown";
 import { canUseInfra } from "@/lib/infra-access";
 import { lockInfraAccount } from "@/lib/infra-balance";
 import {
@@ -391,8 +394,9 @@ async function replayKeyedVideo(
 				? "userId"
 				: video.maxResolutionTier !== request.maxResolutionTier
 					? "maxResolutionTier"
-					: canonicalJson(storedJson(video.metadata)) !==
-							canonicalJson(request.metadata)
+					: canonicalJson(
+								developerVideoPublicMetadata(storedJson(video.metadata)),
+							) !== canonicalJson(request.metadata)
 						? "metadata"
 						: null;
 	if (differs) {