diff --git a/AGENTS.md b/AGENTS.md
index 0116f87f..6ce6a79d 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -39,7 +39,7 @@ Next.js App Router in JavaScript, Tailwind CSS with shadcn/ui, Cloudflare D1 thr
 - **Storage**: models in `models/` (D1 in production, SQLite for tests and local scripts), images in the R2 bucket bound as `IMAGES`, or S3 behind CloudFront, or Vercel Blob (`lib/image-storage.js`), rate limits in Upstash Redis or memory (`lib/rate-limit.js`).
 - **Comments**: subscribers comment on the web issues with no account: a signed link (`lib/reader-links.js`, four kinds, each signed with a key of its own) starts a session for one newsletter (`lib/reader-session.js`), and every function checks the contact is still an active subscriber. A comment's text is parsed to parts and printed as text, never HTML (`lib/comment-body.js`). Readers act through `lib/comments.js`, the owner through `lib/comment-moderation.js` and the `Comments` actions; hiding and removing always carry a reason the author sees. Emails (`lib/comment-notify.js`) are one digest an hour at most to the owner and one reply email to an author, never one per comment. A reader's email never appears in anything public.
 - **Undo send**: the dashboard's Send (the `startSend` server action, `send_campaign` with its dashboard-only `holdForUndo`) puts a draft in the `held` status for the newsletter's `sendUndoSeconds` (`lib/send-hold-rules.js`, default 30) instead of queueing it (`lib/send-hold.js`), and a `release-held-send` job hands it to `queueCampaign` like any send. Release and `undo_campaign_send` are each one write on the same row (held and not yet claimed), so exactly one wins; the hourly cron releases a hold whose job never ran. API, MCP and approved agent sends are never held, and a scheduled send is unaffected. Limits are checked at hold time and again by `queueCampaign`. `BarSend` (in `LayoutDashboard`) is the countdown.
-- **Ready-to-send check**: `check_campaign` (`lib/ready-check-data.js` gathers, `lib/ready-check.js` words each item as pass, warning, blocker or info; the review step's `PanelReady` and the approval card show it). A blocker is what the send itself refuses (`checkCampaignSend` and `getPresendChecks` give the words); a warning never stops a send. The links (`lib/link-check.js`, the `check-links` job, results in `LinkCheck`, kept for the same set of addresses) are the one fetch of an address in an issue, held to `lib/link-check-rules.js`: public hosts, default ports, three redirects followed by hand and each checked.
+- **Ready-to-send check**: `check_campaign` (`lib/ready-check-data.js` gathers, `lib/ready-check.js` words each item as pass, warning, blocker or info; the review step's `PanelReady` and the approval card show it). A blocker is what the send itself refuses (`checkCampaignSend` and `getPresendChecks` give the words); a warning never stops a send. The links (`lib/link-check.js`, the `check-links` job, results in `LinkCheck`, kept for the same set of addresses) are one fetch of an address in an issue, held to `lib/link-check-rules.js`: public hosts, default ports, three redirects followed by hand and each checked. The claim check is the other (`docs/CLAIM-CHECK.md`: `lib/claim-check-rules.js` reads the issue's figures and words the report, `lib/claim-check.js` keeps it in `ClaimCheck` per `campaignContentHash`, the `check-claims` job runs `lib/claim-check-run.js` through the Briefings fetcher's guards): dead links, figures not on the pages their paragraph links to, figures with no source, code only. It never runs in a send; its findings are warnings unless the newsletter has `requireClaimCheck`, which `getSendBlocker` reads.
 - **Editing a sent issue's page**: `update_published_issue` (`lib/actions/published-issues.js`, class `write`) changes only the web version of a sent issue (title, subtitle, body, tags, search settings) in place, once its send is over; the emails that went out are built from the campaign at send time, so nothing already sent changes, but a later step or resend reads the new words. The page as it was goes into `CampaignVersion` (reason `edit`, the same 30) and `restore_campaign_version` works on a sent issue the same way. The RSS feed has no updated date: the entry keeps its `pubDate` and guid and carries the new content; the sitemap's lastmod follows `seo.updatedAt`.
 - **Content calendar**: issues and LinkedIn posts planned in one place (`docs/CONTENT-CALENDAR.md` has the model). `ContentItem` (channel `newsletter` or `linkedin`; copy, funnel stage, pillar, references, private notes, visuals as pointers to `Upload` records, a plan, review), `EditorialBatch` (with an optional recurring pattern that only `apply_editorial_pattern` uses) and `ContentRevision` (the last 50 states of an item's content), in `lib/content-items.js`, `lib/content-batches.js`, `lib/content-plan.js` and the rules in `lib/content-rules.js`; the actions are `lib/actions/content-items.js` and `content-batches.js`, the pages are under `app/(app)/campaigns/calendar`. Planning never sends, schedules or publishes: nothing in these files writes a campaign or queues a job, every planning action is class `write-draft` (reads are `read`, deletes `destructive`), and approving is `decide_content_review`, a `dashboardOnly` action, so no key can approve. Editorial state (`idea` to `delivered`) is apart from a campaign's delivery; a LinkedIn post is posted by hand and only recorded (`record_content_publication`, which needs an approved item and a LinkedIn address), and nothing may call it scheduled or published otherwise. A planned day is a `YYYY-MM-DD` plus an optional wall-clock time in an IANA zone, with its instant worked out by `zonedTimeToInstant` (`lib/time-zone.js`). An edit to the title, hook, body, call to action, destination, visuals or linked issue of an approved item takes the approval back (`changes_requested`, `editedAfterApproval`); a move does not. `externalId` makes creates and imports repeat safely (unique per account). `get_content_calendar` and `lib/calendar.js` are unchanged and leave drafts out; `get_content_plan` is the one that shows plans beside real deliveries.
 - **Growth**: each newsletter's RSS feed (`lib/archive-feed.js`), the account export (any account may run it, even blocked or without a plan: `export_account_data` sets `whileBlocked` and `requiresPlan: false`, and that stays so) and the referral program (`lib/referrals.js`; reward emails are `Message` kind `referral`, sent like welcome emails). Newsletters recommend each other for free (`lib/recommendations.js`, rules in `lib/recommendation-rules.js`): a reader's email reaches another newsletter only through their own tick on the "You might also like" step, as a normal signup with that newsletter's confirmation email, and the dashboard is at `/recommending` because `/recommendations` is the public directory. Recommendations stay inside a region.
diff --git a/app/(app)/newsletters/actions.js b/app/(app)/newsletters/actions.js
index 653d23d8..6d50996e 100644
--- a/app/(app)/newsletters/actions.js
+++ b/app/(app)/newsletters/actions.js
@@ -58,6 +58,7 @@ function readSettings(formData) {
 		preferencesLink: formData.get("preferencesLink") === "on",
 		utmLinks: formData.get("utmLinks") === "on",
 		shareButtons: formData.get("shareButtons") === "on",
+		requireClaimCheck: formData.get("requireClaimCheck") === "on",
 		...(formData.has("customHeaders") && { customHeaders: readHeaderLines(String(formData.get("customHeaders") ?? "")) }),
 		...(formData.has("sendUndoSeconds") && { sendUndoSeconds: Number(readText(formData, "sendUndoSeconds")) }),
 		author: { bio: readText(formData, "authorBio"), imageUrl: readText(formData, "authorImageUrl") },
diff --git a/app/(site)/docs/briefings-bot/page.js b/app/(site)/docs/briefings-bot/page.js
index a55d1b4b..d0abd2f3 100644
--- a/app/(site)/docs/briefings-bot/page.js
+++ b/app/(site)/docs/briefings-bot/page.js
@@ -26,11 +26,16 @@ export default function BriefingsBotPage() {
 
 			<Section title="What it reads" stagger={2}>
 				<p>
-					Only pages that a FlockStack user&apos;s briefing found: a result of a search for the briefing&apos;s topic, a story in a feed the
+					Pages that a FlockStack user&apos;s briefing found: a result of a search for the briefing&apos;s topic, a story in a feed the
 					briefing reads, or a page linked from one of those. It does not crawl a site, follow its links beyond one step, or keep a copy of
 					a page after the briefing&apos;s run: it keeps the facts it needs for a short summary, at most 25 words of quotation, and the
 					link to the page.
 				</p>
+				<p className="mt-4">
+					It also opens the pages a FlockStack issue links to when its writer checks the issue before sending it: it looks for the
+					issue&apos;s figures on the pages it cites and checks that its links load, at most 25 links and 12 pages per check, and keeps
+					nothing of the pages it read.
+				</p>
 				<p className="mt-4">
 					It reads at most 1 MB of a page, waits at most 8 seconds, makes at most 2 requests to one host at a time and at most 300
 					requests in one run, and only to public addresses over https.
diff --git a/app/api/cron/hourly/route.js b/app/api/cron/hourly/route.js
index 42a0ace2..0a29caaf 100644
--- a/app/api/cron/hourly/route.js
+++ b/app/api/cron/hourly/route.js
@@ -4,6 +4,7 @@ import { runAgentHousekeeping } from "@/lib/agent-housekeeping";
 import { announceTelegram } from "@/lib/alerts";
 import { sendCommentDigests } from "@/lib/comment-notify";
 import { sendConfirmationReminders } from "@/lib/confirmation-reminders";
+import { purgeOldClaimChecks } from "@/lib/claim-check";
 import { withCronSecret } from "@/lib/cron";
 import { purgeCustomRequests } from "@/lib/custom-requests";
 import { followDedicatedIps } from "@/lib/dedicated-ip";
@@ -44,10 +45,10 @@ async function runBriefingsInCron() {
 // exports whose links ran out, the owners' digests of new comments and reports, the extra emails Polar hasn't been told
 // about yet, dedicated IPs that no longer match their add-on, the day of every IP warm-up and the stock of spare IPs, the reminders to signups that haven't confirmed, and the
 // Custom plan requests past their two years, the RSS feeds' kept copies nobody has read for a day, comps and gifts that ran out, and
-// pledge charging whose job went quiet, and the agent approvals nobody decided and the agent activity past its 90 days, the held sends whose release job never ran, and the link checks nobody looked at for a week.
+// pledge charging whose job went quiet, and the agent approvals nobody decided and the agent activity past its 90 days, the held sends whose release job never ran, and the link and claim checks nobody looked at for a week.
 // On a self-hosted server with BRIEFINGS_IN_CRON=true, also a tick of the briefings engine.
 export const GET = withCronSecret(async () => {
-	const [postshiba, telegram, expiredExports, commentDigests, extraEmails, dedicatedIps, ipWarmups, ipInventory, reminders, customRequests, feedCopies, grants, pledges, giftsSent, giftsExpired, agentRecords, heldSends, linkChecks, editorSnapshots, briefings] = await Promise.all([
+	const [postshiba, telegram, expiredExports, commentDigests, extraEmails, dedicatedIps, ipWarmups, ipInventory, reminders, customRequests, feedCopies, grants, pledges, giftsSent, giftsExpired, agentRecords, heldSends, linkChecks, claimChecks, editorSnapshots, briefings] = await Promise.all([
 		checkPostshibaStatus(),
 		announceTelegram(),
 		expireAccountExports(),
@@ -66,9 +67,10 @@ export const GET = withCronSecret(async () => {
 		runAgentHousekeeping(),
 		sweepHeldSends(),
 		purgeOldLinkChecks(),
+		purgeOldClaimChecks(),
 		expireCollaborationSnapshots(),
 		runBriefingsInCron(),
 	]);
-	console.info(`[hourly] ${JSON.stringify({ postshiba, telegram, expiredExports, commentDigests, extraEmails, dedicatedIps, ipWarmups, ipInventory, reminders, customRequests, feedCopies, grants, pledges, giftsSent, giftsExpired, agentRecords, heldSends, linkChecks, editorSnapshots, briefings })}`);
+	console.info(`[hourly] ${JSON.stringify({ postshiba, telegram, expiredExports, commentDigests, extraEmails, dedicatedIps, ipWarmups, ipInventory, reminders, customRequests, feedCopies, grants, pledges, giftsSent, giftsExpired, agentRecords, heldSends, linkChecks, claimChecks, editorSnapshots, briefings })}`);
 	return { postshiba, telegram };
 });
diff --git a/app/api/jobs/check-claims/route.js b/app/api/jobs/check-claims/route.js
new file mode 100644
index 00000000..2dfe12cb
--- /dev/null
+++ b/app/api/jobs/check-claims/route.js
@@ -0,0 +1,18 @@
+import { NextResponse } from "next/server";
+import { withQStashSignature } from "@/lib/qstash-route";
+
+export const dynamic = "force-dynamic";
+export const maxDuration = 60;
+
+// Handled outcomes answer 200 so QStash doesn't retry them; a thrown error (database down) is retried. The checker and the
+// fetcher load only when a job comes in.
+async function handleCheck(request) {
+	const body = await request.json().catch(() => null);
+	const job = { accountId: body?.accountId, campaignId: body?.campaignId, hash: body?.hash };
+	const { runClaimCheck } = await import("@/lib/claim-check-run");
+	const result = await runClaimCheck(job);
+	console.info(`[claim-check] ${JSON.stringify({ ...job, ...result })}`);
+	return NextResponse.json(result);
+}
+
+export const POST = withQStashSignature(handleCheck);
diff --git a/components/FormNewsletter.jsx b/components/FormNewsletter.jsx
index 2647badd..ea4a3020 100644
--- a/components/FormNewsletter.jsx
+++ b/components/FormNewsletter.jsx
@@ -429,6 +429,12 @@ export default function FormNewsletter({
 						In the email header
 					</span>
 				</Field>
+				<Field label="Claim check" hint="Before a send, the ready-to-send check opens the issue's links and looks for each figure on the pages its paragraph links to. Its findings are warnings unless you require it to pass." as="div">
+					<span className="flex items-center gap-2 text-sm">
+						<Switch name="requireClaimCheck" checked={draft.isClaimCheckRequired} onCheckedChange={(isChecked) => set("isClaimCheckRequired", isChecked)} aria-label="Require the claim check to pass before a send" />
+						Required before a send
+					</span>
+				</Field>
 				<Field label="Custom headers" hint="Extra headers on every email, one Name: value a line, 10 at most. Names starting with X-, List-Id, List-Archive, List-Help, List-Owner, List-Subscribe, Organization and Keywords are allowed. The sender, signature and unsubscribe headers can't be changed." as="div">
 					<Textarea name="customHeaders" value={draft.customHeaders} rows={3} placeholder="X-Newsletter-Group: weekly" aria-label="Custom headers" className="font-mono text-xs" onChange={update("customHeaders")} />
 				</Field>
diff --git a/components/PanelReady.jsx b/components/PanelReady.jsx
index 4699d459..247f2075 100644
--- a/components/PanelReady.jsx
+++ b/components/PanelReady.jsx
@@ -55,7 +55,7 @@ export default function PanelReady({ ready, extra = [], isApproval = false, onFi
 			{[...blockers, ...warnings, ...infos].length > 0 && (
 				<ul className="divide-y divide-border/60">
 					{[...blockers, ...warnings, ...infos].map((entry) => (
-						<RowItem key={entry.id} entry={entry} isApproval={isApproval} isChecking={result?.isChecking && entry.id === "links"} onFix={onFix} onTest={onTest} />
+						<RowItem key={entry.id} entry={entry} isApproval={isApproval} isChecking={isStillChecking(result, entry.id)} onFix={onFix} onTest={onTest} />
 					))}
 				</ul>
 			)}
@@ -73,6 +73,13 @@ export default function PanelReady({ ready, extra = [], isApproval = false, onFi
 	);
 }
 
+// The links and the claim check are opened by a job: their rows spin until the result is in. A result from before the claim
+// check names no list and only the links are being opened.
+function isStillChecking(result, id) {
+	if (!result?.isChecking) return false;
+	return Array.isArray(result.checking) ? result.checking.includes(id) : id === "links";
+}
+
 const ICONS = {
 	blocker: { Icon: CircleX, label: "To fix", className: "text-red-500" },
 	warning: { Icon: CircleAlert, label: "To check", className: "text-amber-500" },
diff --git a/docs/BRIEFINGS-DESIGN.md b/docs/BRIEFINGS-DESIGN.md
index 0fc026d9..ea4a620f 100644
--- a/docs/BRIEFINGS-DESIGN.md
+++ b/docs/BRIEFINGS-DESIGN.md
@@ -13,7 +13,7 @@ A briefing belongs to a newsletter. From a topic brief (no fixed source list), i
 | Encrypting a stored credential | `lib/credentials.js` (AES-256-GCM, `CREDENTIALS_ENCRYPTION_KEY`, AAD context per value), hidden fields with `select: false` |
 | An idempotent story queue | content items with `externalId` (`lib/content-items.js`) |
 | A draft issue with a retry key | `create_campaign` with `externalId`, called through `runAction` with its own `via` (as `lib/agent-bootstrap.js` does) |
-| Checks shown before a send | `check_campaign` (`lib/ready-check.js`, `lib/ready-check-data.js`) |
+| Checks shown before a send | `check_campaign` (`lib/ready-check.js`, `lib/ready-check-data.js`), with the claim check of any issue (docs/CLAIM-CHECK.md) |
 | Agent send approval | `agentApproval` on the newsletter, `guardCall` in `lib/agent-guard.js` |
 | Other languages for readers | reader translation (`readerTranslations`, `lib/reader-translation.js`; en, es, fr, de, it, pt) |
 | Lean Worker builds without Next.js | `scripts/build-api-worker.mjs` with a different entry, as the readers Worker does |
@@ -116,7 +116,7 @@ Why its own Worker: the app handler has about 250 KB left in its size budget, an
 4. **Rank** (see "Ranking" below), and keep the `shortlist` best stories, then after triage the full stories (`minFull` to `maxFull`) and the brief items. None left means `no_news`: no draft, and the owner gets a one-line email.
 5. **Extract.** For the survivors only, fetch the primary page (and at most one primary source it links to), reduce it to readable text (at most 20,000 characters), and ask the extract model for a record: what happened, who, numbers with the sentence each comes from, and the URL. Quotes are capped at 25 words. A paywalled page is never worked around: the story keeps only facts found on public pages, or is dropped.
 6. **Write.** One call to the write model with the style guide, the brief and the records only (no raw pages): full stories first, then the brief items as one line each with their link. It returns Markdown in which every paragraph cites at least one record by number; code turns the citations into links to the originals.
-7. **Check.** Code checks first: every number in the draft appears in the text of a page it cites; every link resolves (the link checker's rules); every story links to its original; no quote is over 25 words; length within bounds. Then the check model, which must differ from the writer, judges each claim against the record it cites (with a TypeSafe key: one Noul per claim, as in TypeSafe's citation check). Each check is recorded as `pass`, `warning` or `blocker`.
+7. **Check.** Code checks first: every number in the draft appears in the text of a page it cites; every link resolves (the link checker's rules); every story links to its original; no quote is over 25 words; length within bounds. Then the check model, which must differ from the writer, judges each claim against the record it cites (with a TypeSafe key: one Noul per claim, as in TypeSafe's citation check). Each check is recorded as `pass`, `warning` or `blocker`. The same code checks of links and figures, without a briefing's records (the issue's own links are its sources), run on every issue as the ready-to-send check's claim check (docs/CLAIM-CHECK.md, `lib/claim-check-rules.js`), through this engine's fetcher.
 8. **Translate** (beta). When `languages` has more than one, the translate model writes each other language from the checked draft, within its share of the budget. The translations are stored against the draft for readers who choose that language, labelled beta; one that does not fit the budget is skipped and noted.
 9. **Deliver.** Through `BriefingsDelivery`: the issue as a draft campaign (`externalId` `briefing:<briefingId>:<slot>`, so a retried run returns the same draft), one newsletter content item linked to it carrying every story's references (the calendar allows one newsletter item per issue, and per-story items would fill the 5,000-item cap within a year of daily runs; story keys stay on the run), a test email of the draft to `testEmail`, and a separate note to the owner with the run's checks, cost, discovery notes and a keep or drop link per story. The note is never part of the draft. With `send_if_checks_pass` (Phase 3), a run with no blocker and no warning is queued for sending, unless the newsletter has "ask me before an agent sends" on, which turns it into an approval request. A thin run, a run that stopped at the budget, a run with any blocker, and a run with a discovery provider that failed never send: they are held as a draft, with `heldReason` and the reason in the owner's email.
 
diff --git a/docs/CLAIM-CHECK.md b/docs/CLAIM-CHECK.md
new file mode 100644
index 00000000..eea945d8
--- /dev/null
+++ b/docs/CLAIM-CHECK.md
@@ -0,0 +1,47 @@
+# Claim check
+
+Status: built, 2026-10-29.
+
+The ready-to-send check (`check_campaign`, the review step's "Ready to send?" card) checks the claims of any issue: one a person wrote in the editor, one an agent made with `create_campaign`, a briefing's draft or an imported post. It is the code half of the Briefings engine's check step (docs/BRIEFINGS-DESIGN.md, The run, 7), made to work without a briefing's records: the issue's own links are its sources.
+
+## What it reports
+
+For each paragraph, list item, heading and table cell of the issue (and the subject and preview text):
+
+1. **Dead links.** Every link, judged by the Briefings fetcher's `checkLink` or by reading the page: gone (404, 410 or another 4xx), unreachable, a name that doesn't resolve, too many redirects, or an address inside a private network (refused by the guard, never asked). A 401, 403, 429, a server error, a slow answer or a robots.txt refusal says nothing about whether a reader can open the link, so it is listed as "couldn't be confirmed" (`unsureLinks`), as the existing link check does (`lib/link-check-rules.js` `judgeStatus`), not as dead.
+2. **Figures that aren't on their pages.** A figure in a paragraph or list item is looked for on every page that paragraph links to. It is reported when every one of those pages was read and none has it (`unmatchedFigures`). When a page couldn't be read (a file, a refusal, robots.txt, plain http, the check's limits), the figure is neither found nor missing (`unconfirmedFigures`). Figures in a heading, the subject or the preview text sum up the issue and may be on any page it links to.
+3. **Figures with no source.** A paragraph or list item that states a figure and links to nothing (`uncitedClaims`). Headings, the subject and the preview text are never uncited claims.
+
+### Figures
+
+`lib/claim-check-rules.js` `figuresIn` reads a figure with its currency, thousands commas, decimals, percent (`%`, percent, per cent, pct) and scale (thousand, million, billion, trillion, k, m, mn, mm, b, bn, tn), and compares values: $1.7 billion, 1.7bn, $1.7B, 1,700 million and 1,700,000,000 are one figure, and so are 8.0%, 8% and 8 percent. A figure with a scale also matches a more exact one on the page that rounds to it at the precision it was written with (1.7 billion for 1,712,000,000; 1.71bn too). A one-letter scale ("5m") may be minutes or metres, so the bare number counts as well. Figures without a scale are compared exactly.
+
+Left out, as they don't state facts to check: years (1800 to 2199 with no unit), dates with a month name or in numbers (2026-10-29, 10/29/2026), times (10:30, 9 am), ordinals (2nd, 21st), decades (1990s), a list's numbering at the start of a line ("1." or "1)"), labels ("issue 12", "No. 5", "page 40", "step 2", "top 10"), numbers that are part of a word or a version (Q3, A320, COVID-19, v1.2.3), footnote marks ([3]), merge tags, numbers with a leading zero (007), and a bare whole number under 10. Numbers inside addresses (`https://…`, `example.com/2024/…`) and email addresses are dropped before anything is read.
+
+Not handled, and reported as not found: a figure in words ("seven"), a page that writes the figure differently enough (a table in "$ millions" with 1,700 for $1.7 billion), and a source cited by footnote number instead of a link in the same paragraph.
+
+## How it is bounded
+
+- **Per check:** 25 links judged, 12 of them read whole (the ones a paragraph's figures need, in issue order), 60 requests in all (robots.txt and redirects included), and no request starts after 25 seconds (`CLAIM_CHECK`). What wasn't reached is reported as not checked, never as a failure.
+- **Per request:** the Briefings engine's fetcher (`lib/briefings/fetch.js` `createFetcher`), so the same guards hold: https for a page read (a plain http link is only judged as a link), every address the name resolves to must be public (DNS over HTTPS in a Worker), again on each redirect hop, robots.txt for its user agent `FlockStack-Briefings/1.0 (+https://flockstack.io/docs/briefings-bot)`, 1 MB and 8 seconds, two requests at a time per host, no cookies and nothing worked around. The page's text is read for its figures only and never kept: the stored result has the issue's own excerpts (120 characters) and the addresses.
+- **Per account:** 30 checks started an hour, like the link check.
+- **Cache:** the result is kept in `ClaimCheck` for the issue's words (`campaignContentHash`: subject, preview text, format and body), so asking again with the same words reads the kept result for a day and opens nothing; any edit asks again. The hourly cron drops results nobody looked at for a week.
+- **Calls:** code only, no model. An issue with figures but no links needs no request at all and is answered at once; one with neither passes at once.
+
+## Never in the way of a send
+
+The check runs in its own job (`check-claims`, `lib/claim-check-run.js`), started by the ready-to-send check like the link check, and the review step asks again every two seconds, for up to 50 seconds. A send never starts it, never waits for it and never fetches anything for it.
+
+**Blocking decision:** findings are warnings by default, like every other warning in the ready-to-send check. A newsletter can turn on `requireClaimCheck` (the "Claim check" switch in its settings, or `update_newsletter`): then `send_campaign` and `schedule_campaign` (and the dashboard's Send) refuse with `send_check_failed` until a finished check on the issue's words as they are found no dead link, no missing figure and no figure without a source, and the ready-to-send check shows the claim check as a blocker while it runs or fails. That is one read of `ClaimCheck` in the send's own checks, only for those newsletters. "Couldn't be confirmed" never blocks: a site that refuses programs isn't the writer's to fix. There is no per-campaign switch and no plan gating.
+
+A scheduled issue is checked when it is scheduled; one edited after that is not checked again when its time comes.
+
+## Parity
+
+- Registry: `check_campaign` answers `claims` (state, required, passed, the lists with their counts) beside its items, and its item `claims`; `checking` names which of the links and the claim check are still running. REST `GET /api/v1/campaigns/{id}/check` and the MCP tool are the same action.
+- Dashboard: the review step's card and the approval card show the item (`PanelReady`, which spins the rows still being checked); the newsletter settings have the "Claim check" switch, the same field as `update_newsletter`'s `requireClaimCheck`.
+- The existing link check (`check-links`, the first 20 links, `links` item) is unchanged. The claim check judges the links again through the stricter fetcher; when the links item already names the same dead links, the claim check's item says "see Links" instead of listing them twice.
+
+## A model step, left out
+
+A model could judge whether the sentence around a figure says what the cited page says (the Briefings check model, or one TypeSafe claim judgment per paragraph), catch figures in words, and match a table's "$ millions" column. It is left out: it would cost a call per issue on every edit, needs an AI key the account may not have, and its answer is a probability where the code check's is a fact. It would fit as an optional step after the code check, with the account's own key, only on paragraphs whose figures were found.
diff --git a/lib/account-purge.js b/lib/account-purge.js
index 6aa60464..a2eb9b7e 100644
--- a/lib/account-purge.js
+++ b/lib/account-purge.js
@@ -87,6 +87,7 @@ import ContentItem from "@/models/ContentItem";
 import ContentRevision from "@/models/ContentRevision";
 import EditorialBatch from "@/models/EditorialBatch";
 import LinkCheck from "@/models/LinkCheck";
+import ClaimCheck from "@/models/ClaimCheck";
 import Product from "@/models/Product";
 import Referral from "@/models/Referral";
 import Recommendation from "@/models/Recommendation";
@@ -161,6 +162,7 @@ export const CONTENT_MODELS = [
 	SitePage,
 	FeedCache,
 	LinkCheck,
+	ClaimCheck,
 	ContentRevision,
 	ContentItem,
 	EditorialBatch,
diff --git a/lib/actions/campaign-checks.js b/lib/actions/campaign-checks.js
index 0cf0b134..1d2295e0 100644
--- a/lib/actions/campaign-checks.js
+++ b/lib/actions/campaign-checks.js
@@ -4,6 +4,7 @@ import { CampaignSchema, EDITABLE_STATUSES, findCampaign } from "@/lib/actions/c
 import { defineAction } from "@/lib/actions/define-action";
 import { actionError } from "@/lib/actions/errors";
 import { dateOutput, idInput, toIso } from "@/lib/actions/shared";
+import { CLAIM_CHECK } from "@/lib/claim-check-rules";
 import { runReadyCheck } from "@/lib/ready-check-data";
 import { CAMPAIGN_STATUSES } from "@/models/Campaign";
 
@@ -48,7 +49,7 @@ const getCampaignProgress = defineAction({
 });
 
 const ItemSchema = z.object({
-	id: z.string().describe("subject, preview, content, spam, unsubscribe, size, address, sender, links, images-alt, images-size, merge-tags, audience, plan, free-footer, paywall, test, sending or website"),
+	id: z.string().describe("subject, preview, content, spam, unsubscribe, size, address, sender, links, claims, images-alt, images-size, merge-tags, audience, plan, free-footer, paywall, test, sending or website"),
 	status: z.enum(["pass", "warning", "blocker", "info"]).describe("blocker: sending is refused until it's fixed. warning: worth a look, never stops a send. info: something to know."),
 	title: z.string(),
 	message: z.string().describe("One plain sentence"),
@@ -61,13 +62,39 @@ const ItemSchema = z.object({
 		.nullable(),
 });
 
+const LinkFinding = z.object({ url: z.string(), reason: z.string() });
+const FigureFinding = z.object({
+	figure: z.string().describe("The figure as the issue writes it, like $1.7 billion or 8%"),
+	text: z.string().describe("The paragraph or list item it is in, cut at 120 characters"),
+	urls: z.array(z.string()).describe("The pages it was looked for on: the ones its paragraph links to, the first 3"),
+});
+
+const ClaimsSchema = z
+	.object({
+		state: z.enum(["none", "checking", "done", "error"]).describe("none: no figure and no link to check. checking: ask again in a few seconds. error: it couldn't start (too many checks this hour); ask again later."),
+		required: z.boolean().describe("The newsletter's requireClaimCheck: a send is refused until the check passes on the issue's words as they are"),
+		passed: z.boolean().nullable().describe("No dead link, no figure missing from its pages and no figure without a source; null until it is done"),
+		deadLinks: z.array(LinkFinding).describe("Links that don't load: gone (404, 410 or another 4xx), unreachable, a name that doesn't resolve, or an address inside a private network, which is never opened"),
+		unsureLinks: z.array(LinkFinding).describe("Links the site wouldn't let the check confirm (401, 403, 429, a server error, too slow, or robots.txt): not counted as dead"),
+		unmatchedFigures: z.array(FigureFinding).describe("Figures that are on none of the pages their paragraph links to, every one of which was read"),
+		unconfirmedFigures: z.array(FigureFinding.extend({ reason: z.string() })).describe("Figures whose pages couldn't all be read (a file, a refusal, robots.txt, plain http, the check's limits), so they are neither found nor missing"),
+		uncitedClaims: z.array(z.object({ text: z.string(), figures: z.array(z.string()) })).describe("Paragraphs and list items that state figures and link to no source"),
+		counts: z.object({ deadLinks: z.number().int(), unsureLinks: z.number().int(), unmatchedFigures: z.number().int(), unconfirmedFigures: z.number().int(), uncitedClaims: z.number().int() }).describe("The totals; each list above has the first 20"),
+		figuresChecked: z.number().int().describe("Figures that had a page to be looked for on"),
+		linksChecked: z.number().int(),
+		linksTotal: z.number().int(),
+		pagesRead: z.number().int(),
+		checkedAt: z.string().nullable(),
+	})
+	.describe(`The claim check, on any issue: dead links, figures not on the pages they link to, and figures with no source. Code only, no AI model. Up to ${CLAIM_CHECK.maxLinks} links and ${CLAIM_CHECK.maxPages} pages read a check, kept for the issue's words for a day. Its findings are warnings unless the newsletter has requireClaimCheck on.`);
+
 const checkCampaign = defineAction({
 	name: "check_campaign",
 	tryWithoutPlan: true,
 	title: "Check that a campaign is ready to send",
 	group: GROUP,
 	description:
-		"Runs the dashboard's ready-to-send check on a draft or scheduled campaign, so an agent can look before it proposes a send: subject length and tone, preview text, content, the unsubscribe link and the postal address, the sender address, the links (up to 20, opened from FlockStack's servers by a short background job), the pictures' alt text and sizes, merge tags that some contacts have no value for, who it goes to, the plan's limits and a test email. Each item is pass, warning, blocker or info with one sentence and where to fix it. A blocker is something the send itself would refuse; warnings never stop a send. The links come back as info with isChecking true on the first call: ask again after a few seconds.",
+		`Runs the dashboard's ready-to-send check on a draft or scheduled campaign, so an agent can look before it proposes a send: subject length and tone, preview text, content, the unsubscribe link and the postal address, the sender address, the links (up to 20, opened from FlockStack's servers by a short background job), the pictures' alt text and sizes, merge tags that some contacts have no value for, who it goes to, the plan's limits and a test email. It also runs the claim check (claims): links that don't load, figures in a paragraph or list item that aren't on any page it links to, and paragraphs that state figures with no source, from up to ${CLAIM_CHECK.maxPages} pages read by FlockStack's servers under robots.txt; dates, years, list numbers and numbers in addresses are left out, and $1.7 billion, 1.7bn and 1,700,000,000 count as the same figure. Each item is pass, warning, blocker or info with one sentence and where to fix it. A blocker is something the send itself would refuse; warnings never stop a send. The claim check's findings are warnings, or blockers when the newsletter has requireClaimCheck on. The links and the claim check come back as info with isChecking true on the first call (checking names which): ask again after a few seconds.`,
 	http: { method: "GET", path: "/campaigns/{id}/check" },
 	readOnly: true,
 	openWorld: true,
@@ -80,7 +107,9 @@ const checkCampaign = defineAction({
 		blockers: z.number().int(),
 		warnings: z.number().int(),
 		canSend: z.boolean().describe("No blocker: a send would not be refused for these reasons"),
-		isChecking: z.boolean().describe("The links are still being opened: ask again in a few seconds for their result"),
+		isChecking: z.boolean().describe("The links or the claim check are still being opened: ask again in a few seconds for their result"),
+		checking: z.array(z.enum(["links", "claims"])).describe("Which of them are still running"),
+		claims: ClaimsSchema,
 		checkedAt: z.string(),
 	}),
 	handler: async ({ account, input }) => {
diff --git a/lib/actions/campaigns.js b/lib/actions/campaigns.js
index 4b5eb040..ccb3138f 100644
--- a/lib/actions/campaigns.js
+++ b/lib/actions/campaigns.js
@@ -28,6 +28,7 @@ import { PUBLISHED_STATUSES, getIssuePageUrl, revalidateArchive } from "@/lib/ar
 import { deleteAudioOfCampaign } from "@/lib/audio";
 import { PUBLISH_TARGETS } from "@/lib/archive-issues";
 import { isArchiveSlugTaken, uniqueArchiveSlug } from "@/lib/archive-slugs";
+import { getClaimSendProblem } from "@/lib/claim-check";
 import { AUDIENCE_ORDERS } from "@/lib/cohort-order";
 import { MAX_ISSUE_TAGS, getTagSlug, toIssueTags } from "@/lib/issue-tags";
 import { MAX_TAG_LENGTH } from "@/lib/tag-rules";
@@ -459,6 +460,8 @@ export async function reload(account, campaign) {
 async function getSendBlocker(account, campaign, newsletter) {
 	const accountProblem = getAccountSendProblem(account);
 	if (accountProblem) return accountProblem;
+	const claimProblem = await getClaimSendProblem({ account, campaign, newsletter });
+	if (claimProblem) return { code: "send_check_failed", message: claimProblem };
 	if (campaign.publishTo === "web") {
 		const webProblem = getWebPublishProblem({ campaign, newsletter });
 		return webProblem ? { code: "send_check_failed", message: webProblem } : null;
diff --git a/lib/actions/newsletters.js b/lib/actions/newsletters.js
index 26069f69..8aec08f6 100644
--- a/lib/actions/newsletters.js
+++ b/lib/actions/newsletters.js
@@ -120,6 +120,9 @@ const settingsShape = {
 		.number()
 		.int()
 		.describe("How long the dashboard holds a send after Send is pressed, so it can be undone: 0 (off), 10, 30 (the default) or 60 seconds. Sends from the API and MCP go out at once."),
+	requireClaimCheck: z
+		.boolean()
+		.describe("Refuse a send or a schedule until the claim check (check_campaign's claims) has finished on the issue's words as they are and found no dead link, no figure missing from the pages its paragraph links to and no figure without a source. Off by default: its findings are then warnings only, and a send never waits for it."),
 	customHeaders: z
 		.array(z.object({ name: text(CUSTOM_HEADER_LIMITS.name), value: text(CUSTOM_HEADER_LIMITS.value) }))
 		.max(CUSTOM_HEADER_LIMITS.count)
@@ -200,6 +203,7 @@ const NewsletterSchema = z.object({
 	utmLinks: z.boolean().describe("Links to other sites in issues get UTM parameters"),
 	shareButtons: z.boolean().describe("Share buttons in the header of emails whose issue has a web page"),
 	sendUndoSeconds: z.number().int().describe("Seconds the dashboard holds a send for undo: 0, 10, 30 or 60"),
+	requireClaimCheck: z.boolean().describe("A send waits until the claim check passes"),
 	customHeaders: z.array(z.object({ name: z.string(), value: z.string() })).describe("Extra headers on its emails"),
 	defaultStyle: z.object({ header: z.string(), footer: z.string() }).describe("What new issues start with, as HTML"),
 	jsonLd: z.string().describe("Its own structured data as compact JSON, or empty"),
diff --git a/lib/briefings/readable.js b/lib/briefings/readable.js
index 477aa49c..3db52438 100644
--- a/lib/briefings/readable.js
+++ b/lib/briefings/readable.js
@@ -65,6 +65,12 @@ export function previewImageOf(head, base) {
 	}
 }
 
+// All of a page's text, menus, tables and footers too, uncut: where the claim check looks for a figure (lib/claim-check-run.js).
+export function fullPageText(html) {
+	const source = String(html ?? "");
+	return toText(dropElements(innerOf(source, "body") ?? source, ["script", "style", "noscript", "svg", "template"]));
+}
+
 // { title, text, links, canonical, publishedAt, image }. The text is the page's <article> or <main> when it has one, with menus,
 // headers, footers, forms and scripts left out, cut at MAX_READABLE_CHARS.
 export function readablePage(html, base) {
diff --git a/lib/claim-check-rules.js b/lib/claim-check-rules.js
new file mode 100644
index 00000000..e88a886f
--- /dev/null
+++ b/lib/claim-check-rules.js
@@ -0,0 +1,199 @@
+import { decodeEntities } from "./editor-blocks.js";
+import { markdownToHtml } from "./markdown.js";
+import { findLinks } from "./ready-check.js";
+
+// The claim check of the ready-to-send check (docs/CLAIM-CHECK.md): for any issue, which links don't load, which figures in a
+// paragraph or list item aren't on any page that paragraph links to, and which paragraphs state figures with no link at all.
+// Plain functions of the issue and of the pages read; lib/claim-check.js keeps the result and lib/claim-check-run.js reads
+// the pages. Code only: no model call.
+//
+// maxLinks: links judged per check. maxPages: of those, pages read whole for their figures. maxRequests: every request the
+// check makes, robots.txt and redirects included. timeMs: no request starts after it. The result is kept for the issue's
+// words (campaignContentHash, lib/campaign-content-hash.js) for cacheMs.
+export const CLAIM_CHECK = { maxLinks: 25, maxPages: 12, maxRequests: 60, timeMs: 25_000, concurrency: 4, cacheMs: 24 * 60 * 60_000, runningMs: 3 * 60_000, maxListed: 20 };
+
+const SCALES = { thousand: 1e3, k: 1e3, million: 1e6, mn: 1e6, mm: 1e6, m: 1e6, billion: 1e9, bn: 1e9, b: 1e9, trillion: 1e12, tn: 1e12 };
+// A one-letter scale ("5m") may be minutes or metres too, so the bare figure also counts.
+const SHORT_SCALES = new Set(["k", "m", "b"]);
+const MONTH = "(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|june?|july?|aug(?:ust)?|sep(?:t(?:ember)?)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\\.?";
+const BEFORE_MONTH = new RegExp(`\\b${MONTH}\\s*$`, "i");
+const AFTER_MONTH = new RegExp(`^\\s*(?:st|nd|rd|th)?\\s*(?:of\\s+)?${MONTH}(?![a-z])`, "i");
+// A number that names a thing rather than counts it: "issue 12", "No. 5", "step 2".
+const LABEL_BEFORE = /\b(?:no\.|nos\.|number|issue|episode|ep\.|part|chapter|ch\.|page|p\.|pp\.|step|week|day|season|vol\.|volume|version|ver\.|v|rank(?:ed)?|top|level|grade|room|unit|suite|route|highway)\s*$/i;
+// Currency, the digits (thousands with commas), a decimal part, then a percent or a scale. Not part of a word ("A320", "Q3",
+// "COVID-19"), a version ("1.2.3"), a time ("10:30"), a fraction or date ("3/4"), a tag ("#5") or a thousands group.
+const NUMBER =
+	/(?<![\p{L}\p{N}_.,/#:'’]|\p{L}-)((?:US|A|C|NZ|HK|S)?[$€£¥₹]\s?)?(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?(?![.,]?\d)(?!:\d)(?:(\s?(?:%|percent\b|per\s?cent\b|pct\b))|\s?(thousand|million|billion|trillion|mn|bn|tn)\b|(mm|k|m|b)\b)?/giu;
+
+// Text with nothing a figure should be read from: addresses, email addresses, merge tags, footnote marks and written dates.
+function stripNoise(text) {
+	return String(text ?? "")
+		.replace(/\{\{[^{}]*\}\}/g, " ")
+		.replace(/\b(?:https?:\/\/|www\.)\S+/gi, " ")
+		.replace(/\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g, " ")
+		.replace(/\b[\w-]+(?:\.[\w-]+)*\.[a-z]{2,}\/\S*/gi, " ")
+		.replace(/\[\d{1,3}\]/g, " ")
+		.replace(/\b\d{4}-\d{1,2}-\d{1,2}(?:[T ][\d:.]+Z?)?\b/g, " ")
+		.replace(/\b\d{1,2}([/.-])\d{1,2}\1\d{2,4}\b/g, " ");
+}
+
+function round(value) {
+	return Number(value.toPrecision(12));
+}
+
+// Every figure in a text: { token, value, values (what it may be compared as), unit (a scaled figure's rounding step), isClaim }.
+// isClaim: worth checking against a source. Left out of that: years, dates, times, ordinals, decades, a list's numbering, labels
+// ("issue 12") and a bare whole number under 10.
+export function figuresIn(text) {
+	const source = stripNoise(text);
+	const figures = [];
+	for (const match of source.matchAll(NUMBER)) {
+		const [whole, currency, digits, decimals = "", percent, wordScale, shortScale] = match;
+		const scaleName = (wordScale ?? shortScale ?? "").toLowerCase();
+		const scale = SCALES[scaleName] ?? 1;
+		const raw = Number(`${digits.replaceAll(",", "")}${decimals ? `.${decimals}` : ""}`);
+		if (!Number.isFinite(raw)) continue;
+		const value = round(raw * scale);
+		const before = source.slice(Math.max(0, match.index - 24), match.index);
+		const after = source.slice(match.index + whole.length, match.index + whole.length + 24);
+		const isPlain = !currency && !percent && !scaleName && !decimals;
+		const lineStart = /(?:^|\n)\s*$/.test(before);
+		const skip =
+			/^(?:st|nd|rd|th)\b/i.test(after) ||
+			/^'?s\b/i.test(after) ||
+			/^\s?(?:a\.?m\.?|p\.?m\.?)(?![a-z])/i.test(after) ||
+			(isPlain && BEFORE_MONTH.test(before)) ||
+			(isPlain && AFTER_MONTH.test(after)) ||
+			(isPlain && LABEL_BEFORE.test(before)) ||
+			(isPlain && lineStart && /^[.)]\s/.test(after)) ||
+			(isPlain && digits.length === 4 && raw >= 1800 && raw <= 2199) ||
+			(isPlain && raw < 10) ||
+			(isPlain && digits.length > 1 && digits.startsWith("0"));
+		const values = SHORT_SCALES.has(scaleName) ? [value, round(raw)] : [value];
+		figures.push({ token: whole.trim(), value, values, unit: scale > 1 ? scale / 10 ** decimals.length : 0, isClaim: !skip });
+	}
+	return figures;
+}
+
+// What a page's text can back: every figure on it, as values.
+export function pageValues(text) {
+	return new Set(figuresIn(text).flatMap(({ values }) => values));
+}
+
+// A figure is on a page when the page has it in any form ($1.7 billion, 1.7bn, 1,700,000,000; 8.0% and 8%), or, for a figure
+// with a scale, when the page has a more exact one that rounds to it (1.7 billion for 1,712,000,000).
+export function isOnPage(figure, values, sorted = [...values]) {
+	if (figure.values.some((value) => values.has(value))) return true;
+	if (!figure.unit) return false;
+	const half = figure.unit / 2;
+	return sorted.some((value) => Math.abs(value - figure.value) <= half * (1 + 1e-9));
+}
+
+const BOUNDARY = /<\/?(p|li|ul|ol|h[1-6]|blockquote|div|section|article|aside|header|footer|table|thead|tbody|tfoot|tr|td|th|caption|figure|figcaption|dl|dd|dt|pre|hr|details|summary)\b[^>]*>/gi;
+
+function plainText(html) {
+	return decodeEntities(String(html).replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]*>/g, " "))
+		.replace(/[ \t\f\v ]+/g, " ")
+		.replace(/\s*\n\s*/g, "\n")
+		.trim();
+}
+
+// The issue's HTML as the email has it: Markdown rendered with the renderer the send uses.
+export function issueHtml(campaign) {
+	return campaign.format === "markdown" ? markdownToHtml(campaign.markdown ?? "") : String(campaign.html ?? "");
+}
+
+// The issue as the check reads it: each paragraph, list item, heading or table cell with its text, its links and its figures;
+// the subject and the preview text as headings. A nested list's items are units of their own.
+export function issueUnits(campaign) {
+	const html = issueHtml(campaign).replace(/<(script|style|noscript|template|svg|head)\b[\s\S]*?<\/\1\s*>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ");
+	const units = [];
+	const push = (kind, part, field = "body") => {
+		const text = plainText(part);
+		if (text) units.push({ kind, field, text, links: findLinks(part), figures: figuresIn(text).filter(({ isClaim }) => isClaim) });
+	};
+	push("heading", String(campaign.subject ?? "").replace(/[<>&]/g, " "), "subject");
+	push("heading", String(campaign.previewText ?? "").replace(/[<>&]/g, " "), "preview");
+	let kind = "text";
+	let start = 0;
+	for (const match of html.matchAll(BOUNDARY)) {
+		push(kind, html.slice(start, match.index));
+		const isOpening = !match[0].startsWith("</");
+		kind = isOpening && /^h[1-6]$/i.test(match[1]) ? "heading" : "text";
+		start = match.index + match[0].length;
+	}
+	push(kind, html.slice(start));
+	return units;
+}
+
+// The issue's links in the order the check takes them: first those a paragraph with figures needs read, then the rest.
+// pages: the links to read whole, maxPages at most.
+export function planChecks(units) {
+	const read = [];
+	for (const unit of units) if (unit.kind !== "heading" && unit.figures.length) for (const url of unit.links) if (!read.includes(url)) read.push(url);
+	const all = [...read];
+	for (const unit of units) for (const url of unit.links) if (!all.includes(url)) all.push(url);
+	const judged = all.slice(0, CLAIM_CHECK.maxLinks);
+	return { links: judged, pages: read.filter((url) => judged.includes(url)).slice(0, CLAIM_CHECK.maxPages), total: all.length };
+}
+
+function snippet(text) {
+	const line = text.replace(/\s+/g, " ").trim();
+	return line.length > 120 ? `${line.slice(0, 117)}…` : line;
+}
+
+// The report. linkStates: url -> { state: ok | broken | unsure, reason }, for the links that were judged. pages: url -> the
+// page's figures (a Set from pageValues) for each page that was read, or { problem } for one that couldn't be.
+// failures: dead links, figures not on their pages, figures with no source. unconfirmed: what couldn't be read, so isn't known.
+export function buildClaimReport({ units, linkStates = {}, pages = {}, total = 0, checkedAt = new Date() }) {
+	const deadLinks = [];
+	const unsureLinks = [];
+	for (const [url, result] of Object.entries(linkStates)) {
+		if (result.state === "broken") deadLinks.push({ url, reason: result.reason ?? "doesn't load" });
+		else if (result.state === "unsure") unsureLinks.push({ url, reason: result.reason ?? "couldn't be confirmed" });
+	}
+	const read = Object.entries(pages).filter(([, page]) => page.values);
+	const sorted = new Map(read.map(([url, page]) => [url, [...page.values]]));
+	const unmatched = [];
+	const unconfirmed = [];
+	const uncited = [];
+	const issueLinks = [...new Set(units.flatMap(({ links }) => links))];
+	const whyUnread = (sources) => sources.map((url) => pages[url]?.problem).find(Boolean) ?? `not read: the check reads ${CLAIM_CHECK.maxPages} pages and ${CLAIM_CHECK.maxLinks} links at most`;
+	let figuresChecked = 0;
+	for (const unit of units) {
+		if (!unit.figures.length) continue;
+		const isHeading = unit.kind === "heading";
+		if (!isHeading && !unit.links.length) {
+			uncited.push({ text: snippet(unit.text), figures: [...new Set(unit.figures.map(({ token }) => token))] });
+			continue;
+		}
+		// A heading, the subject and the preview sum up the issue: their figures may be on any page it links to.
+		const sources = isHeading ? issueLinks : unit.links;
+		if (!sources.length) continue;
+		figuresChecked += unit.figures.length;
+		const readSources = sources.filter((url) => pages[url]?.values);
+		const allRead = readSources.length === sources.length;
+		for (const figure of unit.figures) {
+			if (readSources.some((url) => isOnPage(figure, pages[url].values, sorted.get(url)))) continue;
+			const entry = { figure: figure.token, text: snippet(unit.text), urls: sources.slice(0, 3) };
+			if (allRead) unmatched.push(entry);
+			else unconfirmed.push({ ...entry, reason: whyUnread(sources) });
+		}
+	}
+	const failures = deadLinks.length + unmatched.length + uncited.length;
+	const cap = (list) => list.slice(0, CLAIM_CHECK.maxListed);
+	return {
+		deadLinks: cap(deadLinks),
+		unsureLinks: cap(unsureLinks),
+		unmatchedFigures: cap(unmatched),
+		unconfirmedFigures: cap(unconfirmed),
+		uncitedClaims: cap(uncited),
+		counts: { deadLinks: deadLinks.length, unsureLinks: unsureLinks.length, unmatchedFigures: unmatched.length, unconfirmedFigures: unconfirmed.length, uncitedClaims: uncited.length },
+		failures,
+		figuresChecked,
+		linksChecked: Object.keys(linkStates).length,
+		linksTotal: total,
+		pagesRead: read.length,
+		checkedAt: new Date(checkedAt).toISOString(),
+	};
+}
diff --git a/lib/claim-check-run.js b/lib/claim-check-run.js
new file mode 100644
index 00000000..9c8f8af0
--- /dev/null
+++ b/lib/claim-check-run.js
@@ -0,0 +1,79 @@
+import "server-only";
+import { createFetcher, mapLimited } from "@/lib/briefings/fetch";
+import { fullPageText } from "@/lib/briefings/readable";
+import { campaignContentHash } from "@/lib/campaign-content-hash";
+import { CLAIM_CHECK, buildClaimReport, issueUnits, pageValues, planChecks } from "@/lib/claim-check-rules";
+import { connectDb } from "@/lib/db";
+import { judgeStatus } from "@/lib/link-check-rules";
+import { isObjectIdString } from "@/lib/validation";
+import Campaign from "@/models/Campaign";
+import ClaimCheck from "@/models/ClaimCheck";
+
+// The check-claims job (docs/CLAIM-CHECK.md): every request goes through the briefings engine's fetcher (lib/briefings/fetch.js),
+// so it is held to the same guards: public addresses only, each name resolved and every address checked, again on each
+// redirect, robots.txt for FlockStack's user agent, 1 MB and 8 s a request, two at a time per host, no cookies. On top of that,
+// CLAIM_CHECK's caps on links, pages, requests and time for one check.
+const READABLE = /html|xml|text\/plain|json/;
+
+// A page read whole: the link's state, and the figures on the page or why it couldn't be read. A failure that isn't the
+// page's own answer (a refused address, a redirect to plain http, no answer) is judged again as a link, by the link rules.
+async function readPage(fetcher, url) {
+	if (!/^https:/i.test(url)) return { link: await fetcher.checkLink(url), page: { problem: "only https pages are read" } };
+	try {
+		const page = await fetcher.get(url);
+		const type = page.contentType.toLowerCase();
+		if (type && !READABLE.test(type)) return { link: { state: "ok" }, page: { problem: `it is a file (${type.split(";")[0]}), not a page` } };
+		return { link: { state: "ok" }, page: { values: pageValues(/html|xml/.test(type) || !type ? fullPageText(page.text) : page.text) } };
+	} catch (error) {
+		const problem = error?.message ?? "it couldn't be read";
+		if (error?.status) return { link: judgeStatus(error.status), page: { problem } };
+		if (error?.robots) return { link: { state: "unsure", reason: "robots.txt asks FlockStack not to open it" }, page: { problem } };
+		if (/over 1 MB/.test(problem)) return { link: { state: "ok" }, page: { problem } };
+		if (/too long/.test(problem)) return { link: { state: "unsure", reason: problem }, page: { problem } };
+		if (/reached its/.test(problem)) return { link: { state: "unsure", reason: "not checked: the check reached its request limit" }, page: { problem: "not read: the check reached its request limit" } };
+		return { link: await fetcher.checkLink(url), page: { problem } };
+	}
+}
+
+// The check itself, from the issue's units: the links to judge, CLAIM_CHECK.concurrency at a time, the ones a paragraph's figures need
+// read whole. No request starts after CLAIM_CHECK.timeMs; what wasn't reached is reported as not checked.
+export async function checkIssue({ units, fetchImpl = globalThis.fetch, resolveHost, now = () => Date.now() }) {
+	const { links, pages, total } = planChecks(units);
+	const deadline = now() + CLAIM_CHECK.timeMs;
+	const fetcher = createFetcher({ fetchImpl, resolveHost, perRun: CLAIM_CHECK.maxRequests, now });
+	const toRead = new Set(pages);
+	const linkStates = {};
+	const read = {};
+	await mapLimited(links, CLAIM_CHECK.concurrency, async (url) => {
+		if (now() >= deadline) {
+			if (toRead.has(url)) read[url] = { problem: "not read: the check reached its time limit" };
+			return;
+		}
+		if (toRead.has(url)) {
+			const { link, page } = await readPage(fetcher, url);
+			linkStates[url] = { state: link.state, reason: link.reason ?? null };
+			read[url] = page;
+		} else {
+			const link = await fetcher.checkLink(url);
+			linkStates[url] = { state: link.state, reason: link.reason ?? null };
+		}
+	});
+	return { report: buildClaimReport({ units, linkStates, pages: read, total, checkedAt: now() }), requests: fetcher.count };
+}
+
+// Runs when QStash delivers the job. A job for words the issue no longer has, or whose result is kept already, does nothing.
+// fetchImpl and resolveHost are for tests; in production they are the Worker's fetch and its DNS over HTTPS.
+export async function runClaimCheck({ accountId, campaignId, hash }, { fetchImpl, resolveHost, now } = {}) {
+	if (!isObjectIdString(String(accountId)) || !isObjectIdString(String(campaignId)) || typeof hash !== "string") return { skipped: "invalid job" };
+	await connectDb();
+	const row = await ClaimCheck.findOne({ accountId, campaignId }).lean();
+	if (row?.status !== "running" || row.hash !== hash) return { skipped: "not waiting for this check" };
+	const campaign = await Campaign.findOne({ accountId, _id: campaignId }).lean();
+	if (!campaign || campaignContentHash(campaign) !== hash) {
+		await ClaimCheck.deleteOne({ accountId, campaignId });
+		return { skipped: "the issue changed" };
+	}
+	const { report, requests } = await checkIssue({ units: issueUnits(campaign), fetchImpl, resolveHost, now });
+	await ClaimCheck.updateOne({ accountId, campaignId, hash, status: "running" }, { $set: { status: "done", checkedAt: new Date(), report } });
+	return { checked: report.linksChecked, pagesRead: report.pagesRead, failures: report.failures, requests };
+}
diff --git a/lib/claim-check.js b/lib/claim-check.js
new file mode 100644
index 00000000..abdf818b
--- /dev/null
+++ b/lib/claim-check.js
@@ -0,0 +1,104 @@
+import "server-only";
+import { scoped } from "@/lib/account-scope";
+import { campaignContentHash } from "@/lib/campaign-content-hash";
+import { CLAIM_CHECK, buildClaimReport, issueUnits, planChecks } from "@/lib/claim-check-rules";
+import { getAppUrl } from "@/lib/config";
+import { connectDb } from "@/lib/db";
+import { isRateLimited } from "@/lib/rate-limit";
+import { publishJob } from "@/lib/sending";
+import ClaimCheck from "@/models/ClaimCheck";
+
+// The claim check (docs/CLAIM-CHECK.md) as the ready-to-send check asks for it: nothing to check, the kept result for these
+// same words, or a check-claims job started (lib/claim-check-run.js reads the pages). It never runs inside a send: a send
+// only reads the kept result, and only for a newsletter that requires the check to pass.
+const STARTS = { name: "claim-check-starts", limit: 30, window: "1 h" };
+
+const NEEDS_CHECK = "This newsletter needs the claim check to pass before a send, and it hasn't finished on these words: open the ready-to-send check (check_campaign) and wait for its result";
+
+function describeFailures({ counts }) {
+	const parts = [];
+	if (counts.deadLinks) parts.push(`${counts.deadLinks === 1 ? "a link that doesn't" : `${counts.deadLinks} links that don't`} load`);
+	if (counts.unmatchedFigures) parts.push(`${counts.unmatchedFigures === 1 ? "a figure that isn't" : `${counts.unmatchedFigures} figures that aren't`} on the page it links to`);
+	if (counts.uncitedClaims) parts.push(`${counts.uncitedClaims === 1 ? "a paragraph" : `${counts.uncitedClaims} paragraphs`} with figures and no source`);
+	return parts.join(", ");
+}
+
+function hasWork(units, plan) {
+	return plan.total > 0 || units.some(({ figures }) => figures.length);
+}
+
+// { state: none | checking | done | error, required, total, report }.
+export async function getClaimState({ account, campaign, newsletter, now = Date.now() }) {
+	const required = Boolean(newsletter?.requireClaimCheck);
+	const units = issueUnits(campaign);
+	const plan = planChecks(units);
+	if (!hasWork(units, plan)) return { state: "none", required };
+	// With no link there is nothing to open: the figures are all without a source, and that is known now.
+	if (plan.total === 0) return { state: "done", required, report: buildClaimReport({ units, checkedAt: now }) };
+	const hash = campaignContentHash(campaign);
+	await connectDb();
+	const row = await ClaimCheck.findOne(scoped(account, { campaignId: campaign._id })).lean();
+	if (row?.hash === hash) {
+		const age = now - new Date(row.checkedAt ?? row.startedAt).getTime();
+		if (row.status === "done" && age < CLAIM_CHECK.cacheMs) return { state: "done", required, report: row.report };
+		if (row.status === "running" && age < CLAIM_CHECK.runningMs) return { state: "checking", required, total: plan.links.length };
+	}
+	if (await isRateLimited({ ...STARTS, key: String(account._id) })) return { state: "error", required };
+	await ClaimCheck.updateOne(
+		scoped(account, { campaignId: campaign._id }),
+		{ $set: { hash, status: "running", startedAt: new Date(now) }, $unset: { checkedAt: 1, report: 1 } },
+		{ upsert: true }
+	);
+	try {
+		await publishJob({ url: `${getAppUrl()}/api/jobs/check-claims`, body: { accountId: String(account._id), campaignId: String(campaign._id), hash } });
+	} catch (error) {
+		console.error("[claim-check] Starting the check failed:", error.message);
+		await ClaimCheck.deleteOne(scoped(account, { campaignId: campaign._id }));
+		return { state: "error", required };
+	}
+	return { state: "checking", required, total: plan.links.length };
+}
+
+// Why a send must wait, for a newsletter that requires the claim check to pass: no finished check for the issue's words as
+// they are, or one that found something. Null otherwise, and always for a newsletter that only warns (the default).
+export async function getClaimSendProblem({ account, campaign, newsletter }) {
+	if (!newsletter?.requireClaimCheck) return null;
+	const units = issueUnits(campaign);
+	const plan = planChecks(units);
+	if (!hasWork(units, plan)) return null;
+	let report;
+	if (plan.total === 0) report = buildClaimReport({ units });
+	else {
+		const row = await ClaimCheck.findOne(scoped(account, { campaignId: campaign._id })).lean();
+		if (row?.status !== "done" || row.hash !== campaignContentHash(campaign)) return NEEDS_CHECK;
+		report = row.report;
+	}
+	return report.failures ? `This newsletter needs the claim check to pass before a send, and it found ${describeFailures(report)}` : null;
+}
+
+// What check_campaign answers about the claim check, the same shape in every state.
+export function toClaimOutput(claims) {
+	const report = claims?.state === "done" ? claims.report : null;
+	return {
+		state: claims?.state ?? "none",
+		required: Boolean(claims?.required),
+		passed: claims?.state === "none" ? true : report ? report.failures === 0 : null,
+		deadLinks: report?.deadLinks ?? [],
+		unsureLinks: report?.unsureLinks ?? [],
+		unmatchedFigures: report?.unmatchedFigures ?? [],
+		unconfirmedFigures: report?.unconfirmedFigures ?? [],
+		uncitedClaims: report?.uncitedClaims ?? [],
+		counts: report?.counts ?? { deadLinks: 0, unsureLinks: 0, unmatchedFigures: 0, unconfirmedFigures: 0, uncitedClaims: 0 },
+		figuresChecked: report?.figuresChecked ?? 0,
+		linksChecked: report?.linksChecked ?? 0,
+		linksTotal: report?.linksTotal ?? claims?.total ?? 0,
+		pagesRead: report?.pagesRead ?? 0,
+		checkedAt: report?.checkedAt ?? null,
+	};
+}
+
+// Results nobody looked at for a week, for the hourly job.
+export async function purgeOldClaimChecks(now = Date.now()) {
+	const cutoff = new Date(now - 7 * 24 * 60 * 60_000);
+	return (await ClaimCheck.deleteMany({ $or: [{ checkedAt: { $lt: cutoff } }, { checkedAt: { $exists: false }, startedAt: { $lt: cutoff } }] }).setOptions({ crossAccount: true })).deletedCount ?? 0;
+}
diff --git a/lib/docs/pages.js b/lib/docs/pages.js
index ea465713..bb37d059 100644
--- a/lib/docs/pages.js
+++ b/lib/docs/pages.js
@@ -81,7 +81,7 @@ export const DOC_PAGES = [
 		href: "/docs/briefings-bot",
 		title: "The FlockStack-Briefings fetcher",
 		summary: "The fetcher that reads pages for FlockStack users' briefings: what it reads, robots.txt, and how a site opts out.",
-		description: "FlockStack-Briefings/1.0 reads public pages that a FlockStack user's briefing found, obeys robots.txt for its user agent and never works around paywalls or blocks. How to opt out, and who to contact.",
+		description: "FlockStack-Briefings/1.0 reads public pages that briefings find or issues cite, obeys robots.txt for its user agent and never works around paywalls or blocks. How to opt out, and who to contact.",
 	},
 	{
 		href: "/docs/subfolder",
diff --git a/lib/newsletter-form.js b/lib/newsletter-form.js
index e786874b..70c3bfaa 100644
--- a/lib/newsletter-form.js
+++ b/lib/newsletter-form.js
@@ -53,6 +53,7 @@ export function getNewsletterDraft({ newsletter, domains, sharedDomain, defaultP
 		isUtmTagged: Boolean(newsletter?.utmLinks),
 		isShareButtons: Boolean(newsletter?.shareButtons),
 		sendUndoSeconds: String(getUndoSeconds(newsletter)),
+		isClaimCheckRequired: Boolean(newsletter?.requireClaimCheck),
 		customHeaders: formatHeaderLines(newsletter?.customHeaders),
 		authorBio: newsletter?.author?.bio ?? "",
 		authorImageUrl: newsletter?.author?.imageUrl ?? "",
diff --git a/lib/newsletter-settings.js b/lib/newsletter-settings.js
index 4206ca00..60bad46f 100644
--- a/lib/newsletter-settings.js
+++ b/lib/newsletter-settings.js
@@ -50,6 +50,7 @@ export function toNewsletterSettings(newsletter) {
 		utmLinks: Boolean(newsletter?.utmLinks),
 		shareButtons: Boolean(newsletter?.shareButtons),
 		sendUndoSeconds: getUndoSeconds(newsletter),
+		requireClaimCheck: Boolean(newsletter?.requireClaimCheck),
 		customHeaders: (newsletter?.customHeaders ?? []).map(({ name, value }) => ({ name, value })),
 		author: { bio: newsletter?.author?.bio ?? "", imageUrl: newsletter?.author?.imageUrl ?? "" },
 		socialLinks: newsletter?.socialLinks ?? [],
diff --git a/lib/ready-check-data.js b/lib/ready-check-data.js
index d6b248b4..dde84ea3 100644
--- a/lib/ready-check-data.js
+++ b/lib/ready-check-data.js
@@ -1,5 +1,6 @@
 import "server-only";
 import { scoped } from "@/lib/account-scope";
+import { getClaimState, toClaimOutput } from "@/lib/claim-check";
 import { cleanRichHtml } from "@/lib/clean-html";
 import { getAppUrl, isSendingEnabled } from "@/lib/config";
 import { listCustomFields } from "@/lib/custom-fields";
@@ -77,13 +78,14 @@ export async function runReadyCheck({ account, campaign }) {
 	const bodyHtml = campaign.format === "markdown" ? markdownToHtml(campaign.markdown ?? "") : (campaign.html ?? "");
 	const images = findImages(bodyHtml);
 	const filter = await getCampaignAudienceFilter(campaign, { audience: campaign.audience ?? "all" });
-	const [sender, imageSizes, segment, audienceCount, plan, links] = await Promise.all([
+	const [sender, imageSizes, segment, audienceCount, plan, links, claims] = await Promise.all([
 		loadSender(account, stored),
 		findImageSizes(account, images),
 		findSegmentName(campaign),
 		filter ? Contact.countDocuments(filter) : 0,
 		getPlanState({ account, campaign, isWebOnly }),
 		getLinkState({ account, campaign }),
+		getClaimState({ account, campaign, newsletter: stored }),
 	]);
 	const usage = findMergeUsage(campaign.subject, campaign.previewText, bodyHtml);
 	const mergeTags = await describeMergeTags({ account, campaign, newsletter: stored, usage, filter });
@@ -105,7 +107,8 @@ export async function runReadyCheck({ account, campaign }) {
 		imageSizes,
 		mergeTags,
 		links,
+		claims,
 		hasPaywallBreak,
 	});
-	return { ...result, items: result.items.map((entry) => ({ ...entry, fix: entry.fix ? { ...entry.fix, url: entry.fix.path ? `${getAppUrl()}${entry.fix.path}` : `${getAppUrl()}/campaigns/${campaign._id}` } : null })) };
+	return { ...result, items: result.items.map((entry) => ({ ...entry, fix: entry.fix ? { ...entry.fix, url: entry.fix.path ? `${getAppUrl()}${entry.fix.path}` : `${getAppUrl()}/campaigns/${campaign._id}` } : null })), claims: toClaimOutput(claims) };
 }
diff --git a/lib/ready-check.js b/lib/ready-check.js
index b996bb46..137782f4 100644
--- a/lib/ready-check.js
+++ b/lib/ready-check.js
@@ -101,6 +101,39 @@ function checkLinks(links) {
 	return item("links", "warning", "Links", `${links.broken.length === 1 ? "A link doesn't" : `${links.broken.length} links don't`} load: ${shown}.${more}`, pointer("body"));
 }
 
+// The claim check (lib/claim-check.js, docs/CLAIM-CHECK.md). Its findings are warnings, never a reason the send refuses,
+// unless the newsletter requires the check to pass: then they, and a check that hasn't finished, are blockers.
+// links: the links item's state, so a dead link it already names isn't listed twice.
+function checkClaims(claims, links) {
+	const title = "Claim check";
+	const needs = claims.required ? " This newsletter needs it to pass before a send." : "";
+	const failing = claims.required ? "blocker" : "warning";
+	if (claims.state === "none") return item("claims", "pass", title, "There are no figures or links to check.");
+	if (claims.state === "checking") return item("claims", claims.required ? "blocker" : "info", title, `Checking ${formatCount(claims.total, "link")} and the figures they back…${needs}`);
+	if (claims.state === "error") return item("claims", claims.required ? "blocker" : "info", title, `The claim check couldn't run just now. Check again in a minute.${needs}`);
+	const { report } = claims;
+	const { counts } = report;
+	const host = (url) => url.replace(/^https?:\/\//, "").slice(0, 60);
+	const listed = (entries, total, word) => entries.slice(0, MAX_LISTED).map(word).join(", ") + (total > MAX_LISTED ? ` and ${total - MAX_LISTED} more` : "");
+	const parts = [];
+	const namedByLinks = new Set(links?.state === "done" ? links.broken.map(({ url }) => url) : []);
+	const isNamed = counts.deadLinks === report.deadLinks.length && report.deadLinks.every(({ url }) => namedByLinks.has(url));
+	if (counts.deadLinks) parts.push(`${counts.deadLinks === 1 ? "a link doesn't" : `${counts.deadLinks} links don't`} load${isNamed ? " (see Links)" : `: ${listed(report.deadLinks, counts.deadLinks, ({ url, reason }) => `${host(url)} (${reason})`)}`}`);
+	if (counts.unmatchedFigures) parts.push(`${counts.unmatchedFigures === 1 ? "a figure isn't" : `${counts.unmatchedFigures} figures aren't`} on the page they link to: ${listed(report.unmatchedFigures, counts.unmatchedFigures, ({ figure, urls }) => `${figure} (${host(urls[0])})`)}`);
+	if (counts.uncitedClaims) parts.push(`${counts.uncitedClaims === 1 ? "a paragraph states" : `${counts.uncitedClaims} paragraphs state`} figures with no link to a source: ${listed(report.uncitedClaims, counts.uncitedClaims, ({ text }) => `"${text.length > 60 ? `${text.slice(0, 57)}…` : text}"`)}`);
+	const more = report.linksTotal > report.linksChecked ? ` The first ${report.linksChecked} of ${report.linksTotal} links were checked.` : "";
+	const unconfirmed = counts.unconfirmedFigures ? ` ${counts.unconfirmedFigures === 1 ? "A figure" : `${counts.unconfirmedFigures} figures`} couldn't be confirmed: ${report.unconfirmedFigures[0].reason}.` : "";
+	if (parts.length) {
+		const sentence = parts.join("; ");
+		return item("claims", failing, title, `${sentence[0].toUpperCase()}${sentence.slice(1)}.${unconfirmed}${more}${needs}`, pointer("body"));
+	}
+	if (unconfirmed) return item("claims", "info", title, `${unconfirmed.trim()}${more}`);
+	if (report.linksChecked === 0) return item("claims", "pass", title, "No figure needs a source checked.");
+	const unsure = counts.unsureLinks ? `, ${counts.unsureLinks} of them blocked the check but are probably fine` : "";
+	const loads = report.linksChecked === 1 ? "the link loads" : `the ${report.linksChecked} links load`;
+	return item("claims", "pass", title, `${report.figuresChecked ? "Every figure is on a page it links to, and" : "No figure needs a source, and"} ${loads}${unsure}.${more}`);
+}
+
 function checkImages(images, sizes) {
 	if (images.length === 0) return [];
 	const items = [];
@@ -149,6 +182,7 @@ export function buildReadyCheck({
 	imageSizes = new Map(),
 	mergeTags = [],
 	links = null,
+	claims = null,
 	hasPaywallBreak = false,
 	now = Date.now(),
 }) {
@@ -214,6 +248,7 @@ export function buildReadyCheck({
 	}
 
 	items.push(checkLinks(links));
+	if (claims) items.push(checkClaims(claims, links));
 	items.push(...checkImages(images, imageSizes));
 	if (!isWebOnly) items.push(...checkMergeTags(mergeTags));
 
@@ -257,7 +292,8 @@ export function buildReadyCheck({
 		blockers: blockers.length,
 		warnings: warnings.length,
 		canSend: blockers.length === 0,
-		isChecking: links?.state === "checking",
+		isChecking: links?.state === "checking" || claims?.state === "checking",
+		checking: [links?.state === "checking" && "links", claims?.state === "checking" && "claims"].filter(Boolean),
 		checkedAt: new Date(now).toISOString(),
 	};
 }
diff --git a/lib/use-ready-check.js b/lib/use-ready-check.js
index bbc97f38..db553e86 100644
--- a/lib/use-ready-check.js
+++ b/lib/use-ready-check.js
@@ -2,11 +2,12 @@ import { useEffect, useState } from "react";
 import { checkCampaign } from "@/app/(app)/campaigns/actions";
 
 const POLL_MS = 2000;
-const MAX_POLLS = 15;
+// Long enough for the claim check (lib/claim-check-rules.js CLAIM_CHECK.timeMs, plus its last requests) to finish.
+const MAX_POLLS = 25;
 
 // The review step's ready-to-send check (lib/ready-check.js): asked for each time the step opens, with the draft saved first,
-// and asked again every couple of seconds while the server is still opening the links. key: what the draft was when the check
-// ran, so a result of words that have changed since doesn't keep the Send button off.
+// and asked again every couple of seconds while the server is still opening the links or running the claim check. key: what
+// the draft was when the check ran, so a result of words that have changed since doesn't keep the Send button off.
 export function useReadyCheck({ campaignId, isActive, persist, key }) {
 	const [state, setState] = useState({ result: null, error: null, key: null, isLoading: false });
 	// Asked again on demand, like after a test email was sent.
diff --git a/migrations/0050_claim_checks.sql b/migrations/0050_claim_checks.sql
new file mode 100644
index 00000000..e7d8ee04
--- /dev/null
+++ b/migrations/0050_claim_checks.sql
@@ -0,0 +1,4 @@
+CREATE TABLE IF NOT EXISTS c_claimchecks (_id TEXT PRIMARY KEY NOT NULL, accountId TEXT, data TEXT NOT NULL);
+CREATE INDEX IF NOT EXISTS i_claimchecks__accountId ON c_claimchecks (accountId);
+CREATE UNIQUE INDEX IF NOT EXISTS u_claimchecks__accountId__campaignId ON c_claimchecks (accountId ASC, json_extract(data, '$.campaignId') ASC);
+CREATE INDEX IF NOT EXISTS i_claimchecks__checkedAt ON c_claimchecks (json_extract(data, '$.checkedAt') ASC);
diff --git a/models/ClaimCheck.js b/models/ClaimCheck.js
new file mode 100644
index 00000000..3e13419a
--- /dev/null
+++ b/models/ClaimCheck.js
@@ -0,0 +1,24 @@
+import mongoose from "../lib/docdb/index.js";
+import { accountScoped } from "../lib/account-scope.js";
+
+// What the claim check found in a draft (lib/claim-check.js, docs/CLAIM-CHECK.md): dead links, figures not on the pages they
+// link to, figures with no source. hash: the issue's words it was made for (campaignContentHash), so the same words are never checked
+// twice in a day and any edit asks again. report: lib/claim-check-rules.js buildClaimReport, addresses and short excerpts of
+// the issue only, never a page's text. Kept apart from the campaign, whose own changes mean "edited" to an approval.
+const claimCheckSchema = new mongoose.Schema(
+	{
+		campaignId: { type: mongoose.Schema.Types.ObjectId, ref: "Campaign", required: true },
+		hash: { type: String, required: true },
+		status: { type: String, enum: ["running", "done"], required: true },
+		startedAt: { type: Date, required: true },
+		checkedAt: { type: Date },
+		report: { type: mongoose.Schema.Types.Mixed },
+	},
+	{ timestamps: true }
+);
+
+claimCheckSchema.plugin(accountScoped);
+claimCheckSchema.index({ accountId: 1, campaignId: 1 }, { unique: true });
+claimCheckSchema.index({ checkedAt: 1 });
+
+export default mongoose.models.ClaimCheck || mongoose.model("ClaimCheck", claimCheckSchema);
diff --git a/models/Newsletter.js b/models/Newsletter.js
index 24541b48..f84cad08 100644
--- a/models/Newsletter.js
+++ b/models/Newsletter.js
@@ -102,6 +102,9 @@ const newsletterSchema = new mongoose.Schema(
 		shareButtons: { type: Boolean },
 		// How long the dashboard holds a send so it can be undone: 0, 10, 30 or 60 seconds (lib/send-hold-rules.js). Unset: 30.
 		sendUndoSeconds: { type: Number },
+		// A send waits until the claim check (lib/claim-check.js) has passed on the issue's words as they are. Unset: its findings are
+		// only warnings.
+		requireClaimCheck: { type: Boolean },
 		// The website's signup pop-up and the gate (lib/popup-rules.js): when it opens, how long closing it snoozes it, where it
 		// shows, and whether older issues show only their beginning to readers who haven't subscribed. Unsaved: the defaults.
 		popup: {
diff --git a/tests/claim-check.test.mjs b/tests/claim-check.test.mjs
new file mode 100644
index 00000000..f767ca6e
--- /dev/null
+++ b/tests/claim-check.test.mjs
@@ -0,0 +1,348 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { as, callApi, form, jsonRequest, startTestApp } from "./helpers/app.mjs";
+import { QSTASH_KEYS, act, createDraft, loadSendingModules, setupSender } from "./helpers/sending.mjs";
+import { published } from "./stubs/qstash.mjs";
+import { CLAIM_CHECK, buildClaimReport, figuresIn, isOnPage, issueUnits, pageValues, planChecks } from "../lib/claim-check-rules.js";
+import { buildReadyCheck } from "../lib/ready-check.js";
+
+// The claim check (docs/CLAIM-CHECK.md): dead links, figures not on the pages they link to and figures with no source, on any
+// issue. Every request in these tests is answered by a stub fetch and a stub resolver: nothing reaches the network.
+const PUBLIC = async (host) => (host.startsWith("inside.") ? ["10.1.2.3"] : ["93.184.216.34"]);
+
+function respond(routes, log = []) {
+	return async (input, init = {}) => {
+		const url = String(input?.url ?? input);
+		log.push({ url, method: init.method ?? "GET", headers: init.headers ?? {} });
+		if (url.endsWith("/robots.txt") && !routes[url]) return new Response("", { status: 404 });
+		const route = routes[`${init.method ?? "GET"} ${url}`] ?? routes[url];
+		if (!route) return new Response("Not found", { status: 404 });
+		if (route.throws) throw Object.assign(new Error("boom"), { name: route.throws });
+		// A new answer each time: a cloned one could never be cancelled, as its twin is never read.
+		return typeof route === "string" ? new Response(route, { headers: { "content-type": "text/html; charset=utf-8" } }) : new Response(route.body ?? null, { status: route.status ?? 200, headers: route.headers ?? {} });
+	};
+}
+
+const tokens = (text) => figuresIn(text).filter(({ isClaim }) => isClaim).map(({ token }) => token);
+const rich = (html, extra = {}) => ({ format: "rich", subject: "", previewText: "", html, ...extra });
+
+describe("figures in an issue", () => {
+	test("the same figure in another form is on the page: $1.7 billion, 1.7bn and 1,700,000,000; 8.0% and 8%", () => {
+		const values = pageValues("Revenue reached $1,700,000,000 last year, a rise of 8% on the year before, with 1,712,000,000 visits.");
+		for (const written of ["$1.7 billion", "1.7bn", "1,700,000,000", "$1.7B", "1700 million", "8.0%", "8%", "8 percent", "1.71 billion"]) {
+			const [figure] = figuresIn(written);
+			assert.ok(isOnPage(figure, values), written);
+		}
+		for (const written of ["$1.8 billion", "8.5%", "17%", "170 million"]) assert.equal(isOnPage(figuresIn(written)[0], values), false, written);
+	});
+
+	test("dates, years, times, ordinals, a list's numbering, labels and numbers in addresses are left out", () => {
+		assert.deepEqual(tokens("On October 29, 2026 at 10:30 am the 2nd report (issue 12, page 40) came out; see https://example.com/2024/report-55?id=9 or example.org/x/77, {{count}} [3], 2026-10-29 and 10/29/2026."), []);
+		assert.deepEqual(tokens("1. The first point\n2) The second point"), []);
+		assert.deepEqual(tokens("In the 1990s, Q3, COVID-19 and the A320 v1.2.3, 3 people"), []);
+		assert.deepEqual(tokens("Marketing 40 staff, Decent 75 seats, sales up 12% in May"), ["40", "75", "12%"], "a word that starts like a month is not a date");
+		assert.deepEqual(tokens("Sales rose 45% to $12 million, from 450,000 to 1,200 users, 10-20% of them"), ["45%", "$12 million", "450,000", "1,200", "10", "20%"]);
+	});
+
+	test("an issue's paragraphs, list items and headings, each with its links; the subject and preview are headings", () => {
+		const units = issueUnits({ format: "markdown", subject: "Up 40% this week", previewText: "", markdown: "# A 30% jump\n\nRevenue rose 45% to [$12 million](https://example.com/a).\n\n- 1,200 users signed up\n- [The report](https://example.org/b) counts 77 jobs\n\nNothing to count here." });
+		assert.deepEqual(
+			units.map(({ kind, field, links, figures }) => [kind, field, links, figures.map(({ token }) => token)]),
+			[
+				["heading", "subject", [], ["40%"]],
+				["heading", "body", [], ["30%"]],
+				["text", "body", ["https://example.com/a"], ["45%", "$12 million"]],
+				["text", "body", [], ["1,200"]],
+				["text", "body", ["https://example.org/b"], ["77"]],
+				["text", "body", [], []],
+			]
+		);
+		assert.deepEqual(planChecks(units), { links: ["https://example.com/a", "https://example.org/b"], pages: ["https://example.com/a", "https://example.org/b"], total: 2 });
+	});
+
+	test("a paragraph that states a figure with no link is an uncited claim; a heading isn't", () => {
+		const units = issueUnits(rich("<h2>Five things, 40% better</h2><p>Signups grew 40% in a month.</p><p>Thanks for reading.</p>"));
+		const report = buildClaimReport({ units });
+		assert.equal(report.failures, 1);
+		assert.deepEqual(report.uncitedClaims, [{ text: "Signups grew 40% in a month.", figures: ["40%"] }]);
+		assert.deepEqual(report.unmatchedFigures, []);
+	});
+});
+
+describe("reading the pages an issue links to", () => {
+	let checkIssue;
+	let robots;
+
+	before(async () => {
+		({ checkIssue } = await import("../lib/claim-check-run.js"));
+		robots = await import("../lib/briefings/robots.js");
+	});
+
+	const run = (campaign, routes, log = [], resolveHost = PUBLIC) => {
+		robots.clearRobotsCache();
+		return checkIssue({ units: issueUnits(campaign), fetchImpl: respond(routes, log), resolveHost });
+	};
+
+	test("a figure that isn't on the page its paragraph links to is reported; one that is, in another form, isn't", async () => {
+		const log = [];
+		const { report } = await run(
+			rich('<p>The firm made <a href="https://news.example.com/a">$1.7 billion</a>, up 8.0%.</p><p>It hired 350 people (<a href="https://news.example.com/b">source</a>).</p>'),
+			{ "https://news.example.com/a": "<html><body><article>Revenue: 1,700,000,000 dollars, 8% more.</article></body></html>", "https://news.example.com/b": "<p>It hired 120 people.</p>" },
+			log
+		);
+		assert.equal(report.pagesRead, 2);
+		assert.deepEqual(report.unmatchedFigures.map(({ figure, urls }) => [figure, urls]), [["350", ["https://news.example.com/b"]]]);
+		assert.equal(report.failures, 1);
+		assert.ok(log.every(({ headers }) => headers["user-agent"]?.startsWith("FlockStack-Briefings/1.0") && !("cookie" in headers)), "the engine's honest user agent, no cookies");
+	});
+
+	test("a dead link is a failure; a site that refuses the check or is slow is only unconfirmed", async () => {
+		const { report } = await run(
+			rich('<p><a href="https://news.example.com/gone">Gone</a> <a href="https://news.example.com/down">Down</a> <a href="https://news.example.com/bot">Bot</a> <a href="https://news.example.com/fine">Fine</a></p>'),
+			{
+				"https://news.example.com/gone": { status: 404, body: "Not found" },
+				"https://news.example.com/down": { throws: "TypeError" },
+				"https://news.example.com/bot": { status: 403, body: "no" },
+				"https://news.example.com/fine": "<p>ok</p>",
+			}
+		);
+		assert.deepEqual(report.deadLinks.map(({ url }) => url).sort(), ["https://news.example.com/down", "https://news.example.com/gone"]);
+		assert.match(report.deadLinks.find(({ url }) => url.endsWith("/gone")).reason, /404/);
+		assert.deepEqual(report.unsureLinks.map(({ url }) => url), ["https://news.example.com/bot"]);
+		assert.equal(report.failures, 2);
+	});
+
+	test("a link to a private address is refused by the guard and never asked, not even after a redirect", async () => {
+		const log = [];
+		const { report } = await run(
+			rich('<p>Up 12% (<a href="https://inside.example.com/admin">x</a>), 30% (<a href="https://10.0.0.1/stats">y</a>) and 45% (<a href="https://news.example.com/moved">z</a>).</p>'),
+			{ "https://news.example.com/moved": { status: 302, headers: { location: "https://169.254.169.254/latest/meta-data" } } },
+			log
+		);
+		assert.deepEqual(report.deadLinks.map(({ url }) => url).sort(), ["https://10.0.0.1/stats", "https://inside.example.com/admin", "https://news.example.com/moved"]);
+		assert.ok(report.deadLinks.every(({ reason }) => /private network/.test(reason)), JSON.stringify(report.deadLinks));
+		assert.ok(!log.some(({ url }) => /inside\.example|10\.0\.0\.1|169\.254/.test(url)), JSON.stringify(log.map(({ url }) => url)));
+		assert.equal(report.unconfirmedFigures.length, 3, "a figure whose page couldn't be read is neither found nor missing");
+	});
+
+	test("robots.txt is read first and a page it keeps the fetcher out of isn't opened", async () => {
+		const log = [];
+		const { report } = await run(rich('<p>A 25% rise (<a href="https://shy.example.com/story">source</a>).</p>'), { "https://shy.example.com/robots.txt": "User-agent: *\nDisallow: /\n", "https://shy.example.com/story": "<p>25%</p>" }, log);
+		assert.deepEqual(log.map(({ url }) => url), ["https://shy.example.com/robots.txt"]);
+		assert.equal(report.unsureLinks[0].reason, "robots.txt asks FlockStack not to open it");
+		assert.equal(report.counts.unconfirmedFigures, 1);
+		assert.equal(report.failures, 0);
+	});
+
+	test("bounded: at most maxLinks links judged and maxPages pages read, and no request starts after the time limit", async () => {
+		const many = Array.from({ length: 30 }, (_, index) => `<p>Up ${index + 11}% (<a href="https://news.example.com/${index}">s</a>)</p>`).join("");
+		const pages = Object.fromEntries(Array.from({ length: 30 }, (_, index) => [`https://news.example.com/${index}`, `<p>${index + 11}%</p>`]));
+		const log = [];
+		const { report } = await run(rich(many), pages, log);
+		assert.equal(report.linksChecked, CLAIM_CHECK.maxLinks);
+		assert.equal(report.linksTotal, 30);
+		assert.equal(report.pagesRead, CLAIM_CHECK.maxPages);
+		assert.ok(log.length <= CLAIM_CHECK.maxRequests);
+		assert.equal(report.counts.unmatchedFigures, 0);
+		assert.equal(report.counts.unconfirmedFigures, 30 - CLAIM_CHECK.maxPages);
+
+		robots.clearRobotsCache();
+		let clock = 0;
+		const slow = [];
+		const late = await checkIssue({ units: issueUnits(rich(many)), fetchImpl: async (...args) => ((clock += 10_000), respond(pages, slow)(...args)), resolveHost: PUBLIC, now: () => clock });
+		assert.ok(late.report.linksChecked < 10, `${late.report.linksChecked} links after the time ran out`);
+		assert.ok(slow.length < 12);
+	});
+});
+
+describe("check_campaign on any issue", () => {
+	let app;
+	let m;
+	let runClaimCheck;
+	let robots;
+
+	before(async () => {
+		app = await startTestApp(QSTASH_KEYS);
+		m = { ...(await loadSendingModules()), claimRoute: await import("../app/api/jobs/check-claims/route.js"), ClaimCheck: (await import("../models/ClaimCheck.js")).default };
+		({ runClaimCheck } = await import("../lib/claim-check-run.js"));
+		robots = await import("../lib/briefings/robots.js");
+	});
+
+	after(() => app?.stop());
+
+	const claimJobs = () => published.filter(({ url }) => url.endsWith("/api/jobs/check-claims"));
+	const runJob = (routes, log = []) => {
+		robots.clearRobotsCache();
+		return runClaimCheck(claimJobs().at(-1).body, { fetchImpl: respond(routes, log), resolveHost: PUBLIC });
+	};
+	const find = (result, id) => result.items.find((entry) => entry.id === id);
+	const BODY = '<p>Acme raised <a href="https://news.example.com/acme">$40 million</a> and now has 1,200 staff.</p><ul><li>Its sales grew 30% (<a href="https://news.example.com/sales">report</a>).</li></ul><p>More on <a href="https://news.example.com/gone">the founders</a>.</p>';
+	const PAGES = {
+		"https://news.example.com/acme": "<p>Acme raised $40M in a round led by Example Ventures.</p>",
+		"https://news.example.com/sales": "<p>Sales grew 25 percent.</p>",
+		"https://news.example.com/gone": { status: 404, body: "Not found" },
+	};
+
+	test("a plain issue, not a briefing's, is checked by a job and the result comes back through the registry and the REST API", async () => {
+		const user = await setupSender(m, "claims-plain@example.com", { contacts: 3 });
+		const id = await createDraft(m, user, { subject: "This week", previewText: "Notes", body: BODY });
+		const before = claimJobs().length;
+		const first = await act(m, user, "check_campaign", { id });
+		assert.equal(first.claims.state, "checking");
+		assert.ok(first.checking.includes("claims"));
+		assert.equal(find(first, "claims").status, "info");
+		assert.match(find(first, "claims").message, /^Checking 3 links and the figures they back…$/);
+		assert.equal(claimJobs().length, before + 1);
+		assert.equal(first.canSend, true, "it never holds a send back on its own");
+
+		const log = [];
+		const outcome = await runJob(PAGES, log);
+		assert.deepEqual({ ...outcome, requests: undefined }, { checked: 3, pagesRead: 2, failures: 3, requests: undefined });
+
+		const done = await act(m, user, "check_campaign", { id });
+		assert.equal(done.claims.state, "done");
+		assert.equal(done.claims.passed, false);
+		assert.deepEqual(done.claims.deadLinks, [{ url: "https://news.example.com/gone", reason: "404, page not found" }]);
+		assert.deepEqual(done.claims.unmatchedFigures.map(({ figure }) => figure), ["1,200", "30%"]);
+		assert.deepEqual(done.claims.uncitedClaims, []);
+		const row = find(done, "claims");
+		assert.equal(row.status, "warning");
+		assert.match(row.message, /A link doesn't load: news\.example\.com\/gone \(404, page not found\); 2 figures aren't on the page they link to: 1,200 \(news\.example\.com\/acme\), 30% \(news\.example\.com\/sales\)\./);
+		assert.equal(row.fix.target, "body");
+		assert.equal(done.canSend, true, "warnings never stop a send");
+
+		const { createApiKey } = await import("../app/(app)/api-keys/actions.js");
+		const { key } = await as(user, () => createApiKey(null, form({ name: "Reader", level: "read_only" })));
+		const response = await callApi("GET", `/api/v1/campaigns/${id}/check`, { key });
+		assert.equal(response.status, 200);
+		assert.deepEqual(response.body.claims.unmatchedFigures, done.claims.unmatchedFigures);
+	});
+
+	test("unchanged words are never checked again: the kept result answers, and an edit asks again", async () => {
+		const user = await setupSender(m, "claims-cache@example.com", { contacts: 2 });
+		const id = await createDraft(m, user, { subject: "Cached", previewText: "p", body: BODY });
+		await act(m, user, "check_campaign", { id });
+		const log = [];
+		await runJob(PAGES, log);
+		const jobs = claimJobs().length;
+		const requests = log.length;
+		for (let round = 0; round < 3; round++) assert.equal((await act(m, user, "check_campaign", { id })).claims.state, "done");
+		assert.equal(claimJobs().length, jobs, "no new job for the same words");
+		assert.equal(log.length, requests, "no page asked again");
+		assert.equal((await runJob(PAGES, log)).skipped, "not waiting for this check", "a job delivered twice does nothing");
+
+		await as(user, () => m.campaigns.saveCampaign(id, { subject: "Cached", previewText: "p", body: `${BODY}<p>One more line.</p>` }));
+		assert.equal((await act(m, user, "check_campaign", { id })).claims.state, "checking", "edited words are checked again");
+		assert.equal(claimJobs().length, jobs + 1);
+	});
+
+	test("a job for words the issue no longer has opens nothing", async () => {
+		const user = await setupSender(m, "claims-stale@example.com", { contacts: 2 });
+		const id = await createDraft(m, user, { subject: "Stale", previewText: "p", body: BODY });
+		await act(m, user, "check_campaign", { id });
+		const job = claimJobs().at(-1);
+		await as(user, () => m.campaigns.saveCampaign(id, { subject: "Stale", previewText: "p", body: "<p>No links now.</p>" }));
+		const log = [];
+		robots.clearRobotsCache();
+		assert.equal((await runClaimCheck(job.body, { fetchImpl: respond(PAGES, log), resolveHost: PUBLIC })).skipped, "the issue changed");
+		assert.deepEqual(log, []);
+		const response = await m.claimRoute.POST(jsonRequest(job.url, { method: "POST", body: { accountId: "nope", campaignId: "nope", hash: "x" } }));
+		assert.equal((await response.json()).skipped, "invalid job");
+	});
+
+	test("figures with no source need no job: they are reported at once, and an issue with neither passes", async () => {
+		const user = await setupSender(m, "claims-uncited@example.com", { contacts: 2 });
+		const jobs = claimJobs().length;
+		const id = await createDraft(m, user, { subject: "Numbers", previewText: "p", body: "<p>Open rates rose 12% in October.</p><ol><li>First</li><li>Second</li></ol>" });
+		const result = await act(m, user, "check_campaign", { id });
+		assert.equal(result.claims.state, "done");
+		assert.deepEqual(result.claims.uncitedClaims, [{ text: "Open rates rose 12% in October.", figures: ["12%"] }]);
+		assert.match(find(result, "claims").message, /^A paragraph states figures with no link to a source: "Open rates rose 12% in October\."\.$/);
+		const plain = await createDraft(m, user, { subject: "Hello", previewText: "p", body: "<p>Just a note on 3 things.</p>" });
+		const clean = await act(m, user, "check_campaign", { id: plain });
+		assert.equal(clean.claims.state, "none");
+		assert.equal(clean.claims.passed, true);
+		assert.equal(find(clean, "claims").status, "pass");
+		assert.equal(claimJobs().length, jobs, "nothing to open, no job");
+	});
+
+	test("a newsletter can require a pass: then the findings, and a check that hasn't finished, refuse the send", async () => {
+		const user = await setupSender(m, "claims-required@example.com", { contacts: 2 });
+		const id = await createDraft(m, user, { subject: "Required", previewText: "p", body: BODY });
+		assert.equal((await act(m, user, "get_newsletter", { id: user.newsletterId })).requireClaimCheck, false, "off by default");
+		await act(m, user, "update_newsletter", { id: user.newsletterId, requireClaimCheck: true });
+		assert.equal((await act(m, user, "get_newsletter", { id: user.newsletterId })).requireClaimCheck, true);
+
+		const waiting = await act(m, user, "check_campaign", { id });
+		assert.equal(find(waiting, "claims").status, "blocker");
+		assert.equal(waiting.canSend, false);
+		await assert.rejects(act(m, user, "send_campaign", { id }), (error) => error.code === "send_check_failed" && /hasn't finished on these words/.test(error.message));
+
+		await runJob(PAGES);
+		const found = await act(m, user, "check_campaign", { id });
+		assert.equal(find(found, "claims").status, "blocker");
+		assert.match(find(found, "claims").message, /This newsletter needs it to pass before a send\.$/);
+		await assert.rejects(act(m, user, "send_campaign", { id }), (error) => error.code === "send_check_failed" && /found a link that doesn't load, 2 figures that aren't on the page it links to/.test(error.message));
+		await assert.rejects(act(m, user, "schedule_campaign", { id, scheduledAt: new Date(Date.now() + 86_400_000).toISOString() }), { code: "send_check_failed" });
+
+		const fixed = '<p>Acme raised <a href="https://news.example.com/acme">$40 million</a>.</p><ul><li>Its sales grew 25% (<a href="https://news.example.com/sales">report</a>).</li></ul>';
+		await as(user, () => m.campaigns.saveCampaign(id, { subject: "Required", previewText: "p", body: fixed }));
+		await act(m, user, "check_campaign", { id });
+		await runJob(PAGES);
+		const passed = await act(m, user, "check_campaign", { id });
+		assert.equal(passed.claims.passed, true);
+		assert.equal(find(passed, "claims").status, "pass");
+		assert.match(find(passed, "claims").message, /^Every figure is on a page it links to, and the 2 links load\.$/);
+		const sent = await act(m, user, "send_campaign", { id });
+		assert.notEqual(sent.status, "draft");
+	});
+
+	test("the dashboard's settings form saves the requirement, and the review step shows the check while it runs", async () => {
+		const user = await setupSender(m, "claims-form@example.com", { contacts: 2 });
+		const { getNewsletterDraft } = await import("../lib/newsletter-form.js");
+		const stored = await m.Newsletter.findOne({ accountId: user.accountId, _id: user.newsletterId }).lean();
+		assert.equal(getNewsletterDraft({ newsletter: stored, domains: [], sharedDomain: null }).isClaimCheckRequired, false);
+		const fields = { id: user.newsletterId, name: stored.name, slug: stored.slug, fromEmail: stored.fromEmail, postalAddress: stored.postalAddress, archiveEnabled: stored.archiveEnabled ? "on" : "" };
+		assert.deepEqual(await as(user, () => m.newsletters.saveNewsletter(null, form({ ...fields, requireClaimCheck: "on" }))).then(({ ok }) => ok), true);
+		const saved = await m.Newsletter.findOne({ accountId: user.accountId, _id: user.newsletterId }).lean();
+		assert.equal(saved.requireClaimCheck, true);
+		assert.equal(getNewsletterDraft({ newsletter: saved, domains: [], sharedDomain: null }).isClaimCheckRequired, true);
+		await as(user, () => m.newsletters.saveNewsletter(null, form(fields)));
+		assert.equal((await m.Newsletter.findOne({ accountId: user.accountId, _id: user.newsletterId }).lean()).requireClaimCheck, false, "the switch off turns it off");
+
+		const { default: PanelReady } = await import("../components/PanelReady.jsx");
+		const ready = {
+			error: null,
+			result: {
+				isChecking: true,
+				checking: ["claims"],
+				items: [
+					{ id: "links", status: "info", title: "Links", message: "The links couldn't be checked just now, so they weren't.", fix: null },
+					{ id: "claims", status: "info", title: "Claim check", message: "Checking 3 links and the figures they back…", fix: null },
+				],
+			},
+		};
+		const html = renderToStaticMarkup(createElement(PanelReady, { ready, onFix() {}, onTest() {}, isTesting: false, isTestDisabled: false }));
+		assert.match(html, /data-check="claims"[^>]*><svg[^>]*aria-label="Checking"/);
+		assert.doesNotMatch(html, /data-check="links"[^>]*><svg[^>]*aria-label="Checking"/, "only the row still running spins");
+	});
+});
+
+describe("the review step's wording", () => {
+	const newsletter = { _id: "n1", name: "Notes", fromEmail: "hello@notes.example.org", postalAddress: "1 Main St, Paris", archiveEnabled: true };
+	const rendered = { html: "<p>Hi</p> {{unsubscribe_url}}", bytes: 20_000 };
+	const campaign = { subject: "A calm subject", previewText: "Something to read", format: "rich", html: "<p>Hello</p>", audience: "all", testSentAt: new Date() };
+	const check = (claims, links = null) => buildReadyCheck({ campaign, newsletter, rendered, audience: { count: 5, label: "Everyone", segmentName: null }, claims, links }).items.find(({ id }) => id === "claims");
+
+	test("warnings by default, blockers when required, and a dead link the links row names is not listed twice", () => {
+		const units = issueUnits(rich('<p>A <a href="https://news.example.com/gone">story</a>.</p>'));
+		const report = buildClaimReport({ units, linkStates: { "https://news.example.com/gone": { state: "broken", reason: "404, page not found" } }, total: 1 });
+		assert.equal(check({ state: "done", required: false, report }).status, "warning");
+		assert.equal(check({ state: "done", required: true, report }).status, "blocker");
+		const links = { state: "done", total: 1, checked: 1, broken: [{ url: "https://news.example.com/gone", reason: "404, page not found" }], unsure: 0 };
+		assert.equal(check({ state: "done", required: false, report }, links).message, "A link doesn't load (see Links).");
+		assert.equal(check(null), undefined, "no claims state, no row");
+	});
+});
diff --git a/tests/ready-check.test.mjs b/tests/ready-check.test.mjs
index 5e7c1cdb..73ebcb70 100644
--- a/tests/ready-check.test.mjs
+++ b/tests/ready-check.test.mjs
@@ -335,7 +335,7 @@ describe("opening the links", () => {
 
 		assert.deepEqual(await runCheckJob(), { checked: 2, broken: 1 });
 		const done = await act(m, user, "check_campaign", { id });
-		assert.equal(done.isChecking, false);
+		assert.deepEqual(done.checking, ["claims"], "the links are done; the claim check is a job of its own");
 		const links = done.items.find(({ id: one }) => one === "links");
 		assert.equal(links.status, "warning");
 		assert.match(links.message, /A link doesn't load: example\.org\/gone \(404, page not found\)/);