diff --git a/RELEASE.rst b/RELEASE.rst
index 5ee0ffa6f0..135ddd745a 100644
--- a/RELEASE.rst
+++ b/RELEASE.rst
@@ -1,6 +1,15 @@
 Release Notes
 =============
 
+Version 0.77.8
+--------------
+
+- Batch the PostHog view-event loader instead of querying per event (#3785)
+- feat: Collect required compliance fields before any enrollment or checkout (#3766)
+- receipt page (#3717)
+- Allow for null course ids in webhook payload (#3776)
+- make healthcheck resistant to k8 pod culling (#3760)
+
 Version 0.77.7 (Released August 18, 2026)
 --------------
 
diff --git a/frontends/api/package.json b/frontends/api/package.json
index 83612e3dac..391af5b986 100644
--- a/frontends/api/package.json
+++ b/frontends/api/package.json
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@mitodl/mit-learn-api-axios": "2026.7.22",
-    "@mitodl/mitxonline-api-axios": "2026.8.6",
+    "@mitodl/mitxonline-api-axios": "2026.8.18",
     "@tanstack/react-query": "^5.66.0",
     "axios": "^1.12.2",
     "tiny-invariant": "^1.3.3"
diff --git a/frontends/api/src/generated/v1/api.ts b/frontends/api/src/generated/v1/api.ts
index 186b779090..1c4f7a43b6 100644
--- a/frontends/api/src/generated/v1/api.ts
+++ b/frontends/api/src/generated/v1/api.ts
@@ -595,13 +595,13 @@ export interface ContentFileWebHookRequest {
    * @type {string}
    * @memberof ContentFileWebHookRequest
    */
-  course_id?: string
+  course_id?: string | null
   /**
    *
    * @type {string}
    * @memberof ContentFileWebHookRequest
    */
-  course_readable_id?: string
+  course_readable_id?: string | null
 }
 
 /**
@@ -627,13 +627,13 @@ export interface ContentFileWebHookRequestRequest {
    * @type {string}
    * @memberof ContentFileWebHookRequestRequest
    */
-  course_id?: string
+  course_id?: string | null
   /**
    *
    * @type {string}
    * @memberof ContentFileWebHookRequestRequest
    */
-  course_readable_id?: string
+  course_readable_id?: string | null
 }
 
 /**
@@ -33656,8 +33656,8 @@ export const WebhooksApiAxiosParamCreator = function (
      * @param {WebhooksContentFilesCreateSourceEnum} source * `mit_edx` - mit_edx * `mitpe` - mitpe * `mitxonline` - mitxonline * `oll` - oll * `ocw` - ocw * `podcast` - podcast * `mit_climate` - mit_climate * `see` - see * `xpro` - xpro * `youtube` - youtube * `canvas` - canvas * `ovs` - ovs
      * @param {ContentFileWebHookRequestRequest} ContentFileWebHookRequestRequest
      * @param {string} [content_path]
-     * @param {string} [course_id]
-     * @param {string} [course_readable_id]
+     * @param {string | null} [course_id]
+     * @param {string | null} [course_readable_id]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
@@ -33665,8 +33665,8 @@ export const WebhooksApiAxiosParamCreator = function (
       source: WebhooksContentFilesCreateSourceEnum,
       ContentFileWebHookRequestRequest: ContentFileWebHookRequestRequest,
       content_path?: string,
-      course_id?: string,
-      course_readable_id?: string,
+      course_id?: string | null,
+      course_readable_id?: string | null,
       options: RawAxiosRequestConfig = {},
     ): Promise<RequestArgs> => {
       // verify required parameter 'source' is not null or undefined
@@ -33845,8 +33845,8 @@ export const WebhooksApiFp = function (configuration?: Configuration) {
      * @param {WebhooksContentFilesCreateSourceEnum} source * &#x60;mit_edx&#x60; - mit_edx * &#x60;mitpe&#x60; - mitpe * &#x60;mitxonline&#x60; - mitxonline * &#x60;oll&#x60; - oll * &#x60;ocw&#x60; - ocw * &#x60;podcast&#x60; - podcast * &#x60;mit_climate&#x60; - mit_climate * &#x60;see&#x60; - see * &#x60;xpro&#x60; - xpro * &#x60;youtube&#x60; - youtube * &#x60;canvas&#x60; - canvas * &#x60;ovs&#x60; - ovs
      * @param {ContentFileWebHookRequestRequest} ContentFileWebHookRequestRequest
      * @param {string} [content_path]
-     * @param {string} [course_id]
-     * @param {string} [course_readable_id]
+     * @param {string | null} [course_id]
+     * @param {string | null} [course_readable_id]
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
@@ -33854,8 +33854,8 @@ export const WebhooksApiFp = function (configuration?: Configuration) {
       source: WebhooksContentFilesCreateSourceEnum,
       ContentFileWebHookRequestRequest: ContentFileWebHookRequestRequest,
       content_path?: string,
-      course_id?: string,
-      course_readable_id?: string,
+      course_id?: string | null,
+      course_readable_id?: string | null,
       options?: RawAxiosRequestConfig,
     ): Promise<
       (
@@ -34052,14 +34052,14 @@ export interface WebhooksApiWebhooksContentFilesCreateRequest {
    * @type {string}
    * @memberof WebhooksApiWebhooksContentFilesCreate
    */
-  readonly course_id?: string
+  readonly course_id?: string | null
 
   /**
    *
    * @type {string}
    * @memberof WebhooksApiWebhooksContentFilesCreate
    */
-  readonly course_readable_id?: string
+  readonly course_readable_id?: string | null
 }
 
 /**
diff --git a/frontends/api/src/mitxonline/hooks/orders/queries.ts b/frontends/api/src/mitxonline/hooks/orders/queries.ts
index 87304be885..351e65bdbb 100644
--- a/frontends/api/src/mitxonline/hooks/orders/queries.ts
+++ b/frontends/api/src/mitxonline/hooks/orders/queries.ts
@@ -1,10 +1,19 @@
 import { queryOptions } from "@tanstack/react-query"
 import { ordersApi } from "../../clients"
-import type { Order } from "@mitodl/mitxonline-api-axios/v2"
+import type {
+  Order,
+  OrdersApiOrdersHistoryListRequest,
+  PaginatedOrderHistoryList,
+} from "@mitodl/mitxonline-api-axios/v2"
 
 const orderKeys = {
   root: ["mitxonline", "orders"],
   receipt: (orderId: number) => [...orderKeys.root, "receipt", orderId],
+  historyList: (opts: OrdersApiOrdersHistoryListRequest) => [
+    ...orderKeys.root,
+    "history",
+    opts,
+  ],
 }
 
 const orderQueries = {
@@ -19,6 +28,24 @@ const orderQueries = {
           .then((res) => res.data)
       },
     }),
+  /**
+   * Fulfilled and refunded orders, most recent first.
+   *
+   * Enrollments carry no reference to their order, so getting from a run or
+   * program to its receipt means searching these lines — see
+   * `useOrderIdForRun` / `useOrderIdForProgram`.
+   *
+   * `opts` is required rather than defaulted: older deployments drop the
+   * pagination envelope when `limit` is absent and return a bare array, which
+   * would not match the declared return type.
+   */
+  historyList: (opts: OrdersApiOrdersHistoryListRequest) =>
+    queryOptions({
+      queryKey: orderKeys.historyList(opts),
+      queryFn: async (): Promise<PaginatedOrderHistoryList> => {
+        return ordersApi.ordersHistoryList(opts).then((res) => res.data)
+      },
+    }),
 }
 
 export { orderQueries, orderKeys }
diff --git a/frontends/api/src/mitxonline/test-utils/factories/orders.ts b/frontends/api/src/mitxonline/test-utils/factories/orders.ts
index b5b004e4da..e9ee249935 100644
--- a/frontends/api/src/mitxonline/test-utils/factories/orders.ts
+++ b/frontends/api/src/mitxonline/test-utils/factories/orders.ts
@@ -1,5 +1,17 @@
 import { faker } from "@faker-js/faker/locale/en"
-import type { Order, TransactionLine } from "@mitodl/mitxonline-api-axios/v2"
+import type {
+  Line,
+  Nested,
+  Order,
+  OrderHistory,
+  OrderRefundsInner,
+  OrderStreetAddress,
+  OrderTransactions,
+  PaginatedOrderHistoryList,
+  Product,
+  RedeemedDiscount,
+  TransactionLine,
+} from "@mitodl/mitxonline-api-axios/v2"
 
 const transactionLine = (
   overrides: Partial<TransactionLine> = {},
@@ -17,19 +29,135 @@ const transactionLine = (
   ...overrides,
 })
 
+const orderTransactions = (
+  overrides: Partial<OrderTransactions> = {},
+): OrderTransactions => ({
+  card_number: `xxxxxxxxxxxx${faker.string.numeric(4)}`,
+  card_type: "Visa",
+  name: faker.person.fullName(),
+  bill_to_email: faker.internet.email(),
+  payment_method: "card",
+  ...overrides,
+})
+
+const orderStreetAddress = (
+  overrides: Partial<OrderStreetAddress> = {},
+): OrderStreetAddress => ({
+  line: [faker.location.streetAddress()],
+  postal_code: faker.location.zipCode(),
+  state: faker.location.state({ abbreviated: true }),
+  city: faker.location.city(),
+  country: "US",
+  ...overrides,
+})
+
+const redeemedDiscount = (
+  overrides: Partial<Nested> = {},
+): RedeemedDiscount => ({
+  redeemed_discount: {
+    id: faker.number.int(),
+    created_on: faker.date.past().toISOString(),
+    updated_on: faker.date.past().toISOString(),
+    amount: faker.commerce.price({ min: 5, max: 50 }),
+    discount_type: "dollars-off",
+    redemption_type: "one-time",
+    discount_code: faker.string.alphanumeric(12),
+    ...overrides,
+  },
+})
+
+const orderRefund = (
+  overrides: Partial<OrderRefundsInner> = {},
+): OrderRefundsInner => ({
+  amount: Number(faker.commerce.price({ min: 5, max: 500 })),
+  date: faker.date.past().toISOString(),
+  ...overrides,
+})
+
 const order = (overrides: Partial<Order> = {}): Order => ({
   id: faker.number.int(),
   state: "fulfilled",
-  purchaser: [],
+  purchaser: {
+    country: "US",
+    email: faker.internet.email(),
+  },
   total_price_paid: faker.commerce.price({ min: 50, max: 500 }),
   lines: [transactionLine()],
   discounts: [],
   refunds: [],
+  refund_eligible: false,
   reference_number: faker.string.alphanumeric(10),
   created_on: faker.date.past().toISOString(),
-  transactions: {},
-  street_address: {},
+  transactions: orderTransactions(),
+  street_address: orderStreetAddress(),
   ...overrides,
 })
 
-export { order, transactionLine }
+/**
+ * The default `purchasable_object` has only an `id`, which matches no variant —
+ * pass a shaped object (with `course`, or neither `course` nor `run_tag`) when the
+ * test needs it to resolve.
+ */
+const product = (overrides: Partial<Product> = {}): Product => ({
+  id: faker.number.int(),
+  price: faker.commerce.price({ min: 50, max: 500 }),
+  description: faker.commerce.productDescription(),
+  is_active: true,
+  purchasable_object: { id: faker.number.int() },
+  ...overrides,
+})
+
+const line = (overrides: Partial<Line> = {}): Line => {
+  const unitPrice = faker.commerce.price({ min: 50, max: 500 })
+  return {
+    id: faker.number.int(),
+    quantity: 1,
+    item_description: faker.commerce.productName(),
+    unit_price: unitPrice,
+    total_price: unitPrice,
+    product: product(),
+    ...overrides,
+  }
+}
+
+const orderHistory = (overrides: Partial<OrderHistory> = {}): OrderHistory => ({
+  id: faker.number.int(),
+  state: "fulfilled",
+  reference_number: faker.string.alphanumeric(10),
+  purchaser: {
+    id: faker.number.int(),
+    name: faker.person.fullName(),
+    created_on: faker.date.past().toISOString(),
+    updated_on: faker.date.past().toISOString(),
+  },
+  total_price_paid: faker.commerce.price({ min: 50, max: 500 }),
+  lines: [line()],
+  created_on: faker.date.past().toISOString(),
+  titles: [],
+  updated_on: faker.date.past().toISOString(),
+  refund_eligible: false,
+  ...overrides,
+})
+
+const orderHistoryList = (
+  results: OrderHistory[],
+  opts: { count?: number; next?: string | null; previous?: string | null } = {},
+): PaginatedOrderHistoryList => ({
+  count: opts.count ?? results.length,
+  next: opts.next ?? null,
+  previous: opts.previous ?? null,
+  results,
+})
+
+export {
+  order,
+  orderHistory,
+  orderHistoryList,
+  orderRefund,
+  orderStreetAddress,
+  orderTransactions,
+  line,
+  product,
+  redeemedDiscount,
+  transactionLine,
+}
diff --git a/frontends/api/src/mitxonline/test-utils/factories/user.ts b/frontends/api/src/mitxonline/test-utils/factories/user.ts
index 4e3614374a..3b16027837 100644
--- a/frontends/api/src/mitxonline/test-utils/factories/user.ts
+++ b/frontends/api/src/mitxonline/test-utils/factories/user.ts
@@ -12,7 +12,13 @@ const enforcerId = new UniqueEnforcer()
 
 const legalAddress = (): LegalAddress => ({
   country: faker.location.countryCode(),
-  state: faker.datatype.boolean() ? faker.location.state() : null,
+  // Real values are ISO-3166-2 codes (e.g. "US-MA"), not the full names
+  // faker.location.state() returns, and only a handful of countries even
+  // have subdivisions. A random name for a random country is never a value
+  // a state <select> would recognize, so it renders as an out-of-range MUI
+  // warning whenever the random country happens to require one (e.g. "US") --
+  // default to null and let tests that care override with a real code.
+  state: null,
 })
 
 const userProfile = (): UserProfile => ({
@@ -62,6 +68,10 @@ const user: PartialFactory<User> = (overrides = {}): User => {
       updated_on: faker.date.recent().toISOString(),
       grants: [],
       is_active: true,
+      // Read-only signal from mitxonline's export-compliance check. Empty means
+      // the profile is complete; override with field names (e.g.
+      // ["city", "postal_code"]) to exercise the just-in-time dialog.
+      compliance_missing_fields: [],
       b2b_organizations: [organization({})],
     },
     overrides,
diff --git a/frontends/api/src/mitxonline/test-utils/urls.ts b/frontends/api/src/mitxonline/test-utils/urls.ts
index 3983dc05b6..6009de6460 100644
--- a/frontends/api/src/mitxonline/test-utils/urls.ts
+++ b/frontends/api/src/mitxonline/test-utils/urls.ts
@@ -3,6 +3,7 @@ import type {
   CoursesApiCourseVariantRunsV3Request,
   CourseCertificatesApiCourseCertificatesRetrieveRequest,
   ProgramCertificatesApiProgramCertificatesRetrieveRequest,
+  OrdersApiOrdersHistoryListRequest,
   ProgramCollectionsApiProgramCollectionsListRequest,
   ProgramsApiProgramsListV2Request,
 } from "@mitodl/mitxonline-api-axios/v2"
@@ -155,6 +156,8 @@ const baskets = {
 const orders = {
   receipt: (orderId: number) =>
     `${getApiBaseUrl()}/api/v0/orders/receipt/${orderId}/`,
+  historyList: (params?: OrdersApiOrdersHistoryListRequest) =>
+    `${getApiBaseUrl()}/api/v0/orders/history/${queryify(params)}`,
 }
 
 const verifiedProgramEnrollments = {
diff --git a/frontends/main/package.json b/frontends/main/package.json
index 152a687380..d4fe006d6b 100644
--- a/frontends/main/package.json
+++ b/frontends/main/package.json
@@ -18,7 +18,7 @@
     "@mitodl/arithmix": "^0.2.3",
     "@mitodl/course-search-utils": "^3.5.2",
     "@mitodl/hacksnack": "^0.1.1",
-    "@mitodl/mitxonline-api-axios": "2026.8.6",
+    "@mitodl/mitxonline-api-axios": "2026.8.18",
     "@mitodl/smoot-design": "6.31.1",
     "@mui/base": "5.0.0-beta.70",
     "@mui/material": "^6.4.5",
diff --git a/frontends/main/src/app-pages/DashboardPage/ContractContent.test.tsx b/frontends/main/src/app-pages/DashboardPage/ContractContent.test.tsx
index 9b321fa855..5cdeca9724 100644
--- a/frontends/main/src/app-pages/DashboardPage/ContractContent.test.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/ContractContent.test.tsx
@@ -12,9 +12,10 @@ import { urls, factories } from "api/mitxonline-test-utils"
 import {
   createCoursesWithContractRuns,
   createTestContracts,
+  setupOrderHistory,
   setupOrgAndUser,
-  setupProgramsAndCourses,
   setupOrgDashboardMocks,
+  setupProgramsAndCourses,
 } from "./CoursewareDisplay/test-utils"
 import {
   CourseWithCourseRunsSerializerV2,
@@ -26,6 +27,11 @@ import { useFeatureFlagEnabled } from "posthog-js/react"
 import { FeatureFlags } from "@/common/feature_flags"
 import { contractAdminView } from "@/common/urls"
 
+// Verified cards look up their order; default to none, tests override.
+beforeEach(() => {
+  setupOrderHistory()
+})
+
 jest.mock("posthog-js/react", () => ({
   ...jest.requireActual("posthog-js/react"),
   useFeatureFlagEnabled: jest.fn(),
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/DashboardDialogs.test.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/DashboardDialogs.test.tsx
index c46cbb4a4b..00dad8c511 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/DashboardDialogs.test.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/DashboardDialogs.test.tsx
@@ -3,32 +3,28 @@ import {
   renderWithProviders,
   screen,
   setMockResponse,
-  setupLocationMock,
   user,
   waitFor,
   within,
 } from "@/test-utils"
 import { HomeEnrollmentsDisplay } from "./HomeEnrollmentsDisplay"
 import { CoursewareCard } from "./CoursewareCard"
-import { buildCourseEntry } from "./model/dashboardViewModel"
-import { dashboardCourse, setupEnrollments } from "./test-utils"
+import { setupEnrollments, setupOrderHistory } from "./test-utils"
 import * as mitxonline from "api/mitxonline-test-utils"
-import {
-  urls as testUrls,
-  factories as testFactories,
-  makeRequest,
-} from "api/test-utils"
+import { makeRequest } from "api/test-utils"
 import { useFeatureFlagEnabled } from "posthog-js/react"
 import { faker } from "@faker-js/faker/locale/en"
 import invariant from "tiny-invariant"
-import { getDescriptionFor } from "ol-test-utilities"
-import type { User as MitxUser } from "@mitodl/mitxonline-api-axios/v2"
-import type { PartialDeep } from "type-fest"
 import {
   trackCourseUnenrolled,
   trackProgramUnenrolled,
 } from "@/common/analytics/gtm"
 
+// Verified cards look up their order; default to none, tests override.
+beforeEach(() => {
+  setupOrderHistory()
+})
+
 jest.mock("posthog-js/react")
 jest.mock("@/common/analytics/gtm", () => ({
   trackCourseUnenrolled: jest.fn(),
@@ -386,355 +382,3 @@ describe("UnenrollProgramDialog", () => {
     },
   )
 })
-
-describe("JustInTimeDialog", () => {
-  const getFields = (root: HTMLElement) => {
-    return {
-      country: within(root).getByRole("combobox", { name: "Country" }),
-      year_of_birth: within(root).getByRole("combobox", {
-        name: "Year of Birth",
-      }),
-    }
-  }
-
-  setupLocationMock()
-
-  type SetupJitOptions = {
-    userOverrides?: PartialDeep<MitxUser>
-  }
-
-  const setupJustInTimeTest = ({
-    userOverrides = {},
-  }: SetupJitOptions = {}) => {
-    // Setup MIT Learn user
-    const mitLearnUser = testFactories.user.user()
-    setMockResponse.get(testUrls.userMe.get(), mitLearnUser)
-
-    // Setup incomplete mitxonline user (missing country and year_of_birth)
-    const incompleteMitxUser = mitxonline.factories.user.user({
-      legal_address: null,
-      user_profile: null,
-      ...userOverrides,
-    })
-    setMockResponse.get(mitxonline.urls.userMe.get(), incompleteMitxUser)
-
-    // Setup countries data
-    const countries = [
-      { code: "US", name: "United States" },
-      { code: "CA", name: "Canada" },
-      { code: "GB", name: "United Kingdom" },
-    ]
-    setMockResponse.get(mitxonline.urls.countries.list(), countries)
-
-    // Setup course for enrollment
-    const b2bContractId = faker.number.int()
-    const run = mitxonline.factories.courses.courseRun({
-      b2b_contract: b2bContractId,
-      is_enrollable: true,
-      live: true,
-      enrollment_start: faker.date.past().toISOString(),
-      enrollment_end: faker.date.future().toISOString(),
-    })
-    const course = dashboardCourse({
-      courseruns: [run],
-      next_run_id: run.id,
-    })
-
-    // Setup enrollment API
-    setMockResponse.post(
-      mitxonline.urls.b2b.courseEnrollment(course.readable_id),
-      null,
-    )
-
-    return { mitLearnUser, incompleteMitxUser, countries, course, run }
-  }
-
-  test("Opens just-in-time dialog when enrolling with incomplete mitxonline user data", async () => {
-    const { course, run } = setupJustInTimeTest()
-
-    const entry = buildCourseEntry(course, [], {
-      contractId: run.b2b_contract ?? undefined,
-    })
-    invariant(entry)
-    renderWithProviders(<CoursewareCard kind="course" entry={entry} />)
-
-    const enrollButtons = await screen.findAllByTestId("courseware-button")
-    await user.click(enrollButtons[0]) // Use the first (desktop) button
-
-    const dialog = await screen.findByRole("dialog", {
-      name: "Just a Few More Details",
-    })
-    expect(dialog).toBeInTheDocument()
-
-    expect(
-      within(dialog).getByText(
-        "We need a bit more info before you can enroll.",
-      ),
-    ).toBeInTheDocument()
-    const fields = getFields(dialog)
-    expect(fields.country).toBeVisible()
-    expect(fields.year_of_birth).toBeInTheDocument()
-  })
-
-  test.each([
-    {
-      userOverrides: { legal_address: { country: "CA" } },
-      expectCountry: "Canada",
-      expectYob: "Please Select",
-    },
-    {
-      userOverrides: { user_profile: { year_of_birth: 1988 } },
-      expectCountry: "Please Select",
-      expectYob: "1988",
-    },
-  ])(
-    "Dialog pre-populates with user data if available",
-    async ({ userOverrides, expectCountry, expectYob }) => {
-      const { course, run } = setupJustInTimeTest({ userOverrides })
-      const entry = buildCourseEntry(course, [], {
-        contractId: run.b2b_contract ?? undefined,
-      })
-      invariant(entry)
-      renderWithProviders(<CoursewareCard kind="course" entry={entry} />)
-      const enrollButtons = await screen.findAllByTestId("courseware-button")
-      await user.click(enrollButtons[0]) // Use the first (desktop) button
-      const dialog = await screen.findByRole("dialog", {
-        name: "Just a Few More Details",
-      })
-      const fields = getFields(dialog)
-      expect(fields.country).toHaveTextContent(expectCountry)
-      expect(fields.year_of_birth).toHaveTextContent(expectYob)
-    },
-  )
-
-  test("Validates required fields in just-in-time dialog", async () => {
-    const { course, run } = setupJustInTimeTest()
-
-    const entry = buildCourseEntry(course, [], {
-      contractId: run.b2b_contract ?? undefined,
-    })
-    invariant(entry)
-    renderWithProviders(<CoursewareCard kind="course" entry={entry} />)
-
-    const enrollButtons = await screen.findAllByTestId("courseware-button")
-    await user.click(enrollButtons[0]) // Use the first (desktop) button
-
-    const dialog = await screen.findByRole("dialog", {
-      name: "Just a Few More Details",
-    })
-
-    const submitButton = within(dialog).getByRole("button", {
-      name: "Submit",
-    })
-
-    // Try submitting with empty fields - should show validation errors
-    await user.click(submitButton)
-
-    // Should show validation errors
-    const fields = getFields(dialog)
-    expect(fields.country).toBeInvalid()
-    expect(fields.year_of_birth).toBeInvalid()
-    expect(getDescriptionFor(fields.country)).toHaveTextContent(
-      "Country is required",
-    )
-    expect(getDescriptionFor(fields.year_of_birth)).toHaveTextContent(
-      "Year of birth is required",
-    )
-  })
-
-  test("Generates correct year of birth options (minimum age 13)", async () => {
-    const { course, run } = setupJustInTimeTest()
-
-    const entry = buildCourseEntry(course, [], {
-      contractId: run.b2b_contract ?? undefined,
-    })
-    invariant(entry)
-    renderWithProviders(<CoursewareCard kind="course" entry={entry} />)
-
-    const enrollButtons = await screen.findAllByTestId("courseware-button")
-    await user.click(enrollButtons[0]) // Use the first (desktop) button
-
-    const dialog = await screen.findByRole("dialog", {
-      name: "Just a Few More Details",
-    })
-    const fields = getFields(dialog)
-    await user.click(fields.year_of_birth)
-
-    const currentYear = new Date().getFullYear()
-    const maxYear = currentYear - 13
-    const options = screen.getAllByRole("option")
-    const optionValues = options.map((opt) => opt.textContent)
-    const expectedYears = Array.from({ length: maxYear - 1900 + 1 }, (_, i) =>
-      (maxYear - i).toString(),
-    )
-    expect(expectedYears.length).toBeGreaterThan(50) // sanity
-    expect(optionValues).toEqual(["Please Select", ...expectedYears])
-  })
-
-  test("Shows expected countries in country dropdown", async () => {
-    const { course, countries, run } = setupJustInTimeTest()
-
-    const entry = buildCourseEntry(course, [], {
-      contractId: run.b2b_contract ?? undefined,
-    })
-    invariant(entry)
-    renderWithProviders(<CoursewareCard kind="course" entry={entry} />)
-
-    const enrollButtons = await screen.findAllByTestId("courseware-button")
-    await user.click(enrollButtons[0]) // Use the first (desktop) button
-
-    const dialog = await screen.findByRole("dialog", {
-      name: "Just a Few More Details",
-    })
-    const fields = getFields(dialog)
-    await user.click(fields.country)
-
-    const options = screen.getAllByRole("option")
-    expect(countries.length).toBeGreaterThan(1) // sanity
-    const optionValues = options.map((opt) => opt.textContent)
-    expect(optionValues).toEqual([
-      "Please Select",
-      ...countries.map((c) => c.name),
-    ])
-  })
-
-  test("Cancels just-in-time dialog without making API calls", async () => {
-    const { course, run } = setupJustInTimeTest()
-
-    const entry = buildCourseEntry(course, [], {
-      contractId: run.b2b_contract ?? undefined,
-    })
-    invariant(entry)
-    renderWithProviders(<CoursewareCard kind="course" entry={entry} />)
-
-    const enrollButtons = await screen.findAllByTestId("courseware-button")
-    await user.click(enrollButtons[0]) // Use the first (desktop) button
-
-    const dialog = await screen.findByRole("dialog", {
-      name: "Just a Few More Details",
-    })
-
-    const cancelButton = within(dialog).getByRole("button", {
-      name: "Cancel",
-    })
-    await user.click(cancelButton)
-
-    // No PATCH calls should have been made
-    expect(makeRequest).not.toHaveBeenCalledWith(
-      expect.objectContaining({
-        method: "patch",
-        url: mitxonline.urls.userMe.get(),
-      }),
-    )
-  })
-
-  test("Submitting just-in-time dialog makes proper API calls", async () => {
-    const { course, run } = setupJustInTimeTest({
-      userOverrides: { user_profile: { year_of_birth: 1988 } },
-    })
-
-    const entry = buildCourseEntry(course, [], {
-      contractId: run.b2b_contract ?? undefined,
-    })
-    invariant(entry)
-    renderWithProviders(<CoursewareCard kind="course" entry={entry} />)
-    const enrollButtons = await screen.findAllByTestId("courseware-button")
-    await user.click(enrollButtons[0]) // Use the first (desktop) button
-
-    const dialog = await screen.findByRole("dialog", {
-      name: "Just a Few More Details",
-    })
-    const fields = getFields(dialog)
-    await user.click(fields.country)
-
-    const option = screen.getByRole("option", { name: "Canada" })
-    await user.click(option) // Select third option (first is "Please Select")
-
-    invariant(course.readable_id)
-    const spies = {
-      createEnrollment: jest.fn(),
-      patchUser: jest.fn(),
-    }
-    setMockResponse.patch(mitxonline.urls.userMe.get(), spies.patchUser, {
-      requestBody: {
-        user_profile: { year_of_birth: 1988 },
-        legal_address: { country: "CA" },
-      },
-    })
-    setMockResponse.post(
-      mitxonline.urls.b2b.courseEnrollment(run.courseware_id),
-      spies.createEnrollment,
-    )
-    setMockResponse.get(mitxonline.urls.enrollment.enrollmentsListV3(), [
-      mitxonline.factories.enrollment.courseEnrollment({
-        run: {
-          courseware_id: run.courseware_id,
-          courseware_url: run.courseware_url,
-        },
-      }),
-    ])
-
-    const submitButton = within(dialog).getByRole("button", {
-      name: "Submit",
-    })
-
-    await user.click(submitButton)
-    await expect(spies.patchUser).toHaveBeenCalled()
-    await expect(spies.createEnrollment).toHaveBeenCalled()
-    expect(window.location.assign).toHaveBeenCalledWith(run.courseware_url)
-  })
-
-  test("Submitting just-in-time dialog includes program_id when parentProgramReadableIds is provided", async () => {
-    const { course, run } = setupJustInTimeTest({
-      userOverrides: { user_profile: { year_of_birth: 1988 } },
-    })
-    const parentProgramReadableIds = ["program-v1:MITx+DEDP"]
-
-    const entry = buildCourseEntry(course, [], {
-      contractId: run.b2b_contract ?? undefined,
-      ancestorContext: { parentProgramReadableIds },
-    })
-    invariant(entry)
-    renderWithProviders(<CoursewareCard kind="course" entry={entry} />)
-    const enrollButtons = await screen.findAllByTestId("courseware-button")
-    await user.click(enrollButtons[0])
-
-    const dialog = await screen.findByRole("dialog", {
-      name: "Just a Few More Details",
-    })
-    const fields = getFields(dialog)
-    await user.click(fields.country)
-
-    const option = screen.getByRole("option", { name: "Canada" })
-    await user.click(option)
-
-    setMockResponse.patch(mitxonline.urls.userMe.get(), null)
-    setMockResponse.post(
-      mitxonline.urls.b2b.courseEnrollment(run.courseware_id),
-      null,
-    )
-    setMockResponse.get(mitxonline.urls.enrollment.enrollmentsListV3(), [
-      mitxonline.factories.enrollment.courseEnrollment({
-        run: {
-          courseware_id: run.courseware_id,
-          courseware_url: run.courseware_url,
-        },
-      }),
-    ])
-
-    const submitButton = within(dialog).getByRole("button", {
-      name: "Submit",
-    })
-    await user.click(submitButton)
-
-    expect(makeRequest).toHaveBeenCalledWith(
-      expect.objectContaining({
-        method: "post",
-        url: mitxonline.urls.b2b.courseEnrollment(run.courseware_id),
-        body: expect.objectContaining({
-          program_id: "program-v1:MITx+DEDP",
-        }),
-      }),
-    )
-  })
-})
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/DashboardDialogs.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/DashboardDialogs.tsx
index 69ea589980..b41781c19a 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/DashboardDialogs.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/DashboardDialogs.tsx
@@ -6,25 +6,16 @@ import {
   DialogActions,
   Stack,
   LoadingSpinner,
-  SimpleSelectField,
-  SimpleSelectOption,
 } from "ol-components"
 import { Button, Checkbox, Alert } from "@mitodl/smoot-design"
-import { useQuery } from "@tanstack/react-query"
 
 import NiceModal, { muiDialogV5 } from "@ebay/nice-modal-react"
 import { useFormik } from "formik"
 import {
-  useCreateB2bEnrollment,
   useDestroyEnrollment,
   useDestroyProgramEnrollment,
   useUpdateEnrollment,
 } from "api/mitxonline-hooks/enrollment"
-import {
-  mitxUserQueries,
-  useUpdateUserMutation,
-} from "api/mitxonline-hooks/user"
-import * as Yup from "yup"
 import { CourseRunEnrollmentV3 } from "@mitodl/mitxonline-api-axios/v2"
 import {
   trackCourseUnenrolled,
@@ -35,10 +26,6 @@ const BoldText = styled.span(({ theme }) => ({
   ...theme.typography.subtitle1,
 }))
 
-const SelectPlaceholder = styled("span")(({ theme }) => ({
-  color: theme.custom.colors.silverGrayDark,
-}))
-
 type DashboardDialogProps = {
   title: string
   enrollment: CourseRunEnrollmentV3
@@ -189,144 +176,8 @@ const UnenrollDialogInner: React.FC<DashboardDialogProps> = ({
   )
 }
 
-const jitSchema = Yup.object().shape({
-  country: Yup.string().required("Country is required"),
-  year_of_birth: Yup.string().required("Year of birth is required"),
-})
-
-const JustInTimeDialogInner: React.FC<{
-  href: string
-  readableId: string
-  programId?: string
-}> = ({ href, readableId, programId }) => {
-  const { data: countries } = useQuery(mitxUserQueries.countries())
-  const updateUser = useUpdateUserMutation()
-  const createEnrollment = useCreateB2bEnrollment()
-  const user = useQuery(mitxUserQueries.me())
-  const modal = NiceModal.useModal()
-
-  // Generate year options (minimum age 13, so current year - 13 back to 1900)
-  const currentYear = new Date().getFullYear()
-  const maxYear = currentYear - 13
-  const years = Array.from({ length: maxYear - 1900 + 1 }, (_, i) =>
-    (maxYear - i).toString(),
-  )
-
-  const yob = user?.data?.user_profile?.year_of_birth
-
-  const formik = useFormik({
-    enableReinitialize: true,
-    validateOnChange: false,
-    validateOnBlur: false,
-    initialValues: {
-      country: user?.data?.legal_address?.country || "",
-      year_of_birth: yob ? yob.toString() : "",
-    },
-    validationSchema: jitSchema,
-    onSubmit: async (values) => {
-      await updateUser.mutateAsync({
-        PatchedUserRequest: {
-          user_profile: {
-            year_of_birth: parseInt(values.year_of_birth, 10),
-          },
-          legal_address: {
-            country: values.country,
-          },
-        },
-      })
-      await createEnrollment.mutateAsync({
-        readable_id: readableId,
-        B2BEnrollRequestRequest: programId
-          ? { program_id: programId }
-          : undefined,
-      })
-      window.location.assign(href)
-      modal.hide()
-    },
-  })
-  const countryOptions: SimpleSelectOption[] = [
-    { value: "", label: "Please Select", disabled: true },
-    ...(countries?.map(({ code, name }) => ({ value: code, label: name })) ??
-      []),
-  ]
-  const yobOptions: SimpleSelectOption[] = [
-    { value: "", label: "Please Select", disabled: true },
-    ...years.map((year): SimpleSelectOption => ({ value: year, label: year })),
-  ]
-
-  return (
-    <FormDialog
-      noValidate
-      title="Just a Few More Details"
-      fullWidth
-      onReset={formik.resetForm}
-      onSubmit={formik.handleSubmit}
-      {...muiDialogV5(modal)}
-      actions={
-        <DialogActions>
-          <Button variant="secondary" onClick={modal.hide}>
-            Cancel
-          </Button>
-          <Button
-            variant="primary"
-            type="submit"
-            disabled={formik.isSubmitting}
-            endIcon={
-              formik.isSubmitting ? (
-                <LoadingSpinner color="inherit" loading={true} size={16} />
-              ) : undefined
-            }
-          >
-            Submit
-          </Button>
-        </DialogActions>
-      }
-    >
-      <Stack direction="column" gap="24px">
-        <Typography variant="body1">
-          We need a bit more info before you can enroll.
-        </Typography>
-
-        <SimpleSelectField
-          options={countryOptions}
-          name="country"
-          label="Country"
-          value={countries ? formik.values.country : ""}
-          onChange={formik.handleChange}
-          fullWidth
-          required
-          renderValue={
-            formik.values.country
-              ? undefined
-              : () => <SelectPlaceholder>Please Select</SelectPlaceholder>
-          }
-          error={!!formik.errors.country}
-          errorText={formik.errors.country}
-        />
-        <SimpleSelectField
-          options={yobOptions}
-          name="year_of_birth"
-          label="Year of Birth"
-          value={formik.values.year_of_birth}
-          onChange={formik.handleChange}
-          fullWidth
-          required
-          renderValue={
-            formik.values.year_of_birth
-              ? undefined
-              : () => <SelectPlaceholder>Please Select</SelectPlaceholder>
-          }
-          error={!!formik.errors.year_of_birth}
-          errorText={formik.errors.year_of_birth}
-        />
-      </Stack>
-    </FormDialog>
-  )
-}
-
 const EmailSettingsDialog = NiceModal.create(EmailSettingsDialogInner)
 const UnenrollDialog = NiceModal.create(UnenrollDialogInner)
-const JustInTimeDialog = NiceModal.create(JustInTimeDialogInner)
 
 type UnenrollProgramDialogProps = {
   title: string
@@ -397,9 +248,4 @@ const UnenrollProgramDialogInner: React.FC<UnenrollProgramDialogProps> = ({
 
 const UnenrollProgramDialog = NiceModal.create(UnenrollProgramDialogInner)
 
-export {
-  EmailSettingsDialog,
-  UnenrollDialog,
-  UnenrollProgramDialog,
-  JustInTimeDialog,
-}
+export { EmailSettingsDialog, UnenrollDialog, UnenrollProgramDialog }
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/EnrolledCourseCard.test.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/EnrolledCourseCard.test.tsx
index 0f829c1d10..01a5438629 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/EnrolledCourseCard.test.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/EnrolledCourseCard.test.tsx
@@ -10,10 +10,17 @@ import {
 } from "@/test-utils"
 import * as mitxonline from "api/mitxonline-test-utils"
 import { mitxonlineLegacyUrl } from "@/common/mitxonline"
+import { receiptByRunView, receiptView } from "@/common/urls"
 import { makeRequest } from "api/test-utils"
 import { faker } from "@faker-js/faker/locale/en"
 import moment from "moment"
 import { EnrolledCourseCard } from "./EnrolledCourseCard"
+import { setupOrderHistory } from "./test-utils"
+
+// Verified cards look up their order; default to none, tests override.
+beforeEach(() => {
+  setupOrderHistory()
+})
 
 const EnrollmentMode = {
   Audit: "audit",
@@ -784,12 +791,13 @@ describe.each([
       enrollment_mode: EnrollmentMode.Verified,
       grades: [mitxonline.factories.enrollment.grade({ passed: true })],
     })
+    setupOrderHistory({ runId: enrollment.run.id })
     renderWithProviders(<EnrolledCourseCard enrollment={enrollment} />)
     await user.click(
       within(getCard()).getByRole("button", { name: "More options" }),
     )
     expect(
-      screen.getByRole("menuitem", { name: "Receipt" }),
+      await screen.findByRole("menuitem", { name: "Receipt" }),
     ).toBeInTheDocument()
   })
 
@@ -809,30 +817,77 @@ describe.each([
     ).not.toBeInTheDocument()
   })
 
-  test("Receipt links to correct MITx Online URL for verified enrollment", async () => {
+  test("Receipt links to the receipt for the order that paid for the run", async () => {
+    setupUserApis()
+    const runId = faker.number.int({ min: 1 })
+    setupOrderHistory({ runId, orderId: 87 })
+    const enrollment = mitxonline.factories.enrollment.courseEnrollment({
+      enrollment_mode: EnrollmentMode.Verified,
+      grades: [mitxonline.factories.enrollment.grade({ passed: true })],
+      run: { id: runId },
+    })
+
+    renderWithProviders(<EnrolledCourseCard enrollment={enrollment} />)
+    await user.click(
+      within(getCard()).getByRole("button", { name: "More options" }),
+    )
+
+    expect(
+      await screen.findByRole("menuitem", { name: "Receipt" }),
+    ).toHaveAttribute("href", receiptView(87))
+  })
+
+  // Verified does not imply a run-level order, so the item must stay hidden.
+  test("Receipt is hidden for a verified enrollment with no order behind it", async () => {
     setupUserApis()
-    const runId = faker.number.int()
+    const runId = faker.number.int({ min: 1 })
+    // An order exists, but for a different run.
+    setupOrderHistory({ runId: runId + 1, orderId: 87 })
     const enrollment = mitxonline.factories.enrollment.courseEnrollment({
       enrollment_mode: EnrollmentMode.Verified,
       grades: [mitxonline.factories.enrollment.grade({ passed: true })],
       run: { id: runId },
     })
-    const windowOpenSpy = jest
-      .spyOn(window, "open")
-      .mockImplementation(() => null)
 
     renderWithProviders(<EnrolledCourseCard enrollment={enrollment} />)
     await user.click(
       within(getCard()).getByRole("button", { name: "More options" }),
     )
-    await user.click(screen.getByRole("menuitem", { name: "Receipt" }))
+    // Wait for a sibling item so we know the menu has rendered.
+    await screen.findByRole("menuitem", { name: "Unenroll" })
+
+    expect(
+      screen.queryByRole("menuitem", { name: "Receipt" }),
+    ).not.toBeInTheDocument()
+  })
+
+  /**
+   * An `orders/history` outage must not look the same as "you never paid for this".
+   * The item stays, pointing at the resolver route, which refetches and renders its
+   * own skeleton or 404 instead of the option silently vanishing from every card.
+   */
+  test("Receipt falls back to the resolver route when the order lookup fails", async () => {
+    setupUserApis()
+    const runId = faker.number.int({ min: 1 })
+    setMockResponse.get(
+      mitxonline.urls.orders.historyList({ limit: 100 }),
+      "Server error",
+      { code: 500 },
+    )
+    const enrollment = mitxonline.factories.enrollment.courseEnrollment({
+      enrollment_mode: EnrollmentMode.Verified,
+      grades: [mitxonline.factories.enrollment.grade({ passed: true })],
+      run: { id: runId },
+    })
 
-    expect(windowOpenSpy).toHaveBeenCalledWith(
-      mitxonlineLegacyUrl(`/orders/receipt/by-run/${runId}/`),
-      "_blank",
-      "noopener,noreferrer",
+    renderWithProviders(<EnrolledCourseCard enrollment={enrollment} />)
+    await user.click(
+      within(getCard()).getByRole("button", { name: "More options" }),
     )
-    windowOpenSpy.mockRestore()
+
+    expect(
+      await screen.findByRole("menuitem", { name: "Receipt" }),
+    ).toHaveAttribute("href", receiptByRunView(runId))
   })
 })
 
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/EnrolledCourseCard.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/EnrolledCourseCard.tsx
index ef5e89fa63..768e641ad5 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/EnrolledCourseCard.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/EnrolledCourseCard.tsx
@@ -27,16 +27,18 @@ import { getCourseDateText } from "./courseDateUtils"
 import { isVerifiedEnrollmentMode } from "@/common/mitxonline"
 import { RiArrowUpCircleLine, RiAwardLine, RiMore2Line } from "@remixicon/react"
 import { useReplaceBasketItem } from "@/common/mitxonline/useReplaceBasketItem"
+import { useComplianceGate } from "@/common/mitxonline/useComplianceGate"
 import { useCreateVerifiedProgramEnrollment } from "api/mitxonline-hooks/enrollment"
 import { isInPast, calendarDaysUntil, NoSSR } from "ol-utilities"
 import { SiblingRunsPanel, SiblingRunsToggle } from "./SiblingRunsAccordion"
 import { EnrollmentStatusIcon } from "./EnrollmentStatus"
 import { mitxUserQueries } from "api/mitxonline-hooks/user"
 import { useQuery } from "@tanstack/react-query"
-import { coursePageView } from "@/common/urls"
+import { coursePageView, receiptByRunView } from "@/common/urls"
 import NiceModal from "@ebay/nice-modal-react"
 import { EmailSettingsDialog, UnenrollDialog } from "./DashboardDialogs"
 import { getReceiptMenuItem } from "./receiptMenuItem"
+import { useOrderIdForRun } from "@/common/mitxonline/useOrderIdForResource"
 import {
   CourseRunEnrollmentV3,
   V3UserProgramEnrollment,
@@ -97,6 +99,7 @@ const UpgradeBanner: React.FC<
 }) => {
   const replaceBasketItem = useReplaceBasketItem()
   const createVerifiedProgramEnrollment = useCreateVerifiedProgramEnrollment()
+  const { ensureCompliance } = useComplianceGate()
 
   const programRequestBody = programReadableIds?.length
     ? programReadableIds
@@ -115,6 +118,11 @@ const UpgradeBanner: React.FC<
     e.preventDefault()
 
     if (canOneClickUpgrade) {
+      // Gated before the try/catch: a dismissed compliance dialog is not an
+      // upgrade failure and must not surface onUpgradeFailure's error
+      // message. The checkout fallback below is gated inside
+      // useReplaceBasketItem instead, so it isn't checked twice.
+      if (!(await ensureCompliance())) return
       try {
         await createVerifiedProgramEnrollment.mutateAsync({
           courserun_id: readableId!,
@@ -251,6 +259,17 @@ export const EnrolledCourseCard = ({
     ) : null
   const mitxOnlineUser = useQuery(mitxUserQueries.me())
   const isStaff = mitxOnlineUser.data?.is_staff
+  /**
+   * Only verified enrollments can have a receipt, so the lookup is skipped
+   * entirely for audit ones. Every card shares one `orders/history` query (same
+   * cache key), so this is a single request for the whole dashboard rather than
+   * one per card.
+   */
+  const receiptResolution = useOrderIdForRun(
+    isVerifiedEnrollmentMode(enrollment?.enrollment_mode)
+      ? (run?.id ?? null)
+      : null,
+  )
   const title = isCompact ? course.title : run?.title || course.title
   const coursewareUrl = run?.courseware_url
   const certificateLink = getCertificateLink(
@@ -455,7 +474,8 @@ export const EnrolledCourseCard = ({
 
   const receiptMenuItem = getReceiptMenuItem(
     enrollment?.enrollment_mode,
-    `/orders/receipt/by-run/${enrollment?.run.id}/`,
+    receiptResolution,
+    receiptByRunView(run.id),
   )
   if (receiptMenuItem) menuItems.push(receiptMenuItem)
 
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/HomeEnrollmentsDisplay.test.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/HomeEnrollmentsDisplay.test.tsx
index 3cc426c761..6ddcd1d085 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/HomeEnrollmentsDisplay.test.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/HomeEnrollmentsDisplay.test.tsx
@@ -27,9 +27,14 @@ import {
 import { HomeEnrollmentsDisplay } from "./HomeEnrollmentsDisplay"
 import * as mitxonline from "api/mitxonline-test-utils"
 import { useFeatureFlagEnabled } from "posthog-js/react"
-import { setupEnrollments } from "./test-utils"
+import { setupEnrollments, setupOrderHistory } from "./test-utils"
 import { faker } from "@faker-js/faker/locale/en"
 
+// Verified cards look up their order; default to none, tests override.
+beforeEach(() => {
+  setupOrderHistory()
+})
+
 jest.mock("posthog-js/react")
 const mockedUseFeatureFlagEnabled = jest
   .mocked(useFeatureFlagEnabled)
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentCard.test.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentCard.test.tsx
index fe38d3abd9..aa2b43178e 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentCard.test.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentCard.test.tsx
@@ -2,8 +2,15 @@ import React from "react"
 import { renderWithProviders, screen, user, within } from "@/test-utils"
 import * as mitxonline from "api/mitxonline-test-utils"
 import { mitxonlineLegacyUrl } from "@/common/mitxonline"
+import { receiptView } from "@/common/urls"
 import { DisplayModeEnum } from "@mitodl/mitxonline-api-axios/v2"
 import { ProgramEnrollmentCard } from "./ProgramEnrollmentCard"
+import { setupOrderHistory } from "./test-utils"
+
+// Verified cards look up their order; default to none, tests override.
+beforeEach(() => {
+  setupOrderHistory()
+})
 
 describe.each([
   { display: "desktop", testId: "enrollment-card-desktop" },
@@ -227,6 +234,7 @@ describe.each([
       mitxonline.factories.enrollment.programEnrollmentV3({
         enrollment_mode: "verified",
       })
+    setupOrderHistory({ programId: programEnrollment.program.id })
     renderWithProviders(
       <ProgramEnrollmentCard programEnrollment={programEnrollment} />,
     )
@@ -234,7 +242,7 @@ describe.each([
       within(getCard()).getByRole("button", { name: "More options" }),
     )
     expect(
-      screen.getByRole("menuitem", { name: "Receipt" }),
+      await screen.findByRole("menuitem", { name: "Receipt" }),
     ).toBeInTheDocument()
   })
 
@@ -254,29 +262,45 @@ describe.each([
     ).not.toBeInTheDocument()
   })
 
-  test("Receipt links to correct MITx Online URL for verified program enrollment", async () => {
+  test("Receipt links to the receipt for the order that paid for the program", async () => {
     const program = mitxonline.factories.programs.simpleProgram({ id: 99 })
+    setupOrderHistory({ programId: 99, orderId: 23 })
     const programEnrollment =
       mitxonline.factories.enrollment.programEnrollmentV3({
         program,
         enrollment_mode: "verified",
       })
-    const windowOpenSpy = jest
-      .spyOn(window, "open")
-      .mockImplementation(() => null)
     renderWithProviders(
       <ProgramEnrollmentCard programEnrollment={programEnrollment} />,
     )
     await user.click(
       within(getCard()).getByRole("button", { name: "More options" }),
     )
-    await user.click(screen.getByRole("menuitem", { name: "Receipt" }))
-    expect(windowOpenSpy).toHaveBeenCalledWith(
-      mitxonlineLegacyUrl("/orders/receipt/by-program/99/"),
-      "_blank",
-      "noopener,noreferrer",
+    expect(
+      await screen.findByRole("menuitem", { name: "Receipt" }),
+    ).toHaveAttribute("href", receiptView(23))
+  })
+
+  test("Receipt is hidden for a verified program enrollment with no order", async () => {
+    const program = mitxonline.factories.programs.simpleProgram({ id: 99 })
+    // An order exists, but for a different program.
+    setupOrderHistory({ programId: 100, orderId: 23 })
+    const programEnrollment =
+      mitxonline.factories.enrollment.programEnrollmentV3({
+        program,
+        enrollment_mode: "verified",
+      })
+    renderWithProviders(
+      <ProgramEnrollmentCard programEnrollment={programEnrollment} />,
+    )
+    await user.click(
+      within(getCard()).getByRole("button", { name: "More options" }),
     )
-    windowOpenSpy.mockRestore()
+    await screen.findByRole("menuitem", { name: "Program Record" })
+
+    expect(
+      screen.queryByRole("menuitem", { name: "Receipt" }),
+    ).not.toBeInTheDocument()
   })
 })
 
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentCard.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentCard.tsx
index 6c3ccc026c..a55713539e 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentCard.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentCard.tsx
@@ -1,5 +1,9 @@
 import React from "react"
-import { programPageView, programView } from "@/common/urls"
+import {
+  programPageView,
+  programView,
+  receiptByProgramView,
+} from "@/common/urls"
 import {
   DisplayModeEnum,
   V3UserProgramEnrollment,
@@ -25,6 +29,7 @@ import { getCertificateLink } from "./model/dashboardViewModel"
 import NiceModal from "@ebay/nice-modal-react"
 import { UnenrollProgramDialog } from "./DashboardDialogs"
 import { getReceiptMenuItem } from "./receiptMenuItem"
+import { useOrderIdForProgram } from "@/common/mitxonline/useOrderIdForResource"
 import { SimpleMenu, Stack } from "ol-components"
 import { EnrollmentStatus } from "./helpers"
 import { ProgressBadge } from "./ProgressBadge"
@@ -55,6 +60,13 @@ export const ProgramEnrollmentCard = ({
   const upgradedAndIncomplete = isVerifiedEnrollmentMode(
     programEnrollment.enrollment_mode,
   )
+  /**
+   * Skipped for audit enrollments, which never have a receipt. Shares one
+   * `orders/history` query with every other card on the dashboard.
+   */
+  const receiptResolution = useOrderIdForProgram(
+    upgradedAndIncomplete ? programId : null,
+  )
   const displayMode = program.display_mode
   const titleSection = (
     <Stack gap="12px">
@@ -114,7 +126,8 @@ export const ProgramEnrollmentCard = ({
   }
   const receiptMenuItem = getReceiptMenuItem(
     programEnrollment.enrollment_mode,
-    `/orders/receipt/by-program/${program.id}/`,
+    receiptResolution,
+    receiptByProgramView(programId),
   )
   if (receiptMenuItem) menuItems.push(receiptMenuItem)
   const contextMenu = (
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentDisplay.test.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentDisplay.test.tsx
index b60b41b513..b83b05025b 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentDisplay.test.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/ProgramEnrollmentDisplay.test.tsx
@@ -28,10 +28,16 @@ import {
 import { ProgramEnrollmentDisplay } from "./ProgramEnrollmentDisplay"
 import * as mitxonline from "api/mitxonline-test-utils"
 import { makeRequest } from "api/test-utils"
+import { setupOrderHistory } from "./test-utils"
 import { useFeatureFlagEnabled } from "posthog-js/react"
 import { faker } from "@faker-js/faker/locale/en"
 import invariant from "tiny-invariant"
 
+// Verified cards look up their order; default to none, tests override.
+beforeEach(() => {
+  setupOrderHistory()
+})
+
 jest.mock("posthog-js/react")
 const mockedUseFeatureFlagEnabled = jest
   .mocked(useFeatureFlagEnabled)
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/UnenrolledCourseCard.compliance.test.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/UnenrolledCourseCard.compliance.test.tsx
new file mode 100644
index 0000000000..9271d7a97a
--- /dev/null
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/UnenrolledCourseCard.compliance.test.tsx
@@ -0,0 +1,97 @@
+import React from "react"
+import {
+  renderWithProviders,
+  screen,
+  setMockResponse,
+  setupLocationMock,
+  user,
+  waitFor,
+  within,
+} from "@/test-utils"
+import * as mitxonline from "api/mitxonline-test-utils"
+import { makeRequest } from "api/test-utils"
+import { faker } from "@faker-js/faker/locale/en"
+import { UnenrolledCourseCard } from "./UnenrolledCourseCard"
+
+/**
+ * Kept out of UnenrolledCourseCard.test.tsx deliberately. This is the only test
+ * that drives a full enroll → gate → dialog → enroll round trip, and running it
+ * after that file's ~70 tests made it flaky: an earlier test's request resolves
+ * after its own test ended, by which point jest has cleared the mock registry,
+ * and the stray call is attributed here. Its own file gives it clean state.
+ */
+describe("UnenrolledCourseCard — resuming enrollment after the compliance gate", () => {
+  setupLocationMock()
+
+  test("completing the just-in-time dialog resumes the B2B enrollment, including program_id", async () => {
+    // The dialog no longer enrolls; it only saves the profile and hands control
+    // back, so the enrollment must still carry the program context it was
+    // triggered with.
+    const parentProgramReadableIds = ["program-v1:MITx+DEDP"]
+    const userData = mitxonline.factories.user.user({
+      compliance_missing_fields: [],
+      legal_address: {
+        first_name: "Ada",
+        last_name: "Lovelace",
+        country: "GB",
+        street_address_1: "1 Main St",
+        city: "London",
+      },
+      // The only outstanding field, so the dialog opens with everything else
+      // already filled in and needs a single selection to satisfy.
+      user_profile: { year_of_birth: null },
+    })
+    const b2bContractId = faker.number.int()
+    const run = mitxonline.factories.courses.courseRun({
+      b2b_contract: b2bContractId,
+      is_enrollable: true,
+    })
+    const course = mitxonline.factories.courses.course({
+      courseruns: [run],
+      next_run_id: run.id,
+    })
+    const enrollmentUrl = mitxonline.urls.b2b.courseEnrollment(
+      run.courseware_id,
+    )
+
+    setMockResponse.get(mitxonline.urls.userMe.get(), userData)
+    setMockResponse.get(mitxonline.urls.enrollment.enrollmentsListV3(), [])
+    setMockResponse.get(mitxonline.urls.countries.list(), [
+      { code: "GB", name: "United Kingdom", states: [] },
+    ])
+    setMockResponse.patch(mitxonline.urls.userMe.get(), null)
+    setMockResponse.post(enrollmentUrl, { result: "b2b-enroll-success" })
+
+    renderWithProviders(
+      <UnenrolledCourseCard
+        course={course}
+        contractId={b2bContractId}
+        ancestorContext={{ parentProgramReadableIds }}
+      />,
+    )
+
+    const card = screen.getByTestId("enrollment-card-desktop")
+    await user.click(within(card).getByTestId("courseware-button"))
+
+    const dialog = await screen.findByRole("dialog", {
+      name: "Just a Few More Details",
+    })
+    await user.click(
+      within(dialog).getByRole("combobox", { name: "Year of Birth" }),
+    )
+    await user.click(await screen.findByRole("option", { name: "1988" }))
+    await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+    await waitFor(() =>
+      expect(makeRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "post",
+          url: enrollmentUrl,
+          body: expect.objectContaining({
+            program_id: "program-v1:MITx+DEDP",
+          }),
+        }),
+      ),
+    )
+  })
+})
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/UnenrolledCourseCard.test.tsx b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/UnenrolledCourseCard.test.tsx
index ad6547b9fe..45b099a984 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/UnenrolledCourseCard.test.tsx
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/UnenrolledCourseCard.test.tsx
@@ -363,8 +363,11 @@ describe.each([
   )
 
   test.each(
+    // The two independent reasons the gate blocks: MITx Online reports missing
+    // export-compliance fields, or we have no year of birth for the minimum-age
+    // requirement.
     cartesianProduct(ENROLLMENT_TRIGGERS, [
-      { userData: mitxUser({ legal_address: { country: "" } }) },
+      { userData: mitxUser({ compliance_missing_fields: ["country"] }) },
       { userData: mitxUser({ user_profile: { year_of_birth: null } }) },
     ]),
   )(
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/hooks/useEnrollmentHandler.ts b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/hooks/useEnrollmentHandler.ts
index feb2fa7f3b..fca020debd 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/hooks/useEnrollmentHandler.ts
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/hooks/useEnrollmentHandler.ts
@@ -3,29 +3,27 @@ import {
   CourseRunV2,
   CourseWithCourseRunsSerializerV2,
 } from "@mitodl/mitxonline-api-axios/v2"
-import { useQuery } from "@tanstack/react-query"
 import {
   useCreateB2bEnrollment,
   useCreateEnrollment,
   useCreateVerifiedProgramEnrollment,
 } from "api/mitxonline-hooks/enrollment"
-import { mitxUserQueries } from "api/mitxonline-hooks/user"
 import React from "react"
-import { JustInTimeDialog } from "../DashboardDialogs"
 import NiceModal from "@ebay/nice-modal-react"
 import { getCourseEnrollmentAction } from "@/common/mitxonline"
+import { useComplianceGate } from "@/common/mitxonline/useComplianceGate"
 import CourseEnrollmentDialog from "@/page-components/EnrollmentDialogs/CourseEnrollmentDialog"
 import { trackCourseEnrolled } from "@/common/analytics/gtm"
 
 export const useEnrollmentHandler = () => {
-  const mitxOnlineUser = useQuery(mitxUserQueries.me())
   const createB2bEnrollment = useCreateB2bEnrollment()
   const createEnrollment = useCreateEnrollment()
   const createVerifiedProgramEnrollment = useCreateVerifiedProgramEnrollment()
   const replaceBasketItem = useReplaceBasketItem()
+  const { ensureCompliance } = useComplianceGate()
 
   const enroll = React.useCallback(
-    ({
+    async ({
       course,
       readableId,
       href,
@@ -70,31 +68,21 @@ export const useEnrollmentHandler = () => {
           })
           return
         }
-        const userCountry = mitxOnlineUser.data?.legal_address?.country
-        const userYearOfBirth = mitxOnlineUser.data?.user_profile?.year_of_birth
-        const showJustInTimeDialog = !userCountry || !userYearOfBirth
+        if (!(await ensureCompliance())) return
 
-        if (showJustInTimeDialog) {
-          NiceModal.show(JustInTimeDialog, {
-            href: destinationUrl,
-            readableId,
-            programId: b2bProgramId,
-          })
-        } else {
-          createB2bEnrollment.mutate(
-            {
-              readable_id: readableId,
-              B2BEnrollRequestRequest: b2bProgramId
-                ? { program_id: b2bProgramId }
-                : undefined,
-            },
-            {
-              onSuccess: () => {
-                window.location.href = destinationUrl
-              },
+        createB2bEnrollment.mutate(
+          {
+            readable_id: readableId,
+            B2BEnrollRequestRequest: b2bProgramId
+              ? { program_id: b2bProgramId }
+              : undefined,
+          },
+          {
+            onSuccess: () => {
+              window.location.href = destinationUrl
             },
-          )
-        }
+          },
+        )
       } else if (
         isVerifiedProgram &&
         readableId &&
@@ -121,6 +109,7 @@ export const useEnrollmentHandler = () => {
           : programCoursewareId
             ? [programCoursewareId]
             : []
+        if (!(await ensureCompliance())) return
         createVerifiedProgramEnrollment.mutate(
           { courserun_id: readableId, request_body: requestBody },
           {
@@ -133,6 +122,7 @@ export const useEnrollmentHandler = () => {
         const enrollmentAction = getCourseEnrollmentAction(course)
 
         if (enrollmentAction.type === "audit") {
+          if (!(await ensureCompliance())) return
           createEnrollment.mutate(
             { run_id: enrollmentAction.run.id },
             {
@@ -163,8 +153,7 @@ export const useEnrollmentHandler = () => {
       }
     },
     [
-      mitxOnlineUser.data?.legal_address?.country,
-      mitxOnlineUser.data?.user_profile?.year_of_birth,
+      ensureCompliance,
       createB2bEnrollment,
       createEnrollment,
       createVerifiedProgramEnrollment,
@@ -179,6 +168,5 @@ export const useEnrollmentHandler = () => {
       createEnrollment.isPending ||
       createVerifiedProgramEnrollment.isPending ||
       replaceBasketItem.isPending,
-    mitxOnlineUser: mitxOnlineUser.data,
   }
 }
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/receiptMenuItem.test.ts b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/receiptMenuItem.test.ts
index ac90a57595..2df1ab94ba 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/receiptMenuItem.test.ts
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/receiptMenuItem.test.ts
@@ -1,11 +1,84 @@
 import { getReceiptMenuItem } from "./receiptMenuItem"
+import type { OrderIdResolution } from "@/common/mitxonline/useOrderIdForResource"
+
+const RESOLVER_HREF = "/receipt/by-program/99"
+
+const resolution = (
+  overrides: Partial<OrderIdResolution> = {},
+): OrderIdResolution => ({
+  isPending: false,
+  isError: false,
+  orderId: null,
+  ...overrides,
+})
 
 describe("getReceiptMenuItem", () => {
   test("returns null when enrollment mode is undefined", () => {
-    const menuItem = getReceiptMenuItem(
-      undefined,
-      "/orders/receipt/by-program/99/",
+    expect(
+      getReceiptMenuItem(undefined, resolution({ orderId: 87 }), RESOLVER_HREF),
+    ).toBeNull()
+  })
+
+  test("returns null for audit enrollments, since auditing is free", () => {
+    expect(
+      getReceiptMenuItem("audit", resolution({ orderId: 87 }), RESOLVER_HREF),
+    ).toBeNull()
+  })
+
+  test("returns null while the order lookup is still pending", () => {
+    expect(
+      getReceiptMenuItem(
+        "verified",
+        resolution({ isPending: true }),
+        RESOLVER_HREF,
+      ),
+    ).toBeNull()
+  })
+
+  test("links straight to the resolved receipt", () => {
+    expect(
+      getReceiptMenuItem(
+        "verified",
+        resolution({ orderId: 87 }),
+        RESOLVER_HREF,
+      ),
+    ).toEqual(
+      expect.objectContaining({
+        key: "receipt",
+        label: "Receipt",
+        href: "/receipt/87",
+      }),
+    )
+  })
+
+  /**
+   * The lookup succeeded and found nothing — e.g. verified via a program purchase
+   * that upgraded an existing audit enrollment, which creates no order.
+   */
+  test("hides the item when the lookup found no order", () => {
+    expect(
+      getReceiptMenuItem("verified", resolution(), RESOLVER_HREF),
+    ).toBeNull()
+  })
+
+  /**
+   * A failed lookup must not look like "no receipt", or an `orders/history` outage
+   * would silently drop Receipt from every card at once. Link to the resolver
+   * route, which refetches and renders its own skeleton or 404.
+   */
+  test("falls back to the resolver route when the lookup failed", () => {
+    expect(
+      getReceiptMenuItem(
+        "verified",
+        resolution({ isError: true }),
+        RESOLVER_HREF,
+      ),
+    ).toEqual(
+      expect.objectContaining({
+        key: "receipt",
+        label: "Receipt",
+        href: RESOLVER_HREF,
+      }),
     )
-    expect(menuItem).toBeNull()
   })
 })
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/receiptMenuItem.ts b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/receiptMenuItem.ts
index 3b3e77244d..730d609562 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/receiptMenuItem.ts
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/receiptMenuItem.ts
@@ -1,26 +1,46 @@
 import { SimpleMenuItem } from "ol-components"
-import {
-  isVerifiedEnrollmentMode,
-  mitxonlineLegacyUrl,
-} from "@/common/mitxonline"
+import { isVerifiedEnrollmentMode } from "@/common/mitxonline"
+import { receiptView } from "@/common/urls"
+import type { OrderIdResolution } from "@/common/mitxonline/useOrderIdForResource"
 
+/**
+ * The "Receipt" item for a dashboard card, or null when there is nothing to link
+ * to.
+ *
+ * Verified track alone is not enough — a program purchase can upgrade an existing
+ * audit enrollment without creating any order, leaving no receipt.
+ *
+ * The three reasons `orderId` can be null are deliberately not equivalent:
+ *
+ * - still loading — show nothing yet rather than a link that may not work
+ * - lookup failed — we do not know whether a receipt exists, so link to
+ *   `resolverHref`, which refetches and shows its own skeleton or 404. Hiding the
+ *   item here would make a failing request indistinguishable from "you never paid
+ *   for this", and would silently drop Receipt from every card at once.
+ * - looked up and found nothing — genuinely no receipt, so hide the item
+ */
 const getReceiptMenuItem = (
   enrollmentMode: string | null | undefined,
-  receiptPath: string,
+  resolution: OrderIdResolution,
+  resolverHref: string,
 ): SimpleMenuItem | null => {
   if (!enrollmentMode || !isVerifiedEnrollmentMode(enrollmentMode)) return null
+  if (resolution.isPending) return null
+
+  const href =
+    resolution.orderId !== null
+      ? receiptView(resolution.orderId)
+      : resolution.isError
+        ? resolverHref
+        : null
+
+  if (href === null) return null
 
   return {
     className: "dashboard-card-menu-item",
     key: "receipt",
     label: "Receipt",
-    onClick: () => {
-      window.open(
-        mitxonlineLegacyUrl(receiptPath),
-        "_blank",
-        "noopener,noreferrer",
-      )
-    },
+    href,
   }
 }
 
diff --git a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/test-utils.ts b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/test-utils.ts
index a9269a57a9..ec4cfb8cd4 100644
--- a/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/test-utils.ts
+++ b/frontends/main/src/app-pages/DashboardPage/CoursewareDisplay/test-utils.ts
@@ -25,6 +25,67 @@ const makeCourseEnrollment = factories.enrollment.courseEnrollment
 const makeGrade = factories.enrollment.grade
 const makeContract = factories.contracts.contract
 
+/**
+ * Mock the order history that verified enrollment cards fetch to decide whether to
+ * show a "Receipt" item. Required in any suite rendering a verified enrollment,
+ * or the unmocked request fails the test. Defaults to an empty history (no
+ * receipt); pass `runId`/`programId` to make one resolve.
+ */
+const setupOrderHistory = ({
+  runId,
+  programId,
+  orderId = faker.number.int({ min: 1 }),
+}: {
+  runId?: number
+  programId?: number
+  orderId?: number
+} = {}) => {
+  const lines = []
+  if (runId !== undefined) {
+    lines.push(
+      factories.orders.line({
+        product: factories.orders.product({
+          purchasable_object: {
+            id: runId,
+            title: "Some Run",
+            course: { id: faker.number.int(), title: "Some Course" },
+          },
+        }),
+      }),
+    )
+  }
+  if (programId !== undefined) {
+    lines.push(
+      factories.orders.line({
+        product: factories.orders.product({
+          purchasable_object: {
+            id: programId,
+            title: "Some Program",
+            readable_id: "program-v1:MITxT+SysEng",
+          },
+        }),
+      }),
+    )
+  }
+
+  setMockResponse.get(
+    urls.orders.historyList({ limit: 100 }),
+    factories.orders.orderHistoryList(
+      lines.length > 0
+        ? [
+            factories.orders.orderHistory({
+              id: orderId,
+              state: "fulfilled",
+              lines,
+            }),
+          ]
+        : [],
+    ),
+  )
+
+  return { orderId }
+}
+
 const dashboardCourse: PartialFactory<CourseWithCourseRunsSerializerV2> = (
   ...overrides
 ) => {
@@ -563,6 +624,7 @@ const buildProgramScenario = (
 export {
   dashboardCourse,
   dashboardProgram,
+  setupOrderHistory,
   setupEnrollments,
   setupProgramsAndCourses,
   setupOrgAndUser,
diff --git a/frontends/main/src/app-pages/ProductPages/CourseEnrollArea.test.tsx b/frontends/main/src/app-pages/ProductPages/CourseEnrollArea.test.tsx
index 29b610389a..62fd2c0002 100644
--- a/frontends/main/src/app-pages/ProductPages/CourseEnrollArea.test.tsx
+++ b/frontends/main/src/app-pages/ProductPages/CourseEnrollArea.test.tsx
@@ -43,6 +43,9 @@ const makeUser = factories.user.user
 function setupAuth() {
   setMockResponse.get(urls.userMe.get(), makeUser({ is_authenticated: true }))
   setMockResponse.get(mitxUrls.enrollment.enrollmentsListV3(), [])
+  // Clicking enroll consults the MITx Online profile through the compliance
+  // gate; the factory default has nothing missing, so it passes straight through.
+  setMockResponse.get(mitxUrls.userMe.get(), mitxFactories.user.user())
 }
 
 describe("CourseEnrollArea — both scenario", () => {
diff --git a/frontends/main/src/app-pages/ProductPages/CoursePage.test.tsx b/frontends/main/src/app-pages/ProductPages/CoursePage.test.tsx
index 02f591abc2..cb47b28782 100644
--- a/frontends/main/src/app-pages/ProductPages/CoursePage.test.tsx
+++ b/frontends/main/src/app-pages/ProductPages/CoursePage.test.tsx
@@ -118,6 +118,9 @@ const setupApis = ({
     learnUrls.userMe.get(),
     learnFactories.user.user({ is_authenticated: false }),
   )
+  // Clicking enroll consults the MITx Online profile through the compliance
+  // gate; the factory default has nothing missing, so it passes straight through.
+  setMockResponse.get(mitxUrls.userMe.get(), mitxFactories.user.user())
 
   const stayUpdatedFormId =
     process.env.NEXT_PUBLIC_STAY_UPDATED_HUBSPOT_FORM_ID?.trim()
diff --git a/frontends/main/src/app-pages/ProductPages/ProgramAsCoursePage.test.tsx b/frontends/main/src/app-pages/ProductPages/ProgramAsCoursePage.test.tsx
index e4ebe0b85b..a641dfb798 100644
--- a/frontends/main/src/app-pages/ProductPages/ProgramAsCoursePage.test.tsx
+++ b/frontends/main/src/app-pages/ProductPages/ProgramAsCoursePage.test.tsx
@@ -102,6 +102,9 @@ const setupApis = ({
     learnUrls.userMe.get(),
     learnFactories.user.user({ is_authenticated: false }),
   )
+  // Clicking enroll consults the MITx Online profile through the compliance
+  // gate; the factory default has nothing missing, so it passes straight through.
+  setMockResponse.get(urls.userMe.get(), factories.user.user())
 
   const stayUpdatedFormId =
     process.env.NEXT_PUBLIC_STAY_UPDATED_HUBSPOT_FORM_ID?.trim()
diff --git a/frontends/main/src/app-pages/ProductPages/ProgramHeaderEnrollButton.test.tsx b/frontends/main/src/app-pages/ProductPages/ProgramHeaderEnrollButton.test.tsx
index 447af40e91..7f7a8d9350 100644
--- a/frontends/main/src/app-pages/ProductPages/ProgramHeaderEnrollButton.test.tsx
+++ b/frontends/main/src/app-pages/ProductPages/ProgramHeaderEnrollButton.test.tsx
@@ -30,6 +30,9 @@ const makeUser = factories.user.user
 function setupAuth() {
   setMockResponse.get(urls.userMe.get(), makeUser({ is_authenticated: true }))
   setMockResponse.get(mitxUrls.programEnrollments.enrollmentsListV3(), [])
+  // Clicking enroll consults the MITx Online profile through the compliance
+  // gate; the factory default has nothing missing, so it passes straight through.
+  setMockResponse.get(mitxUrls.userMe.get(), mitxFactories.user.user())
 }
 
 describe("ProgramHeaderEnrollButton", () => {
diff --git a/frontends/main/src/app-pages/ProductPages/useCourseEnrollment.test.tsx b/frontends/main/src/app-pages/ProductPages/useCourseEnrollment.test.tsx
index 44061a9c97..11a04b621b 100644
--- a/frontends/main/src/app-pages/ProductPages/useCourseEnrollment.test.tsx
+++ b/frontends/main/src/app-pages/ProductPages/useCourseEnrollment.test.tsx
@@ -345,6 +345,10 @@ describe("useCourseEnrollment — actions", () => {
     process.env.NEXT_PUBLIC_POSTHOG_API_KEY = "test-key"
     setMockResponse.get(urls.userMe.get(), makeUser({ is_authenticated: true }))
     setMockResponse.get(mitxUrls.enrollment.enrollmentsListV3(), [])
+    // Enrolling now consults the MITx Online profile through the compliance
+    // gate. The factory default has nothing missing, so it passes straight
+    // through; see JustInTimeDialog tests for the blocked case.
+    setMockResponse.get(mitxUrls.userMe.get(), mitxFactories.user.user())
   })
 
   afterEach(() => {
diff --git a/frontends/main/src/app-pages/ProductPages/useCourseEnrollment.ts b/frontends/main/src/app-pages/ProductPages/useCourseEnrollment.ts
index 196244e8c7..5d656c881c 100644
--- a/frontends/main/src/app-pages/ProductPages/useCourseEnrollment.ts
+++ b/frontends/main/src/app-pages/ProductPages/useCourseEnrollment.ts
@@ -6,6 +6,7 @@ import type {
 import { userQueries } from "api/hooks/user"
 import { useCreateEnrollment } from "api/mitxonline-hooks/enrollment"
 import { useReplaceBasketItem } from "@/common/mitxonline/useReplaceBasketItem"
+import { useComplianceGate } from "@/common/mitxonline/useComplianceGate"
 import { enrollmentAlertSuccessUrl } from "@/common/mitxonline"
 import { useRouter } from "next-nprogress-bar"
 import { usePostHog } from "posthog-js/react"
@@ -63,6 +64,9 @@ export const useCourseEnrollment = (
   const createEnrollment = useCreateEnrollment()
   const router = useRouter()
   const posthog = usePostHog()
+  // Paid enrollments are gated inside useReplaceBasketItem; the free track
+  // calls the enrollment endpoint directly and so gates here.
+  const { ensureCompliance } = useComplianceGate()
 
   const isEnrolledInSelected =
     selectedRun !== undefined && enrolledRunIds.includes(selectedRun.id)
@@ -82,7 +86,7 @@ export const useCourseEnrollment = (
 
   const makeOnClick =
     (kind: EnrollActionKind, label: string): EnrollAction["onClick"] =>
-    (e) => {
+    async (e) => {
       fireEnrollCta(posthog, {
         placement: opts?.tracking.placement,
         kind,
@@ -103,6 +107,7 @@ export const useCourseEnrollment = (
         }
       } else if (kind === "free") {
         if (selectedRun) {
+          if (!(await ensureCompliance())) return
           createEnrollment.mutate(
             { run_id: selectedRun.id },
             {
diff --git a/frontends/main/src/app-pages/ProductPages/useProgramEnrollment.test.tsx b/frontends/main/src/app-pages/ProductPages/useProgramEnrollment.test.tsx
index 1fa826f4f9..efd0a592b9 100644
--- a/frontends/main/src/app-pages/ProductPages/useProgramEnrollment.test.tsx
+++ b/frontends/main/src/app-pages/ProductPages/useProgramEnrollment.test.tsx
@@ -221,6 +221,10 @@ describe("useProgramEnrollment — actions", () => {
   beforeEach(() => {
     jest.clearAllMocks()
     process.env.NEXT_PUBLIC_POSTHOG_API_KEY = "test-key"
+    // Enrolling now consults the MITx Online profile through the compliance
+    // gate. The factory default has nothing missing, so it passes straight
+    // through; see JustInTimeDialog tests for the blocked case.
+    setMockResponse.get(mitxUrls.userMe.get(), mitxFactories.user.user())
   })
 
   afterEach(() => {
diff --git a/frontends/main/src/app-pages/ProductPages/useProgramEnrollment.ts b/frontends/main/src/app-pages/ProductPages/useProgramEnrollment.ts
index d4a18a9cda..079eaccb43 100644
--- a/frontends/main/src/app-pages/ProductPages/useProgramEnrollment.ts
+++ b/frontends/main/src/app-pages/ProductPages/useProgramEnrollment.ts
@@ -3,6 +3,7 @@ import type { V2ProgramDetail } from "@mitodl/mitxonline-api-axios/v2"
 import { userQueries } from "api/hooks/user"
 import { useCreateProgramEnrollment } from "api/mitxonline-hooks/enrollment"
 import { useReplaceBasketItem } from "@/common/mitxonline/useReplaceBasketItem"
+import { useComplianceGate } from "@/common/mitxonline/useComplianceGate"
 import { enrollmentAlertSuccessUrl } from "@/common/mitxonline"
 import { useRouter } from "next-nprogress-bar"
 import { usePostHog } from "posthog-js/react"
@@ -51,6 +52,9 @@ export const useProgramEnrollment = (
   const createProgramEnrollment = useCreateProgramEnrollment()
   const router = useRouter()
   const posthog = usePostHog()
+  // Paid enrollments are gated inside useReplaceBasketItem; the free track
+  // calls the enrollment endpoint directly and so gates here.
+  const { ensureCompliance } = useComplianceGate()
 
   const offering = getProgramOffering(program)
 
@@ -64,7 +68,7 @@ export const useProgramEnrollment = (
 
   const makeOnClick =
     (kind: EnrollActionKind, label: string): EnrollAction["onClick"] =>
-    (e) => {
+    async (e) => {
       // Same event as the course hook; `resourceType: "program"` distinguishes
       // program CTA clicks (including program-as-course display).
       fireEnrollCta(posthog, {
@@ -84,6 +88,7 @@ export const useProgramEnrollment = (
           replaceBasketItem.mutate(product.id)
         }
       } else if (kind === "free") {
+        if (!(await ensureCompliance())) return
         createProgramEnrollment.mutate(
           { V3ProgramEnrollmentRequestRequest: { program_id: program.id } },
           {
diff --git a/frontends/main/src/app-pages/ReceiptPage/ReceiptCard.tsx b/frontends/main/src/app-pages/ReceiptPage/ReceiptCard.tsx
new file mode 100644
index 0000000000..2150475fa3
--- /dev/null
+++ b/frontends/main/src/app-pages/ReceiptPage/ReceiptCard.tsx
@@ -0,0 +1,48 @@
+import { styled } from "ol-components"
+
+/**
+ * The white card the receipt is built from. Shared so the summary, the detail
+ * sections and the issuer block stay in step.
+ *
+ * `cardshadow` in the design system is `0 4px 8px #13141514`.
+ */
+const ReceiptCard = styled.div(({ theme }) => ({
+  display: "flex",
+  flexDirection: "column",
+  gap: "24px",
+  padding: "32px",
+  borderRadius: "4px",
+  backgroundColor: theme.custom.colors.white,
+  boxShadow: "0 4px 8px 0 rgba(19, 20, 21, 0.08)",
+  [theme.breakpoints.down("sm")]: {
+    gap: "12px",
+    padding: "16px",
+  },
+}))
+
+/**
+ * The Order / Customer / Payment cards read as one block: a 1px gap shows the
+ * seams while only the outer corners are rounded.
+ *
+ * Uses `:first-of-type` / `:last-of-type` rather than the child index because a
+ * section is omitted entirely when the API supplied none of its fields.
+ */
+const ReceiptCardStack = styled.div({
+  display: "flex",
+  flexDirection: "column",
+  gap: "1px",
+  width: "100%",
+  "> *": {
+    borderRadius: 0,
+  },
+  "> *:first-of-type": {
+    borderTopLeftRadius: "4px",
+    borderTopRightRadius: "4px",
+  },
+  "> *:last-of-type": {
+    borderBottomLeftRadius: "4px",
+    borderBottomRightRadius: "4px",
+  },
+})
+
+export { ReceiptCard, ReceiptCardStack }
diff --git a/frontends/main/src/app-pages/ReceiptPage/ReceiptDetailList.tsx b/frontends/main/src/app-pages/ReceiptPage/ReceiptDetailList.tsx
new file mode 100644
index 0000000000..5e71945b67
--- /dev/null
+++ b/frontends/main/src/app-pages/ReceiptPage/ReceiptDetailList.tsx
@@ -0,0 +1,86 @@
+import React from "react"
+import { styled } from "ol-components"
+
+/** A label/value pair. A nullish `value` means the row is dropped. */
+type ReceiptDetail = {
+  label: string
+  value: React.ReactNode
+}
+
+const Rows = styled.dl({
+  display: "flex",
+  flexDirection: "column",
+  gap: "16px",
+  width: "100%",
+  margin: 0,
+})
+
+/** `dl > div` wrapping a dt/dd pair is the standard grouping form. */
+const Row = styled.div({
+  display: "flex",
+  gap: "10px",
+  alignItems: "flex-start",
+})
+
+/**
+ * Fixed-width label column, so values line up down the card without needing a
+ * grid. It narrows on mobile to leave the value room to wrap rather than truncate.
+ */
+const Label = styled.dt(({ theme }) => ({
+  ...theme.typography.body2,
+  fontWeight: theme.typography.fontWeightBold,
+  flexShrink: 0,
+  width: "200px",
+  margin: 0,
+  [theme.breakpoints.down("sm")]: {
+    ...theme.typography.body3,
+    fontWeight: theme.typography.fontWeightBold,
+    width: "104px",
+  },
+}))
+
+const Value = styled.dd(({ theme }) => ({
+  ...theme.typography.body2,
+  flex: "1 0 0",
+  minWidth: 0,
+  margin: 0,
+  wordBreak: "break-word",
+  [theme.breakpoints.down("sm")]: {
+    ...theme.typography.body3,
+  },
+}))
+
+/**
+ * Drop rows the API did not supply, so callers can tell whether a section has any
+ * content left and skip rendering it along with its heading. MITx Online leaves
+ * optional receipt fields unset rather than blank, and an order with no payment
+ * transaction has every payment and address field null.
+ */
+const populatedRows = (rows: ReceiptDetail[]): ReceiptDetail[] =>
+  rows.filter(
+    ({ value }) => value !== null && value !== undefined && value !== "",
+  )
+
+/**
+ * The label/value rows inside a receipt card. Renders nothing when every row was
+ * filtered out; see {@link populatedRows}.
+ */
+const ReceiptDetailList: React.FC<{
+  rows: ReceiptDetail[]
+  className?: string
+}> = ({ rows, className }) => (
+  <Rows className={className}>
+    {populatedRows(rows).map(({ label, value }, index) => (
+      // Labels repeat when an order has more than one line, so position is the
+      // only unique key available.
+      // eslint-disable-next-line react/no-array-index-key
+      <Row key={`${label}-${index}`}>
+        <Label>{label}</Label>
+        <Value>{value}</Value>
+      </Row>
+    ))}
+  </Rows>
+)
+
+export { ReceiptDetailList, populatedRows }
+export type { ReceiptDetail }
diff --git a/frontends/main/src/app-pages/ReceiptPage/ReceiptOrderSummary.tsx b/frontends/main/src/app-pages/ReceiptPage/ReceiptOrderSummary.tsx
new file mode 100644
index 0000000000..efeed02953
--- /dev/null
+++ b/frontends/main/src/app-pages/ReceiptPage/ReceiptOrderSummary.tsx
@@ -0,0 +1,165 @@
+import React from "react"
+import { styled } from "ol-components"
+import { StateEnum } from "@mitodl/mitxonline-api-axios/v2"
+import type { Order } from "@mitodl/mitxonline-api-axios/v2"
+import { ReceiptCard } from "./ReceiptCard"
+import { formatMoney, formatReceiptDate } from "./receiptUtils"
+
+const SummaryCard = styled(ReceiptCard)(({ theme }) => ({
+  gap: "20px",
+  [theme.breakpoints.down("sm")]: {
+    gap: "12px",
+  },
+}))
+
+/** The heading and the total share a size; only the section headings are red. */
+const Heading = styled.h2(({ theme }) => ({
+  ...theme.typography.h5,
+  color: theme.custom.colors.darkGray2,
+  margin: 0,
+  [theme.breakpoints.down("sm")]: theme.typography.subtitle1,
+}))
+
+const Rows = styled.div({
+  display: "flex",
+  flexDirection: "column",
+  gap: "16px",
+})
+
+const Row = styled.div({
+  display: "flex",
+  gap: "16px",
+  alignItems: "flex-start",
+  justifyContent: "space-between",
+})
+
+const RowLabel = styled.span(({ theme }) => ({
+  ...theme.typography.body2,
+  fontWeight: theme.typography.fontWeightBold,
+  color: theme.custom.colors.darkGray2,
+  [theme.breakpoints.down("sm")]: {
+    ...theme.typography.body3,
+    fontWeight: theme.typography.fontWeightBold,
+  },
+}))
+
+const RowValue = styled.span(({ theme }) => ({
+  ...theme.typography.body2,
+  color: theme.custom.colors.darkGray2,
+  textAlign: "right",
+  whiteSpace: "nowrap",
+  [theme.breakpoints.down("sm")]: {
+    ...theme.typography.body3,
+  },
+}))
+
+const DiscountValue = styled(RowValue)(({ theme }) => ({
+  color: theme.custom.colors.green,
+}))
+
+const RefundLabel = styled(RowLabel)(({ theme }) => ({
+  color: theme.custom.colors.red,
+}))
+
+const RefundValue = styled(RowValue)(({ theme }) => ({
+  color: theme.custom.colors.red,
+}))
+
+const TotalRow = styled(Row)(({ theme }) => ({
+  ...theme.typography.h5,
+  color: theme.custom.colors.darkGray2,
+  borderTop: `1px solid ${theme.custom.colors.lightGray2}`,
+  paddingTop: "24px",
+  [theme.breakpoints.down("sm")]: theme.typography.subtitle1,
+}))
+
+/** `line.discount` is per unit, hence the multiply. */
+const getTotalDiscount = (order: Order): number =>
+  order.lines.reduce(
+    (total, line) => total + Number(line.discount) * line.quantity,
+    0,
+  )
+
+const getTotalQuantity = (order: Order): number =>
+  order.lines.reduce((total, line) => total + line.quantity, 0)
+
+const isRefundedState = (state: Order["state"]): boolean =>
+  state === StateEnum.Refunded || state === StateEnum.PartiallyRefunded
+
+/**
+ * One row per refund, so a refunded order does not read as a plain paid receipt.
+ * `total_price_paid` is stamped at fulfillment and a refund never reduces it, so
+ * the total below stays at the amount charged.
+ *
+ * Refunds normally come from refund transactions, but the
+ * `refund_fulfilled_order` management command flips an order's state without
+ * writing one — hence the state fallback, which has no amount to show.
+ */
+const getRefundRows = (order: Order): { label: string; amount?: number }[] => {
+  if (order.refunds.length > 0) {
+    return order.refunds.map((refund) => ({
+      label: refund.date
+        ? `Refund applied (${formatReceiptDate(refund.date)})`
+        : "Refund applied",
+      amount: refund.amount,
+    }))
+  }
+  return isRefundedState(order.state) ? [{ label: "Refund applied" }] : []
+}
+
+/**
+ * Per-item prices, discount and quantity totals, and the amount paid. The
+ * design's "Tax" and "Total Before Tax" rows are omitted — the payload has no tax
+ * data, so "Total Before Tax" would just restate the total.
+ */
+const ReceiptOrderSummary: React.FC<{ order: Order; className?: string }> = ({
+  order,
+  className,
+}) => {
+  const totalDiscount = getTotalDiscount(order)
+  const totalQuantity = getTotalQuantity(order)
+
+  return (
+    <SummaryCard className={className}>
+      <Heading>Order Summary</Heading>
+      <Rows>
+        {order.lines.map((line, index) => (
+          // Receipt lines carry no id, and the same product can legitimately
+          // appear twice, so position is the only stable key available.
+          // eslint-disable-next-line react/no-array-index-key
+          <Row key={`${line.readable_id}-${index}`}>
+            <RowLabel>{line.content_title}</RowLabel>
+            <RowValue>{formatMoney(line.price)}</RowValue>
+          </Row>
+        ))}
+        {totalDiscount > 0 ? (
+          <Row>
+            <RowLabel>Discount</RowLabel>
+            <DiscountValue>{`- ${formatMoney(totalDiscount)}`}</DiscountValue>
+          </Row>
+        ) : null}
+        <Row>
+          <RowLabel>Quantity</RowLabel>
+          <RowValue>{`x ${totalQuantity}`}</RowValue>
+        </Row>
+        {getRefundRows(order).map(({ label, amount }, index) => (
+          // An order can carry several refunds and nothing identifies them, so
+          // position is the only stable key available.
+          // eslint-disable-next-line react/no-array-index-key
+          <Row key={`${label}-${index}`}>
+            <RefundLabel>{label}</RefundLabel>
+            {amount === undefined ? null : (
+              <RefundValue>{`- ${formatMoney(amount)}`}</RefundValue>
+            )}
+          </Row>
+        ))}
+      </Rows>
+      <TotalRow>
+        <span>Total:</span>
+        <span>{formatMoney(order.total_price_paid)}</span>
+      </TotalRow>
+    </SummaryCard>
+  )
+}
+
+export { ReceiptOrderSummary, getTotalDiscount, getTotalQuantity }
diff --git a/frontends/main/src/app-pages/ReceiptPage/ReceiptPage.test.tsx b/frontends/main/src/app-pages/ReceiptPage/ReceiptPage.test.tsx
new file mode 100644
index 0000000000..158bda8180
--- /dev/null
+++ b/frontends/main/src/app-pages/ReceiptPage/ReceiptPage.test.tsx
@@ -0,0 +1,552 @@
+import React from "react"
+import {
+  renderWithProviders,
+  screen,
+  setMockResponse,
+  user,
+  within,
+} from "@/test-utils"
+import * as mitxonline from "api/mitxonline-test-utils"
+import ReceiptPage from "./ReceiptPage"
+import * as urls from "@/common/urls"
+
+const ORDER_ID = 4242
+
+const setupApis = ({
+  order,
+  user,
+}: {
+  order?: ReturnType<typeof mitxonline.factories.orders.order>
+  user?: ReturnType<typeof mitxonline.factories.user.user>
+} = {}) => {
+  const mitxUser = user ?? mitxonline.factories.user.user()
+  const receipt = order ?? mitxonline.factories.orders.order({ id: ORDER_ID })
+  setMockResponse.get(mitxonline.urls.userMe.get(), mitxUser)
+  setMockResponse.get(mitxonline.urls.orders.receipt(ORDER_ID), receipt)
+  return { mitxUser, receipt }
+}
+
+/** Reads a label's value cell within one section, since labels repeat. */
+const findValueFor = async (sectionName: string, label: string) => {
+  const heading = await screen.findByRole("heading", { name: sectionName })
+  // The heading and its detail list are siblings inside the section element.
+  const section = heading.closest("section")
+  if (!section) throw new Error(`No section found for "${sectionName}"`)
+  const term = within(section).getByText(label)
+  const value = term.closest("dt")?.nextElementSibling
+  if (!value) throw new Error(`No value cell found for "${label}"`)
+  return value
+}
+
+describe("ReceiptPage", () => {
+  test("renders order information from the receipt", async () => {
+    const line = mitxonline.factories.orders.transactionLine({
+      content_title: "The Iterative Innovation Process",
+      readable_id: "program-v1:xPRO+SysEngx",
+      start_date: "2024-09-01T00:00:00Z",
+      end_date: "2025-12-24T00:00:00Z",
+      price: "1524.60",
+      quantity: 1,
+      discount: "0.00",
+      CEUs: "20",
+    })
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        lines: [line],
+        reference_number: "xpro-b2c-production-66238",
+        created_on: "2024-06-14T00:00:00Z",
+        total_price_paid: "1524.60",
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await screen.findByRole("heading", { name: "Receipt", level: 1 }),
+    ).toBeInTheDocument()
+
+    expect(
+      await findValueFor("Order Information", "Order Item:"),
+    ).toHaveTextContent("The Iterative Innovation Process")
+    expect(await findValueFor("Order Information", "Dates:")).toHaveTextContent(
+      "September 01, 2024 - December 24, 2025",
+    )
+    expect(
+      await findValueFor("Order Information", "Order Number:"),
+    ).toHaveTextContent("xpro-b2c-production-66238")
+    expect(
+      await findValueFor("Order Information", "Order Date:"),
+    ).toHaveTextContent("June 14, 2024")
+    expect(
+      await findValueFor("Order Information", "Unit Price:"),
+    ).toHaveTextContent("$1,524.60")
+    expect(
+      await findValueFor("Order Information", "Total Paid:"),
+    ).toHaveTextContent("$1,524.60")
+    expect(
+      await findValueFor("Order Information", "Product Number:"),
+    ).toHaveTextContent("program-v1:xPRO+SysEngx")
+    expect(await findValueFor("Order Information", "CEUs:")).toHaveTextContent(
+      "20",
+    )
+  })
+
+  test("formats dates in UTC so they match the recorded order", async () => {
+    // Local formatting would render these a day early.
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        created_on: "2026-07-09T00:00:00Z",
+        lines: [
+          mitxonline.factories.orders.transactionLine({
+            start_date: "2026-07-08T00:00:00Z",
+            end_date: "2027-07-09T00:00:00Z",
+          }),
+        ],
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(await findValueFor("Order Information", "Dates:")).toHaveTextContent(
+      "July 08, 2026 - July 09, 2027",
+    )
+    expect(
+      await findValueFor("Order Information", "Order Date:"),
+    ).toHaveTextContent("July 09, 2026")
+  })
+
+  test("shows only the known end of the range when a run has no end date", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        lines: [
+          mitxonline.factories.orders.transactionLine({
+            start_date: "2026-06-22T00:00:00Z",
+            end_date: null as unknown as string,
+          }),
+        ],
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(await findValueFor("Order Information", "Dates:")).toHaveTextContent(
+      "June 22, 2026",
+    )
+  })
+
+  test("shows cents on whole-dollar amounts", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        lines: [
+          mitxonline.factories.orders.transactionLine({ price: "500.00" }),
+        ],
+        total_price_paid: "500.00",
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await findValueFor("Order Information", "Unit Price:"),
+    ).toHaveTextContent("$500.00")
+  })
+
+  test("takes the customer name and email from the MITx Online user", async () => {
+    const { mitxUser } = setupApis({
+      user: mitxonline.factories.user.user({
+        name: "Peter Pinch",
+        email: "pdpinch@mit.edu",
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await findValueFor("Customer Information", "Name:"),
+    ).toHaveTextContent(mitxUser.name!)
+    expect(
+      await findValueFor("Customer Information", "Email:"),
+    ).toHaveTextContent("pdpinch@mit.edu")
+  })
+
+  test("renders the billing address as a single line", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        street_address: {
+          line: ["123 Main Street"],
+          city: "Danvers",
+          state: "MA",
+          postal_code: "01923",
+          country: "US",
+        },
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await findValueFor("Customer Information", "Address:"),
+    ).toHaveTextContent("123 Main Street, Danvers MA, 01923, US")
+  })
+
+  test("renders card payment details", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        transactions: {
+          payment_method: "card",
+          card_type: "Visa",
+          card_number: "xxxxxxxxxxxx1111",
+          name: "Peter Pinch",
+        },
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await findValueFor("Payment Information", "Payment Method:"),
+    ).toHaveTextContent("Visa | xxxxxxxxxxxx1111")
+    expect(
+      await findValueFor("Payment Information", "Name:"),
+    ).toHaveTextContent("Peter Pinch")
+  })
+
+  test("renders Paypal payments without card details", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        transactions: {
+          payment_method: "paypal",
+          bill_to_email: "pdpinch@mit.edu",
+          name: "Peter Pinch",
+        },
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await findValueFor("Payment Information", "Payment Method:"),
+    ).toHaveTextContent("PayPal")
+  })
+
+  // Parity with the MITx Online receipt, which shows the payer's email for PayPal
+  // orders in place of card details.
+  test("shows the payer email for Paypal orders", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        transactions: {
+          payment_method: "paypal",
+          bill_to_email: "payer@example.com",
+          name: "Peter Pinch",
+        },
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await findValueFor("Payment Information", "Email:"),
+    ).toHaveTextContent("payer@example.com")
+  })
+
+  // Parity: MITx Online shows a per-line total. It is redundant on a single-line
+  // order, where it equals the order total shown below.
+  test("omits the per-line total on a single-line order", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        lines: [mitxonline.factories.orders.transactionLine()],
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    await screen.findByRole("heading", { name: "Order Information" })
+    expect(screen.queryByText("Line Total:")).not.toBeInTheDocument()
+  })
+
+  test("shows a per-line total when the order has multiple lines", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        lines: [
+          mitxonline.factories.orders.transactionLine({ total_paid: "100.00" }),
+          mitxonline.factories.orders.transactionLine({ total_paid: "250.00" }),
+        ],
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    await screen.findByRole("heading", { name: "Order Information" })
+    expect(screen.getAllByText("Line Total:")).toHaveLength(2)
+    expect(screen.getByText("$100.00")).toBeInTheDocument()
+    expect(screen.getByText("$250.00")).toBeInTheDocument()
+  })
+
+  test("shows the discount code when one was redeemed", async () => {
+    const discountCode = "30468acf5a4e4c3c9c31a262caf984c9" // pragma: allowlist secret
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        discounts: [
+          mitxonline.factories.orders.redeemedDiscount({
+            discount_code: discountCode,
+          }),
+        ],
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await findValueFor("Order Information", "Discount Code:"),
+    ).toHaveTextContent(discountCode) //
+  })
+
+  test("omits rows the receipt payload does not provide", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        // No discount redeemed and no per-line discount.
+        discounts: [],
+        lines: [
+          mitxonline.factories.orders.transactionLine({
+            discount: "0.00",
+            // MITx Online hardcodes CEUs to null on receipts today.
+            CEUs: null as unknown as string,
+          }),
+        ],
+        street_address: {},
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    await screen.findByRole("heading", { name: "Order Information" })
+
+    expect(screen.queryByText("Discount Code:")).not.toBeInTheDocument()
+    expect(screen.queryByText("Discount:")).not.toBeInTheDocument()
+    expect(screen.queryByText("CEUs:")).not.toBeInTheDocument()
+    expect(screen.getByText("Address:")).toBeInTheDocument() // MIT Learn's own
+    expect(
+      within(
+        (
+          await screen.findByRole("heading", { name: "Customer Information" })
+        ).closest("section")!,
+      ).queryByText("Address:"),
+    ).not.toBeInTheDocument()
+  })
+
+  test("drops the Payment Information section when there is no transaction", async () => {
+    // Matches a real zero-value order: MITx Online returns the
+    // transaction and address objects with every field null.
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        transactions: {
+          card_number: undefined,
+          card_type: undefined,
+          name: undefined,
+          bill_to_email: undefined,
+          payment_method: undefined,
+        },
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    await screen.findByRole("heading", { name: "Order Information" })
+
+    expect(
+      screen.queryByRole("heading", { name: "Payment Information" }),
+    ).not.toBeInTheDocument()
+  })
+
+  test("renders the order summary with total and quantity", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        lines: [
+          mitxonline.factories.orders.transactionLine({
+            content_title: "The Iterative Innovation Process",
+            price: "1524.60",
+            quantity: 2,
+            discount: "10.00",
+          }),
+        ],
+        total_price_paid: "3029.20",
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    const summary = (
+      await screen.findByRole("heading", { name: "Order Summary" })
+    ).closest("div")!
+
+    expect(summary).toHaveTextContent("The Iterative Innovation Process")
+    expect(summary).toHaveTextContent("x 2")
+    // 10.00 per unit × 2 units
+    expect(summary).toHaveTextContent("- $20.00")
+    expect(summary).toHaveTextContent("$3,029.20")
+  })
+
+  test("shows a row per refund, leaving the total at the amount charged", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        state: "partially_refunded",
+        total_price_paid: "1524.60",
+        refunds: [
+          mitxonline.factories.orders.orderRefund({
+            amount: 500,
+            date: "2024-07-02T00:00:00Z",
+          }),
+          mitxonline.factories.orders.orderRefund({
+            amount: 24.6,
+            date: "2024-08-15T00:00:00Z",
+          }),
+        ],
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    const summary = (
+      await screen.findByRole("heading", { name: "Order Summary" })
+    ).closest("div")!
+
+    expect(summary).toHaveTextContent("Refund applied (July 02, 2024)")
+    expect(summary).toHaveTextContent("- $500.00")
+    expect(summary).toHaveTextContent("Refund applied (August 15, 2024)")
+    expect(summary).toHaveTextContent("- $24.60")
+    // total_price_paid is stamped at fulfillment; a refund never reduces it.
+    expect(summary).toHaveTextContent("$1,524.60")
+  })
+
+  // `refund_fulfilled_order` flips the state without writing a refund transaction.
+  test("notes a refund when the state says refunded but no refunds are recorded", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        state: "refunded",
+        refunds: [],
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    const summary = (
+      await screen.findByRole("heading", { name: "Order Summary" })
+    ).closest("div")!
+
+    expect(summary).toHaveTextContent("Refund applied")
+  })
+
+  test("shows no refund row on a fulfilled order", async () => {
+    setupApis({
+      order: mitxonline.factories.orders.order({
+        id: ORDER_ID,
+        state: "fulfilled",
+        refunds: [],
+      }),
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    await screen.findByRole("heading", { name: "Order Summary" })
+
+    expect(screen.queryByText(/Refund applied/)).not.toBeInTheDocument()
+  })
+
+  // Someone else's order 404s like a missing one; both get the generic 404.
+  test("renders the generic 404 when the order is not found or not yours", async () => {
+    setMockResponse.get(
+      mitxonline.urls.userMe.get(),
+      mitxonline.factories.user.user(),
+    )
+    setMockResponse.get(mitxonline.urls.orders.receipt(ORDER_ID), "Not found", {
+      code: 404,
+    })
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(
+      await screen.findByText(/couldn't find what you were looking for/i),
+    ).toBeInTheDocument()
+    expect(
+      screen.queryByText(/We could not load this receipt/i),
+    ).not.toBeInTheDocument()
+  })
+
+  // A 500 says nothing about existence, so it keeps an actionable message.
+  test("keeps an actionable message when the request fails for another reason", async () => {
+    setMockResponse.get(
+      mitxonline.urls.userMe.get(),
+      mitxonline.factories.user.user(),
+    )
+    setMockResponse.get(
+      mitxonline.urls.orders.receipt(ORDER_ID),
+      "Server error",
+      { code: 500 },
+    )
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    // An alert, so the failure is read out rather than silently replacing the
+    // skeleton.
+    expect(await screen.findByRole("alert")).toHaveTextContent(
+      /We could not load this receipt/i,
+    )
+    expect(
+      screen.getByRole("link", { name: "Back to Dashboard" }),
+    ).toHaveAttribute("href", "/dashboard")
+  })
+
+  /**
+   * jsdom starts each test file with a single history entry, matching a receipt
+   * opened directly in a fresh tab.
+   */
+  test("Back goes to the dashboard when there is no history to return to", async () => {
+    setupApis()
+
+    const { location } = renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+    await screen.findByRole("heading", { name: "Order Summary" })
+    await user.click(screen.getByRole("button", { name: "Back" }))
+
+    expect(location.current.pathname).toBe("/dashboard")
+  })
+
+  test("Back uses history when there is somewhere to return to", async () => {
+    setupApis()
+    // A second entry, so history.back() has an effect.
+    window.history.pushState({}, "", urls.receiptView(ORDER_ID))
+
+    const { location } = renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+    await screen.findByRole("heading", { name: "Order Summary" })
+    await user.click(screen.getByRole("button", { name: "Back" }))
+
+    expect(location.current.pathname).not.toBe("/dashboard")
+  })
+
+  test("announces loading and then the loaded receipt", async () => {
+    setupApis()
+
+    renderWithProviders(<ReceiptPage orderId={ORDER_ID} />)
+
+    expect(screen.getByRole("status")).toHaveTextContent("Loading receipt.")
+
+    await screen.findByRole("heading", { name: "Order Summary" })
+
+    expect(screen.getByRole("status")).toHaveTextContent("Receipt loaded.")
+  })
+})
diff --git a/frontends/main/src/app-pages/ReceiptPage/ReceiptPage.tsx b/frontends/main/src/app-pages/ReceiptPage/ReceiptPage.tsx
new file mode 100644
index 0000000000..0bcb19490a
--- /dev/null
+++ b/frontends/main/src/app-pages/ReceiptPage/ReceiptPage.tsx
@@ -0,0 +1,359 @@
+"use client"
+
+import React from "react"
+import Image from "next/image"
+import { useRouter } from "next-nprogress-bar"
+import { useQuery } from "@tanstack/react-query"
+import { RiArrowLeftLine, RiPrinterLine } from "@remixicon/react"
+import { Container, Skeleton, Typography, styled } from "ol-components"
+import { Button, ButtonLink, VisuallyHidden } from "@mitodl/smoot-design"
+import { orderQueries } from "api/mitxonline-hooks/orders"
+import { mitxUserQueries } from "api/mitxonline-hooks/user"
+import type { Order } from "@mitodl/mitxonline-api-axios/v2"
+import type { AxiosError } from "axios"
+import NotFoundPage from "@/app-pages/ErrorPage/NotFoundPage"
+import mitLearnLogo from "@/public/images/mit-learn-logo-black.svg"
+import { env } from "@/env"
+import * as urls from "@/common/urls"
+import { ReceiptCard, ReceiptCardStack } from "./ReceiptCard"
+import { ReceiptDetailList, populatedRows } from "./ReceiptDetailList"
+import type { ReceiptDetail } from "./ReceiptDetailList"
+import { ReceiptOrderSummary } from "./ReceiptOrderSummary"
+import {
+  formatDateRange,
+  formatMoney,
+  formatPaymentMethod,
+  formatReceiptDate,
+  formatStreetAddress,
+  getDiscountCode,
+} from "./receiptUtils"
+
+const SUPPORT_EMAIL = env("NEXT_PUBLIC_MITOL_SUPPORT_EMAIL") || ""
+
+/** MIT Learn's own details — not learner data, not from the API. */
+const MIT_LEARN_ADDRESS =
+  "600 Technology Square, NE49-2000, Cambridge, MA 02139 USA"
+
+const Background = styled.div(({ theme }) => ({
+  backgroundColor: theme.custom.colors.lightGray1,
+  minHeight: "100%",
+}))
+
+const PageContainer = styled(Container)(({ theme }) => ({
+  display: "flex",
+  flexDirection: "column",
+  gap: "24px",
+  paddingTop: "64px",
+  paddingBottom: "64px",
+  [theme.breakpoints.down("sm")]: {
+    paddingTop: "32px",
+    paddingBottom: "32px",
+  },
+}))
+
+const TitleRow = styled.div({
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  gap: "16px",
+})
+
+const PageHeading = styled.h1(({ theme }) => ({
+  ...theme.typography.h3,
+  color: theme.custom.colors.black,
+  margin: 0,
+  [theme.breakpoints.down("sm")]: theme.typography.h5,
+}))
+
+const Actions = styled.div(({ theme }) => ({
+  display: "flex",
+  gap: "32px",
+  flexShrink: 0,
+  [theme.breakpoints.down("sm")]: {
+    gap: "16px",
+  },
+  // Neither button belongs in a printed receipt.
+  "@media print": {
+    display: "none",
+  },
+}))
+
+/**
+ * Two columns on desktop with the summary on the right; one column on mobile with
+ * the summary first. The summary leads in the DOM so mobile needs no reordering,
+ * and desktop places it explicitly in the second column.
+ */
+const Columns = styled.div(({ theme }) => ({
+  display: "grid",
+  gap: "40px",
+  gridTemplateColumns: "minmax(0, 1fr)",
+  alignItems: "start",
+  [theme.breakpoints.up("md")]: {
+    gridTemplateColumns: "minmax(0, 825fr) minmax(0, 411fr)",
+  },
+}))
+
+const SummaryColumn = styled.div(({ theme }) => ({
+  [theme.breakpoints.up("md")]: {
+    gridColumn: 2,
+    gridRow: 1,
+  },
+}))
+
+const DetailColumn = styled.div(({ theme }) => ({
+  display: "flex",
+  flexDirection: "column",
+  gap: "16px",
+  [theme.breakpoints.up("md")]: {
+    gridColumn: 1,
+    gridRow: 1,
+  },
+}))
+
+const SectionHeading = styled.h2(({ theme }) => ({
+  ...theme.typography.h5,
+  color: theme.custom.colors.red,
+  margin: 0,
+  [theme.breakpoints.down("sm")]: theme.typography.subtitle1,
+}))
+
+const IssuerCard = styled(ReceiptCard)({
+  padding: "32px",
+})
+
+const IssuerLogo = styled(Image)(({ theme }) => ({
+  display: "block",
+  alignSelf: "flex-start",
+  width: "auto",
+  height: "34px",
+  [theme.breakpoints.down("sm")]: {
+    height: "24px",
+  },
+}))
+
+const SupportLink = styled.a(({ theme }) => ({
+  color: theme.custom.colors.red,
+  textDecoration: "none",
+  ":hover": {
+    textDecoration: "underline",
+  },
+}))
+
+const ErrorState = styled.div({
+  display: "flex",
+  flexDirection: "column",
+  alignItems: "flex-start",
+  gap: "16px",
+})
+
+/**
+ * One group of rows per line item, then the order-level rows. The design's "Tax"
+ * and "HSN" rows are omitted — the payload has no such fields. "CEUs" is wired up
+ * but MITx Online always returns null for it today.
+ */
+const getOrderDetailRows = (order: Order): ReceiptDetail[] => [
+  ...order.lines.flatMap((line) => [
+    { label: "Order Item:", value: line.content_title },
+    { label: "Dates:", value: formatDateRange(line.start_date, line.end_date) },
+    { label: "Product Number:", value: line.readable_id },
+    { label: "CEUs:", value: line.CEUs },
+    { label: "Unit Price:", value: formatMoney(line.price) },
+    { label: "Quantity:", value: line.quantity },
+    {
+      label: "Discount:",
+      value:
+        Number(line.discount) > 0 ? `-${formatMoney(line.discount)}` : null,
+    },
+    {
+      // Per-line total, as the MITx Online receipt shows. Omitted for a
+      // single-line order, where it just restates the order total below.
+      label: "Line Total:",
+      value: order.lines.length > 1 ? formatMoney(line.total_paid) : null,
+    },
+  ]),
+  { label: "Order Number:", value: order.reference_number },
+  { label: "Order Date:", value: formatReceiptDate(order.created_on) },
+  { label: "Discount Code:", value: getDiscountCode(order) },
+  { label: "Total Paid:", value: formatMoney(order.total_price_paid) },
+]
+
+const ReceiptSkeleton: React.FC = () => (
+  <DetailColumn>
+    <Skeleton variant="rectangular" width="100%" height={280} />
+    <Skeleton variant="rectangular" width="100%" height={120} />
+  </DetailColumn>
+)
+
+const ReceiptPage: React.FC<{ orderId: number }> = ({ orderId }) => {
+  const router = useRouter()
+  const orderQuery = useQuery(orderQueries.receipt(orderId))
+  /**
+   * `Order.purchaser` has no name field. The endpoint only returns the requester's
+   * own orders, so the logged-in user is the purchaser.
+   */
+  const userQuery = useQuery(mitxUserQueries.me())
+
+  const order = orderQuery.data
+  const user = userQuery.data
+
+  /**
+   * Filtered up front so a section with no rows can be dropped along with its
+   * heading — zero-value orders have no payment or billing details at all.
+   */
+  const customerRows = order
+    ? populatedRows([
+        { label: "Name:", value: user?.name },
+        { label: "Email:", value: user?.email },
+        { label: "Address:", value: formatStreetAddress(order.street_address) },
+      ])
+    : []
+
+  const paymentRows = order
+    ? populatedRows([
+        { label: "Name:", value: order.transactions?.name },
+        // PayPal orders carry the payer's email instead of card details.
+        { label: "Email:", value: order.transactions?.bill_to_email },
+        { label: "Payment Method:", value: formatPaymentMethod(order) },
+      ])
+    : []
+
+  /**
+   * The endpoint is purchaser-scoped, so someone else's order 404s just like a
+   * missing one. Both get the generic 404 so a prober cannot tell them apart.
+   * Other failures keep the message below, since they say nothing about whether
+   * the order exists.
+   */
+  const isNotFound =
+    !orderQuery.isPending &&
+    (orderQuery.error as AxiosError | null)?.response?.status === 404
+
+  if (isNotFound) {
+    return <NotFoundPage />
+  }
+
+  /**
+   * `router.back()` is `history.back()`, which does nothing when the receipt is the
+   * tab's only entry — a bookmarked or newly opened link. Real history is still
+   * preferred, since it returns to the dashboard with its scroll position intact.
+   */
+  const handleBack = () => {
+    if (window.history.length > 1) {
+      router.back()
+    } else {
+      router.push(urls.DASHBOARD_HOME)
+    }
+  }
+
+  /**
+   * The heading and buttons render before the receipt does, and skeletons carry no
+   * ARIA, so the swap needs announcing. Failure is left to `ErrorState`, which is
+   * an assertive live region of its own.
+   */
+  const statusMessage = orderQuery.isPending
+    ? "Loading receipt."
+    : order
+      ? "Receipt loaded."
+      : null
+
+  return (
+    <Background>
+      <PageContainer>
+        <VisuallyHidden role="status" aria-live="polite" aria-atomic="true">
+          {statusMessage}
+        </VisuallyHidden>
+
+        <TitleRow>
+          <PageHeading>Receipt</PageHeading>
+          <Actions>
+            <Button
+              variant="tertiary"
+              startIcon={<RiArrowLeftLine />}
+              onClick={handleBack}
+            >
+              Back
+            </Button>
+            <Button
+              variant="tertiary"
+              startIcon={<RiPrinterLine />}
+              onClick={() => window.print()}
+            >
+              Print
+            </Button>
+          </Actions>
+        </TitleRow>
+
+        {orderQuery.isPending ? (
+          <ReceiptSkeleton />
+        ) : orderQuery.isError || !order ? (
+          <ErrorState role="alert">
+            <Typography variant="body1">
+              We could not load this receipt.{" "}
+              {SUPPORT_EMAIL ? (
+                <>
+                  <SupportLink href={`mailto:${SUPPORT_EMAIL}`}>
+                    Contact support
+                  </SupportLink>{" "}
+                  if the problem persists.
+                </>
+              ) : (
+                "Please try again in a moment."
+              )}
+            </Typography>
+            <ButtonLink variant="secondary" href={urls.DASHBOARD_HOME}>
+              Back to Dashboard
+            </ButtonLink>
+          </ErrorState>
+        ) : (
+          <Columns>
+            <SummaryColumn>
+              <ReceiptOrderSummary order={order} />
+            </SummaryColumn>
+
+            <DetailColumn>
+              <ReceiptCardStack>
+                <ReceiptCard as="section">
+                  <SectionHeading>Order Information</SectionHeading>
+                  <ReceiptDetailList rows={getOrderDetailRows(order)} />
+                </ReceiptCard>
+
+                {customerRows.length > 0 ? (
+                  <ReceiptCard as="section">
+                    <SectionHeading>Customer Information</SectionHeading>
+                    <ReceiptDetailList rows={customerRows} />
+                  </ReceiptCard>
+                ) : null}
+
+                {paymentRows.length > 0 ? (
+                  <ReceiptCard as="section">
+                    <SectionHeading>Payment Information</SectionHeading>
+                    <ReceiptDetailList rows={paymentRows} />
+                  </ReceiptCard>
+                ) : null}
+              </ReceiptCardStack>
+
+              <IssuerCard as="section">
+                <IssuerLogo src={mitLearnLogo} alt="MIT Learn" />
+                <ReceiptDetailList
+                  rows={[
+                    { label: "Address:", value: MIT_LEARN_ADDRESS },
+                    {
+                      label: "Support:",
+                      value: SUPPORT_EMAIL ? (
+                        <SupportLink href={`mailto:${SUPPORT_EMAIL}`}>
+                          {SUPPORT_EMAIL}
+                        </SupportLink>
+                      ) : null,
+                    },
+                  ]}
+                />
+              </IssuerCard>
+            </DetailColumn>
+          </Columns>
+        )}
+      </PageContainer>
+    </Background>
+  )
+}
+
+export default ReceiptPage
+export { getOrderDetailRows }
diff --git a/frontends/main/src/app-pages/ReceiptPage/ReceiptRedirect.test.tsx b/frontends/main/src/app-pages/ReceiptPage/ReceiptRedirect.test.tsx
new file mode 100644
index 0000000000..a2800e2298
--- /dev/null
+++ b/frontends/main/src/app-pages/ReceiptPage/ReceiptRedirect.test.tsx
@@ -0,0 +1,266 @@
+import React from "react"
+import {
+  renderWithProviders,
+  screen,
+  setMockResponse,
+  waitFor,
+} from "@/test-utils"
+import * as mitxonline from "api/mitxonline-test-utils"
+import { receiptView } from "@/common/urls"
+import {
+  ReceiptByProgramRedirect,
+  ReceiptByRunRedirect,
+} from "./ReceiptRedirect"
+
+const RUN_ID = 500
+const PROGRAM_ID = 99
+const ORDER_ID = 4242
+
+/** Must match the hook's request exactly, params included. */
+const HISTORY_URL = mitxonline.urls.orders.historyList({ limit: 100 })
+
+/** Course run: the only variant with `course`. */
+const courseRunLine = (runId: number) =>
+  mitxonline.factories.orders.line({
+    product: mitxonline.factories.orders.product({
+      purchasable_object: {
+        id: runId,
+        title: "Some Run",
+        readable_id: "course-v1:MITxT+1.234",
+        course: { id: 7, title: "Some Course" },
+      },
+    }),
+  })
+
+/** Program: neither `course` nor `run_tag`. */
+const programLine = (programId: number) =>
+  mitxonline.factories.orders.line({
+    product: mitxonline.factories.orders.product({
+      purchasable_object: {
+        id: programId,
+        title: "Some Program",
+        readable_id: "program-v1:MITxT+SysEng",
+      },
+    }),
+  })
+
+/** Program run: has `run_tag`, and its `id` is the run's, not the program's. */
+const programRunLine = (programRunId: number) =>
+  mitxonline.factories.orders.line({
+    product: mitxonline.factories.orders.product({
+      purchasable_object: {
+        id: programRunId,
+        run_tag: "R1",
+        start_date: "2024-09-01T00:00:00Z",
+        end_date: "2025-12-24T00:00:00Z",
+      },
+    }),
+  })
+
+describe("ReceiptByRunRedirect", () => {
+  test("redirects to the receipt for the order that paid for the run", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          id: ORDER_ID,
+          state: "fulfilled",
+          lines: [courseRunLine(RUN_ID)],
+        }),
+      ]),
+    )
+
+    const { location } = renderWithProviders(
+      <ReceiptByRunRedirect runId={RUN_ID} />,
+    )
+
+    await waitFor(() => {
+      expect(location.current.pathname).toBe(receiptView(ORDER_ID))
+    })
+  })
+
+  test("announces loading and then the redirect", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          id: ORDER_ID,
+          state: "fulfilled",
+          lines: [courseRunLine(RUN_ID)],
+        }),
+      ]),
+    )
+
+    renderWithProviders(<ReceiptByRunRedirect runId={RUN_ID} />)
+
+    expect(screen.getByRole("status")).toHaveTextContent("Loading receipt.")
+
+    await waitFor(() => {
+      expect(screen.getByRole("status")).toHaveTextContent(
+        "Receipt found. Redirecting.",
+      )
+    })
+  })
+
+  test("picks the most recent matching order", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      // MITx Online returns order history most-recent-first.
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          id: 999,
+          state: "fulfilled",
+          lines: [courseRunLine(RUN_ID)],
+        }),
+        mitxonline.factories.orders.orderHistory({
+          id: 111,
+          state: "fulfilled",
+          lines: [courseRunLine(RUN_ID)],
+        }),
+      ]),
+    )
+
+    const { location } = renderWithProviders(
+      <ReceiptByRunRedirect runId={RUN_ID} />,
+    )
+
+    await waitFor(() => {
+      expect(location.current.pathname).toBe(receiptView(999))
+    })
+  })
+
+  test("ignores orders that were not fulfilled", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          id: 999,
+          state: "canceled",
+          lines: [courseRunLine(RUN_ID)],
+        }),
+        mitxonline.factories.orders.orderHistory({
+          id: ORDER_ID,
+          state: "fulfilled",
+          lines: [courseRunLine(RUN_ID)],
+        }),
+      ]),
+    )
+
+    const { location } = renderWithProviders(
+      <ReceiptByRunRedirect runId={RUN_ID} />,
+    )
+
+    await waitFor(() => {
+      expect(location.current.pathname).toBe(receiptView(ORDER_ID))
+    })
+  })
+
+  test("does not match a program whose id happens to equal the run id", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          id: ORDER_ID,
+          state: "fulfilled",
+          lines: [programLine(RUN_ID)],
+        }),
+      ]),
+    )
+
+    renderWithProviders(<ReceiptByRunRedirect runId={RUN_ID} />)
+
+    expect(
+      await screen.findByText(/couldn't find what you were looking for/i),
+    ).toBeInTheDocument()
+  })
+
+  test("shows not found when no order references the run", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          state: "fulfilled",
+          lines: [courseRunLine(RUN_ID + 1)],
+        }),
+      ]),
+    )
+
+    renderWithProviders(<ReceiptByRunRedirect runId={RUN_ID} />)
+
+    expect(
+      await screen.findByText(/couldn't find what you were looking for/i),
+    ).toBeInTheDocument()
+  })
+
+  // Indistinguishable from an absent receipt, on purpose.
+  test("shows the generic 404 when the order lookup fails", async () => {
+    setMockResponse.get(HISTORY_URL, "Server error", { code: 500 })
+
+    renderWithProviders(<ReceiptByRunRedirect runId={RUN_ID} />)
+
+    expect(
+      await screen.findByText(/couldn't find what you were looking for/i),
+    ).toBeInTheDocument()
+  })
+})
+
+describe("ReceiptByProgramRedirect", () => {
+  test("redirects to the receipt for the order that paid for the program", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          id: ORDER_ID,
+          state: "fulfilled",
+          lines: [programLine(PROGRAM_ID)],
+        }),
+      ]),
+    )
+
+    const { location } = renderWithProviders(
+      <ReceiptByProgramRedirect programId={PROGRAM_ID} />,
+    )
+
+    await waitFor(() => {
+      expect(location.current.pathname).toBe(receiptView(ORDER_ID))
+    })
+  })
+
+  test("does not match a program run whose id happens to equal the program id", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          id: ORDER_ID,
+          state: "fulfilled",
+          lines: [programRunLine(PROGRAM_ID)],
+        }),
+      ]),
+    )
+
+    renderWithProviders(<ReceiptByProgramRedirect programId={PROGRAM_ID} />)
+
+    expect(
+      await screen.findByText(/couldn't find what you were looking for/i),
+    ).toBeInTheDocument()
+  })
+
+  test("does not match a course run whose id happens to equal the program id", async () => {
+    setMockResponse.get(
+      HISTORY_URL,
+      mitxonline.factories.orders.orderHistoryList([
+        mitxonline.factories.orders.orderHistory({
+          id: ORDER_ID,
+          state: "fulfilled",
+          lines: [courseRunLine(PROGRAM_ID)],
+        }),
+      ]),
+    )
+
+    renderWithProviders(<ReceiptByProgramRedirect programId={PROGRAM_ID} />)
+
+    expect(
+      await screen.findByText(/couldn't find what you were looking for/i),
+    ).toBeInTheDocument()
+  })
+})
diff --git a/frontends/main/src/app-pages/ReceiptPage/ReceiptRedirect.tsx b/frontends/main/src/app-pages/ReceiptPage/ReceiptRedirect.tsx
new file mode 100644
index 0000000000..3a8c2977bd
--- /dev/null
+++ b/frontends/main/src/app-pages/ReceiptPage/ReceiptRedirect.tsx
@@ -0,0 +1,72 @@
+"use client"
+
+import React from "react"
+import { useRouter } from "next-nprogress-bar"
+import { Container, Skeleton, styled } from "ol-components"
+import { VisuallyHidden } from "@mitodl/smoot-design"
+import * as urls from "@/common/urls"
+import NotFoundPage from "@/app-pages/ErrorPage/NotFoundPage"
+import {
+  useOrderIdForProgram,
+  useOrderIdForRun,
+} from "@/common/mitxonline/useOrderIdForResource"
+import type { OrderIdResolution } from "@/common/mitxonline/useOrderIdForResource"
+
+const PageContainer = styled(Container)({
+  paddingTop: "40px",
+  paddingBottom: "80px",
+  display: "flex",
+  flexDirection: "column",
+  gap: "16px",
+})
+
+/**
+ * Resolves a course run or program to its order, then replaces the history entry
+ * with that order's receipt. `replace`, not `push`, so "Back" from the receipt
+ * skips this route. Mirrors MITx Online's `ReceiptByRunView`.
+ */
+const ReceiptRedirect: React.FC<{ resolution: OrderIdResolution }> = ({
+  resolution,
+}) => {
+  const router = useRouter()
+  const { isPending, orderId } = resolution
+
+  React.useEffect(() => {
+    if (orderId !== null) {
+      router.replace(urls.receiptView(orderId))
+    }
+  }, [orderId, router])
+
+  if (isPending || orderId !== null) {
+    return (
+      <PageContainer>
+        {/* Skeletons carry no ARIA, and this route only ever shows them. */}
+        <VisuallyHidden role="status" aria-live="polite" aria-atomic="true">
+          {isPending ? "Loading receipt." : "Receipt found. Redirecting."}
+        </VisuallyHidden>
+        <Skeleton variant="text" width="30%" height={36} />
+        <Skeleton variant="rectangular" width="100%" height={280} />
+      </PageContainer>
+    )
+  }
+
+  /**
+   * No order covers this run/program, or the lookup failed. Generic 404 for both,
+   * so a prober cannot tell a well-formed id from an unresolvable one.
+   */
+  return <NotFoundPage />
+}
+
+const ReceiptByRunRedirect: React.FC<{ runId: number }> = ({ runId }) => {
+  const resolution = useOrderIdForRun(runId)
+  return <ReceiptRedirect resolution={resolution} />
+}
+
+const ReceiptByProgramRedirect: React.FC<{ programId: number }> = ({
+  programId,
+}) => {
+  const resolution = useOrderIdForProgram(programId)
+  return <ReceiptRedirect resolution={resolution} />
+}
+
+export { ReceiptRedirect, ReceiptByRunRedirect, ReceiptByProgramRedirect }
diff --git a/frontends/main/src/app-pages/ReceiptPage/receiptUtils.ts b/frontends/main/src/app-pages/ReceiptPage/receiptUtils.ts
new file mode 100644
index 0000000000..8bb3a45862
--- /dev/null
+++ b/frontends/main/src/app-pages/ReceiptPage/receiptUtils.ts
@@ -0,0 +1,70 @@
+import moment from "moment"
+import type { Order, OrderStreetAddress } from "@mitodl/mitxonline-api-axios/v2"
+import { formatPrice } from "@/common/mitxonline"
+
+/** Receipt amounts always show cents, unlike catalog prices. */
+const formatMoney = (amount: number | string): string =>
+  formatPrice(amount, { avoidCents: false })
+
+/**
+ * Long-form receipt dates, e.g. "June 14, 2024". UTC, not the viewer's zone:
+ * course dates are stored at UTC midnight and would otherwise render a day early
+ * west of Greenwich.
+ */
+const formatReceiptDate = (date: string): string =>
+  moment.utc(date).format("MMMM DD, YYYY")
+
+/** A line's dates as one range; either end may be absent. */
+const formatDateRange = (
+  startDate?: string | null,
+  endDate?: string | null,
+): string | null => {
+  const start = startDate ? formatReceiptDate(startDate) : null
+  const end = endDate ? formatReceiptDate(endDate) : null
+  if (start && end) return `${start} - ${end}`
+  return start ?? end
+}
+
+/**
+ * Billing address as one line, e.g. "123 Main Street, Danvers MA, 01923". Every
+ * part is optional, so only present ones are joined.
+ */
+const formatStreetAddress = (
+  address: OrderStreetAddress | undefined,
+): string | null => {
+  if (!address) return null
+  const cityAndState = [address.city, address.state]
+    .filter(Boolean)
+    .join(" ")
+    .trim()
+  const parts = [
+    ...(address.line ?? []),
+    cityAndState,
+    address.postal_code,
+    address.country,
+  ].filter((part): part is string => Boolean(part && part.trim()))
+
+  return parts.length > 0 ? parts.join(", ") : null
+}
+
+/** e.g. "Visa | xxxxxxxxxxxx1111", or null when there was no payment. */
+const formatPaymentMethod = (order: Order): string | null => {
+  const transaction = order.transactions
+  if (!transaction) return null
+  if (transaction.payment_method === "paypal") return "PayPal"
+  const parts = [transaction.card_type, transaction.card_number].filter(Boolean)
+  return parts.length > 0 ? parts.join(" | ") : null
+}
+
+/** The discount code redeemed on the order, if any. */
+const getDiscountCode = (order: Order): string | null =>
+  order.discounts[0]?.redeemed_discount?.discount_code ?? null
+
+export {
+  formatDateRange,
+  formatMoney,
+  formatPaymentMethod,
+  formatReceiptDate,
+  formatStreetAddress,
+  getDiscountCode,
+}
diff --git a/frontends/main/src/app/(site)/receipt/[orderId]/page.tsx b/frontends/main/src/app/(site)/receipt/[orderId]/page.tsx
new file mode 100644
index 0000000000..6ca5a91e76
--- /dev/null
+++ b/frontends/main/src/app/(site)/receipt/[orderId]/page.tsx
@@ -0,0 +1,26 @@
+import React from "react"
+import type { Metadata } from "next"
+import { notFound } from "next/navigation"
+import { standardizeMetadata } from "@/common/metadata"
+import ReceiptPage from "@/app-pages/ReceiptPage/ReceiptPage"
+
+export const metadata: Metadata = standardizeMetadata({
+  title: "Receipt",
+  robots: { index: false },
+})
+
+/**
+ * Fetched client-side: MITx Online's session cookie is not forwarded on
+ * server-side requests, so the order cannot be prefetched here.
+ */
+const Page: React.FC<PageProps<"/receipt/[orderId]">> = async ({ params }) => {
+  const { orderId } = await params
+  const id = Number(orderId)
+  if (!Number.isInteger(id) || id <= 0) {
+    notFound()
+  }
+
+  return <ReceiptPage orderId={id} />
+}
+
+export default Page
diff --git a/frontends/main/src/app/(site)/receipt/by-program/[programId]/page.tsx b/frontends/main/src/app/(site)/receipt/by-program/[programId]/page.tsx
new file mode 100644
index 0000000000..42b597af6f
--- /dev/null
+++ b/frontends/main/src/app/(site)/receipt/by-program/[programId]/page.tsx
@@ -0,0 +1,28 @@
+import React from "react"
+import type { Metadata } from "next"
+import { notFound } from "next/navigation"
+import { standardizeMetadata } from "@/common/metadata"
+import { ReceiptByProgramRedirect } from "@/app-pages/ReceiptPage/ReceiptRedirect"
+
+export const metadata: Metadata = standardizeMetadata({
+  title: "Receipt",
+  robots: { index: false },
+})
+
+/**
+ * Resolves a program to the order covering it and redirects to that order's
+ * receipt. See `ReceiptRedirect` for why this route exists.
+ */
+const Page: React.FC<PageProps<"/receipt/by-program/[programId]">> = async ({
+  params,
+}) => {
+  const { programId } = await params
+  const id = Number(programId)
+  if (!Number.isInteger(id) || id <= 0) {
+    notFound()
+  }
+
+  return <ReceiptByProgramRedirect programId={id} />
+}
+
+export default Page
diff --git a/frontends/main/src/app/(site)/receipt/by-run/[runId]/page.tsx b/frontends/main/src/app/(site)/receipt/by-run/[runId]/page.tsx
new file mode 100644
index 0000000000..020ac0e2a8
--- /dev/null
+++ b/frontends/main/src/app/(site)/receipt/by-run/[runId]/page.tsx
@@ -0,0 +1,28 @@
+import React from "react"
+import type { Metadata } from "next"
+import { notFound } from "next/navigation"
+import { standardizeMetadata } from "@/common/metadata"
+import { ReceiptByRunRedirect } from "@/app-pages/ReceiptPage/ReceiptRedirect"
+
+export const metadata: Metadata = standardizeMetadata({
+  title: "Receipt",
+  robots: { index: false },
+})
+
+/**
+ * Resolves a course run to the order covering it and redirects to that order's
+ * receipt. See `ReceiptRedirect` for why this route exists.
+ */
+const Page: React.FC<PageProps<"/receipt/by-run/[runId]">> = async ({
+  params,
+}) => {
+  const { runId } = await params
+  const id = Number(runId)
+  if (!Number.isInteger(id) || id <= 0) {
+    notFound()
+  }
+
+  return <ReceiptByRunRedirect runId={id} />
+}
+
+export default Page
diff --git a/frontends/main/src/app/(site)/receipt/layout.tsx b/frontends/main/src/app/(site)/receipt/layout.tsx
new file mode 100644
index 0000000000..13e7d0584f
--- /dev/null
+++ b/frontends/main/src/app/(site)/receipt/layout.tsx
@@ -0,0 +1,22 @@
+import React from "react"
+import RestrictedRoute from "@/components/RestrictedRoute/RestrictedRoute"
+import { Permission } from "api/hooks/user"
+
+/**
+ * Gates all three receipt routes behind authentication.
+ *
+ * Receipts are bookmark-prone — saved for expense reports and reopened days
+ * later, or opened from a dashboard tab left overnight — so a stale cookie is a
+ * routine case rather than an edge one. Without this, the receipt query fails and
+ * the learner dead-ends on the generic error page. `RestrictedRoute` instead sends
+ * them through Keycloak and back to the receipt they asked for.
+ */
+const Layout: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  return (
+    <RestrictedRoute requires={Permission.Authenticated}>
+      {children}
+    </RestrictedRoute>
+  )
+}
+
+export default Layout
diff --git a/frontends/main/src/app/providers.tsx b/frontends/main/src/app/providers.tsx
index bda3c6bc9b..6f21d355e6 100644
--- a/frontends/main/src/app/providers.tsx
+++ b/frontends/main/src/app/providers.tsx
@@ -9,6 +9,7 @@ import {
   theme,
 } from "ol-components"
 import { Provider as NiceModalProvider } from "@ebay/nice-modal-react"
+import { ComplianceGateProvider } from "@/common/mitxonline/useComplianceGate"
 import { usePrefetchWarnings } from "api/ssr/usePrefetchWarnings"
 import { AppProgressBar as ProgressBar } from "next-nprogress-bar"
 import type { NProgressOptions } from "next-nprogress-bar"
@@ -35,7 +36,9 @@ export default function Providers({ children }: { children: React.ReactNode }) {
         <ReloadOnUserChange />
         <NextJsAppRouterCacheProvider>
           <ThemeProvider>
-            <NiceModalProvider>{children}</NiceModalProvider>
+            <NiceModalProvider>
+              <ComplianceGateProvider>{children}</ComplianceGateProvider>
+            </NiceModalProvider>
           </ThemeProvider>
         </NextJsAppRouterCacheProvider>
       </QueryClientProvider>
diff --git a/frontends/main/src/common/mitxonline/useComplianceGate.test.tsx b/frontends/main/src/common/mitxonline/useComplianceGate.test.tsx
new file mode 100644
index 0000000000..73238a4f7b
--- /dev/null
+++ b/frontends/main/src/common/mitxonline/useComplianceGate.test.tsx
@@ -0,0 +1,191 @@
+import React from "react"
+import { renderHook, screen, user, waitFor, within } from "@/test-utils"
+import { QueryClientProvider } from "@tanstack/react-query"
+import { ThemeProvider } from "ol-components"
+import { makeBrowserQueryClient } from "@/app/getQueryClient"
+import { makeRequest, setMockResponse } from "api/test-utils"
+import * as mitxonline from "api/mitxonline-test-utils"
+import NiceModal from "@ebay/nice-modal-react"
+import { useComplianceGate, ComplianceGateProvider } from "./useComplianceGate"
+
+const wrapper = ({ children }: { children: React.ReactNode }) => {
+  const queryClient = makeBrowserQueryClient({ maxRetries: 0 })
+  return (
+    <QueryClientProvider client={queryClient}>
+      <ThemeProvider>
+        <NiceModal.Provider>
+          <ComplianceGateProvider>{children}</ComplianceGateProvider>
+        </NiceModal.Provider>
+      </ThemeProvider>
+    </QueryClientProvider>
+  )
+}
+
+describe("useComplianceGate", () => {
+  test("a concurrent second call resolves false, even though the first resolves true", async () => {
+    const mitxUser = mitxonline.factories.user.user({
+      compliance_missing_fields: ["city"],
+      legal_address: { country: "GB" },
+      user_profile: { year_of_birth: 1990 },
+    })
+    setMockResponse.get(mitxonline.urls.userMe.get(), mitxUser)
+    setMockResponse.get(mitxonline.urls.countries.list(), [
+      { code: "GB", name: "United Kingdom", states: [] },
+    ])
+
+    const { result } = renderHook(() => useComplianceGate(), { wrapper })
+
+    // Synchronous, like two rapid clicks on the same button: the second call
+    // happens before the first's profile fetch has resolved.
+    const first = result.current.ensureCompliance()
+    // `second` is chained onto the first's own promise, so it can't be
+    // awaited before the first actually resolves (below) without deadlocking.
+    const second = result.current.ensureCompliance()
+
+    const dialog = await screen.findByRole("dialog", {
+      name: "Just a Few More Details",
+    })
+    await user.click(within(dialog).getByRole("button", { name: "Cancel" }))
+
+    await expect(first).resolves.toBe(false)
+    // The second caller never waited on the dialog outcome itself -- it was
+    // told "no" as soon as it discovered a check already in flight.
+    await expect(second).resolves.toBe(false)
+  })
+
+  test("a concurrent second call still resolves false when the first succeeds", async () => {
+    const mitxUser = mitxonline.factories.user.user({
+      compliance_missing_fields: [],
+      legal_address: {
+        first_name: "Ada",
+        last_name: "Lovelace",
+        country: "GB",
+        street_address_1: "1 Main St",
+        city: "London",
+      },
+      user_profile: { year_of_birth: null },
+    })
+    setMockResponse.get(mitxonline.urls.userMe.get(), mitxUser)
+    setMockResponse.get(mitxonline.urls.countries.list(), [
+      { code: "GB", name: "United Kingdom", states: [] },
+    ])
+    setMockResponse.patch(mitxonline.urls.userMe.get(), null)
+
+    const { result } = renderHook(() => useComplianceGate(), { wrapper })
+
+    const first = result.current.ensureCompliance()
+    const second = result.current.ensureCompliance()
+
+    const dialog = await screen.findByRole("dialog", {
+      name: "Just a Few More Details",
+    })
+    await user.click(
+      within(dialog).getByRole("combobox", { name: "Year of Birth" }),
+    )
+    await user.click(await screen.findByRole("option", { name: "1988" }))
+    await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+    // Only the initiating caller sees the real outcome; the doubled-up second
+    // call must not also come back true and fire its own mutation.
+    await expect(first).resolves.toBe(true)
+    await expect(second).resolves.toBe(false)
+    await waitFor(() =>
+      expect(
+        screen.queryByRole("dialog", { name: "Just a Few More Details" }),
+      ).not.toBeInTheDocument(),
+    )
+  })
+
+  test("fails closed when the profile check itself fails -- shows the dialog rather than proceeding", async () => {
+    setMockResponse.get(mitxonline.urls.userMe.get(), "Server error", {
+      code: 500,
+    })
+    setMockResponse.get(mitxonline.urls.countries.list(), [])
+
+    const { result } = renderHook(() => useComplianceGate(), { wrapper })
+
+    const ensured = result.current.ensureCompliance()
+
+    // A failed pre-check must not be indistinguishable from "compliant" --
+    // it routes into the same dialog as a definite "info is missing".
+    const dialog = await screen.findByRole("dialog", {
+      name: "Just a Few More Details",
+    })
+    await user.click(within(dialog).getByRole("button", { name: "Cancel" }))
+
+    await expect(ensured).resolves.toBe(false)
+  })
+
+  test("does not reuse a stale cached profile -- checks fresh on every call", async () => {
+    const compliant = mitxonline.factories.user.user({
+      compliance_missing_fields: [],
+      user_profile: { year_of_birth: 1990 },
+    })
+    setMockResponse.get(mitxonline.urls.userMe.get(), compliant)
+
+    const { result } = renderHook(() => useComplianceGate(), { wrapper })
+
+    await expect(result.current.ensureCompliance()).resolves.toBe(true)
+    await expect(result.current.ensureCompliance()).resolves.toBe(true)
+
+    const profileGets = jest
+      .mocked(makeRequest)
+      .mock.calls.map(([request]) => request)
+      .filter(
+        ({ method, url }) =>
+          method === "get" && url === mitxonline.urls.userMe.get(),
+      )
+    // The query client's default staleTime would otherwise let the second
+    // call reuse the first's cached response without hitting the network.
+    expect(profileGets.length).toBeGreaterThanOrEqual(2)
+  })
+
+  test("two separate call sites sharing a ComplianceGateProvider collapse onto one check", async () => {
+    const mitxUser = mitxonline.factories.user.user({
+      compliance_missing_fields: [],
+      legal_address: {
+        first_name: "Ada",
+        last_name: "Lovelace",
+        country: "GB",
+        street_address_1: "1 Main St",
+        city: "London",
+      },
+      user_profile: { year_of_birth: null },
+    })
+    setMockResponse.get(mitxonline.urls.userMe.get(), mitxUser)
+    setMockResponse.get(mitxonline.urls.countries.list(), [
+      { code: "GB", name: "United Kingdom", states: [] },
+    ])
+    setMockResponse.patch(mitxonline.urls.userMe.get(), null)
+
+    // Unlike the tests above, which call ensureCompliance() twice on the same
+    // hook instance, this calls it from two independent useComplianceGate()
+    // invocations -- e.g. two dashboard cards -- each with its own local ref.
+    // Only the shared ComplianceGateProvider ties them together.
+    const { result } = renderHook(
+      () => ({ cardA: useComplianceGate(), cardB: useComplianceGate() }),
+      { wrapper },
+    )
+
+    const first = result.current.cardA.ensureCompliance()
+    const second = result.current.cardB.ensureCompliance()
+
+    const dialog = await screen.findByRole("dialog", {
+      name: "Just a Few More Details",
+    })
+    // The second card's click must collapse onto the first's in-flight
+    // check rather than opening its own dialog.
+    expect(screen.getAllByRole("dialog")).toHaveLength(1)
+
+    await user.click(
+      within(dialog).getByRole("combobox", { name: "Year of Birth" }),
+    )
+    await user.click(await screen.findByRole("option", { name: "1988" }))
+    await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+    // Only the initiating card resumes as compliant; the collapsed second
+    // card must not also fire its own enroll/basket mutation.
+    await expect(first).resolves.toBe(true)
+    await expect(second).resolves.toBe(false)
+  })
+})
diff --git a/frontends/main/src/common/mitxonline/useComplianceGate.tsx b/frontends/main/src/common/mitxonline/useComplianceGate.tsx
new file mode 100644
index 0000000000..f5ad6e0820
--- /dev/null
+++ b/frontends/main/src/common/mitxonline/useComplianceGate.tsx
@@ -0,0 +1,115 @@
+import React from "react"
+import NiceModal from "@ebay/nice-modal-react"
+import { useQueryClient } from "@tanstack/react-query"
+import { mitxUserQueries } from "api/mitxonline-hooks/user"
+import { JustInTimeDialog } from "@/page-components/EnrollmentDialogs/JustInTimeDialog"
+import { needsComplianceInfo } from "@/page-components/EnrollmentDialogs/complianceFields"
+
+/**
+ * Holds the single in-flight compliance check for the whole tree.
+ *
+ * It has to be shared rather than per-hook: a product page has two gate
+ * instances (the free-enrollment gate, plus the one inside
+ * `useReplaceBasketItem`) and the dashboard has one per card. `NiceModal.show`
+ * returns the *same* promise when the dialog is already open, so without
+ * sharing, each instance awaits one dialog and each resumes its own mutation
+ * from a single submit.
+ *
+ * A provider rather than module-level state, so the ref cannot outlive the
+ * tree. A dialog left unresolved (e.g. a test that opens it and never closes
+ * it) leaves the promise pending forever; module state would pin that
+ * indefinitely and silently make every later enroll click a no-op.
+ */
+const ComplianceGateContext =
+  React.createContext<React.MutableRefObject<Promise<boolean> | null> | null>(
+    null,
+  )
+
+const ComplianceGateProvider: React.FC<{ children: React.ReactNode }> = ({
+  children,
+}) => {
+  const inFlight = React.useRef<Promise<boolean> | null>(null)
+  return (
+    <ComplianceGateContext.Provider value={inFlight}>
+      {children}
+    </ComplianceGateContext.Provider>
+  )
+}
+
+/**
+ * Gate for actions MITx Online rejects without a complete profile — enrolling
+ * and adding a product to the basket both require the export-compliance (OFAC)
+ * fields, and MIT separately requires a year of birth.
+ *
+ * `ensureCompliance()` resolves `true` when the action may proceed, either
+ * because nothing was missing or because the user just filled it in. It
+ * resolves `false` when they dismissed the dialog, in which case the caller
+ * should abandon the action **silently** — a cancel is not an error, so callers
+ * must not surface a failure message for it.
+ *
+ * Paid and checkout paths are gated centrally inside `useReplaceBasketItem`;
+ * free and verified-program enrollments call this directly, because the
+ * `useMutation` contract has no way to express "cancelled" that does not either
+ * reject (which reads as a failure to the caller) or resolve as if the
+ * enrollment had happened.
+ */
+const useComplianceGate = () => {
+  const queryClient = useQueryClient()
+  // Collapses concurrent callers (e.g. two dashboard cards clicked before the
+  // dialog appears) onto a single check, so a second click can't slip through
+  // and start its own mutation while the first is still awaiting the profile
+  // fetch or dialog. Falls back to a per-instance ref when no
+  // ComplianceGateProvider is mounted, so a gate still works in isolation --
+  // it just can't collapse calls from sibling instances.
+  const shared = React.useContext(ComplianceGateContext)
+  const local = React.useRef<Promise<boolean> | null>(null)
+  const inFlight = shared ?? local
+
+  const ensureCompliance = React.useCallback((): Promise<boolean> => {
+    if (inFlight.current) {
+      // A second caller arriving while the first is still in flight (e.g. a
+      // double-clicked enroll button) must not also resume once the first
+      // resolves true -- only the action that actually initiated the check
+      // should proceed, or both fire their own enroll/basket mutation.
+      return inFlight.current.then(() => false)
+    }
+
+    const promise = (async (): Promise<boolean> => {
+      // Defaults to "missing" so a failed check fails closed: with no
+      // definitive answer, treat it the same as compliance info being
+      // missing rather than letting the action through unchecked.
+      let missing = true
+      try {
+        // Fetched on demand rather than subscribed to, so merely rendering an
+        // enroll button costs no request, and the compliance state backing the
+        // decision is read at the moment the user acts on it -- staleTime: 0
+        // overrides the query client's default so a cached profile from
+        // minutes ago can't stand in for a live check.
+        const user = await queryClient.fetchQuery({
+          ...mitxUserQueries.me(),
+          staleTime: 0,
+        })
+        missing = needsComplianceInfo(user)
+      } catch {
+        // Swallow the fetch error -- `missing` already defaults to `true`,
+        // which routes into the dialog below. The dialog fetches the profile
+        // itself and lets the user submit fresh values regardless of why
+        // this pre-check failed, so it doubles as the retry surface: a
+        // transient failure here just means the dialog opens with blank
+        // fields instead of prefilled ones, and a real backend outage
+        // surfaces as the dialog's own save-error alert.
+      }
+      if (!missing) return true
+      return (await NiceModal.show(JustInTimeDialog)) === true
+    })().finally(() => {
+      inFlight.current = null
+    })
+
+    inFlight.current = promise
+    return promise
+  }, [queryClient, inFlight])
+
+  return { ensureCompliance }
+}
+
+export { useComplianceGate, ComplianceGateProvider }
diff --git a/frontends/main/src/common/mitxonline/useOrderIdForResource.ts b/frontends/main/src/common/mitxonline/useOrderIdForResource.ts
new file mode 100644
index 0000000000..6d1b3a3250
--- /dev/null
+++ b/frontends/main/src/common/mitxonline/useOrderIdForResource.ts
@@ -0,0 +1,91 @@
+import { useQuery } from "@tanstack/react-query"
+import { orderQueries } from "api/mitxonline-hooks/orders"
+import type {
+  Line,
+  OrderHistory,
+  ProductPurchasableObject,
+} from "@mitodl/mitxonline-api-axios/v2"
+import { StateEnum } from "@mitodl/mitxonline-api-axios/v2"
+
+/**
+ * An explicit limit is required: without one, `orders/history` bypasses
+ * pagination and returns a bare array instead of `{count, results}`. We do not
+ * follow `next`, so orders past this many are not found.
+ */
+const ORDER_HISTORY_LIMIT = 100
+
+type OrderIdResolution = {
+  isPending: boolean
+  /**
+   * True when the history could not be fetched, so whether a receipt exists is
+   * unknown. Distinct from `orderId === null`, which means we looked and there is
+   * genuinely no order — callers must not treat the two the same, or a failing
+   * request looks identical to "you never paid for this".
+   */
+  isError: boolean
+  /** Most recent fulfilled order covering the resource. May be zero-value. */
+  orderId: number | null
+}
+
+/**
+ * `purchasable_object` is an untagged union whose variants all expose a bare `id`,
+ * and those ids come from different tables — so match on shape, not id alone.
+ * Program-run products match neither guard, which is fine: their id is the run's,
+ * not the program's.
+ */
+const isCourseRun = (obj: ProductPurchasableObject): boolean =>
+  "course" in obj && obj.course !== undefined
+
+const isProgram = (obj: ProductPurchasableObject): boolean =>
+  !isCourseRun(obj) && !("run_tag" in obj && obj.run_tag !== undefined)
+
+const matchesLine = (
+  line: Line,
+  resourceId: number,
+  isVariant: (obj: ProductPurchasableObject) => boolean,
+): boolean => {
+  const purchased = line.product.purchasable_object
+  return purchased?.id === resourceId && isVariant(purchased)
+}
+
+/**
+ * Most recent fulfilled order covering a resource. History comes back
+ * newest-first. Refunded orders are excluded, matching `ReceiptByRunView` —
+ * revisit when the refund section is built.
+ */
+const useOrderIdForResource = (
+  resourceId: number | null,
+  isVariant: (obj: ProductPurchasableObject) => boolean,
+): OrderIdResolution => {
+  const history = useQuery({
+    ...orderQueries.historyList({ limit: ORDER_HISTORY_LIMIT }),
+    enabled: resourceId !== null,
+  })
+
+  if (resourceId === null) {
+    return { isPending: false, isError: false, orderId: null }
+  }
+  if (history.isPending) {
+    return { isPending: true, isError: false, orderId: null }
+  }
+  if (history.isError || !history.data) {
+    return { isPending: false, isError: true, orderId: null }
+  }
+
+  const match = history.data.results.find(
+    (order: OrderHistory) =>
+      order.state === StateEnum.Fulfilled &&
+      order.lines.some((line) => matchesLine(line, resourceId, isVariant)),
+  )
+
+  return { isPending: false, isError: false, orderId: match?.id ?? null }
+}
+
+const useOrderIdForRun = (runId: number | null): OrderIdResolution =>
+  useOrderIdForResource(runId, isCourseRun)
+
+const useOrderIdForProgram = (programId: number | null): OrderIdResolution =>
+  useOrderIdForResource(programId, isProgram)
+
+export { useOrderIdForRun, useOrderIdForProgram }
+export type { OrderIdResolution }
diff --git a/frontends/main/src/common/mitxonline/useReplaceBasketItem.test.tsx b/frontends/main/src/common/mitxonline/useReplaceBasketItem.test.tsx
index 18abf6543b..8533f78906 100644
--- a/frontends/main/src/common/mitxonline/useReplaceBasketItem.test.tsx
+++ b/frontends/main/src/common/mitxonline/useReplaceBasketItem.test.tsx
@@ -1,7 +1,20 @@
 import { act, renderHook, setupLocationMock } from "@/test-utils"
+import React from "react"
+import { QueryClientProvider } from "@tanstack/react-query"
+import { makeBrowserQueryClient } from "@/app/getQueryClient"
+import { setMockResponse } from "api/test-utils"
+import * as mitxonline from "api/mitxonline-test-utils"
 import { mitxonlineLegacyUrl } from "@/common/mitxonline"
 import { useReplaceBasketItem } from "./useReplaceBasketItem"
 
+// The compliance gate fetches the MITx Online user through react-query.
+const wrapper = ({ children }: { children: React.ReactNode }) => {
+  const queryClient = makeBrowserQueryClient({ maxRetries: 0 })
+  return (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  )
+}
+
 const reset = jest.fn()
 const mutate = jest.fn(
   (_productId: number, opts?: { onSuccess?: () => void }) =>
@@ -34,13 +47,19 @@ describe("useReplaceBasketItem", () => {
 
   beforeEach(() => {
     jest.clearAllMocks()
+    // The compliance gate reads the MITx Online user before touching the
+    // basket. A complete profile (the factory default) lets it through.
+    setMockResponse.get(
+      mitxonline.urls.userMe.get(),
+      mitxonline.factories.user.user(),
+    )
   })
 
-  test("redirects after the sync mutate path succeeds", () => {
+  test("redirects after the sync mutate path succeeds", async () => {
     const assign = jest.mocked(window.location.assign)
-    const { result } = renderHook(() => useReplaceBasketItem())
+    const { result } = renderHook(() => useReplaceBasketItem(), { wrapper })
 
-    act(() => {
+    await act(async () => {
       result.current.mutate(42)
     })
 
@@ -58,7 +77,7 @@ describe("useReplaceBasketItem", () => {
 
   test("redirects after the async mutateAsync path succeeds", async () => {
     const assign = jest.mocked(window.location.assign)
-    const { result } = renderHook(() => useReplaceBasketItem())
+    const { result } = renderHook(() => useReplaceBasketItem(), { wrapper })
 
     await act(async () => {
       await result.current.mutateAsync(42)
@@ -70,14 +89,14 @@ describe("useReplaceBasketItem", () => {
     expect(assign).toHaveBeenCalledWith(mitxonlineLegacyUrl("/cart/"))
   })
 
-  test("does not add or redirect when the sync clear never succeeds", () => {
+  test("does not add or redirect when the sync clear never succeeds", async () => {
     const assign = jest.mocked(window.location.assign)
     // Simulate clear failing: its onSuccess is never invoked. This also pins the
     // ordering — add must be nested inside clear's onSuccess, not fired directly.
     clearMutate.mockImplementationOnce(() => {})
-    const { result } = renderHook(() => useReplaceBasketItem())
+    const { result } = renderHook(() => useReplaceBasketItem(), { wrapper })
 
-    act(() => {
+    await act(async () => {
       result.current.mutate(42)
     })
 
@@ -89,7 +108,7 @@ describe("useReplaceBasketItem", () => {
   test("does not add or redirect when the async clear rejects", async () => {
     const assign = jest.mocked(window.location.assign)
     clearMutateAsync.mockRejectedValueOnce(new Error("clear failed"))
-    const { result } = renderHook(() => useReplaceBasketItem())
+    const { result } = renderHook(() => useReplaceBasketItem(), { wrapper })
 
     await act(async () => {
       await expect(result.current.mutateAsync(42)).rejects.toThrow(
diff --git a/frontends/main/src/common/mitxonline/useReplaceBasketItem.ts b/frontends/main/src/common/mitxonline/useReplaceBasketItem.ts
index 04ea858966..8de072f4c6 100644
--- a/frontends/main/src/common/mitxonline/useReplaceBasketItem.ts
+++ b/frontends/main/src/common/mitxonline/useReplaceBasketItem.ts
@@ -1,25 +1,42 @@
 import { useAddToBasket, useClearBasket } from "api/mitxonline-hooks/baskets"
 import { mitxonlineLegacyUrl } from "@/common/mitxonline"
+import { useComplianceGate } from "./useComplianceGate"
 
 const cartUrl = () => mitxonlineLegacyUrl("/cart/")
 
+/**
+ * Replaces the basket's contents with a single product and sends the user to
+ * checkout.
+ *
+ * This is the one path every paid enrollment takes, so the compliance gate
+ * lives here: a new checkout entry point cannot skip it. If the user dismisses
+ * the gate, nothing is added and no redirect happens — callers see a resolved
+ * promise with no navigation, so a cancel never reads as a failure.
+ */
 const useReplaceBasketItem = () => {
   const addToBasket = useAddToBasket()
   const clearBasket = useClearBasket()
+  const { ensureCompliance } = useComplianceGate()
 
   const redirect = () => window.location.assign(cartUrl())
 
+  // Returns void, like the `useMutation` mutate it stands in for, so call sites
+  // stay fire-and-forget and don't acquire a promise to handle.
   const mutate = (productId: number) => {
-    addToBasket.reset()
-    clearBasket.mutate(undefined, {
-      onSuccess: () =>
-        addToBasket.mutate(productId, {
-          onSuccess: redirect,
-        }),
+    void ensureCompliance().then((allowed) => {
+      if (!allowed) return
+      addToBasket.reset()
+      clearBasket.mutate(undefined, {
+        onSuccess: () =>
+          addToBasket.mutate(productId, {
+            onSuccess: redirect,
+          }),
+      })
     })
   }
 
   const mutateAsync = async (productId: number) => {
+    if (!(await ensureCompliance())) return
     addToBasket.reset()
     await clearBasket.mutateAsync()
     await addToBasket.mutateAsync(productId)
diff --git a/frontends/main/src/common/urls.ts b/frontends/main/src/common/urls.ts
index 2badba9ee3..2b61c9ba61 100644
--- a/frontends/main/src/common/urls.ts
+++ b/frontends/main/src/common/urls.ts
@@ -115,6 +115,20 @@ export const PROGRAM_VIEW = "/dashboard/program/[id]"
 export const programView = (id: number) =>
   generatePath(PROGRAM_VIEW, { id: String(id) })
 
+export const RECEIPT_VIEW = "/receipt/[orderId]"
+export const receiptView = (orderId: number) =>
+  generatePath(RECEIPT_VIEW, { orderId: String(orderId) })
+/**
+ * Enrollments carry no order reference, so these routes resolve the order from the
+ * run/program before redirecting to `RECEIPT_VIEW`.
+ */
+export const RECEIPT_BY_RUN_VIEW = "/receipt/by-run/[runId]"
+export const receiptByRunView = (runId: number) =>
+  generatePath(RECEIPT_BY_RUN_VIEW, { runId: String(runId) })
+export const RECEIPT_BY_PROGRAM_VIEW = "/receipt/by-program/[programId]"
+export const receiptByProgramView = (programId: number) =>
+  generatePath(RECEIPT_BY_PROGRAM_VIEW, { programId: String(programId) })
+
 export const SEARCH = "/search"
 
 export const ABOUT = "/about"
diff --git a/frontends/main/src/page-components/EnrollmentDialogs/CourseEnrollmentDialog.test.tsx b/frontends/main/src/page-components/EnrollmentDialogs/CourseEnrollmentDialog.test.tsx
index 8e455edda4..4c268fba2a 100644
--- a/frontends/main/src/page-components/EnrollmentDialogs/CourseEnrollmentDialog.test.tsx
+++ b/frontends/main/src/page-components/EnrollmentDialogs/CourseEnrollmentDialog.test.tsx
@@ -62,6 +62,13 @@ describe("CourseEnrollmentDialog", () => {
 
   setupLocationMock()
 
+  beforeEach(() => {
+    // Enrolling and adding to cart both consult the MITx Online profile through
+    // the compliance gate. The factory default has nothing missing, so it passes
+    // straight through; see JustInTimeDialog tests for the blocked case.
+    setMockResponse.get(mitxUrls.userMe.get(), mitxFactories.user.user())
+  })
+
   describe("Course run dropdown", () => {
     test("Shows one entry for each enrollable course run", async () => {
       const run1 = enrollableRun()
diff --git a/frontends/main/src/page-components/EnrollmentDialogs/CourseEnrollmentDialog.tsx b/frontends/main/src/page-components/EnrollmentDialogs/CourseEnrollmentDialog.tsx
index a387159d20..3475704275 100644
--- a/frontends/main/src/page-components/EnrollmentDialogs/CourseEnrollmentDialog.tsx
+++ b/frontends/main/src/page-components/EnrollmentDialogs/CourseEnrollmentDialog.tsx
@@ -27,6 +27,7 @@ import {
 } from "@/common/mitxonline"
 import { useCreateEnrollment } from "api/mitxonline-hooks/enrollment"
 import { useReplaceBasketItem } from "@/common/mitxonline/useReplaceBasketItem"
+import { useComplianceGate } from "@/common/mitxonline/useComplianceGate"
 import { useRouter } from "next-nprogress-bar"
 import { useQuery } from "@tanstack/react-query"
 import { productQueries } from "api/mitxonline-hooks/products"
@@ -330,6 +331,9 @@ const CourseEnrollmentDialogInner: React.FC<CourseEnrollmentDialogProps> = ({
   const enrollmentType = getEnrollmentType(run?.enrollment_modes)
   const createEnrollment = useCreateEnrollment()
   const router = useRouter()
+  // The "Add to Cart" path inside CertificateUpsell is gated by
+  // useReplaceBasketItem; this free-enrollment submit gates here.
+  const { ensureCompliance } = useComplianceGate()
   return (
     <StyledFormDialog
       {...muiDialogV5(modal)}
@@ -343,6 +347,7 @@ const CourseEnrollmentDialogInner: React.FC<CourseEnrollmentDialogProps> = ({
       onSubmit={async (e) => {
         e.preventDefault()
         if (!run) return
+        if (!(await ensureCompliance())) return
         createEnrollment.mutate(
           {
             run_id: run.id,
diff --git a/frontends/main/src/page-components/EnrollmentDialogs/JustInTimeDialog.test.tsx b/frontends/main/src/page-components/EnrollmentDialogs/JustInTimeDialog.test.tsx
new file mode 100644
index 0000000000..978c8d3d3e
--- /dev/null
+++ b/frontends/main/src/page-components/EnrollmentDialogs/JustInTimeDialog.test.tsx
@@ -0,0 +1,424 @@
+import {
+  act,
+  renderWithProviders,
+  screen,
+  setMockResponse,
+  user,
+  waitFor,
+  within,
+} from "@/test-utils"
+import { makeRequest } from "api/test-utils"
+import {
+  urls as mitxUrls,
+  factories as mitxFactories,
+} from "api/mitxonline-test-utils"
+import type { User as MitxUser } from "@mitodl/mitxonline-api-axios/v2"
+import type { PartialDeep } from "type-fest"
+import NiceModal from "@ebay/nice-modal-react"
+import { getDescriptionFor } from "ol-test-utilities"
+import { JustInTimeDialog } from "./JustInTimeDialog"
+
+const COUNTRIES = [
+  {
+    code: "US",
+    name: "United States",
+    states: [
+      { code: "US-MA", name: "Massachusetts" },
+      { code: "US-NY", name: "New York" },
+    ],
+  },
+  {
+    code: "CA",
+    name: "Canada",
+    states: [{ code: "CA-ON", name: "Ontario" }],
+  },
+  { code: "GB", name: "United Kingdom", states: [] },
+]
+
+const setup = (userOverrides: PartialDeep<MitxUser> = {}) => {
+  const mitxUser = mitxFactories.user.user({
+    legal_address: null,
+    user_profile: null,
+    compliance_missing_fields: ["city", "country", "street_address_1"],
+    ...userOverrides,
+  })
+  setMockResponse.get(mitxUrls.userMe.get(), mitxUser)
+  setMockResponse.get(mitxUrls.countries.list(), COUNTRIES)
+  setMockResponse.patch(mitxUrls.userMe.get(), null)
+  return { mitxUser }
+}
+
+const openDialog = async () => {
+  renderWithProviders(null)
+  await act(async () => {
+    NiceModal.show(JustInTimeDialog)
+  })
+  return screen.findByRole("dialog", { name: "Just a Few More Details" })
+}
+
+const textbox = (dialog: HTMLElement, name: string) =>
+  within(dialog).getByRole("textbox", { name })
+const combobox = (dialog: HTMLElement, name: string) =>
+  within(dialog).getByRole("combobox", { name })
+
+const chooseOption = async (control: HTMLElement, optionName: string) => {
+  await user.click(control)
+  await user.click(await screen.findByRole("option", { name: optionName }))
+}
+
+const patchCalls = () =>
+  jest
+    .mocked(makeRequest)
+    .mock.calls.map(([request]) => request)
+    .filter(
+      ({ method, url }) => method === "patch" && url === mitxUrls.userMe.get(),
+    )
+
+describe("JustInTimeDialog", () => {
+  test("collects every export-compliance field plus year of birth", async () => {
+    setup()
+    const dialog = await openDialog()
+
+    // Rendered whether or not the API reported them missing, so a value that is
+    // present but wrong can still be corrected.
+    ;[
+      "First Name",
+      "Last Name",
+      "Address",
+      "Address Line 2 (optional)",
+      "City",
+    ].forEach((label) => expect(textbox(dialog, label)).toBeVisible())
+
+    expect(combobox(dialog, "Country")).toBeVisible()
+    expect(combobox(dialog, "Year of Birth")).toBeVisible()
+  })
+
+  test("prefills the fields already on file so wrong values can be corrected", async () => {
+    setup({
+      legal_address: {
+        first_name: "Ada",
+        last_name: "Lovelace",
+        country: "GB",
+        city: "London",
+      },
+      user_profile: { year_of_birth: 1988 },
+    })
+    const dialog = await openDialog()
+
+    await waitFor(() =>
+      expect(textbox(dialog, "First Name")).toHaveValue("Ada"),
+    )
+    expect(textbox(dialog, "Last Name")).toHaveValue("Lovelace")
+    expect(textbox(dialog, "City")).toHaveValue("London")
+    expect(combobox(dialog, "Country")).toHaveTextContent("United Kingdom")
+    expect(combobox(dialog, "Year of Birth")).toHaveTextContent("1988")
+    // Not on file, so still empty rather than absent.
+    expect(textbox(dialog, "Address")).toHaveValue("")
+  })
+
+  describe("country-conditional subdivision fields", () => {
+    test("State and Postal Code are absent for a country with no subdivisions", async () => {
+      setup({ legal_address: { country: "GB" } })
+      const dialog = await openDialog()
+
+      await waitFor(() =>
+        expect(combobox(dialog, "Country")).toHaveTextContent("United Kingdom"),
+      )
+      expect(
+        within(dialog).queryByRole("combobox", { name: "State/Province" }),
+      ).not.toBeInTheDocument()
+      expect(
+        within(dialog).queryByRole("textbox", { name: "Postal Code" }),
+      ).not.toBeInTheDocument()
+      expect(
+        within(dialog).queryByRole("textbox", { name: "Zip Code" }),
+      ).not.toBeInTheDocument()
+    })
+
+    test("selecting the US reveals State and a Zip Code field, and announces the new requirement", async () => {
+      // compliance_missing_fields cannot warn about these: it is computed from
+      // the country already stored, which here is none.
+      setup()
+      const dialog = await openDialog()
+
+      await chooseOption(combobox(dialog, "Country"), "United States")
+
+      const state = await within(dialog).findByRole("combobox", {
+        name: "State/Province",
+      })
+      expect(state).toBeVisible()
+      await chooseOption(state, "Massachusetts")
+      expect(state).toHaveTextContent("Massachusetts")
+
+      // US uses local terminology, not the generic "Postal Code" label.
+      expect(textbox(dialog, "Zip Code")).toBeVisible()
+      expect(
+        within(dialog).queryByRole("textbox", { name: "Postal Code" }),
+      ).not.toBeInTheDocument()
+
+      expect(
+        within(dialog).getByText(
+          "State/Province and Zip Code are required for United States.",
+        ),
+      ).toBeInTheDocument()
+    })
+
+    test("selecting Canada reveals State and a Postal Code field (not Zip Code)", async () => {
+      setup()
+      const dialog = await openDialog()
+
+      await chooseOption(combobox(dialog, "Country"), "Canada")
+
+      const state = await within(dialog).findByRole("combobox", {
+        name: "State/Province",
+      })
+      expect(state).toBeVisible()
+
+      expect(textbox(dialog, "Postal Code")).toBeVisible()
+      expect(
+        within(dialog).queryByRole("textbox", { name: "Zip Code" }),
+      ).not.toBeInTheDocument()
+
+      expect(
+        within(dialog).getByText(
+          "State/Province and Postal Code are required for Canada.",
+        ),
+      ).toBeInTheDocument()
+    })
+
+    test("switching to a country without subdivisions clears the chosen state and postal code", async () => {
+      setup()
+      const dialog = await openDialog()
+
+      await chooseOption(combobox(dialog, "Country"), "United States")
+      await chooseOption(
+        await within(dialog).findByRole("combobox", { name: "State/Province" }),
+        "Massachusetts",
+      )
+      await user.type(textbox(dialog, "Zip Code"), "02139")
+      await chooseOption(combobox(dialog, "Country"), "United Kingdom")
+
+      await waitFor(() =>
+        expect(
+          within(dialog).queryByRole("combobox", { name: "State/Province" }),
+        ).not.toBeInTheDocument(),
+      )
+      expect(
+        within(dialog).queryByRole("textbox", { name: "Zip Code" }),
+      ).not.toBeInTheDocument()
+      expect(
+        within(dialog).queryByRole("textbox", { name: "Postal Code" }),
+      ).not.toBeInTheDocument()
+
+      // Re-selecting the US must not resurrect the stale subdivision or postal code.
+      await chooseOption(combobox(dialog, "Country"), "United States")
+      const state = await within(dialog).findByRole("combobox", {
+        name: "State/Province",
+      })
+      expect(state).toHaveTextContent("Please Select")
+      expect(textbox(dialog, "Zip Code")).toHaveValue("")
+    })
+
+    test("switching between two subdivision countries clears the stale state and postal code", async () => {
+      // US -> Canada takes neither branch of the old subdivision-vs-not check
+      // (both require a subdivision), which is exactly the case that let a
+      // US state code survive into Canada's province list.
+      setup()
+      const dialog = await openDialog()
+
+      await chooseOption(combobox(dialog, "Country"), "United States")
+      await chooseOption(
+        await within(dialog).findByRole("combobox", { name: "State/Province" }),
+        "Massachusetts",
+      )
+      await user.type(textbox(dialog, "Zip Code"), "02139")
+
+      await chooseOption(combobox(dialog, "Country"), "Canada")
+
+      const state = await within(dialog).findByRole("combobox", {
+        name: "State/Province",
+      })
+      // Must not still read "Massachusetts" -- that option doesn't exist in
+      // Canada's list, which is what produced MUI's out-of-range warning.
+      expect(state).toHaveTextContent("Please Select")
+      expect(textbox(dialog, "Postal Code")).toHaveValue("")
+    })
+  })
+
+  describe("validation", () => {
+    test("blocks submission and explains each empty required field", async () => {
+      setup()
+      const dialog = await openDialog()
+
+      await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+      const expectations: [string, string][] = [
+        ["First Name", "First name is required"],
+        ["Last Name", "Last name is required"],
+        ["Address", "Address is required"],
+        ["City", "City is required"],
+      ]
+      for (const [label, message] of expectations) {
+        const field = textbox(dialog, label)
+        expect(field).toBeInvalid()
+        expect(getDescriptionFor(field)).toHaveTextContent(message)
+      }
+      expect(getDescriptionFor(combobox(dialog, "Country"))).toHaveTextContent(
+        "Country is required",
+      )
+      expect(
+        getDescriptionFor(combobox(dialog, "Year of Birth")),
+      ).toHaveTextContent("Year of birth is required")
+
+      expect(patchCalls()).toHaveLength(0)
+    })
+
+    test("moves focus to the first field needing attention", async () => {
+      setup({
+        legal_address: { first_name: "Ada", country: "GB", city: "London" },
+      })
+      const dialog = await openDialog()
+      await waitFor(() =>
+        expect(textbox(dialog, "First Name")).toHaveValue("Ada"),
+      )
+
+      await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+      // First Name is filled, so Last Name is the first outstanding field.
+      expect(textbox(dialog, "Last Name")).toHaveFocus()
+    })
+
+    test("whitespace does not satisfy a required field", async () => {
+      setup()
+      const dialog = await openDialog()
+
+      await user.type(textbox(dialog, "First Name"), "   ")
+      await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+      expect(
+        getDescriptionFor(textbox(dialog, "First Name")),
+      ).toHaveTextContent("First name is required")
+      expect(patchCalls()).toHaveLength(0)
+    })
+
+    test("postal code is neither shown nor required outside the US and Canada", async () => {
+      setup({
+        legal_address: {
+          first_name: "Ada",
+          last_name: "Lovelace",
+          country: "GB",
+          street_address_1: "1 Main St",
+          city: "London",
+        },
+        user_profile: { year_of_birth: 1988 },
+      })
+      const dialog = await openDialog()
+      await waitFor(() => expect(textbox(dialog, "City")).toHaveValue("London"))
+
+      expect(
+        within(dialog).queryByRole("textbox", { name: "Postal Code" }),
+      ).not.toBeInTheDocument()
+
+      await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+      await waitFor(() => expect(patchCalls()).toHaveLength(1))
+    })
+  })
+
+  describe("submission", () => {
+    test("saves the address and year of birth", async () => {
+      setup()
+      const dialog = await openDialog()
+
+      await user.type(textbox(dialog, "First Name"), "Ada")
+      await user.type(textbox(dialog, "Last Name"), "Lovelace")
+      await user.type(textbox(dialog, "Address"), "1 Main St")
+      await user.type(textbox(dialog, "City"), "Cambridge")
+      await chooseOption(combobox(dialog, "Country"), "United States")
+      await chooseOption(
+        await within(dialog).findByRole("combobox", { name: "State/Province" }),
+        "Massachusetts",
+      )
+      // US uses "Zip Code", not the generic "Postal Code" label.
+      await user.type(textbox(dialog, "Zip Code"), "02139")
+      await chooseOption(combobox(dialog, "Year of Birth"), "1988")
+
+      await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+      await waitFor(() => expect(patchCalls()).toHaveLength(1))
+      expect(patchCalls()[0].body).toEqual({
+        legal_address: {
+          first_name: "Ada",
+          last_name: "Lovelace",
+          country: "US",
+          street_address_1: "1 Main St",
+          street_address_2: "",
+          city: "Cambridge",
+          state: "US-MA",
+          postal_code: "02139",
+        },
+        user_profile: { year_of_birth: 1988 },
+      })
+    }, 10000)
+
+    test("closes once saved, so the caller can resume the action", async () => {
+      setup({
+        legal_address: {
+          first_name: "Ada",
+          last_name: "Lovelace",
+          country: "GB",
+          street_address_1: "1 Main St",
+          city: "London",
+        },
+        user_profile: { year_of_birth: 1988 },
+      })
+      const dialog = await openDialog()
+      await waitFor(() => expect(textbox(dialog, "City")).toHaveValue("London"))
+
+      await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+      await waitFor(() =>
+        expect(
+          screen.queryByRole("dialog", { name: "Just a Few More Details" }),
+        ).not.toBeInTheDocument(),
+      )
+    })
+
+    test("stays open and explains a failed save", async () => {
+      setup()
+      setMockResponse.patch(mitxUrls.userMe.get(), null, { code: 500 })
+      const dialog = await openDialog()
+
+      await user.type(textbox(dialog, "First Name"), "Ada")
+      await user.type(textbox(dialog, "Last Name"), "Lovelace")
+      await user.type(textbox(dialog, "Address"), "1 Main St")
+      await user.type(textbox(dialog, "City"), "London")
+      await chooseOption(combobox(dialog, "Country"), "United Kingdom")
+      await chooseOption(combobox(dialog, "Year of Birth"), "1988")
+
+      await user.click(within(dialog).getByRole("button", { name: "Submit" }))
+
+      expect(
+        await within(dialog).findByText(
+          "There was a problem saving your details. Please try again later.",
+        ),
+      ).toBeInTheDocument()
+      // The entered values survive so the user can retry without retyping.
+      expect(textbox(dialog, "First Name")).toHaveValue("Ada")
+    }, 10000)
+
+    test("cancelling saves nothing", async () => {
+      setup()
+      const dialog = await openDialog()
+
+      await user.click(within(dialog).getByRole("button", { name: "Cancel" }))
+
+      expect(patchCalls()).toHaveLength(0)
+      await waitFor(() =>
+        expect(
+          screen.queryByRole("dialog", { name: "Just a Few More Details" }),
+        ).not.toBeInTheDocument(),
+      )
+    })
+  })
+})
diff --git a/frontends/main/src/page-components/EnrollmentDialogs/JustInTimeDialog.tsx b/frontends/main/src/page-components/EnrollmentDialogs/JustInTimeDialog.tsx
new file mode 100644
index 0000000000..e3e1efefb9
--- /dev/null
+++ b/frontends/main/src/page-components/EnrollmentDialogs/JustInTimeDialog.tsx
@@ -0,0 +1,291 @@
+import React from "react"
+import {
+  Typography,
+  styled,
+  FormDialog,
+  DialogActions,
+  Stack,
+  LoadingSpinner,
+  SimpleSelectField,
+  SimpleSelectOption,
+  SelectChangeEvent,
+} from "ol-components"
+import { Alert, Button, TextField, VisuallyHidden } from "@mitodl/smoot-design"
+import { useQuery } from "@tanstack/react-query"
+import NiceModal, { muiDialogV5 } from "@ebay/nice-modal-react"
+import { useFormik } from "formik"
+import {
+  mitxUserQueries,
+  useUpdateUserMutation,
+} from "api/mitxonline-hooks/user"
+import {
+  FIELD_SPECS,
+  JIT_FIELDS,
+  initialJitValues,
+  isFieldRequired,
+  jitPatchPayload,
+  jitSchema,
+  postalCodeLabel,
+  requiresSubdivision,
+  subdivisionOptions,
+  yearOfBirthOptions,
+} from "./complianceFields"
+import type { JitField } from "./complianceFields"
+
+const SelectPlaceholder = styled("span")(({ theme }) => ({
+  color: theme.custom.colors.silverGrayDark,
+}))
+
+const PLACEHOLDER_LABEL = "Please Select"
+
+const placeholderOption: SimpleSelectOption = {
+  value: "",
+  label: PLACEHOLDER_LABEL,
+  disabled: true,
+}
+
+/**
+ * Focusable control within a field wrapper. A `SimpleSelectField` renders a
+ * `role="combobox"` element alongside an `aria-hidden` native input carrying
+ * the name, so the hidden input is skipped.
+ */
+const FOCUSABLE_CONTROL = '[role="combobox"], input:not([aria-hidden="true"])'
+
+/**
+ * Collects the profile information MITx Online needs before an enrollment or
+ * checkout can proceed: the export-compliance (OFAC) fields it reports via
+ * `compliance_missing_fields`, plus the year of birth backing MIT's
+ * minimum-age requirement.
+ *
+ * Every field is rendered and prefilled from the existing profile, not just the
+ * ones reported missing, so a value that is present but incorrect can be
+ * corrected here.
+ *
+ * Resolves `true` once the profile has been saved and `false` if the user backs
+ * out, so callers can continue or abandon the action that triggered it. This
+ * dialog only updates the profile — it does not enroll.
+ */
+const JustInTimeDialogInner: React.FC = () => {
+  const modal = NiceModal.useModal()
+  const user = useQuery(mitxUserQueries.me())
+  const countries = useQuery(mitxUserQueries.countries())
+  const updateUser = useUpdateUserMutation()
+  const fieldsRef = React.useRef<HTMLDivElement>(null)
+  const [subdivisionNotice, setSubdivisionNotice] = React.useState("")
+
+  const formik = useFormik({
+    enableReinitialize: true,
+    validateOnChange: false,
+    validateOnBlur: false,
+    initialValues: initialJitValues(user.data),
+    validationSchema: jitSchema,
+    onSubmit: async (values) => {
+      try {
+        await updateUser.mutateAsync({
+          PatchedUserRequest: jitPatchPayload(
+            values,
+            user.data?.user_profile?.year_of_birth,
+          ),
+        })
+      } catch {
+        // Keep the dialog open so the entered values survive; the error alert
+        // below is driven by updateUser.isError.
+        return
+      }
+      modal.resolve(true)
+      modal.hide()
+    },
+  })
+
+  // Move focus to the first field that failed validation. Errors only change on
+  // submit (validateOnChange/Blur are off), so this cannot steal focus mid-typing.
+  const { submitCount, errors } = formik
+  const focusedSubmitCount = React.useRef(0)
+  React.useEffect(() => {
+    if (submitCount === focusedSubmitCount.current) return
+    const firstInvalid = JIT_FIELDS.find((field) => errors[field])
+    if (!firstInvalid) return
+    focusedSubmitCount.current = submitCount
+    fieldsRef.current
+      ?.querySelector(`[data-jit-field="${firstInvalid}"]`)
+      ?.querySelector<HTMLElement>(FOCUSABLE_CONTROL)
+      ?.focus()
+  }, [submitCount, errors])
+
+  const selectedCountry = countries.data?.find(
+    ({ code }) => code === formik.values.country,
+  )
+  const showSubdivision = requiresSubdivision(formik.values.country)
+
+  const handleClose = () => {
+    // A save in flight must run to completion: closing mid-submit would
+    // resolve this modal `false` while `onSubmit` could still land and
+    // resolve/hide it again, letting a cancelled action's caller and a
+    // just-completed save race for the final outcome.
+    if (formik.isSubmitting) return
+    modal.resolve(false)
+    modal.hide()
+  }
+
+  const handleCountryChange = (event: SelectChangeEvent<string>) => {
+    const nextCountry = event.target.value
+    formik.setFieldValue("country", nextCountry)
+    // A subdivision code (and, similarly, a postal/zip code) is only ever
+    // meaningful under the country it was entered for -- e.g. "US-MA" isn't
+    // an option in Canada's province list. Clearing both unconditionally,
+    // before branching below, avoids a stale value surviving a switch
+    // between two countries that both require them (US -> CA), which would
+    // otherwise leave the state select holding a value absent from its own
+    // options.
+    formik.setFieldValue("state", "")
+    formik.setFieldValue("postal_code", "")
+    const nextName = countries.data?.find(
+      ({ code }) => code === nextCountry,
+    )?.name
+    if (requiresSubdivision(nextCountry)) {
+      // State and postal code appear (or become required) as a result of this
+      // change, so announce it rather than inserting fields silently.
+      setSubdivisionNotice(
+        `${FIELD_SPECS.state.label} and ${postalCodeLabel(nextCountry)} are required for ${nextName ?? "this country"}.`,
+      )
+    } else {
+      setSubdivisionNotice("")
+    }
+  }
+
+  const renderField = (field: JitField) => {
+    const spec = FIELD_SPECS[field]
+
+    const name = field
+    const value = formik.values[name]
+    const shared = {
+      name,
+      label:
+        name === "postal_code"
+          ? postalCodeLabel(formik.values.country)
+          : spec.label,
+      required: isFieldRequired(name, formik.values.country),
+      error: !!errors[name],
+      errorText: errors[name],
+      fullWidth: true,
+    }
+
+    if (spec.kind === "text") {
+      return (
+        <TextField {...shared} value={value} onChange={formik.handleChange} />
+      )
+    }
+
+    // The remaining kinds are selects. `renderValue` supplies the greyed
+    // placeholder that a disabled first option cannot render on its own.
+    const options: SimpleSelectOption[] =
+      spec.kind === "country"
+        ? [
+            placeholderOption,
+            ...(countries.data?.map(({ code, name: label }) => ({
+              value: code,
+              label,
+            })) ?? []),
+          ]
+        : spec.kind === "state"
+          ? [
+              placeholderOption,
+              ...subdivisionOptions(selectedCountry).map(
+                ({ code, name: label }) => ({ value: code, label }),
+              ),
+            ]
+          : [
+              placeholderOption,
+              ...yearOfBirthOptions().map((year) => ({
+                value: year,
+                label: year,
+              })),
+            ]
+
+    return (
+      <SimpleSelectField
+        {...shared}
+        options={options}
+        // Until the countries have loaded, MUI would warn about a value that
+        // is not among the options — country's own list is empty, and so is
+        // state's (it's derived from the matched country's subdivisions).
+        value={
+          (spec.kind === "country" || spec.kind === "state") && !countries.data
+            ? ""
+            : value
+        }
+        onChange={
+          spec.kind === "country" ? handleCountryChange : formik.handleChange
+        }
+        renderValue={
+          value
+            ? undefined
+            : () => <SelectPlaceholder>{PLACEHOLDER_LABEL}</SelectPlaceholder>
+        }
+      />
+    )
+  }
+
+  const visibleFields = JIT_FIELDS.filter(
+    (field) =>
+      (field !== "state" && field !== "postal_code") || showSubdivision,
+  )
+
+  return (
+    <FormDialog
+      noValidate
+      title="Just a Few More Details"
+      fullWidth
+      onReset={formik.resetForm}
+      onSubmit={formik.handleSubmit}
+      {...muiDialogV5(modal)}
+      onClose={handleClose}
+      actions={
+        <DialogActions>
+          <Button
+            variant="secondary"
+            onClick={handleClose}
+            disabled={formik.isSubmitting}
+          >
+            Cancel
+          </Button>
+          <Button
+            variant="primary"
+            type="submit"
+            disabled={formik.isSubmitting}
+            endIcon={
+              formik.isSubmitting ? (
+                <LoadingSpinner color="inherit" loading={true} size={16} />
+              ) : undefined
+            }
+          >
+            Submit
+          </Button>
+        </DialogActions>
+      }
+    >
+      <Stack direction="column" gap="24px" ref={fieldsRef}>
+        <Typography variant="body1">
+          We need a bit more info before you can enroll.
+        </Typography>
+        {visibleFields.map((field) => (
+          <div key={field} data-jit-field={field}>
+            {renderField(field)}
+          </div>
+        ))}
+        <VisuallyHidden aria-live="polite" aria-atomic="true">
+          {subdivisionNotice}
+        </VisuallyHidden>
+        {updateUser.isError && (
+          <Alert severity="error">
+            There was a problem saving your details. Please try again later.
+          </Alert>
+        )}
+      </Stack>
+    </FormDialog>
+  )
+}
+
+const JustInTimeDialog = NiceModal.create(JustInTimeDialogInner)
+
+export { JustInTimeDialog }
diff --git a/frontends/main/src/page-components/EnrollmentDialogs/complianceFields.test.ts b/frontends/main/src/page-components/EnrollmentDialogs/complianceFields.test.ts
new file mode 100644
index 0000000000..9dd8793886
--- /dev/null
+++ b/frontends/main/src/page-components/EnrollmentDialogs/complianceFields.test.ts
@@ -0,0 +1,323 @@
+import type { User } from "@mitodl/mitxonline-api-axios/v2"
+import { factories as mitxFactories } from "api/mitxonline-test-utils"
+import {
+  MINIMUM_AGE,
+  initialJitValues,
+  isFieldRequired,
+  jitPatchPayload,
+  needsComplianceInfo,
+  postalCodeLabel,
+  requiresSubdivision,
+  subdivisionOptions,
+  yearOfBirthOptions,
+} from "./complianceFields"
+import type { JitFormValues } from "./complianceFields"
+
+const values = (overrides: Partial<JitFormValues> = {}): JitFormValues => ({
+  first_name: "Ada",
+  last_name: "Lovelace",
+  country: "US",
+  street_address_1: "1 Main St",
+  street_address_2: "",
+  city: "Cambridge",
+  state: "US-MA",
+  postal_code: "02139",
+  year_of_birth: "1990",
+  ...overrides,
+})
+
+describe("needsComplianceInfo", () => {
+  test("no user yet -> not blocked", () => {
+    expect(needsComplianceInfo(undefined)).toBe(false)
+  })
+
+  test("complete profile -> not blocked", () => {
+    const user = mitxFactories.user.user({
+      compliance_missing_fields: [],
+      user_profile: { year_of_birth: 1990 },
+    })
+    expect(needsComplianceInfo(user)).toBe(false)
+  })
+
+  test("missing export-compliance fields -> blocked", () => {
+    const user = mitxFactories.user.user({
+      compliance_missing_fields: ["city", "postal_code"],
+      user_profile: { year_of_birth: 1990 },
+    })
+    expect(needsComplianceInfo(user)).toBe(true)
+  })
+
+  test.each([{ year_of_birth: null }, { year_of_birth: 0 }])(
+    "missing year of birth ($year_of_birth) -> blocked even when compliance is satisfied",
+    (profile) => {
+      const user = mitxFactories.user.user({
+        compliance_missing_fields: [],
+        user_profile: profile,
+      })
+      expect(needsComplianceInfo(user)).toBe(true)
+    },
+  )
+
+  test("deployment without compliance_missing_fields -> treated as nothing missing", () => {
+    // Production predating mitodl/mitxonline#3818 omits the field entirely. It
+    // must not read as "everything is missing".
+    const user: User = mitxFactories.user.user({
+      user_profile: { year_of_birth: 1990 },
+    })
+    delete (user as Partial<User>).compliance_missing_fields
+    expect(needsComplianceInfo(user)).toBe(false)
+  })
+
+  test("postal_code/state reported missing outside US/CA -> not blocked", () => {
+    // mitodl/mitxonline#3850 flags these as missing whenever they're empty,
+    // for every country, but the dialog only ever collects them for US/CA —
+    // so outside those countries, they can never be resolved. Counting them
+    // here would gate an entire population forever with no field to fix it.
+    const user = mitxFactories.user.user({
+      compliance_missing_fields: ["postal_code", "state"],
+      legal_address: { country: "FR" },
+      user_profile: { year_of_birth: 1990 },
+    })
+    expect(needsComplianceInfo(user)).toBe(false)
+  })
+
+  test("postal_code/state reported missing for US/CA -> blocked", () => {
+    const user = mitxFactories.user.user({
+      compliance_missing_fields: ["postal_code"],
+      legal_address: { country: "US" },
+      user_profile: { year_of_birth: 1990 },
+    })
+    expect(needsComplianceInfo(user)).toBe(true)
+  })
+
+  test("a genuinely missing field outside US/CA still blocks", () => {
+    // Only postal_code/state get the always-flagged-everywhere treatment;
+    // other fields still gate normally regardless of country.
+    const user = mitxFactories.user.user({
+      compliance_missing_fields: ["postal_code", "city"],
+      legal_address: { country: "FR" },
+      user_profile: { year_of_birth: 1990 },
+    })
+    expect(needsComplianceInfo(user)).toBe(true)
+  })
+})
+
+describe("postalCodeLabel", () => {
+  test.each([
+    ["US", "Zip Code"],
+    ["us", "Zip Code"],
+    [" US ", "Zip Code"],
+  ])("%s -> %s", (country, expected) => {
+    expect(postalCodeLabel(country)).toBe(expected)
+  })
+
+  test.each([
+    ["CA", "Postal Code"],
+    ["GB", "Postal Code"],
+    ["", "Postal Code"],
+    [null, "Postal Code"],
+    [undefined, "Postal Code"],
+  ])("%s -> %s", (country, expected) => {
+    expect(postalCodeLabel(country)).toBe(expected)
+  })
+})
+
+describe("requiresSubdivision", () => {
+  test.each(["US", "CA", "us", " ca "])("%s requires a subdivision", (code) => {
+    expect(requiresSubdivision(code)).toBe(true)
+  })
+
+  test.each(["GB", "FR", "", null, undefined])(
+    "%s does not require a subdivision",
+    (code) => {
+      expect(requiresSubdivision(code)).toBe(false)
+    },
+  )
+})
+
+describe("isFieldRequired", () => {
+  test.each([
+    "first_name",
+    "last_name",
+    "country",
+    "street_address_1",
+    "city",
+    "year_of_birth",
+  ] as const)("%s is required regardless of country", (field) => {
+    expect(isFieldRequired(field, "GB")).toBe(true)
+    expect(isFieldRequired(field, "US")).toBe(true)
+  })
+
+  test.each(["state", "postal_code"] as const)(
+    "%s is required only for US/CA",
+    (field) => {
+      expect(isFieldRequired(field, "US")).toBe(true)
+      expect(isFieldRequired(field, "CA")).toBe(true)
+      expect(isFieldRequired(field, "GB")).toBe(false)
+      expect(isFieldRequired(field, "")).toBe(false)
+    },
+  )
+
+  test("street_address_2 is never required", () => {
+    expect(isFieldRequired("street_address_2", "US")).toBe(false)
+    expect(isFieldRequired("street_address_2", "GB")).toBe(false)
+  })
+})
+
+describe("initialJitValues", () => {
+  test("prefills from the stored profile, including partial data", () => {
+    const user = mitxFactories.user.user({
+      legal_address: {
+        first_name: "Ada",
+        last_name: "",
+        country: "US",
+        city: "Cambridge",
+        state: "US-MA",
+      },
+      user_profile: { year_of_birth: 1988 },
+    })
+    expect(initialJitValues(user)).toEqual({
+      first_name: "Ada",
+      last_name: "",
+      country: "US",
+      street_address_1: "",
+      street_address_2: "",
+      city: "Cambridge",
+      state: "US-MA",
+      postal_code: "",
+      year_of_birth: "1988",
+    })
+  })
+
+  test("no profile at all -> every field empty", () => {
+    const user = mitxFactories.user.user({
+      legal_address: null,
+      user_profile: null,
+    })
+    expect(Object.values(initialJitValues(user))).toEqual(
+      expect.arrayContaining([""]),
+    )
+    expect(initialJitValues(user).year_of_birth).toBe("")
+    expect(initialJitValues(user).country).toBe("")
+  })
+})
+
+describe("jitPatchPayload", () => {
+  test("splits fields between legal_address and user_profile", () => {
+    expect(jitPatchPayload(values(), 1975)).toEqual({
+      legal_address: {
+        first_name: "Ada",
+        last_name: "Lovelace",
+        country: "US",
+        street_address_1: "1 Main St",
+        street_address_2: "",
+        city: "Cambridge",
+        state: "US-MA",
+        postal_code: "02139",
+      },
+      user_profile: { year_of_birth: 1990 },
+    })
+  })
+
+  test("trims whitespace the backend would treat as absent", () => {
+    const payload = jitPatchPayload(
+      values({
+        first_name: "  Ada  ",
+        city: " Cambridge ",
+        postal_code: " 1 ",
+      }),
+      1975,
+    )
+    expect(payload.legal_address).toMatchObject({
+      first_name: "Ada",
+      city: "Cambridge",
+      postal_code: "1",
+    })
+  })
+
+  test("drops a subdivision that does not apply to the chosen country", () => {
+    // Someone who had US-MA stored and switches to the UK must not submit a US
+    // state under a country that has none.
+    const payload = jitPatchPayload(
+      values({ country: "GB", state: "US-MA" }),
+      1975,
+    )
+    expect(payload.legal_address?.state).toBe("")
+  })
+
+  test("drops a postal code entered before switching to a country without subdivisions", () => {
+    // Mirrors the state case above: the field is hidden once the country
+    // changes, so a stale value from when it was visible must not be sent.
+    const payload = jitPatchPayload(
+      values({ country: "GB", postal_code: "02139" }),
+      1975,
+    )
+    expect(payload.legal_address?.postal_code).toBe("")
+  })
+
+  test("year of birth is sent as an integer", () => {
+    expect(
+      jitPatchPayload(values({ year_of_birth: "1975" }), 1990).user_profile,
+    ).toEqual({ year_of_birth: 1975 })
+  })
+
+  test("omits user_profile when year of birth is unchanged", () => {
+    // mitxonline's UserSerializer recomputes addl_field_flag from whichever
+    // keys are present in the user_profile payload, not the stored profile —
+    // sending year_of_birth on every submit would silently reset that flag
+    // for a user who already had it set, even though nothing changed.
+    const payload = jitPatchPayload(values({ year_of_birth: "1990" }), 1990)
+    expect(payload).not.toHaveProperty("user_profile")
+  })
+
+  test("includes user_profile when year of birth is newly set", () => {
+    const payload = jitPatchPayload(values({ year_of_birth: "1990" }), null)
+    expect(payload.user_profile).toEqual({ year_of_birth: 1990 })
+  })
+
+  test("includes user_profile when year of birth changed", () => {
+    const payload = jitPatchPayload(values({ year_of_birth: "1990" }), 1975)
+    expect(payload.user_profile).toEqual({ year_of_birth: 1990 })
+  })
+})
+
+describe("subdivisionOptions", () => {
+  test("narrows the loosely-typed states array", () => {
+    const country = {
+      code: "US",
+      name: "United States",
+      states: [{ code: "US-MA", name: "Massachusetts" }],
+    }
+    expect(subdivisionOptions(country)).toEqual([
+      { code: "US-MA", name: "Massachusetts" },
+    ])
+  })
+
+  test("skips malformed entries rather than trusting the shape", () => {
+    const country = {
+      code: "US",
+      name: "United States",
+      states: [{ code: "US-MA", name: "Massachusetts" }, { code: 5 }, {}],
+    }
+    expect(subdivisionOptions(country)).toEqual([
+      { code: "US-MA", name: "Massachusetts" },
+    ])
+  })
+
+  test("countries without subdivisions yield none", () => {
+    expect(
+      subdivisionOptions({ code: "GB", name: "United Kingdom", states: [] }),
+    ).toEqual([])
+    expect(subdivisionOptions(undefined)).toEqual([])
+  })
+})
+
+describe("yearOfBirthOptions", () => {
+  test("runs from the newest year satisfying the minimum age back to 1900", () => {
+    const options = yearOfBirthOptions()
+    const newest = new Date().getFullYear() - MINIMUM_AGE
+    expect(options[0]).toBe(newest.toString())
+    expect(options.at(-1)).toBe("1900")
+    expect(options).toHaveLength(newest - 1900 + 1)
+  })
+})
diff --git a/frontends/main/src/page-components/EnrollmentDialogs/complianceFields.ts b/frontends/main/src/page-components/EnrollmentDialogs/complianceFields.ts
new file mode 100644
index 0000000000..68440661ec
--- /dev/null
+++ b/frontends/main/src/page-components/EnrollmentDialogs/complianceFields.ts
@@ -0,0 +1,312 @@
+import * as Yup from "yup"
+import type {
+  Country,
+  LegalAddressRequest,
+  PatchedUserRequest,
+  User,
+} from "@mitodl/mitxonline-api-axios/v2"
+
+/**
+ * Fields the just-in-time dialog collects, in display order.
+ *
+ * Country leads the address block because the subdivision and postal code
+ * requirements — and the list of state options — depend on it.
+ *
+ * Two entries are not export-compliance fields:
+ *  - `street_address_2` is never required, but belongs to an address form.
+ *  - `year_of_birth` backs MIT's minimum-age requirement, which Learn enforces
+ *    itself. It is deliberately absent from `compliance_missing_fields`: that
+ *    list is CyberSource-shaped and read-only, and year of birth is not a
+ *    bill-to field. We read it straight off `user_profile` instead.
+ *
+ * Email is deliberately not collected here: it comes from the user's SSO
+ * identity, so editing it would silently diverge the MITx Online account from
+ * Keycloak, and the dialog can't change it anyway.
+ */
+const JIT_FIELDS = [
+  "first_name",
+  "last_name",
+  "country",
+  "street_address_1",
+  "street_address_2",
+  "city",
+  "state",
+  "postal_code",
+  "year_of_birth",
+] as const
+
+type JitField = (typeof JIT_FIELDS)[number]
+
+type JitFormValues = Record<JitField, string>
+
+type FieldSpec = {
+  label: string
+  /**
+   * Which control renders this field. `country`, `state` and `year` are
+   * selects over generated option lists.
+   */
+  kind: "text" | "country" | "state" | "year"
+  /** Branch of the PATCH payload this field belongs to, or null if not written. */
+  patch: "legal_address" | "user_profile" | null
+}
+
+const FIELD_SPECS: Record<JitField, FieldSpec> = {
+  first_name: { label: "First Name", kind: "text", patch: "legal_address" },
+  last_name: { label: "Last Name", kind: "text", patch: "legal_address" },
+  country: { label: "Country", kind: "country", patch: "legal_address" },
+  street_address_1: { label: "Address", kind: "text", patch: "legal_address" },
+  street_address_2: {
+    label: "Address Line 2 (optional)",
+    kind: "text",
+    patch: "legal_address",
+  },
+  city: { label: "City", kind: "text", patch: "legal_address" },
+  state: { label: "State/Province", kind: "state", patch: "legal_address" },
+  postal_code: { label: "Postal Code", kind: "text", patch: "legal_address" },
+  year_of_birth: {
+    label: "Year of Birth",
+    kind: "year",
+    patch: "user_profile",
+  },
+}
+
+/**
+ * Countries for which CyberSource requires a subdivision and postal code.
+ *
+ * Mirrors `_missing_bill_to_fields` in mitxonline's `compliance/api.py`, which
+ * adds `administrative_area` and `postal_code` to the required set only for
+ * these countries. We have to mirror the rule rather than read it off
+ * `compliance_missing_fields`, because that list is computed from the country
+ * *already stored* on the profile — a user with no country on file gets a list
+ * with no state/postal in it, then picks "United States" in this dialog. If we
+ * trusted the list verbatim they could submit an address that still fails the
+ * export check.
+ */
+const SUBDIVISION_COUNTRIES = new Set(["US", "CA"])
+
+const requiresSubdivision = (country: string | null | undefined): boolean =>
+  SUBDIVISION_COUNTRIES.has((country ?? "").trim().toUpperCase())
+
+/**
+ * The postal-code field's label follows local terminology: US calls it a
+ * "Zip Code", everywhere else (including Canada) calls it a "Postal Code".
+ * The field itself is only shown for {@link SUBDIVISION_COUNTRIES}, so the
+ * fallback here never actually renders — it exists so a label is always
+ * defined rather than undefined mid-render while the country is unset.
+ */
+const postalCodeLabel = (country: string | null | undefined): string =>
+  (country ?? "").trim().toUpperCase() === "US" ? "Zip Code" : "Postal Code"
+
+type CountrySubdivision = { code: string; name: string }
+
+/**
+ * Subdivisions for a country, as `{ code, name }` where code is ISO-3166-2
+ * (e.g. `US-MA`). The spec types `states` as an untyped object array
+ * (`additionalProperties: {}`), so entries are narrowed rather than cast; the
+ * array is empty for every country outside {@link SUBDIVISION_COUNTRIES}.
+ *
+ * The full ISO code is what we store — mitxonline's
+ * `_normalize_administrative_area` strips the country prefix when building the
+ * CyberSource payload.
+ */
+const subdivisionOptions = (
+  country: Country | undefined,
+): CountrySubdivision[] =>
+  (country?.states ?? []).flatMap((state) =>
+    typeof state.code === "string" && typeof state.name === "string"
+      ? [{ code: state.code, name: state.name }]
+      : [],
+  )
+
+/** MIT requires learners to be at least this old. */
+const MINIMUM_AGE = 13
+
+const EARLIEST_BIRTH_YEAR = 1900
+
+/** Year options from the newest year satisfying {@link MINIMUM_AGE} back to 1900. */
+const yearOfBirthOptions = (): string[] => {
+  const maxYear = new Date().getFullYear() - MINIMUM_AGE
+  return Array.from({ length: maxYear - EARLIEST_BIRTH_YEAR + 1 }, (_, i) =>
+    (maxYear - i).toString(),
+  )
+}
+
+/**
+ * `compliance_missing_fields` entries this dialog can actually resolve.
+ *
+ * mitxonline flags `state`/`postal_code` as missing whenever they're empty,
+ * for *every* country (mitodl/mitxonline#3850) — not just
+ * {@link SUBDIVISION_COUNTRIES}, unlike the CyberSource check itself. The
+ * dialog only collects those two fields for US/CA, so for anyone else they
+ * can never be cleared. Counting them here would gate that entire population
+ * on every enroll attempt, forever, with no field in the form to fix it —
+ * so they're disregarded unless the stored country actually requires them.
+ */
+const relevantMissingFields = (user: User): string[] => {
+  const missing = user.compliance_missing_fields ?? []
+  if (requiresSubdivision(user.legal_address?.country)) return missing
+  return missing.filter((field) => field !== "state" && field !== "postal_code")
+}
+
+/**
+ * Whether the user must supply profile information before enrolling.
+ *
+ * Two independent reasons, either of which opens the dialog: MITx Online
+ * reports missing export-compliance fields, or we have no year of birth for
+ * the minimum-age requirement.
+ */
+const needsComplianceInfo = (user: User | undefined): boolean => {
+  if (!user) return false
+  return (
+    relevantMissingFields(user).length > 0 || !user.user_profile?.year_of_birth
+  )
+}
+
+/**
+ * Seed the form from the profile we already have.
+ *
+ * Every field is prefilled, not just the ones reported missing, so a value
+ * that is present but wrong can be corrected here — a field can also be
+ * reported missing while holding a whitespace-only value, which the backend
+ * treats as absent.
+ */
+const initialJitValues = (user: User | undefined): JitFormValues => {
+  const address = user?.legal_address
+  const yearOfBirth = user?.user_profile?.year_of_birth
+  return {
+    first_name: address?.first_name ?? "",
+    last_name: address?.last_name ?? "",
+    country: address?.country ?? "",
+    street_address_1: address?.street_address_1 ?? "",
+    street_address_2: address?.street_address_2 ?? "",
+    city: address?.city ?? "",
+    state: address?.state ?? "",
+    postal_code: address?.postal_code ?? "",
+    year_of_birth: yearOfBirth ? yearOfBirth.toString() : "",
+  }
+}
+
+/** Fields export compliance requires regardless of country, plus year of birth. */
+const ALWAYS_REQUIRED_FIELDS = [
+  "first_name",
+  "last_name",
+  "country",
+  "street_address_1",
+  "city",
+  "year_of_birth",
+] as const satisfies readonly JitField[]
+
+/** Fields required only for {@link SUBDIVISION_COUNTRIES}. */
+const SUBDIVISION_REQUIRED_FIELDS = [
+  "state",
+  "postal_code",
+] as const satisfies readonly JitField[]
+
+/**
+ * Whether a field is required given the currently *selected* country.
+ *
+ * Single source of truth: {@link jitSchema} validates against this, and the
+ * dialog marks inputs `required` from it, so the two cannot drift.
+ */
+const isFieldRequired = (
+  field: JitField,
+  country: string | null | undefined,
+): boolean => {
+  if ((ALWAYS_REQUIRED_FIELDS as readonly string[]).includes(field)) return true
+  return (
+    (SUBDIVISION_REQUIRED_FIELDS as readonly string[]).includes(field) &&
+    requiresSubdivision(country)
+  )
+}
+
+/**
+ * A string field whose required-ness is resolved from {@link isFieldRequired}
+ * against the sibling `country` value.
+ */
+const requiredWhen = (field: JitField, message: string) =>
+  Yup.string().when("country", {
+    is: (country: string) => isFieldRequired(field, country),
+    then: (schema) => schema.trim().required(message),
+    otherwise: (schema) => schema.optional(),
+  })
+
+/**
+ * Validation for the collected fields. `state` and `postal_code` become
+ * required reactively based on the selected country, per
+ * {@link SUBDIVISION_COUNTRIES}.
+ *
+ * `country` is declared directly rather than via {@link requiredWhen}: a
+ * `when("country")` on `country` itself would be a cyclic dependency.
+ */
+const jitSchema = Yup.object().shape({
+  first_name: requiredWhen("first_name", "First name is required"),
+  last_name: requiredWhen("last_name", "Last name is required"),
+  country: Yup.string().trim().required("Country is required"),
+  street_address_1: requiredWhen("street_address_1", "Address is required"),
+  street_address_2: Yup.string(),
+  city: requiredWhen("city", "City is required"),
+  state: requiredWhen("state", "State or province is required"),
+  // Generic on purpose: the field's own label switches between "Zip Code"
+  // (US) and "Postal Code" (CA), and this message has to read sensibly under
+  // either without needing its own country-reactive lookup.
+  postal_code: requiredWhen("postal_code", "ZIP/postal code is required"),
+  year_of_birth: requiredWhen("year_of_birth", "Year of birth is required"),
+})
+
+/**
+ * Build the `users/me` PATCH body.
+ *
+ * Because the dialog renders the whole address, we submit it whole rather
+ * than diffing, which sidesteps partial-update semantics on the nested
+ * serializer.
+ *
+ * `user_profile` is the exception: it is only included when `year_of_birth`
+ * actually changed from `currentYearOfBirth`. mitxonline's `UserSerializer`
+ * recomputes `addl_field_flag` from whatever keys are present in the
+ * `user_profile` payload rather than the stored profile, so a PATCH
+ * containing only `year_of_birth` unconditionally resets that flag to
+ * `false` — sending the branch on every submit would silently clobber it for
+ * any user who already had it set.
+ */
+const jitPatchPayload = (
+  values: JitFormValues,
+  currentYearOfBirth: number | null | undefined,
+): PatchedUserRequest => {
+  const legalAddress: LegalAddressRequest = {
+    first_name: values.first_name.trim(),
+    last_name: values.last_name.trim(),
+    country: values.country,
+    street_address_1: values.street_address_1.trim(),
+    street_address_2: values.street_address_2.trim(),
+    city: values.city.trim(),
+    // A US state, or a postal code entered while the field was visible, is
+    // meaningless under a country that has no subdivisions, so a
+    // previously-stored value is dropped rather than carried over.
+    state: requiresSubdivision(values.country) ? values.state : "",
+    postal_code: requiresSubdivision(values.country)
+      ? values.postal_code.trim()
+      : "",
+  }
+  const yearOfBirth = Number.parseInt(values.year_of_birth, 10)
+  const payload: PatchedUserRequest = { legal_address: legalAddress }
+  if (yearOfBirth !== currentYearOfBirth) {
+    payload.user_profile = { year_of_birth: yearOfBirth }
+  }
+  return payload
+}
+
+export {
+  JIT_FIELDS,
+  FIELD_SPECS,
+  MINIMUM_AGE,
+  requiresSubdivision,
+  postalCodeLabel,
+  subdivisionOptions,
+  isFieldRequired,
+  yearOfBirthOptions,
+  needsComplianceInfo,
+  initialJitValues,
+  jitSchema,
+  jitPatchPayload,
+}
+export type { JitField, JitFormValues }
diff --git a/frontends/main/src/test-utils/index.tsx b/frontends/main/src/test-utils/index.tsx
index 35dfad8e41..e13f853304 100644
--- a/frontends/main/src/test-utils/index.tsx
+++ b/frontends/main/src/test-utils/index.tsx
@@ -4,6 +4,7 @@ import { QueryClientProvider, QueryClient } from "@tanstack/react-query"
 import { ThemeProvider } from "ol-components"
 import { Provider as NiceModalProvider } from "@ebay/nice-modal-react"
 
+import { ComplianceGateProvider } from "@/common/mitxonline/useComplianceGate"
 import { makeBrowserQueryClient } from "@/app/getQueryClient"
 import { render } from "@testing-library/react"
 import { factories, setMockResponse } from "api/test-utils"
@@ -49,7 +50,9 @@ const TestProviders: React.FC<{
 }> = ({ children, queryClient }) => (
   <QueryClientProvider client={queryClient}>
     <ThemeProvider>
-      <NiceModalProvider>{children}</NiceModalProvider>
+      <NiceModalProvider>
+        <ComplianceGateProvider>{children}</ComplianceGateProvider>
+      </NiceModalProvider>
     </ThemeProvider>
   </QueryClientProvider>
 )
diff --git a/learning_resources/etl/posthog.py b/learning_resources/etl/posthog.py
index e0de751678..90e10e20a8 100644
--- a/learning_resources/etl/posthog.py
+++ b/learning_resources/etl/posthog.py
@@ -4,6 +4,7 @@
 import io
 import json
 import logging
+import uuid
 from collections.abc import Generator
 from datetime import UTC, datetime
 
@@ -14,6 +15,7 @@
 
 from learning_resources.models import LearningResource, LearningResourceViewEvent
 from learning_resources.utils import resource_upserted_actions
+from main.utils import chunks
 
 log = logging.getLogger(__name__)
 
@@ -29,6 +31,12 @@
 # properties holds the full PostHog client context per event.
 POSTHOG_EXTRACT_BATCH_SIZE = 1000
 
+# Events loaded per database round trip. The per-event path costs 2-8 queries
+# against a table of several million rows; batching brings a full backlog pass
+# back inside the celery visibility timeout, past which acks_late redelivers a
+# still-running task to another worker and the copies multiply.
+POSTHOG_LOAD_BATCH_SIZE = 1000
+
 
 @dataclasses.dataclass
 class PostHogLearningResourceViewEvent:
@@ -217,19 +225,193 @@ def load_posthog_lrd_view_event(
     return lr_event
 
 
+@dataclasses.dataclass
+class _NormalizedEvent:
+    """
+    A view event with its identifiers coerced to the types the ORM returns.
+
+    PostHog properties are JSON, so resource_id arrives as either an int or a
+    string and event_uuid as a string. The per-event path only ever handed
+    those to the ORM, which coerced them; the batch path compares them in
+    Python against values read back from the database, where "3235" != 3235 and
+    a str never equals a uuid.UUID. Coercing once, up front, keeps membership
+    tests, legacy adoption and the returned id set all in agreement.
+    """
+
+    resource_id: int
+    event_date: datetime
+    event_uuid: uuid.UUID
+    source: PostHogLearningResourceViewEvent
+
+
+def _normalize_events(
+    events: list[PostHogLearningResourceViewEvent],
+) -> list[_NormalizedEvent]:
+    """Coerce each event's identifiers, dropping any that cannot be parsed."""
+    normalized = []
+    for event in events:
+        try:
+            resource_id = int(event.resource_id)
+        except (TypeError, ValueError):
+            log.warning(
+                "Skipping lrd_view event for resource %r - invalid ID",
+                event.resource_id,
+            )
+            continue
+        try:
+            event_uuid = uuid.UUID(str(event.event_uuid))
+        except (TypeError, ValueError):
+            log.warning(
+                "Skipping lrd_view event for resource %s - malformed uuid %r",
+                resource_id,
+                event.event_uuid,
+            )
+            continue
+        normalized.append(
+            _NormalizedEvent(
+                resource_id=resource_id,
+                event_date=event.event_date,
+                event_uuid=event_uuid,
+                source=event,
+            )
+        )
+    return normalized
+
+
+def _claim_legacy_rows(
+    events: list[_NormalizedEvent],
+) -> list[tuple[int, uuid.UUID]]:
+    """
+    Pair each event with a distinct legacy row to adopt, where one exists.
+
+    Legacy rows predate event_uuid; stamping one stops a re-read S3 file
+    inserting a duplicate alongside it. The tail can hold several rows for the
+    same (resource, event_date), so a row is claimed at most once per batch.
+
+    Args:
+    - events (list[_NormalizedEvent]): events not already stored
+    Returns:
+    List of (row primary key, event uuid) pairs to stamp
+    """
+    wanted = {(event.resource_id, event.event_date) for event in events}
+    candidates: dict[tuple[int, datetime], list[int]] = {}
+    rows = (
+        LearningResourceViewEvent.objects.filter(
+            event_uuid__isnull=True,
+            learning_resource_id__in={key[0] for key in wanted},
+            event_date__in={key[1] for key in wanted},
+        )
+        .order_by("id")
+        .values_list("id", "learning_resource_id", "event_date")
+    )
+    for row_id, resource_id, event_date in rows:
+        key = (resource_id, event_date)
+        # The filter is a cross product of ids and dates rather than a set of
+        # exact pairs, so it also returns rows no event in this batch asked for.
+        if key in wanted:
+            candidates.setdefault(key, []).append(row_id)
+
+    assignments = []
+    for event in events:
+        available = candidates.get((event.resource_id, event.event_date))
+        if available:
+            assignments.append((available.pop(0), event.event_uuid))
+    return assignments
+
+
+def _load_posthog_lrd_view_event_batch(
+    events: list[PostHogLearningResourceViewEvent],
+) -> tuple[set[int], int]:
+    """
+    Load one batch of events.
+
+    Args:
+    - events (list[PostHogLearningResourceViewEvent]): the batch to load
+    Returns:
+    Tuple of (resource ids needing a recount, number of events loaded)
+    """
+    normalized = _normalize_events(events)
+    # Resolve every resource in one query. Ids are validated in
+    # _normalize_events first: a non-integer inside pk__in raises for the whole
+    # batch, where the per-event path skipped only its own event.
+    existing_resource_ids = set(
+        LearningResource.objects.filter(
+            pk__in={event.resource_id for event in normalized}
+        ).values_list("id", flat=True)
+    )
+    normalized = [
+        event for event in normalized if event.resource_id in existing_resource_ids
+    ]
+    if not normalized:
+        return set(), 0
+
+    # Most events arrive already stored: the extract re-reads the newest S3
+    # object every run, because its last_modified always postdates the events
+    # it holds.
+    stored_uuids = set(
+        LearningResourceViewEvent.objects.filter(
+            event_uuid__in=[event.event_uuid for event in normalized]
+        ).values_list("event_uuid", flat=True)
+    )
+    resource_ids = {event.resource_id for event in normalized}
+    new_events = [event for event in normalized if event.event_uuid not in stored_uuids]
+    if not new_events:
+        return resource_ids, 0
+
+    assignments = _claim_legacy_rows(new_events)
+    if assignments:
+        adopted = [
+            LearningResourceViewEvent(pk=row_id, event_uuid=event_uuid)
+            for row_id, event_uuid in assignments
+        ]
+        try:
+            with transaction.atomic():
+                LearningResourceViewEvent.objects.bulk_update(
+                    adopted, ["event_uuid"], batch_size=POSTHOG_LOAD_BATCH_SIZE
+                )
+        except IntegrityError:
+            # A concurrent run adopted one of these rows for the same uuid.
+            # bulk_update fails the whole batch where the per-event path fails
+            # a single event, so fall back to it rather than lose the batch.
+            log.info(
+                "Legacy view event adoption raced for %d row(s); "
+                "falling back to per-event load",
+                len(adopted),
+            )
+            loaded = [
+                event
+                for event in new_events
+                if load_posthog_lrd_view_event(event.source) is not None
+            ]
+            return resource_ids, len(loaded)
+
+    LearningResourceViewEvent.objects.bulk_create(
+        [
+            LearningResourceViewEvent(
+                learning_resource_id=event.resource_id,
+                event_date=event.event_date,
+                event_uuid=event.event_uuid,
+            )
+            for event in new_events
+        ],
+        # ON CONFLICT DO NOTHING against the partial unique index on event_uuid.
+        # Atomic where get_or_create is a read-then-write race, so overlapping
+        # runs converge instead of raising.
+        ignore_conflicts=True,
+        batch_size=POSTHOG_LOAD_BATCH_SIZE,
+    )
+    return resource_ids, len(new_events)
+
+
 def load_posthog_lrd_view_events(
     events: iter,
 ) -> set[int]:
     """
     Load PostHogLearningResourceViewEvents into the database.
 
-    Consumes `events` one at a time and keeps only the set of learning resource
-    ids that need recounting. Returning the loaded rows instead -- as the
-    per-resource loaders in loaders.py do -- is safe at their scale but not
-    here: this is called once with a generator over the whole S3 backlog, and
-    load_posthog_lrd_view_event returns a row on every path (including the
-    early return for an event that is already stored), so retaining them meant
-    holding a model instance per event for millions of events.
+    Consumes `events` in batches and keeps only the set of learning resource
+    ids that need recounting, so memory stays bounded by one batch rather than
+    by the size of the backlog.
 
     Args:
     - events (iterable[PostHogLearningResourceViewEvent]): the events to load
@@ -239,14 +421,13 @@ def load_posthog_lrd_view_events(
 
     attempted = 0
     loaded = 0
-    learning_resource_ids = set()
+    learning_resource_ids: set[int] = set()
 
-    for event in events:
-        attempted += 1
-        lr_event = load_posthog_lrd_view_event(event)
-        if lr_event is not None:
-            loaded += 1
-            learning_resource_ids.add(lr_event.learning_resource_id)
+    for batch in chunks(events, chunk_size=POSTHOG_LOAD_BATCH_SIZE):
+        attempted += len(batch)
+        batch_resource_ids, batch_loaded = _load_posthog_lrd_view_event_batch(batch)
+        learning_resource_ids |= batch_resource_ids
+        loaded += batch_loaded
 
     log.info(
         "PostHog lrd_view load: %d event(s) attempted, %d loaded, "
diff --git a/learning_resources/etl/posthog_test.py b/learning_resources/etl/posthog_test.py
index 8e62ce6a9c..2f33d73911 100644
--- a/learning_resources/etl/posthog_test.py
+++ b/learning_resources/etl/posthog_test.py
@@ -1,10 +1,12 @@
 """Tests for the PostHog ETL library."""
 
+import uuid
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 
 import pytest
-from django.db import IntegrityError
+from django.db import IntegrityError, connection
+from django.test.utils import CaptureQueriesContext
 from freezegun import freeze_time
 
 from learning_resources.etl import posthog
@@ -220,3 +222,167 @@ def test_load_posthog_lrd_view_event_adoption_lost_to_concurrent_run(mocker):
 
     assert lr_event is not None
     assert LearningResourceViewEvent.objects.filter(event_uuid=event_uuid).count() == 1
+
+
+def _view_event(resource_id, *, minutes_ago=0):
+    """Build a transformed event without going through parquet."""
+    return posthog.PostHogLearningResourceViewEvent(
+        resource_id=resource_id,
+        event_date=now_in_utc() - timedelta(minutes=minutes_ago),
+        event_uuid=str(uuid.uuid4()),
+    )
+
+
+@pytest.mark.django_db
+def test_load_posthog_lrd_view_events_does_not_query_per_event(mocker):
+    """
+    Query count must not scale with the number of events.
+
+    The per-event path cost 2-8 queries each, which is what made a full backlog
+    pass outrun the celery visibility timeout; past that, acks_late redelivers
+    the still-running task to another worker and the copies multiply until they
+    own the pool.
+    """
+    mocker.patch(
+        "learning_resources.etl.posthog.resource_upserted_actions", autospec=True
+    )
+    resource = LearningResourceFactory.create()
+
+    with CaptureQueriesContext(connection) as small:
+        posthog.load_posthog_lrd_view_events(
+            [_view_event(resource.id, minutes_ago=i) for i in range(5)]
+        )
+    with CaptureQueriesContext(connection) as large:
+        posthog.load_posthog_lrd_view_events(
+            [_view_event(resource.id, minutes_ago=i) for i in range(100, 200)]
+        )
+
+    assert LearningResourceViewEvent.objects.count() == 105
+    # 20x the events, same number of round trips: both fit in one batch.
+    assert len(large.captured_queries) == len(small.captured_queries)
+
+
+@pytest.mark.django_db
+def test_load_posthog_lrd_view_events_spans_batches(mocker, settings):
+    """Events beyond one batch are still loaded."""
+    mocker.patch(
+        "learning_resources.etl.posthog.resource_upserted_actions", autospec=True
+    )
+    mocker.patch.object(posthog, "POSTHOG_LOAD_BATCH_SIZE", 10)
+    resource = LearningResourceFactory.create()
+
+    recounted = posthog.load_posthog_lrd_view_events(
+        [_view_event(resource.id, minutes_ago=i) for i in range(25)]
+    )
+
+    assert recounted == {resource.id}
+    assert LearningResourceViewEvent.objects.count() == 25
+
+
+@pytest.mark.django_db
+def test_load_posthog_lrd_view_events_survives_invalid_resource_id(mocker):
+    """
+    A malformed resource id skips its own event, not the whole batch.
+
+    The per-event path caught ValueError per event; batched, an unfiltered bad
+    id inside pk__in would raise and lose every event alongside it.
+    """
+    mocker.patch(
+        "learning_resources.etl.posthog.resource_upserted_actions", autospec=True
+    )
+    resource = LearningResourceFactory.create()
+    events = [
+        _view_event(resource.id, minutes_ago=1),
+        _view_event("not-an-integer", minutes_ago=2),
+        _view_event(resource.id, minutes_ago=3),
+    ]
+
+    recounted = posthog.load_posthog_lrd_view_events(events)
+
+    assert recounted == {resource.id}
+    assert LearningResourceViewEvent.objects.count() == 2
+
+
+@pytest.mark.django_db
+def test_load_posthog_lrd_view_events_is_idempotent(mocker):
+    """Re-loading the same events inserts nothing further.
+
+    bulk_create(ignore_conflicts=True) leans on the partial unique index over
+    event_uuid, so a repeat run -- which is every run, since the newest S3
+    object is always re-read -- converges instead of duplicating.
+    """
+    mocker.patch(
+        "learning_resources.etl.posthog.resource_upserted_actions", autospec=True
+    )
+    resource = LearningResourceFactory.create()
+    events = [_view_event(resource.id, minutes_ago=i) for i in range(10)]
+
+    posthog.load_posthog_lrd_view_events(events)
+    posthog.load_posthog_lrd_view_events(events)
+
+    assert LearningResourceViewEvent.objects.count() == 10
+
+
+@pytest.mark.django_db
+def test_load_posthog_lrd_view_events_accepts_string_resource_id(mocker):
+    """
+    A resource id that arrives as a string still loads.
+
+    PostHog properties are JSON, so learning_resource_id can be either an int
+    or a string. The per-event path handed it to filter(pk=...), which coerced
+    it; the batch path compares it against ids read back from the database,
+    where "3235" != 3235 would drop the event without a trace.
+    """
+    mocker.patch(
+        "learning_resources.etl.posthog.resource_upserted_actions", autospec=True
+    )
+    resource = LearningResourceFactory.create()
+
+    recounted = posthog.load_posthog_lrd_view_events(
+        [_view_event(str(resource.id), minutes_ago=1)]
+    )
+
+    assert recounted == {resource.id}
+    assert LearningResourceViewEvent.objects.count() == 1
+
+
+@pytest.mark.django_db
+def test_load_posthog_lrd_view_events_batch_survives_adoption_race(mocker):
+    """
+    An IntegrityError from bulk_update loads the batch per-event instead.
+
+    bulk_update fails the whole batch where the per-event savepoint fails a
+    single event, so without this fallback one adoption race would lose every
+    event alongside it.
+    """
+    mocker.patch(
+        "learning_resources.etl.posthog.resource_upserted_actions", autospec=True
+    )
+    resource = LearningResourceFactory.create()
+    events = [_view_event(resource.id, minutes_ago=i) for i in range(1, 4)]
+
+    # A legacy row for the first event, so the adoption path is reached at all.
+    LearningResourceViewEventFactory.create(
+        learning_resource=resource,
+        event_date=events[0].event_date,
+        event_uuid=None,
+    )
+    bulk_update = mocker.patch.object(
+        LearningResourceViewEvent.objects,
+        "bulk_update",
+        side_effect=IntegrityError("adopted concurrently"),
+    )
+
+    recounted = posthog.load_posthog_lrd_view_events(events)
+
+    assert bulk_update.called
+    assert recounted == {resource.id}
+    # All three survive via the per-event fallback: the legacy row adopted by
+    # the first event, plus a fresh row for each of the other two.
+    assert LearningResourceViewEvent.objects.count() == 3
+    assert (
+        LearningResourceViewEvent.objects.filter(
+            event_uuid__in=[uuid.UUID(event.event_uuid) for event in events]
+        ).count()
+        == 3
+    )
diff --git a/main/settings.py b/main/settings.py
index 9e83a06a57..24e420f437 100644
--- a/main/settings.py
+++ b/main/settings.py
@@ -36,7 +36,7 @@
 from main.settings_pluggy import *  # noqa: F403
 from openapi.settings_spectacular import open_spectacular_settings
 
-VERSION = "0.77.7"
+VERSION = "0.77.8"
 
 log = logging.getLogger()
 
@@ -800,6 +800,18 @@ def get_all_config_keys():
     name="QDRANT_ENCODER", default="vector_search.encoders.gensim.GensimEncoder"
 )
 
+# Max Sentry alerts the embeddings healthcheck sends per alert type per run. The
+# healthcheck reports per resource, so an environment that is simply behind on
+# embedding (e.g. RC) would otherwise burn thousands of events in one run.
+# Production should set this high (a large backlog there is a real incident, not
+# expected drift); 0 or less disables the cap entirely. The default is deliberately
+# low so an unconfigured environment can't spend the quota, and the cap sends one
+# explicit notice when it engages, so a capped run is never mistaken for a clean one.
+EMBEDDINGS_HEALTHCHECK_ALERT_CAP = get_int(
+    name="EMBEDDINGS_HEALTHCHECK_ALERT_CAP",
+    default=20,
+)
+
 QDRANT_POINT_UPLOAD_BATCH_SIZE = get_int(
     name="QDRANT_POINT_UPLOAD_BATCH_SIZE", default=1000
 )
diff --git a/openapi/specs/v1.yaml b/openapi/specs/v1.yaml
index a052fcef65..b972580b41 100644
--- a/openapi/specs/v1.yaml
+++ b/openapi/specs/v1.yaml
@@ -9864,10 +9864,12 @@ paths:
         name: course_id
         schema:
           type: string
+          nullable: true
       - in: query
         name: course_readable_id
         schema:
           type: string
+          nullable: true
       - in: query
         name: source
         schema:
@@ -10445,8 +10447,10 @@ components:
           $ref: '#/components/schemas/SourceEnum'
         course_id:
           type: string
+          nullable: true
         course_readable_id:
           type: string
+          nullable: true
       required:
       - source
     ContentFileWebHookRequestRequest:
@@ -10459,8 +10463,10 @@ components:
           $ref: '#/components/schemas/SourceEnum'
         course_id:
           type: string
+          nullable: true
         course_readable_id:
           type: string
+          nullable: true
       required:
       - source
     Course:
diff --git a/vector_search/tasks.py b/vector_search/tasks.py
index 1d933c37c1..c465c6283a 100644
--- a/vector_search/tasks.py
+++ b/vector_search/tasks.py
@@ -1,5 +1,6 @@
 import datetime
 import logging
+from uuid import uuid4
 
 import celery
 import grpc
@@ -18,7 +19,6 @@
 )
 from learning_resources.serializers import (
     ContentFileSerializer,
-    LearningResourceSerializer,
 )
 from learning_resources.utils import load_course_blocklist
 from learning_resources_search.constants import (
@@ -60,6 +60,23 @@
 
 EMBED_FAILURE_TTL = 60 * 60 * 24  # 24h defensive cleanup for the per-run counter
 
+# point ids per Qdrant existence lookup in the healthcheck tasks
+HEALTHCHECK_POINT_BATCH_SIZE = 200
+
+# resources per batched resource-embedding check task. Checking a resource is one
+# payload-free point, so batching trades task count for Qdrant round trips: at 1 per
+# task a full run costs one round trip per resource.
+HEALTHCHECK_RESOURCE_BATCH_SIZE = 200
+
+# content files per batched content-file check task. Lower than the resource batch:
+# each one is serialized with its chunked text, so this bounds the text a worker
+# holds at once
+HEALTHCHECK_CONTENT_FILE_BATCH_SIZE = 100
+
+# TTL for the per-run Sentry alert counters; long enough to outlive a healthcheck
+# run (including redelivered tasks) and short enough to not accumulate in redis
+HEALTHCHECK_ALERT_TTL = 60 * 60 * 24
+
 
 def _record_embedding_failure(failure_key: str) -> None:
     """Bump the per-invocation embedding-failure counter in the shared redis cache."""
@@ -603,113 +620,197 @@ def remove_unpublished_run_content_files(self, run_id):
     return _replace_with_chain(self, tasks)
 
 
-@app.task
-def embeddings_healthcheck():
+@app.task(bind=True, acks_late=True, reject_on_worker_lost=True)
+def embeddings_healthcheck(self):
     """
-    Check for missing embeddings and summaries in Qdrant and log warnings to Sentry
+    Dispatch the embeddings healthcheck as a group of independent, self-reporting
+    tasks: batches of resources, batches of content files, and the summaries check.
+
+    Both checks are dispatched over their own rows, so nothing is queued for a
+    resource with no content files, and neither list is built from the other.
     """
+    resources = LearningResource.objects.filter(Q(published=True) | Q(test_mode=True))
+    resource_ids = list(resources.order_by("id").values_list("id", flat=True))
+
+    # streamed with iterator(): there are far more content files than resources, and
+    # only one batch of ids needs to be in memory at a time to build the signatures
+    content_file_ids = (
+        ContentFile.objects.filter(published=True)
+        .exclude(Q(content="") | Q(content__isnull=True))
+        .filter(
+            Q(run__learning_resource__in=resources) | Q(learning_resource__in=resources)
+        )
+        .order_by("id")
+        .values_list("id", flat=True)
+        .iterator(chunk_size=HEALTHCHECK_CONTENT_FILE_BATCH_SIZE)
+    )
 
-    remaining_content_file_ids = []
-    remaining_resources = []
-    resource_point_ids = {}
-    all_resources = LearningResource.objects.filter(
-        Q(published=True) | Q(test_mode=True)
+    # scopes the per-run Sentry alert cap: every task dispatched here shares one
+    # budget. Redelivery reuses the same task id, so a culled and re-dispatched run
+    # keeps its already-spent budget rather than paying for the same alerts twice.
+    # A direct call (a shell invocation rather than delay()) has no task id, and
+    # falling back to a generated key keeps the cap on: without one, this would hand
+    # every dispatched task run_key=None and uncap the entire run.
+    run_key = self.request.id or str(uuid4())
+
+    content_file_tasks = [
+        embeddings_healthcheck_content_files.si(batch, run_key=run_key)
+        for batch in chunks(
+            content_file_ids, chunk_size=HEALTHCHECK_CONTENT_FILE_BATCH_SIZE
+        )
+    ]
+    resource_tasks = [
+        embeddings_healthcheck_resource_embeddings.si(batch, run_key=run_key)
+        for batch in chunks(resource_ids, chunk_size=HEALTHCHECK_RESOURCE_BATCH_SIZE)
+    ]
+    log.info(
+        "Embeddings healthcheck dispatching %d resource batches for %d resources "
+        "and %d content file batches",
+        len(resource_tasks),
+        len(resource_ids),
+        len(content_file_tasks),
     )
 
-    for lr in all_resources:
-        serialized = LearningResourceSerializer(lr).data
-        point_id = vector_point_id(vector_point_key(serialized))
-        resource_point_ids[point_id] = {"resource_id": lr.readable_id, "id": lr.id}
-        content_file_point_ids = {}
-        # All runs are embedded in Qdrant, not just best_run.
-        content_files = ContentFile.objects.for_serialization().filter(
-            Q(run__learning_resource=lr) | Q(learning_resource=lr),
-            published=True,
+    return self.replace(
+        celery.group(
+            [
+                summaries_healthcheck.si(run_key=run_key),
+                *resource_tasks,
+                *content_file_tasks,
+            ]
         )
-        for cf in content_files:
-            if cf and cf.content:
-                serialized_cf = ContentFileSerializer(cf).data
-                point_id = vector_point_id(
-                    vector_point_key(
-                        serialized_cf, chunk_number=0, document_type="content_file"
-                    )
-                )
-                content_file_point_ids[point_id] = {"key": cf.key, "id": cf.id}
-        for batch in chunks(content_file_point_ids.keys(), chunk_size=200):
-            remaining_content_files = filter_existing_qdrant_points_by_ids(
-                batch, collection_name=CONTENT_FILES_COLLECTION_NAME
-            )
-            remaining_content_file_ids.extend(
-                [
-                    content_file_point_ids.get(p, {}).get("id")
-                    for p in remaining_content_files
-                ]
-            )
+    )
 
+
+@app.task(acks_late=True, reject_on_worker_lost=True)
+def embeddings_healthcheck_resource_embeddings(resource_ids, run_key=None):
+    """
+    Check a batch of learning resources for their own missing embeddings in Qdrant
+    and report the findings to Sentry.
+
+    Batched: each resource contributes one point and no payload, so the cost here is
+    Qdrant round trips rather than memory.
+
+    Read-only, so re-running after a worker is culled mid-check is safe.
+    """
+    # Build the point ids from the same bulk serialization the embedding pipeline
+    # uses, so the healthcheck can't disagree with it about a resource's point key.
+    resource_point_ids = {
+        vector_point_id(vector_point_key(serialized)): serialized["_id"]
+        for serialized in serialize_bulk_learning_resources(resource_ids)
+    }
+
+    missing_resource_ids = []
     for batch in chunks(
-        all_resources.values_list("id", flat=True),
-        chunk_size=200,
+        resource_point_ids.keys(), chunk_size=HEALTHCHECK_POINT_BATCH_SIZE
     ):
-        remaining_resources.extend(
-            filter_existing_qdrant_points_by_ids(
-                [
-                    vector_point_id(vector_point_key(serialized_resource))
-                    for serialized_resource in serialize_bulk_learning_resources(batch)
-                ],
-                collection_name=RESOURCES_COLLECTION_NAME,
+        missing_resource_ids.extend(
+            resource_point_ids[p]
+            for p in filter_existing_qdrant_points_by_ids(
+                batch, collection_name=RESOURCES_COLLECTION_NAME
             )
+            if p in resource_point_ids
         )
 
-    remaining_resource_ids = [
-        resource_point_ids.get(p, {}).get("id") for p in remaining_resources
-    ]
-    missing_summaries = _missing_summaries()
-    log.info(
-        "Embeddings healthcheck found %d missing content file embeddings",
-        len(remaining_content_file_ids),
-    )
-    log.info(
-        "Embeddings healthcheck found %d missing resource embeddings",
-        len(remaining_resources),
-    )
     log.info(
-        "Embeddings healthcheck found %d missing summaries and flashcards",
-        len(missing_summaries),
+        "Embeddings healthcheck: %d of %d resources missing their embedding",
+        len(missing_resource_ids),
+        len(resource_ids),
     )
 
-    if len(remaining_content_file_ids) > 0:
+    # one alert per batch rather than per resource: the ids identify the resources
+    # without spending an alert (and a slice of the per-run cap) on each one
+    if missing_resource_ids:
         _sentry_healthcheck_log(
             "embeddings",
-            "missing_content_file_embeddings",
+            "missing_learning_resource_embeddings",
             {
-                "count": len(remaining_content_file_ids),
-                "ids": remaining_content_file_ids,
-                "run_ids": set(
-                    ContentFile.objects.filter(
-                        id__in=remaining_content_file_ids
-                    ).values_list("run__run_id", flat=True)[:100]
+                "count": len(missing_resource_ids),
+                "ids": missing_resource_ids,
+                "readable_ids": list(
+                    LearningResource.objects.filter(
+                        id__in=missing_resource_ids
+                    ).values_list("readable_id", flat=True)[:100]
                 ),
             },
-            f"Warning: {len(remaining_content_file_ids)} missing content file "
-            "embeddings detected",
+            "Warning: learning resources are missing their embeddings",
+            run_key=run_key,
+        )
+
+
+@app.task(acks_late=True, reject_on_worker_lost=True)
+def embeddings_healthcheck_content_files(content_file_ids, run_key=None):
+    """
+    Check a batch of content files for missing embeddings in Qdrant and report the
+    findings to Sentry.
+
+    Batched over content files rather than over the resources that own them: the
+    batch size then bounds how much serialized text a worker holds at once,
+    regardless of how many content files any one resource has.
+
+    Read-only, so re-running after a worker is culled mid-check is safe.
+    """
+    missing_content_file_ids = []
+
+    content_file_point_ids = {}
+    # All runs are embedded in Qdrant, not just best_run, so this batch is drawn from
+    # content files directly rather than from any one run.
+    for cf in ContentFile.objects.for_serialization().filter(id__in=content_file_ids):
+        if cf and cf.content:
+            serialized_cf = ContentFileSerializer(cf).data
+            point_id = vector_point_id(
+                vector_point_key(
+                    serialized_cf, chunk_number=0, document_type="content_file"
+                )
+            )
+            content_file_point_ids[point_id] = cf.id
+    for batch in chunks(
+        content_file_point_ids.keys(), chunk_size=HEALTHCHECK_POINT_BATCH_SIZE
+    ):
+        missing_content_file_ids.extend(
+            content_file_point_ids[p]
+            for p in filter_existing_qdrant_points_by_ids(
+                batch, collection_name=CONTENT_FILES_COLLECTION_NAME
+            )
+            if p in content_file_point_ids
         )
 
-    if len(remaining_resources) > 0:
+    log.info(
+        "Embeddings healthcheck: %d of %d content files missing embeddings",
+        len(missing_content_file_ids),
+        len(content_file_ids),
+    )
+
+    if missing_content_file_ids:
         _sentry_healthcheck_log(
             "embeddings",
-            "missing_learning_resource_embeddings",
+            "missing_content_file_embeddings",
             {
-                "count": len(remaining_resource_ids),
-                "ids": remaining_resource_ids,
-                "titles": list(
-                    LearningResource.objects.filter(
-                        id__in=remaining_resource_ids
-                    ).values_list("title", flat=True)
+                "count": len(missing_content_file_ids),
+                "ids": missing_content_file_ids,
+                "run_ids": set(
+                    ContentFile.objects.filter(
+                        id__in=missing_content_file_ids
+                    ).values_list("run__run_id", flat=True)[:100]
                 ),
             },
-            f"Warning: {len(remaining_resource_ids)} missing learning resource "
-            "embeddings detected",
+            "Warning: content files are missing embeddings",
+            run_key=run_key,
         )
+
+
+@app.task(acks_late=True, reject_on_worker_lost=True)
+def summaries_healthcheck(run_key=None):
+    """
+    Check for content files missing summaries/flashcards and report to Sentry.
+
+    Read-only, so re-running after a worker is culled is safe.
+    """
+    missing_summaries = _missing_summaries()
+    log.info(
+        "Embeddings healthcheck found %d missing summaries and flashcards",
+        len(missing_summaries),
+    )
     if len(missing_summaries) > 0:
         _sentry_healthcheck_log(
             "embeddings",
@@ -723,8 +824,8 @@ def embeddings_healthcheck():
                     )[:100]
                 ),
             },
-            f"Warning: {len(missing_summaries)} missing content file summaries "
-            "detected",
+            "Warning: missing content file summaries detected",
+            run_key=run_key,
         )
 
 
@@ -749,14 +850,78 @@ def _missing_summaries():
     )
 
 
-def _sentry_healthcheck_log(healthcheck, alert_type, context, message):
+def _capture_healthcheck_message(healthcheck, alert_type, context, message):
+    """Send one healthcheck message to Sentry, uncapped."""
     with sentry_sdk.new_scope() as scope:
         scope.set_tag("healthcheck", healthcheck)
         scope.set_tag("alert_type", alert_type)
-        scope.set_context("missing_content_file_embeddings", context)
+        # key the context off the alert so resource/summary alerts don't file their
+        # payload under a content-file key
+        scope.set_context(alert_type, context)
         sentry_sdk.capture_message(message)
 
 
+def _healthcheck_alert_count(run_key, alert_type):
+    """
+    Atomically count this run's alerts of one type, so the per-run cap holds across
+    every worker running the healthcheck's tasks.
+    """
+    cache = caches["redis"]
+    key = f"healthcheck_alerts:{run_key}:{alert_type}"
+    try:
+        return cache.incr(key)
+    except ValueError:  # key absent
+        # add() is atomic, so exactly one of the workers racing to create the counter
+        # wins it; the losers fall through to incr instead of each resetting it to 1
+        # and handing every racer the same count of 1
+        if cache.add(key, 1, HEALTHCHECK_ALERT_TTL):
+            return 1
+        try:
+            return cache.incr(key)
+        except ValueError:
+            # expired between add() and incr(): only reachable if this run outlives
+            # HEALTHCHECK_ALERT_TTL, in which case counting from 1 again is right
+            return 1
+
+
+def _sentry_healthcheck_log(healthcheck, alert_type, context, message, run_key=None):
+    """
+    Report a healthcheck finding to Sentry, capped per run per alert type.
+
+    The healthcheck reports per resource, so an environment that is merely behind on
+    embedding produces one alert per affected resource. Without a cap that is
+    thousands of events for a single expected condition. run_key scopes the counter
+    to one healthcheck run; callers without one (direct calls, tests) are uncapped.
+
+    Each alert type gets its own budget: the checks are independent signals, and a
+    run works through resources for hours, so a shared budget would be spent by
+    whichever check happens to find something first.
+    """
+    cap = settings.EMBEDDINGS_HEALTHCHECK_ALERT_CAP
+    if run_key and cap > 0:
+        count = _healthcheck_alert_count(run_key, alert_type)
+        if count > cap:
+            # the count is atomic, so exactly one worker sees cap + 1 and the notice
+            # is sent once: a capped run must never look like a run that only found
+            # `cap` problems
+            if count == cap + 1:
+                log.warning(
+                    "Embeddings healthcheck reached the Sentry alert cap (%d) for %s; "
+                    "further alerts of this type are suppressed for this run",
+                    cap,
+                    alert_type,
+                )
+                _capture_healthcheck_message(
+                    healthcheck,
+                    f"{alert_type}_suppressed",
+                    {"suppressed_alert_type": alert_type, "cap": cap},
+                    "Warning: healthcheck alerts suppressed after reaching the "
+                    "per-run cap",
+                )
+            return
+    _capture_healthcheck_message(healthcheck, alert_type, context, message)
+
+
 @app.task(acks_late=True, reject_on_worker_lost=True)
 def sync_topics():
     """
diff --git a/vector_search/tasks_test.py b/vector_search/tasks_test.py
index e821d5bc16..ccf67a3a1d 100644
--- a/vector_search/tasks_test.py
+++ b/vector_search/tasks_test.py
@@ -6,6 +6,7 @@
 from celery.exceptions import Retry
 from django.conf import settings
 from django.core.cache.backends.locmem import LocMemCache
+from django.db.models import Q
 
 from learning_resources.etl.constants import (
     RESOURCE_FILE_ETL_SOURCES,
@@ -28,23 +29,31 @@
     PROGRAM_TYPE,
 )
 from learning_resources_search.exceptions import RetryError
-from learning_resources_search.serializers import serialize_bulk_content_files
+from learning_resources_search.serializers import (
+    serialize_bulk_content_files,
+    serialize_bulk_learning_resources,
+)
 from main.utils import now_in_utc
 from vector_search.constants import CONTENT_FILE_PREPASS_PAYLOAD_FIELDS
 from vector_search.tasks import (
+    _healthcheck_alert_count,
     _record_embedding_failure,
     _retry_countdown,
+    _sentry_healthcheck_log,
     embed_learning_resources_by_id,
     embed_new_content_files,
     embed_new_learning_resources,
     embed_run_content_files,
     embeddings_healthcheck,
+    embeddings_healthcheck_content_files,
+    embeddings_healthcheck_resource_embeddings,
     finalize_embeddings,
     generate_embeddings,
     remove_embeddings,
     remove_run_content_files,
     remove_unpublished_run_content_files,
     start_embed_resources,
+    summaries_healthcheck,
 )
 from vector_search.utils import vector_point_id, vector_point_key
 
@@ -998,80 +1007,518 @@ def test_embed_run_content_files_all_unchanged_dispatches_nothing(
     mocked_celery.chain.assert_not_called()
 
 
-def test_embeddings_healthcheck_no_missing_embeddings(mocker):
+def _missing_everything(batch, collection_name=None):
+    """Report every point in the batch as absent from Qdrant."""
+    return list(batch)
+
+
+def _missing_only(collection):
+    """Report every point absent for one collection, nothing missing elsewhere."""
+
+    def fake_filter(batch, collection_name=None):
+        return list(batch) if collection_name == collection else []
+
+    return fake_filter
+
+
+def test_embeddings_healthcheck_dispatches_batches_of_each_kind(mocker, mocked_celery):
+    """
+    embeddings_healthcheck should dispatch batches of resources and batches of content
+    files, each drawn from its own rows, plus the standalone summaries task
     """
-    Test embeddings_healthcheck when there are no missing embeddings
+    resources = LearningResourceFactory.create_batch(5, published=True)
+    content_files = [
+        ContentFileFactory.create(
+            run=None, learning_resource=resource, content="test", published=True
+        )
+        for resource in resources
+    ]
+    LearningResourceFactory.create_batch(2, published=False, test_mode=False)
+    expected_ids = sorted(
+        LearningResource.objects.filter(
+            Q(published=True) | Q(test_mode=True)
+        ).values_list("id", flat=True)
+    )
+    mocker.patch("vector_search.tasks.HEALTHCHECK_RESOURCE_BATCH_SIZE", 2)
+    mocker.patch("vector_search.tasks.HEALTHCHECK_CONTENT_FILE_BATCH_SIZE", 2)
+    mock_resource_check = mocker.patch(
+        "vector_search.tasks.embeddings_healthcheck_resource_embeddings", autospec=True
+    )
+    mock_content_check = mocker.patch(
+        "vector_search.tasks.embeddings_healthcheck_content_files", autospec=True
+    )
+    mock_summaries = mocker.patch(
+        "vector_search.tasks.summaries_healthcheck", autospec=True
+    )
+
+    with pytest.raises(mocked_celery.replace_exception_class):
+        embeddings_healthcheck.delay()
+
+    # the resource check is batched, and every eligible resource lands in a batch
+    resource_batches = [call.args[0] for call in mock_resource_check.si.mock_calls]
+    assert all(len(batch) <= 2 for batch in resource_batches)
+    assert sorted(rid for batch in resource_batches for rid in batch) == expected_ids
+    # the content-file check is batched over content files, not over their resources
+    content_batches = [call.args[0] for call in mock_content_check.si.mock_calls]
+    assert all(len(batch) <= 2 for batch in content_batches)
+    assert sorted(cid for batch in content_batches for cid in batch) == sorted(
+        cf.id for cf in content_files
+    )
+    assert mocked_celery.group.call_count == 1
+    assert mocked_celery.replace.call_args[0][1] == mocked_celery.group.return_value
+    assert mocked_celery.group.call_args[0][0][0] is mock_summaries.si.return_value
+    # every dispatched task shares one run_key, so they share one Sentry alert budget
+    run_keys = (
+        {call.kwargs["run_key"] for call in mock_resource_check.si.mock_calls}
+        | {call.kwargs["run_key"] for call in mock_content_check.si.mock_calls}
+        | {call.kwargs["run_key"] for call in mock_summaries.si.mock_calls}
+    )
+    assert len(run_keys) == 1
+    assert next(iter(run_keys)) is not None
+
+
+def test_embeddings_healthcheck_dispatch_only_queues_checkable_content_files(
+    mocker, mocked_celery
+):
+    """
+    Only content files the check could report on are queued -- published, with
+    content, belonging to an eligible resource. Anything else is a batch slot spent on
+    a file the check would skip, and a resource with no content files at all never
+    costs a task.
+    """
+    published_resource = LearningResourceFactory.create(
+        published=True, create_runs=False
+    )
+    run = LearningResourceRunFactory.create(
+        published=True, learning_resource=published_resource
+    )
+    by_run = ContentFileFactory.create(run=run, content="test", published=True)
+    by_resource = ContentFileFactory.create(
+        run=None, learning_resource=published_resource, content="test", published=True
+    )
+
+    # none of these should reach a content-file task
+    ContentFileFactory.create(
+        run=None, learning_resource=published_resource, content="test", published=False
+    )
+    ContentFileFactory.create(
+        run=None, learning_resource=published_resource, content="", published=True
+    )
+    ContentFileFactory.create(
+        run=None, learning_resource=published_resource, content=None, published=True
+    )
+    unpublished_resource = LearningResourceFactory.create(
+        published=False, test_mode=False, create_runs=False
+    )
+    ContentFileFactory.create(
+        run=None, learning_resource=unpublished_resource, content="test", published=True
+    )
+    # a resource with no content files at all costs no content-file task
+    LearningResourceFactory.create(published=True, create_runs=False)
+
+    mock_content_check = mocker.patch(
+        "vector_search.tasks.embeddings_healthcheck_content_files", autospec=True
+    )
+    mocker.patch(
+        "vector_search.tasks.embeddings_healthcheck_resource_embeddings", autospec=True
+    )
+    mocker.patch("vector_search.tasks.summaries_healthcheck", autospec=True)
+
+    with pytest.raises(mocked_celery.replace_exception_class):
+        embeddings_healthcheck.delay()
+
+    queued_ids = sorted(
+        cid for call in mock_content_check.si.mock_calls for cid in call.args[0]
+    )
+    assert queued_ids == sorted([by_run.id, by_resource.id])
+
+
+def test_embeddings_healthcheck_caps_a_direct_invocation(mocker, mocked_celery):
+    """
+    A direct call -- embeddings_healthcheck() in a shell rather than delay() -- has no
+    task id. Without a generated fallback every dispatched task would get
+    run_key=None, and one manual run would send an uncapped alert per affected
+    resource.
+    """
+    LearningResourceFactory.create_batch(3, published=True)
+    mock_resource_check = mocker.patch(
+        "vector_search.tasks.embeddings_healthcheck_resource_embeddings", autospec=True
+    )
+    mocker.patch(
+        "vector_search.tasks.embeddings_healthcheck_content_files", autospec=True
+    )
+    mocker.patch("vector_search.tasks.summaries_healthcheck", autospec=True)
+
+    with pytest.raises(mocked_celery.replace_exception_class):
+        embeddings_healthcheck()
+
+    run_keys = {call.kwargs["run_key"] for call in mock_resource_check.si.mock_calls}
+    assert len(run_keys) == 1
+    assert next(iter(run_keys)) is not None
+
+
+def test_embeddings_healthcheck_content_files_no_missing_embeddings(mocker):
+    """
+    A content-file check should stay silent when Qdrant has every point it checks
     """
     lr = LearningResourceFactory.create(published=True)
     LearningResourceRunFactory.create(published=True, learning_resource=lr)
-    ContentFileFactory.create(run=lr.runs.first(), content="test", published=True)
+    cf = ContentFileFactory.create(run=lr.runs.first(), content="test", published=True)
     mock_sentry = mocker.patch("vector_search.tasks.sentry_sdk", autospec=True)
     mocker.patch(
         "vector_search.tasks.filter_existing_qdrant_points_by_ids", return_value=[]
     )
 
-    embeddings_healthcheck()
+    embeddings_healthcheck_content_files([cf.id])
     assert mock_sentry.capture_message.call_count == 0
 
 
-def test_embeddings_healthcheck_missing_both(mocker):
+def test_embeddings_healthcheck_resource_embeddings_no_missing(mocker):
+    """
+    A batched resource check should stay silent when Qdrant has every point
+    """
+    resources = LearningResourceFactory.create_batch(3, published=True)
+    mock_log = mocker.patch("vector_search.tasks._sentry_healthcheck_log")
+    mocker.patch(
+        "vector_search.tasks.filter_existing_qdrant_points_by_ids", return_value=[]
+    )
+
+    embeddings_healthcheck_resource_embeddings([lr.id for lr in resources])
+    assert mock_log.call_count == 0
+
+
+def test_embeddings_healthcheck_resource_embeddings_batches_qdrant_lookups(mocker):
+    """
+    A batch must cost one Qdrant lookup per HEALTHCHECK_POINT_BATCH_SIZE points rather
+    than one per resource: checking resources one at a time is what turned a full run
+    into thousands of round trips.
+    """
+    resources = LearningResourceFactory.create_batch(5, published=True)
+    mocker.patch("vector_search.tasks.HEALTHCHECK_POINT_BATCH_SIZE", 2)
+    mock_filter = mocker.patch(
+        "vector_search.tasks.filter_existing_qdrant_points_by_ids", return_value=[]
+    )
+
+    embeddings_healthcheck_resource_embeddings([lr.id for lr in resources])
+
+    # 5 points at 2 per lookup is 3 lookups, not 5
+    assert mock_filter.call_count == 3
+
+
+def test_embeddings_healthcheck_resource_embeddings_reports_the_batch_once(mocker):
+    """
+    A batch sends one alert listing the resources it found, rather than one alert per
+    resource, so a batch costs a single slice of the per-run cap
+    """
+    resources = LearningResourceFactory.create_batch(3, published=True)
+    mocker.patch(
+        "vector_search.tasks.filter_existing_qdrant_points_by_ids",
+        side_effect=_missing_everything,
+    )
+    mock_log = mocker.patch("vector_search.tasks._sentry_healthcheck_log")
+
+    embeddings_healthcheck_resource_embeddings([lr.id for lr in resources])
+
+    assert mock_log.call_count == 1
+    assert mock_log.mock_calls[0].args[1] == "missing_learning_resource_embeddings"
+    context = mock_log.mock_calls[0].args[2]
+    assert context["count"] == len(resources)
+    assert sorted(context["ids"]) == sorted(lr.id for lr in resources)
+    # the readable ids identify the resources without needing a lookup from Sentry
+    assert sorted(context["readable_ids"]) == sorted(lr.readable_id for lr in resources)
+
+
+def test_embeddings_healthcheck_resource_embeddings_ignores_present_resources(mocker):
+    """
+    Only the resources Qdrant is actually missing are reported, so a batch can't
+    implicate the resources it merely shared a task with
+    """
+    present, missing = LearningResourceFactory.create_batch(2, published=True)
+    missing_point_ids = [
+        vector_point_id(vector_point_key(serialized))
+        for serialized in serialize_bulk_learning_resources([missing.id])
+    ]
+    mocker.patch(
+        "vector_search.tasks.filter_existing_qdrant_points_by_ids",
+        side_effect=lambda point_ids, **_: [
+            p for p in point_ids if p in missing_point_ids
+        ],
+    )
+    mock_log = mocker.patch("vector_search.tasks._sentry_healthcheck_log")
+
+    embeddings_healthcheck_resource_embeddings([present.id, missing.id])
+
+    assert mock_log.call_count == 1
+    assert mock_log.mock_calls[0].args[2]["ids"] == [missing.id]
+
+
+def test_embeddings_healthcheck_reports_both_kinds_of_gap(mocker):
     """
-    Test embeddings_healthcheck when there are missing content files and learning resources
+    The two checks together report both the missing content files and the missing
+    resource embeddings, each under its own alert type carrying its own ids
     """
     lr = LearningResourceFactory.create(published=True, create_runs=False)
     LearningResourceRunFactory.create(published=True, learning_resource=lr)
     cf = ContentFileFactory.create(run=lr.runs.first(), content="test", published=True)
     mocker.patch(
         "vector_search.tasks.filter_existing_qdrant_points_by_ids",
-        side_effect=[
-            [vector_point_id(lr.readable_id)],
-            [
-                vector_point_id(
-                    f"{cf.run.learning_resource.id}.{cf.run.run_id}.{cf.key}.0"
-                )
-            ],
-        ],
+        side_effect=_missing_everything,
     )
-    mock_sentry = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+    mock_log = mocker.patch("vector_search.tasks._sentry_healthcheck_log")
 
-    embeddings_healthcheck()
+    embeddings_healthcheck_content_files([cf.id])
+    embeddings_healthcheck_resource_embeddings([lr.id])
 
-    assert mock_sentry.call_count == 2
+    assert mock_log.call_count == 2
+    by_alert_type = {call.args[1]: call.args[2] for call in mock_log.mock_calls}
+    assert by_alert_type["missing_content_file_embeddings"]["ids"] == [cf.id]
+    assert by_alert_type["missing_learning_resource_embeddings"]["ids"] == [lr.id]
+    # each alert carries the ids it found rather than a count alone
+    for context in by_alert_type.values():
+        assert context["count"] == 1
 
 
-def test_embeddings_healthcheck_checks_all_runs(mocker):
+def test_embeddings_healthcheck_content_files_checks_all_runs(mocker):
     """
-    embeddings_healthcheck should check content files from every run, not just best_run
+    A content-file check should check content files from every run, not just best_run
     """
     from vector_search.constants import CONTENT_FILES_COLLECTION_NAME
 
     lr = LearningResourceFactory.create(published=True, create_runs=False)
     run_a = LearningResourceRunFactory.create(published=True, learning_resource=lr)
     run_b = LearningResourceRunFactory.create(published=True, learning_resource=lr)
-    ContentFileFactory.create(run=run_a, content="test", published=True)
-    ContentFileFactory.create(run=run_b, content="test", published=True)
+    cf_a = ContentFileFactory.create(run=run_a, content="test", published=True)
+    cf_b = ContentFileFactory.create(run=run_b, content="test", published=True)
 
-    def fake_filter(batch, collection_name=None):
-        # report every content file point as missing, no missing resources
-        return list(batch) if collection_name == CONTENT_FILES_COLLECTION_NAME else []
+    mocker.patch(
+        "vector_search.tasks.filter_existing_qdrant_points_by_ids",
+        side_effect=_missing_only(CONTENT_FILES_COLLECTION_NAME),
+    )
+    mock_log = mocker.patch("vector_search.tasks._sentry_healthcheck_log")
+
+    embeddings_healthcheck_content_files([cf_a.id, cf_b.id])
+
+    assert mock_log.call_count == 1
+    assert mock_log.mock_calls[0].args[1] == "missing_content_file_embeddings"
+    context = mock_log.mock_calls[0].args[2]
+    assert context["count"] == 2
+    assert sorted(context["ids"]) == sorted([cf_a.id, cf_b.id])
+
+
+def test_embeddings_healthcheck_content_files_ignores_files_outside_its_batch(mocker):
+    """
+    A batch only reports the content files it was given, so sibling tasks can't
+    double-report the same content files
+    """
+    mine = LearningResourceFactory.create(published=True, create_runs=False)
+    run_mine = LearningResourceRunFactory.create(published=True, learning_resource=mine)
+    my_cf = ContentFileFactory.create(run=run_mine, content="test", published=True)
+
+    theirs = LearningResourceFactory.create(published=True, create_runs=False)
+    run_theirs = LearningResourceRunFactory.create(
+        published=True, learning_resource=theirs
+    )
+    other_cf = ContentFileFactory.create(run=run_theirs, content="test", published=True)
 
     mocker.patch(
         "vector_search.tasks.filter_existing_qdrant_points_by_ids",
-        side_effect=fake_filter,
+        side_effect=_missing_everything,
     )
-    mock_sentry = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+    mock_log = mocker.patch("vector_search.tasks._sentry_healthcheck_log")
 
-    embeddings_healthcheck()
+    embeddings_healthcheck_content_files([my_cf.id])
 
-    assert (
-        mock_sentry.mock_calls[0].args[0]
-        == "Warning: 2 missing content file embeddings detected"
+    reported_file_ids = {
+        file_id
+        for call in mock_log.mock_calls
+        for file_id in call.args[2].get("ids", [])
+    }
+    assert reported_file_ids == {my_cf.id}
+    assert other_cf.id not in reported_file_ids
+
+
+def test_embeddings_healthcheck_sentry_messages_are_count_free(mocker):
+    """
+    Sentry messages must not interpolate counts or ids, or the per-resource
+    reports each become a separate Sentry issue instead of grouped occurrences
+    of one. Details live in the context, which is keyed by alert_type.
+    """
+    lr = LearningResourceFactory.create(published=True, create_runs=False)
+    LearningResourceRunFactory.create(published=True, learning_resource=lr)
+    cf = ContentFileFactory.create(run=lr.runs.first(), content="test", published=True)
+    mocker.patch(
+        "vector_search.tasks.filter_existing_qdrant_points_by_ids",
+        side_effect=_missing_everything,
     )
+    mock_scope = mocker.MagicMock()
+    mocker.patch(
+        "vector_search.tasks.sentry_sdk.new_scope"
+    ).return_value.__enter__.return_value = mock_scope
+    mock_capture = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+
+    embeddings_healthcheck_content_files([cf.id])
+    embeddings_healthcheck_resource_embeddings([lr.id])
+
+    messages = [call.args[0] for call in mock_capture.mock_calls]
+    assert set(messages) == {
+        "Warning: content files are missing embeddings",
+        "Warning: learning resources are missing their embeddings",
+    }
+    assert not any(char.isdigit() for message in messages for char in message)
+    # context key tracks the alert, so resource alerts aren't filed under a
+    # content-file key
+    context_keys = [call.args[0] for call in mock_scope.set_context.mock_calls]
+    assert sorted(context_keys) == [
+        "missing_content_file_embeddings",
+        "missing_learning_resource_embeddings",
+    ]
+
+
+def test_sentry_healthcheck_log_caps_alerts_per_run(mocker, embed_cache, settings):
+    """
+    An environment that is simply behind on embedding produces one alert per
+    affected resource, so the per-run cap must stop sending after the limit rather
+    than spending the whole Sentry quota on one expected condition.
+    """
+    settings.EMBEDDINGS_HEALTHCHECK_ALERT_CAP = 3
+    mock_capture = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+
+    for _ in range(10):
+        _sentry_healthcheck_log(
+            "embeddings", "missing_thing", {"a": 1}, "Warning: thing", run_key="run-1"
+        )
+
+    messages = [call.args[0] for call in mock_capture.mock_calls]
+    # 3 real alerts, then exactly one notice that the cap engaged, then silence
+    assert messages == [
+        "Warning: thing",
+        "Warning: thing",
+        "Warning: thing",
+        "Warning: healthcheck alerts suppressed after reaching the per-run cap",
+    ]
+
+
+def test_sentry_healthcheck_log_cap_is_per_alert_type(mocker, embed_cache, settings):
+    """
+    Each alert type gets its own budget, so a flood of one kind can't hide a
+    different kind of failure entirely. A run works through resources for hours, so a
+    shared budget would go to whichever check found something first.
+    """
+    settings.EMBEDDINGS_HEALTHCHECK_ALERT_CAP = 1
+    mock_capture = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+
+    for _ in range(50):
+        _sentry_healthcheck_log(
+            "embeddings", "type_a", {}, "Warning: a", run_key="run-1"
+        )
+    _sentry_healthcheck_log("embeddings", "type_b", {}, "Warning: b", run_key="run-1")
+
+    messages = [call.args[0] for call in mock_capture.mock_calls]
+    assert messages.count("Warning: a") == 1
+    assert messages.count("Warning: b") == 1
+
+
+def test_sentry_healthcheck_log_notifies_once_per_capped_type(
+    mocker, embed_cache, settings
+):
+    """
+    Each capped type reports that it was capped exactly once, so a capped run is
+    never mistaken for a clean one and isn't itself a flood
+    """
+    settings.EMBEDDINGS_HEALTHCHECK_ALERT_CAP = 1
+    mock_capture = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+
+    for alert_type in ("type_a", "type_b"):
+        for _ in range(5):
+            _sentry_healthcheck_log(
+                "embeddings", alert_type, {}, f"Warning: {alert_type}", run_key="run-1"
+            )
+
+    messages = [call.args[0] for call in mock_capture.mock_calls]
+    suppressed = "Warning: healthcheck alerts suppressed after reaching the per-run cap"
+    assert messages.count(suppressed) == 2
+
+
+def test_healthcheck_alert_count_does_not_reset_on_concurrent_create(
+    mocker, embed_cache
+):
+    """
+    Workers racing to create a run's counter must not each be handed a count of 1:
+    the healthcheck fans out across workers, so a lost count means the cap overshoots
+    by however many raced.
+    """
+    real_incr = embed_cache.incr
+    raises_left = 2
+
+    def racing_incr(*args, **kwargs):
+        # both racers check the counter before either has created it, so both see it
+        # as absent; afterwards the key really does exist
+        nonlocal raises_left
+        if raises_left:
+            raises_left -= 1
+            raise ValueError
+        return real_incr(*args, **kwargs)
+
+    mocker.patch.object(embed_cache, "incr", side_effect=racing_incr)
+
+    counts = [_healthcheck_alert_count("run-1", "type_a") for _ in range(2)]
+
+    # the racer that won add() counts 1; the loser falls through to a real incr
+    # rather than resetting the counter and counting 1 as well
+    assert counts == [1, 2]
+
+
+def test_sentry_healthcheck_log_cap_is_per_run(mocker, embed_cache, settings):
+    """
+    The budget resets between runs, so a capped run doesn't silence the next one
+    """
+    settings.EMBEDDINGS_HEALTHCHECK_ALERT_CAP = 1
+    mock_capture = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+
+    for run_key in ("run-1", "run-2"):
+        for _ in range(3):
+            _sentry_healthcheck_log(
+                "embeddings", "missing_thing", {}, "Warning: thing", run_key=run_key
+            )
+
+    messages = [call.args[0] for call in mock_capture.mock_calls]
+    assert messages.count("Warning: thing") == 2
+
+
+@pytest.mark.parametrize("cap", [0, -1])
+def test_sentry_healthcheck_log_cap_disabled(mocker, embed_cache, settings, cap):
+    """
+    A cap of 0 or less disables capping, for environments (production) where a
+    large backlog is a real incident rather than expected drift
+    """
+    settings.EMBEDDINGS_HEALTHCHECK_ALERT_CAP = cap
+    mock_capture = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+
+    for _ in range(10):
+        _sentry_healthcheck_log(
+            "embeddings", "missing_thing", {}, "Warning: thing", run_key="run-1"
+        )
+
+    assert mock_capture.call_count == 10
+
+
+def test_sentry_healthcheck_log_uncapped_without_run_key(mocker, embed_cache, settings):
+    """
+    Callers with no run_key (direct invocations) are uncapped, so the cap can't
+    silently swallow one-off checks
+    """
+    settings.EMBEDDINGS_HEALTHCHECK_ALERT_CAP = 1
+    mock_capture = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
+
+    for _ in range(5):
+        _sentry_healthcheck_log("embeddings", "missing_thing", {}, "Warning: thing")
+
+    assert mock_capture.call_count == 5
 
 
-def test_embeddings_healthcheck_missing_summaries(mocker):
+def test_summaries_healthcheck_missing_summaries(mocker):
     """
-    Test embeddings_healthcheck for missing contentfile summaries/flashcards
+    Test summaries_healthcheck for missing contentfile summaries/flashcards
     """
     content_extension = [".srt"]
     content_type = ["file"]
@@ -1107,17 +1554,17 @@ def test_embeddings_healthcheck_missing_summaries(mocker):
     )
     mock_sentry = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
 
-    embeddings_healthcheck()
+    summaries_healthcheck()
     assert mock_sentry.call_count == 1
     assert (
         mock_sentry.mock_calls[0].args[0]
-        == "Warning: 1 missing content file summaries detected"
+        == "Warning: missing content file summaries detected"
     )
 
 
-def test_embeddings_healthcheck_excludes_already_summarized(mocker):
+def test_summaries_healthcheck_excludes_already_summarized(mocker):
     """
-    embeddings_healthcheck should not count content files that already have
+    summaries_healthcheck should not count content files that already have
     a summary as missing (regression test for passing overwrite=True
     implicitly by mis-ordering get_unprocessed_content_file_ids arguments)
     """
@@ -1156,13 +1603,13 @@ def test_embeddings_healthcheck_excludes_already_summarized(mocker):
     )
     mock_sentry = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
 
-    embeddings_healthcheck()
+    summaries_healthcheck()
     assert mock_sentry.call_count == 0
 
 
-def test_embeddings_healthcheck_summaries_scoped_to_require_summaries(mocker):
+def test_summaries_healthcheck_scoped_to_require_summaries(mocker):
     """
-    embeddings_healthcheck should only count missing summaries for learning
+    summaries_healthcheck should only count missing summaries for learning
     resources that require them, not every learning resource (regression
     test for get_unprocessed_content_file_ids never receiving
     learning_resource_ids)
@@ -1201,7 +1648,7 @@ def test_embeddings_healthcheck_summaries_scoped_to_require_summaries(mocker):
     )
     mock_sentry = mocker.patch("vector_search.tasks.sentry_sdk.capture_message")
 
-    embeddings_healthcheck()
+    summaries_healthcheck()
     assert mock_sentry.call_count == 0
 
 
diff --git a/vector_search/utils.py b/vector_search/utils.py
index ba3d574944..b61ecc1247 100644
--- a/vector_search/utils.py
+++ b/vector_search/utils.py
@@ -1587,11 +1587,15 @@ def filter_existing_qdrant_points_by_ids(
     Return only points that dont exist in qdrant
     """
     client = qdrant_client()
+    # existence check only: payloads/vectors would be fetched and discarded, and for
+    # content files the payload carries the chunked text
     response = client.retrieve(
         collection_name=collection_name,
         ids=point_ids,
+        with_payload=False,
+        with_vectors=False,
     )
-    existing = [record.id for record in response]
+    existing = {record.id for record in response}
     return [point_id for point_id in point_ids if point_id not in existing]
 
 
diff --git a/webhooks/serializers.py b/webhooks/serializers.py
index 9438d77c7e..ecbb272849 100644
--- a/webhooks/serializers.py
+++ b/webhooks/serializers.py
@@ -18,8 +18,10 @@ class ContentFileWebHookRequestSerializer(serializers.Serializer):
     content_path = serializers.CharField(required=False, allow_blank=True)
     source_choices = [(e.name.lower(), e.value) for e in ETLSource]
     source = serializers.ChoiceField(choices=source_choices)
-    course_id = serializers.CharField(required=False, allow_blank=True)
-    course_readable_id = serializers.CharField(required=False, allow_blank=True)
+    course_id = serializers.CharField(required=False, allow_blank=True, allow_null=True)
+    course_readable_id = serializers.CharField(
+        required=False, allow_blank=True, allow_null=True
+    )
 
 
 class OVSVideoWebhookRequestSerializer(serializers.Serializer):
diff --git a/webhooks/views_test.py b/webhooks/views_test.py
index cb24298e40..f40b5da1af 100644
--- a/webhooks/views_test.py
+++ b/webhooks/views_test.py
@@ -185,6 +185,36 @@ def test_content_file_webhook_view_canvas_success(settings, client, mocker):
     mock_ingest.assert_called_once_with(["/path/to/canvas/course.tar.gz", False])
 
 
+@pytest.mark.django_db
+@pytest.mark.parametrize(
+    ("course_id", "course_readable_id"),
+    [(2198, None), (None, "2198")],
+)
+def test_content_file_webhook_view_canvas_null_id(
+    settings, client, mocker, course_id, course_readable_id
+):
+    """
+    Test ContentFileWebhookView accepts Canvas create webhooks with null IDs
+    """
+    url = reverse("webhooks:v1:content_file_webhook")
+    mock_ingest = mocker.patch("webhooks.views.ingest_canvas_course.apply_async")
+
+    data = {
+        "source": ETLSource.canvas.name,
+        "content_path": "/path/to/canvas/course.tar.gz",
+        "course_id": course_id,
+        "course_readable_id": course_readable_id,
+    }
+    response = client.post(
+        url,
+        data=json.dumps(data),
+        content_type="application/json",
+        headers={"X-MITLearn-Signature": get_secret(data, settings)},
+    )
+    assert response.status_code == 200
+    mock_ingest.assert_called_once_with(["/path/to/canvas/course.tar.gz", False])
+
+
 @pytest.mark.django_db
 @pytest.mark.parametrize(
     ("etl_source", "content_path", "readable_id"),
diff --git a/yarn.lock b/yarn.lock
index 7680650f4e..6a60e76cf0 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3631,13 +3631,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@mitodl/mitxonline-api-axios@npm:2026.8.6":
-  version: 2026.8.6
-  resolution: "@mitodl/mitxonline-api-axios@npm:2026.8.6"
+"@mitodl/mitxonline-api-axios@npm:2026.8.18":
+  version: 2026.8.18
+  resolution: "@mitodl/mitxonline-api-axios@npm:2026.8.18"
   dependencies:
     "@types/node": "npm:^20.11.19"
     axios: "npm:^1.6.5"
-  checksum: 10/88e68269e1b9e5fb2e79d97ea7232e131dfc4a73d0cb6b0193b2a5cbc24af5eef8f3dbd4f9a63347fbcbd715364bf54b48a2eb9d32b71c7c18186d96ac4d3e8c
+  checksum: 10/5efd646218d5da28446b06da59327041a6604926828de8ea896847a37b96159a66f899482031888e2f4303af23fa4b684687b6bda893e14297da6541b2699a2d
   languageName: node
   linkType: hard
 
@@ -9550,7 +9550,7 @@ __metadata:
   dependencies:
     "@faker-js/faker": "npm:^10.0.0"
     "@mitodl/mit-learn-api-axios": "npm:2026.7.22"
-    "@mitodl/mitxonline-api-axios": "npm:2026.8.6"
+    "@mitodl/mitxonline-api-axios": "npm:2026.8.18"
     "@tanstack/react-query": "npm:^5.66.0"
     "@testing-library/react": "npm:^16.3.0"
     axios: "npm:^1.12.2"
@@ -16898,7 +16898,7 @@ __metadata:
     "@mitodl/arithmix": "npm:^0.2.3"
     "@mitodl/course-search-utils": "npm:^3.5.2"
     "@mitodl/hacksnack": "npm:^0.1.1"
-    "@mitodl/mitxonline-api-axios": "npm:2026.8.6"
+    "@mitodl/mitxonline-api-axios": "npm:2026.8.18"
     "@mitodl/smoot-design": "npm:6.31.1"
     "@mui/base": "npm:5.0.0-beta.70"
     "@mui/material": "npm:^6.4.5"