diff --git a/apps/web/components/dashboard/quota-banner.test.tsx b/apps/web/components/dashboard/quota-banner.test.tsx
new file mode 100644
index 000000000..04c14dbe4
--- /dev/null
+++ b/apps/web/components/dashboard/quota-banner.test.tsx
@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import { QuotaRejectionDetail } from "./quota-banner";
+
+/** The text a reader sees: everything outside `<...>` tags in rendered markup. */
+function visibleText(html: string): string {
+  let text = "";
+  let inTag = false;
+  for (const char of html) {
+    if (char === "<") inTag = true;
+    else if (char === ">") inTag = false;
+    else if (!inTag) text += char;
+  }
+  return text;
+}
+
+describe("QuotaRejectionDetail", () => {
+  it("renders nothing before any webhook was rejected", () => {
+    expect(renderToStaticMarkup(<QuotaRejectionDetail rejections={null} />)).toBe("");
+    expect(
+      renderToStaticMarkup(
+        <QuotaRejectionDetail rejections={{ total: 0, endpointCount: 0, endpoints: [] }} />
+      )
+    ).toBe("");
+  });
+
+  it("names the total and each affected endpoint", () => {
+    const html = renderToStaticMarkup(
+      <QuotaRejectionDetail
+        rejections={{
+          total: 1420,
+          endpointCount: 2,
+          endpoints: [
+            { slug: "stripe-prod", rejected: 1000 },
+            { slug: "gh-staging", rejected: 420 },
+          ],
+        }}
+      />
+    );
+    const text = visibleText(html);
+    expect(text).toBe(
+      "1,420 webhooks rejected this period on stripe-prod (1,000), gh-staging (420)."
+    );
+    expect(html).toContain('<code class="font-mono">stripe-prod</code>');
+  });
+
+  it("uses singular wording and summarizes unlisted endpoints", () => {
+    const one = renderToStaticMarkup(
+      <QuotaRejectionDetail
+        rejections={{ total: 1, endpointCount: 1, endpoints: [{ slug: "solo", rejected: 1 }] }}
+      />
+    );
+    expect(visibleText(one)).toBe("1 webhook rejected this period on solo (1).");
+
+    const many = renderToStaticMarkup(
+      <QuotaRejectionDetail
+        rejections={{ total: 9, endpointCount: 4, endpoints: [{ slug: "a", rejected: 9 }] }}
+      />
+    );
+    expect(visibleText(many)).toBe(
+      "9 webhooks rejected this period on a (9) and 3 more endpoints."
+    );
+  });
+
+  it("escapes slugs", () => {
+    const html = renderToStaticMarkup(
+      <QuotaRejectionDetail
+        rejections={{
+          total: 1,
+          endpointCount: 1,
+          endpoints: [{ slug: "<script>x</script>", rejected: 1 }],
+        }}
+      />
+    );
+    expect(html).not.toContain("<script>");
+  });
+});
diff --git a/apps/web/components/dashboard/quota-banner.tsx b/apps/web/components/dashboard/quota-banner.tsx
index 965465c19..175174248 100644
--- a/apps/web/components/dashboard/quota-banner.tsx
+++ b/apps/web/components/dashboard/quota-banner.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useEffect, useState } from "react";
+import { Fragment, useEffect, useState } from "react";
 import Link from "next/link";
 import { OctagonAlert } from "lucide-react";
 import { useAuth } from "@/components/providers/supabase-auth-provider";
@@ -8,8 +8,40 @@ import { UpgradeButton } from "@/components/billing/upgrade-button";
 import { ACCOUNT_PROFILE_SELECT, type AccountProfile } from "@/lib/account-profile";
 import { isQuotaExhausted } from "@/lib/quota";
 import { createClient } from "@/lib/supabase/client";
+import type { QuotaRejections } from "@/lib/supabase/quota-rejections";
 import { subscribeToUserProfileChanges } from "@/lib/supabase/realtime";
 
+function plural(count: number, one: string, many: string): string {
+  return `${count.toLocaleString("en-US")} ${count === 1 ? one : many}`;
+}
+
+/**
+ * What the receiver has turned away this period, per endpoint. Renders nothing
+ * until a webhook has actually been rejected: the banner appears the moment
+ * the quota runs out, before the first 429.
+ */
+export function QuotaRejectionDetail({ rejections }: { rejections: QuotaRejections | null }) {
+  if (!rejections || rejections.total <= 0 || rejections.endpoints.length === 0) return null;
+
+  const more = Math.max(0, rejections.endpointCount - rejections.endpoints.length);
+  return (
+    <p className="text-sm">
+      <span className="font-medium">
+        {plural(rejections.total, "webhook", "webhooks")} rejected this period
+      </span>{" "}
+      on{" "}
+      {rejections.endpoints.map((endpoint, index) => (
+        <Fragment key={endpoint.slug}>
+          {index > 0 && ", "}
+          <code className="font-mono">{endpoint.slug}</code> (
+          {endpoint.rejected.toLocaleString("en-US")})
+        </Fragment>
+      ))}
+      {more > 0 && ` and ${plural(more, "more endpoint", "more endpoints")}`}.
+    </p>
+  );
+}
+
 /**
  * Shown while the receiver is rejecting the user's webhooks with 429. Without
  * it a capped user only sees captures stop arriving; usage lives on /account.
@@ -21,6 +53,7 @@ export function QuotaBanner() {
   const [profile, setProfile] = useState<AccountProfile | null>(null);
   const [nowMs, setNowMs] = useState(() => Date.now());
   const [teamBilledEndpoints, setTeamBilledEndpoints] = useState(0);
+  const [rejections, setRejections] = useState<QuotaRejections | null>(null);
   const userId = user?.id;
   const accessToken = session?.access_token ?? null;
 
@@ -60,14 +93,17 @@ export function QuotaBanner() {
   const exhausted = isQuotaExhausted(profile, nowMs);
   const periodEnd = profile?.period_end ?? null;
 
-  // team_endpoints is not readable by clients, so ask the usage route.
+  // team_endpoints and endpoint_daily_stats are not readable by clients, so ask
+  // the usage route.
   useEffect(() => {
     if (!exhausted || !accessToken) return;
     let cancelled = false;
     void fetch("/api/usage", { headers: { Authorization: `Bearer ${accessToken}` } })
       .then((response) => (response.ok ? response.json() : null))
-      .then((usage: { teamBilledEndpoints?: number } | null) => {
-        if (!cancelled) setTeamBilledEndpoints(usage?.teamBilledEndpoints ?? 0);
+      .then((usage: { teamBilledEndpoints?: number; quotaRejections?: QuotaRejections } | null) => {
+        if (cancelled) return;
+        setTeamBilledEndpoints(usage?.teamBilledEndpoints ?? 0);
+        setRejections(usage?.quotaRejections ?? null);
       })
       .catch(() => {});
     return () => {
@@ -103,6 +139,7 @@ export function QuotaBanner() {
             {teamBilledEndpoints > 0 &&
               " Endpoints shared with a team use the team's quota and keep capturing."}
           </p>
+          <QuotaRejectionDetail rejections={rejections} />
           <p className="text-sm text-muted-foreground">
             {isFree
               ? "Pro raises the limit to 100,000 requests a month for $8/month. "
diff --git a/apps/web/lib/changelog.ts b/apps/web/lib/changelog.ts
index 6ed88555a..31afa93f6 100644
--- a/apps/web/lib/changelog.ts
+++ b/apps/web/lib/changelog.ts
@@ -15,13 +15,24 @@ export const TRACK_LABELS: Record<ChangelogTrack, string> = {
   mcp: "MCP",
 };
 
-export const APP_VERSION = "0.40.3";
+export const APP_VERSION = "0.40.4";
 export const CLI_VERSION = "1.4.1";
 export const SDK_VERSION = "1.15.0";
 export const MCP_VERSION = "1.12.1";
 
 export const CHANGELOG: ChangelogEntry[] = [
   // ─── Web App ────────────────────────────────────────────────────────
+  {
+    version: "0.40.4",
+    date: "2026-10-22",
+    title: "Rejected Webhook Counts in Quota Alerts",
+    track: "web",
+    items: [
+      "The quota-exhausted email and the dashboard quota banner now say how many webhooks were rejected this period and on which endpoints, most rejected first, with the rest summarized as a count",
+      "Rejections on endpoints billed to a subscribed team are left out, matching the existing note that those endpoints keep capturing",
+      "New get_quota_rejections() database function (migration 00060) reads the per-endpoint counts from endpoint_daily_stats; /api/usage returns them as quotaRejections while the quota is exhausted",
+    ],
+  },
   {
     version: "0.40.3",
     date: "2026-10-20",
diff --git a/apps/web/lib/email/quota-exhausted-email.test.ts b/apps/web/lib/email/quota-exhausted-email.test.ts
index ba82bff32..50b9eb578 100644
--- a/apps/web/lib/email/quota-exhausted-email.test.ts
+++ b/apps/web/lib/email/quota-exhausted-email.test.ts
@@ -36,4 +36,92 @@ describe("buildQuotaExhaustedEmail", () => {
     expect(message.html).toContain('href="https://webhooks.cc/account/plan"');
     expect(message.html).toContain('href="https://webhooks.cc/teams"');
   });
+  describe("rejected webhooks", () => {
+    const base = {
+      to: "dev@example.com",
+      requestLimit: 50,
+      periodEnd: new Date("2026-09-29T18:30:00Z"),
+      teamBilledEndpoints: 0,
+      appUrl: "https://webhooks.cc",
+    };
+
+    it("keeps the generic copy when nothing has been rejected yet", () => {
+      for (const rejections of [undefined, null, { total: 0, endpointCount: 0, endpoints: [] }]) {
+        const email = buildQuotaExhaustedEmail({ ...base, rejections });
+        expect(email.text).toBe(message.text);
+        expect(email.html).toBe(message.html);
+      }
+    });
+
+    it("lists the total and each affected endpoint", () => {
+      const email = buildQuotaExhaustedEmail({
+        ...base,
+        rejections: {
+          total: 1420,
+          endpointCount: 2,
+          endpoints: [
+            { slug: "stripe-prod", rejected: 1000 },
+            { slug: "gh-staging", rejected: 420 },
+          ],
+        },
+      });
+      expect(email.text).toContain(
+        "So far in this period 1,420 webhooks were rejected across 2 endpoints:"
+      );
+      expect(email.text).toContain("  stripe-prod: 1,000 rejected webhooks");
+      expect(email.text).toContain("  gh-staging: 420 rejected webhooks");
+      expect(email.text).not.toContain("more endpoint");
+      expect(email.html).toContain("<li><code>stripe-prod</code>: 1,000 rejected webhooks</li>");
+      expect(email.html).toContain("<li><code>gh-staging</code>: 420 rejected webhooks</li>");
+    });
+
+    it("uses singular wording for one webhook on one endpoint", () => {
+      const email = buildQuotaExhaustedEmail({
+        ...base,
+        rejections: { total: 1, endpointCount: 1, endpoints: [{ slug: "solo", rejected: 1 }] },
+      });
+      expect(email.text).toContain("1 webhook was rejected across 1 endpoint:");
+      expect(email.text).toContain("  solo: 1 rejected webhook");
+      expect(email.text).not.toContain("1 rejected webhooks");
+    });
+
+    it("summarizes endpoints beyond the listed ones", () => {
+      const email = buildQuotaExhaustedEmail({
+        ...base,
+        rejections: {
+          total: 900,
+          endpointCount: 4,
+          endpoints: [
+            { slug: "a", rejected: 500 },
+            { slug: "b", rejected: 300 },
+          ],
+        },
+      });
+      expect(email.text).toContain("  and 2 more endpoints");
+      expect(email.html).toContain("<li>and 2 more endpoints</li>");
+    });
+
+    it("places the rejection list before the upgrade call to action", () => {
+      const email = buildQuotaExhaustedEmail({
+        ...base,
+        rejections: { total: 5, endpointCount: 1, endpoints: [{ slug: "a", rejected: 5 }] },
+      });
+      expect(email.text.indexOf("  a: 5 rejected webhooks")).toBeLessThan(
+        email.text.indexOf("Upgrade to Pro")
+      );
+    });
+
+    it("escapes slugs in the HTML variant", () => {
+      const email = buildQuotaExhaustedEmail({
+        ...base,
+        rejections: {
+          total: 2,
+          endpointCount: 1,
+          endpoints: [{ slug: `<img src=x onerror="alert(1)">`, rejected: 2 }],
+        },
+      });
+      expect(email.html).not.toContain("<img");
+      expect(email.html).toContain("&lt;img src=x onerror=&quot;alert(1)&quot;&gt;");
+    });
+  });
 });
diff --git a/apps/web/lib/email/quota-exhausted-email.ts b/apps/web/lib/email/quota-exhausted-email.ts
index 9c7b97856..69e4e54b2 100644
--- a/apps/web/lib/email/quota-exhausted-email.ts
+++ b/apps/web/lib/email/quota-exhausted-email.ts
@@ -1,10 +1,50 @@
+import type { QuotaRejections } from "@/lib/supabase/quota-rejections";
 import type { EmailMessage } from "./mailer";
 
+function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function plural(count: number, one: string, many: string): string {
+  return `${count.toLocaleString("en-US")} ${count === 1 ? one : many}`;
+}
+
+/**
+ * The sentence and per-endpoint lines describing what was rejected, or null
+ * when nothing was: the email goes out within minutes of the quota running
+ * out, so the first send often precedes the first rejection.
+ */
+function rejectionLines(rejections: QuotaRejections | null | undefined): {
+  headline: string;
+  endpoints: { slug: string; rejected: string }[];
+  more: string | null;
+} | null {
+  if (!rejections || rejections.total <= 0 || rejections.endpoints.length === 0) return null;
+
+  const remaining = Math.max(0, rejections.endpointCount - rejections.endpoints.length);
+  return {
+    headline:
+      `So far in this period ${plural(rejections.total, "webhook was", "webhooks were")} ` +
+      `rejected across ${plural(rejections.endpointCount, "endpoint", "endpoints")}:`,
+    endpoints: rejections.endpoints.map((endpoint) => ({
+      slug: endpoint.slug,
+      rejected: plural(endpoint.rejected, "rejected webhook", "rejected webhooks"),
+    })),
+    more: remaining > 0 ? `and ${plural(remaining, "more endpoint", "more endpoints")}` : null,
+  };
+}
+
 /**
  * Builds the email sent when a free user's quota runs out and the receiver
  * starts rejecting their webhooks. Pure (no I/O) so it is unit-testable; the
- * caller sends it through sendEmail(). Every interpolated value comes from the
- * database or env, not user input, so the HTML variant needs no escaping.
+ * caller sends it through sendEmail(). The limit, dates and counts come from
+ * the database or env. Endpoint slugs are escaped in the HTML variant anyway,
+ * since they are the one value a user could have chosen.
  */
 export function buildQuotaExhaustedEmail(params: {
   to: string;
@@ -12,9 +52,11 @@ export function buildQuotaExhaustedEmail(params: {
   periodEnd: Date;
   /** Owned endpoints billed to a team; they keep capturing and are named as unaffected. */
   teamBilledEndpoints: number;
+  /** Rejected webhooks this period; omitted or empty leaves the generic copy. */
+  rejections?: QuotaRejections | null;
   appUrl: string;
 }): EmailMessage {
-  const { to, requestLimit, periodEnd, teamBilledEndpoints, appUrl } = params;
+  const { to, requestLimit, periodEnd, teamBilledEndpoints, rejections, appUrl } = params;
   const accountLink = `${appUrl}/account/plan`;
   const teamsLink = `${appUrl}/teams`;
   const limit = requestLimit.toLocaleString("en-US");
@@ -23,6 +65,7 @@ export function buildQuotaExhaustedEmail(params: {
     teamBilledEndpoints > 0
       ? "Endpoints shared with a team use the team's quota and keep capturing."
       : null;
+  const rejected = rejectionLines(rejections);
 
   return {
     to,
@@ -32,6 +75,14 @@ export function buildQuotaExhaustedEmail(params: {
       `Until the period resets at ${resetsAt}, new webhooks sent to your endpoints`,
       `are rejected with HTTP 429 and are not captured.`,
       ...(teamNote ? [teamNote] : []),
+      ...(rejected
+        ? [
+            ``,
+            rejected.headline,
+            ...rejected.endpoints.map((e) => `  ${e.slug}: ${e.rejected}`),
+            ...(rejected.more ? [`  ${rejected.more}`] : []),
+          ]
+        : []),
       ``,
       `Upgrade to Pro for 100,000 requests a month and 31-day retention, $8/month:`,
       accountLink,
@@ -47,6 +98,14 @@ export function buildQuotaExhaustedEmail(params: {
         `are rejected with HTTP 429 and are not captured.` +
         (teamNote ? ` ${teamNote}` : "") +
         `</p>`,
+      ...(rejected
+        ? [
+            `<p>${rejected.headline}</p>`,
+            `<ul>${rejected.endpoints
+              .map((e) => `<li><code>${escapeHtml(e.slug)}</code>: ${e.rejected}</li>`)
+              .join("")}${rejected.more ? `<li>${rejected.more}</li>` : ""}</ul>`,
+          ]
+        : []),
       `<p><a href="${accountLink}">Upgrade to Pro</a> for 100,000 requests a month ` +
         `and 31-day retention, $8/month.</p>`,
       `<p>Capturing for a company? A <a href="${teamsLink}">team</a> gets a pooled quota ` +
diff --git a/apps/web/lib/quota-emails.test.ts b/apps/web/lib/quota-emails.test.ts
index 0735e292d..6c53c7ce4 100644
--- a/apps/web/lib/quota-emails.test.ts
+++ b/apps/web/lib/quota-emails.test.ts
@@ -72,4 +72,49 @@ describe("sendQuotaExhaustedEmails", () => {
     await expect(sendQuotaExhaustedEmails()).rejects.toThrow("boom");
     expect(sendEmail).not.toHaveBeenCalled();
   });
+
+  it("names this period's rejected webhooks in each email", async () => {
+    rpc.mockImplementation(async (fn: string, args?: { p_user_id?: string }) => {
+      if (fn === "claim_quota_exhausted_users") return { data: claimed, error: null };
+      if (fn === "get_quota_rejections") {
+        return args?.p_user_id === "u1"
+          ? {
+              data: [
+                { slug: "stripe-prod", quota_rejected: 7, total_rejected: 9, endpoint_count: 2 },
+                { slug: "gh-staging", quota_rejected: 2, total_rejected: 9, endpoint_count: 2 },
+              ],
+              error: null,
+            }
+          : { data: [], error: null };
+      }
+      return { error: null };
+    });
+    sendEmail.mockResolvedValue(undefined);
+
+    await expect(sendQuotaExhaustedEmails()).resolves.toEqual({ sent: 2, failed: 0 });
+    expect(rpc).toHaveBeenCalledWith("get_quota_rejections", { p_user_id: "u1", p_limit: 5 });
+    expect(rpc).toHaveBeenCalledWith("get_quota_rejections", { p_user_id: "u2", p_limit: 5 });
+
+    const [first, second] = sendEmail.mock.calls.map(([message]) => message);
+    expect(first.text).toContain("9 webhooks were rejected across 2 endpoints");
+    expect(first.text).toContain("stripe-prod: 7 rejected webhooks");
+    expect(first.text).toContain("gh-staging: 2 rejected webhooks");
+    expect(second.text).not.toContain("rejected across");
+  });
+
+  it("still sends the generic email when the rejection counts cannot be read", async () => {
+    rpc.mockImplementation(async (fn: string) => {
+      if (fn === "claim_quota_exhausted_users") return { data: [claimed[0]], error: null };
+      if (fn === "get_quota_rejections") return { data: null, error: { message: "stats down" } };
+      return { error: null };
+    });
+    sendEmail.mockResolvedValue(undefined);
+    vi.spyOn(console, "error").mockImplementation(() => {});
+
+    await expect(sendQuotaExhaustedEmails()).resolves.toEqual({ sent: 1, failed: 0 });
+    expect(sendEmail).toHaveBeenCalledTimes(1);
+    expect(sendEmail.mock.calls[0][0].text).not.toContain("rejected across");
+    expect(rpc).toHaveBeenCalledWith("mark_quota_email_sent", { p_user_id: "u1" });
+    expect(update).not.toHaveBeenCalled();
+  });
 });
diff --git a/apps/web/lib/quota-emails.ts b/apps/web/lib/quota-emails.ts
index 78290a62e..0a3835ec1 100644
--- a/apps/web/lib/quota-emails.ts
+++ b/apps/web/lib/quota-emails.ts
@@ -2,6 +2,7 @@ import { publicEnv } from "@/lib/env";
 import { buildQuotaExhaustedEmail } from "@/lib/email/quota-exhausted-email";
 import { sendEmail } from "@/lib/email/mailer";
 import { createAdminClient } from "@/lib/supabase/admin";
+import { getQuotaRejections, type QuotaRejections } from "@/lib/supabase/quota-rejections";
 import { reportError } from "@/lib/observability";
 
 const POLL_INTERVAL_MS = 10 * 60 * 1000;
@@ -12,7 +13,10 @@ const BATCH_SIZE = 50;
  * a 15-minute lease on each user it returns, so concurrent polls never email
  * the same user. Only a successful send starts the 7-day resend window
  * (mark_quota_email_sent); a failed send releases the lease so the next poll
- * retries, and a poll that dies mid-batch simply lets its leases expire.
+ * retries, and a poll that dies mid-batch simply lets its leases expire. Each
+ * email names this period's rejected webhooks per endpoint when there are any
+ * yet; the poll runs every 10 minutes, so a user claimed just after hitting
+ * the limit usually has none and gets the generic copy.
  */
 export async function sendQuotaExhaustedEmails(): Promise<{ sent: number; failed: number }> {
   const admin = createAdminClient();
@@ -26,6 +30,15 @@ export async function sendQuotaExhaustedEmails(): Promise<{ sent: number; failed
   let failed = 0;
 
   for (const user of data ?? []) {
+    // The counts are extra detail: if they cannot be read, the generic email
+    // still goes out rather than the user hearing nothing.
+    let rejections: QuotaRejections | null = null;
+    try {
+      rejections = await getQuotaRejections(user.id);
+    } catch (rejectionsError) {
+      reportError("[quota-emails] rejection counts failed", rejectionsError);
+    }
+
     try {
       await sendEmail(
         buildQuotaExhaustedEmail({
@@ -33,6 +46,7 @@ export async function sendQuotaExhaustedEmails(): Promise<{ sent: number; failed
           requestLimit: user.request_limit,
           periodEnd: new Date(user.period_end),
           teamBilledEndpoints: user.team_billed_endpoints,
+          rejections,
           appUrl,
         })
       );
diff --git a/apps/web/lib/supabase/database.ts b/apps/web/lib/supabase/database.ts
index 58066aa94..4797d9266 100644
--- a/apps/web/lib/supabase/database.ts
+++ b/apps/web/lib/supabase/database.ts
@@ -1025,6 +1025,15 @@ export interface Database {
         Args: { p_user_id: string };
         Returns: number;
       };
+      get_quota_rejections: {
+        Args: { p_user_id: string; p_limit?: number };
+        Returns: Array<{
+          slug: string;
+          quota_rejected: number;
+          total_rejected: number;
+          endpoint_count: number;
+        }>;
+      };
     };
     Enums: Record<string, never>;
     CompositeTypes: Record<string, never>;
diff --git a/apps/web/lib/supabase/quota-rejections.test.ts b/apps/web/lib/supabase/quota-rejections.test.ts
new file mode 100644
index 000000000..c8c172bd5
--- /dev/null
+++ b/apps/web/lib/supabase/quota-rejections.test.ts
@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const rpc = vi.fn();
+
+vi.mock("./admin", () => ({
+  createAdminClient: () => ({ rpc }),
+}));
+
+const { getQuotaRejections, NO_QUOTA_REJECTIONS, QUOTA_REJECTION_ENDPOINT_LIMIT } =
+  await import("./quota-rejections");
+
+describe("getQuotaRejections", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("asks for the default number of endpoints", async () => {
+    rpc.mockResolvedValue({ data: [], error: null });
+    await getQuotaRejections("u1");
+    expect(rpc).toHaveBeenCalledWith("get_quota_rejections", {
+      p_user_id: "u1",
+      p_limit: QUOTA_REJECTION_ENDPOINT_LIMIT,
+    });
+  });
+
+  it("returns the empty summary when there are no rejections", async () => {
+    rpc.mockResolvedValue({ data: [], error: null });
+    await expect(getQuotaRejections("u1")).resolves.toBe(NO_QUOTA_REJECTIONS);
+    rpc.mockResolvedValue({ data: null, error: null });
+    await expect(getQuotaRejections("u1")).resolves.toBe(NO_QUOTA_REJECTIONS);
+  });
+
+  it("maps rows into a total and per-endpoint counts", async () => {
+    rpc.mockResolvedValue({
+      data: [
+        { slug: "a", quota_rejected: "30", total_rejected: "42", endpoint_count: "3" },
+        { slug: "b", quota_rejected: 10, total_rejected: 42, endpoint_count: 3 },
+      ],
+      error: null,
+    });
+    await expect(getQuotaRejections("u1", 2)).resolves.toEqual({
+      total: 42,
+      endpointCount: 3,
+      endpoints: [
+        { slug: "a", rejected: 30 },
+        { slug: "b", rejected: 10 },
+      ],
+    });
+  });
+
+  it("throws when the query fails", async () => {
+    const error = { message: "boom" };
+    rpc.mockResolvedValue({ data: null, error });
+    await expect(getQuotaRejections("u1")).rejects.toBe(error);
+  });
+});
diff --git a/apps/web/lib/supabase/quota-rejections.ts b/apps/web/lib/supabase/quota-rejections.ts
new file mode 100644
index 000000000..0b0e62ce6
--- /dev/null
+++ b/apps/web/lib/supabase/quota-rejections.ts
@@ -0,0 +1,48 @@
+import { createAdminClient } from "./admin";
+
+/** Endpoints named in the email and banner; the rest are summarized as a count. */
+export const QUOTA_REJECTION_ENDPOINT_LIMIT = 5;
+
+export interface QuotaRejectedEndpoint {
+  slug: string;
+  rejected: number;
+}
+
+export interface QuotaRejections {
+  /** Webhooks rejected with 429 this period, across every affected endpoint. */
+  total: number;
+  /** How many endpoints had a rejection, including ones not in `endpoints`. */
+  endpointCount: number;
+  /** The most rejected endpoints, most rejected first. */
+  endpoints: QuotaRejectedEndpoint[];
+}
+
+export const NO_QUOTA_REJECTIONS: QuotaRejections = { total: 0, endpointCount: 0, endpoints: [] };
+
+/**
+ * This period's quota rejections for one user's own, owner-billed endpoints,
+ * read from endpoint_daily_stats (get_quota_rejections(), migration 00060).
+ * Counts are per UTC day, so the first day of a period can include a few
+ * rejections from just before it began.
+ */
+export async function getQuotaRejections(
+  userId: string,
+  limit: number = QUOTA_REJECTION_ENDPOINT_LIMIT
+): Promise<QuotaRejections> {
+  const admin = createAdminClient();
+  const { data, error } = await admin.rpc("get_quota_rejections", {
+    p_user_id: userId,
+    p_limit: limit,
+  });
+  if (error) throw error;
+
+  const rows = data ?? [];
+  if (rows.length === 0) return NO_QUOTA_REJECTIONS;
+
+  // bigint columns arrive as numbers from PostgREST; counts stay far below 2^53.
+  return {
+    total: Number(rows[0].total_rejected),
+    endpointCount: Number(rows[0].endpoint_count),
+    endpoints: rows.map((row) => ({ slug: row.slug, rejected: Number(row.quota_rejected) })),
+  };
+}
diff --git a/apps/web/lib/supabase/usage.ts b/apps/web/lib/supabase/usage.ts
index 790ca3ab5..e93312353 100644
--- a/apps/web/lib/supabase/usage.ts
+++ b/apps/web/lib/supabase/usage.ts
@@ -1,5 +1,7 @@
 import { createAdminClient } from "./admin";
 import type { UserPlan } from "./api-keys";
+import { reportError } from "@/lib/observability";
+import { getQuotaRejections, NO_QUOTA_REJECTIONS, type QuotaRejections } from "./quota-rejections";
 
 export interface UsageInfo {
   used: number;
@@ -14,6 +16,11 @@ export interface UsageInfo {
   teamBilledEndpoints: number;
   /** How many of `used` were emails (owner-billed, current period). */
   emails: number;
+  /**
+   * Webhooks rejected with 429 this period on the user's own endpoints, by
+   * endpoint. Only read while the quota is exhausted; empty otherwise.
+   */
+  quotaRejections: QuotaRejections;
 }
 
 export async function getUsageForUser(userId: string): Promise<UsageInfo | null> {
@@ -51,6 +58,19 @@ export async function getUsageForUser(userId: string): Promise<UsageInfo | null>
   const emails =
     user.period_start && user.emails_period_start === user.period_start ? user.emails_used : 0;
 
+  const exhausted = periodActive && user.request_limit > 0 && used >= user.request_limit;
+  // The counts are extra detail: if they cannot be read (e.g. migration 00060
+  // not applied yet), usage still returns rather than failing for the users
+  // who most need it.
+  let quotaRejections = NO_QUOTA_REJECTIONS;
+  if (exhausted) {
+    try {
+      quotaRejections = await getQuotaRejections(userId);
+    } catch (rejectionsError) {
+      reportError("[usage] quota rejection counts failed", rejectionsError);
+    }
+  }
+
   return {
     used,
     limit: user.request_limit,
@@ -59,5 +79,6 @@ export async function getUsageForUser(userId: string): Promise<UsageInfo | null>
     periodEnd: periodActive ? periodEndMs : null,
     teamBilledEndpoints: teamBilledEndpoints ?? 0,
     emails: Math.min(emails, used),
+    quotaRejections,
   };
 }
diff --git a/apps/web/package.json b/apps/web/package.json
index 72a695303..eb6fee7df 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -1,6 +1,6 @@
 {
   "name": "web",
-  "version": "0.40.3",
+  "version": "0.40.4",
   "private": true,
   "scripts": {
     "dev": "next dev",
diff --git a/apps/web/tests/integration/supabase-control-plane.test.ts b/apps/web/tests/integration/supabase-control-plane.test.ts
index 5877caa7d..e64d1ab91 100644
--- a/apps/web/tests/integration/supabase-control-plane.test.ts
+++ b/apps/web/tests/integration/supabase-control-plane.test.ts
@@ -285,6 +285,7 @@ describe("Supabase Control Plane Integration", () => {
       periodEnd: expect.any(Number),
       teamBilledEndpoints: 0,
       emails: 0,
+      quotaRejections: { total: 0, endpointCount: 0, endpoints: [] },
     });
   });
 });
diff --git a/apps/web/tests/integration/supabase-quota-rejections.test.ts b/apps/web/tests/integration/supabase-quota-rejections.test.ts
new file mode 100644
index 000000000..265337c38
--- /dev/null
+++ b/apps/web/tests/integration/supabase-quota-rejections.test.ts
@@ -0,0 +1,259 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { createClient } from "@supabase/supabase-js";
+import { buildQuotaExhaustedEmail } from "@/lib/email/quota-exhausted-email";
+import { createEndpointForUser } from "@/lib/supabase/endpoints";
+import { getQuotaRejections } from "@/lib/supabase/quota-rejections";
+import { getUsageForUser } from "@/lib/supabase/usage";
+
+if (!process.env.SUPABASE_URL) throw new Error("SUPABASE_URL env var required");
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SERVICE_ROLE_KEY = process.env.SUPABASE_SERVICE_ROLE_KEY!;
+
+if (!SERVICE_ROLE_KEY) {
+  throw new Error("SUPABASE_SERVICE_ROLE_KEY env var required for integration tests");
+}
+
+const admin = createClient(SUPABASE_URL, SERVICE_ROLE_KEY, {
+  auth: { autoRefreshToken: false, persistSession: false },
+});
+
+const ts = Date.now();
+const createdUserIds: string[] = [];
+const createdTeamIds: string[] = [];
+const createdEndpointIds: string[] = [];
+
+async function createTestUser(label: string): Promise<string> {
+  const { data, error } = await admin.auth.admin.createUser({
+    email: `test-quota-rej-${label}-${ts}@webhooks-test.local`,
+    password: "TestPassword123!",
+    email_confirm: true,
+  });
+  if (error) throw error;
+  createdUserIds.push(data.user!.id);
+  return data.user!.id;
+}
+
+async function createTestEndpoint(userId: string) {
+  const endpoint = await createEndpointForUser({ userId, name: "quota rejection endpoint" });
+  createdEndpointIds.push(endpoint.id);
+  return endpoint;
+}
+
+// All 10 parameters are named: the dev database still carries a legacy
+// 9-argument overload (see supabase-team-quota.test.ts).
+async function capture(slug: string) {
+  const { data, error } = await admin.rpc("capture_webhook", {
+    p_slug: slug,
+    p_method: "POST",
+    p_path: "/",
+    p_headers: { "content-type": "application/json" },
+    p_body: '{"n":1}',
+    p_query_params: {},
+    p_content_type: "application/json",
+    p_ip: "127.0.0.1",
+    p_received_at: new Date().toISOString(),
+    p_body_raw: null,
+  });
+  if (error) throw error;
+  return data as { status: string };
+}
+
+/** Puts a user at their free limit with a period that began a moment ago. */
+async function exhaust(userId: string) {
+  const { error } = await admin
+    .from("users")
+    .update({
+      plan: "free",
+      requests_used: 50,
+      request_limit: 50,
+      period_start: new Date(Date.now() - 60_000).toISOString(),
+      period_end: new Date(Date.now() + 60 * 60_000).toISOString(),
+    })
+    .eq("id", userId);
+  if (error) throw error;
+}
+
+async function reject(slug: string, times: number) {
+  for (let i = 0; i < times; i++) {
+    expect((await capture(slug)).status).toBe("quota_exceeded");
+  }
+}
+
+async function rejections(userId: string, limit = 5) {
+  const { data, error } = await admin.rpc("get_quota_rejections", {
+    p_user_id: userId,
+    p_limit: limit,
+  });
+  if (error) throw error;
+  return data as {
+    slug: string;
+    quota_rejected: number;
+    total_rejected: number;
+    endpoint_count: number;
+  }[];
+}
+
+afterAll(async () => {
+  if (createdEndpointIds.length > 0) {
+    await admin.from("endpoint_daily_stats").delete().in("endpoint_id", createdEndpointIds);
+    await admin.from("requests").delete().in("endpoint_id", createdEndpointIds);
+    await admin.from("team_endpoints").delete().in("endpoint_id", createdEndpointIds);
+    await admin.from("endpoints").delete().in("id", createdEndpointIds);
+  }
+  if (createdTeamIds.length > 0) {
+    await admin.from("teams").delete().in("id", createdTeamIds);
+  }
+  for (const userId of createdUserIds) {
+    await admin.auth.admin.deleteUser(userId);
+  }
+});
+
+describe("get_quota_rejections", () => {
+  let userId: string;
+  let busy: { id: string; slug: string };
+  let quiet: { id: string; slug: string };
+  let shared: { id: string; slug: string };
+
+  beforeAll(async () => {
+    userId = await createTestUser("owner");
+    busy = await createTestEndpoint(userId);
+    quiet = await createTestEndpoint(userId);
+    shared = await createTestEndpoint(userId);
+    await exhaust(userId);
+
+    await reject(busy.slug, 3);
+    await reject(quiet.slug, 1);
+    await reject(shared.slug, 2);
+  });
+
+  it("returns nothing for a user with no rejections", async () => {
+    const otherId = await createTestUser("none");
+    await createTestEndpoint(otherId);
+    expect(await rejections(otherId)).toEqual([]);
+  });
+
+  it("returns each endpoint's count, most rejected first, with totals", async () => {
+    expect(await rejections(userId)).toEqual([
+      { slug: busy.slug, quota_rejected: 3, total_rejected: 6, endpoint_count: 3 },
+      { slug: shared.slug, quota_rejected: 2, total_rejected: 6, endpoint_count: 3 },
+      { slug: quiet.slug, quota_rejected: 1, total_rejected: 6, endpoint_count: 3 },
+    ]);
+  });
+
+  it("limits the rows but not the totals", async () => {
+    const rows = await rejections(userId, 1);
+    expect(rows).toEqual([
+      { slug: busy.slug, quota_rejected: 3, total_rejected: 6, endpoint_count: 3 },
+    ]);
+    expect(await rejections(userId, 0)).toEqual([]);
+  });
+
+  it("only counts days from the UTC date of the period start", async () => {
+    // endpoint_daily_stats cannot be written from here, so move the period
+    // instead: every row so far is dated today, before a period that starts
+    // in two days.
+    const setPeriodStart = async (periodStart: Date) => {
+      const { error } = await admin
+        .from("users")
+        .update({ period_start: periodStart.toISOString() })
+        .eq("id", userId);
+      if (error) throw error;
+    };
+
+    await setPeriodStart(new Date(Date.now() + 2 * 86_400_000));
+    expect(await rejections(userId)).toEqual([]);
+
+    await setPeriodStart(new Date(Date.now() - 60_000));
+    expect((await rejections(userId))[0].total_rejected).toBe(6);
+  });
+
+  it("matches what the email and usage report for the owner", async () => {
+    const summary = await getQuotaRejections(userId);
+    expect(summary).toEqual({
+      total: 6,
+      endpointCount: 3,
+      endpoints: [
+        { slug: busy.slug, rejected: 3 },
+        { slug: shared.slug, rejected: 2 },
+        { slug: quiet.slug, rejected: 1 },
+      ],
+    });
+
+    const email = buildQuotaExhaustedEmail({
+      to: "owner@example.com",
+      requestLimit: 50,
+      periodEnd: new Date(Date.now() + 60 * 60_000),
+      teamBilledEndpoints: 0,
+      rejections: summary,
+      appUrl: "https://webhooks.cc",
+    });
+    expect(email.text).toContain("6 webhooks were rejected across 3 endpoints");
+    expect(email.text).toContain(`${busy.slug}: 3 rejected webhooks`);
+    expect(email.text).toContain(`${quiet.slug}: 1 rejected webhook\n`);
+
+    expect((await getUsageForUser(userId))?.quotaRejections).toEqual(summary);
+  });
+
+  it("leaves out endpoints billed to a subscribed team", async () => {
+    const { data, error } = await admin.rpc("create_team_with_owner", {
+      p_user_id: userId,
+      p_name: `QuotaRej ${ts}`,
+    });
+    if (error) throw error;
+    const teamId = (data as { id: string }).id;
+    createdTeamIds.push(teamId);
+
+    const { error: activateError } = await admin
+      .from("teams")
+      .update({
+        subscription_status: "active",
+        seats: 1,
+        request_limit: 100_000,
+        requests_used: 0,
+        period_start: new Date().toISOString(),
+        period_end: new Date(Date.now() + 30 * 86_400_000).toISOString(),
+        polar_subscription_id: `sub_quota_rej_${ts}`,
+      })
+      .eq("id", teamId);
+    if (activateError) throw activateError;
+
+    const { error: shareError } = await admin
+      .from("team_endpoints")
+      .insert({ team_id: teamId, endpoint_id: shared.id, shared_by: userId });
+    if (shareError) throw shareError;
+
+    expect(await rejections(userId)).toEqual([
+      { slug: busy.slug, quota_rejected: 3, total_rejected: 4, endpoint_count: 2 },
+      { slug: quiet.slug, quota_rejected: 1, total_rejected: 4, endpoint_count: 2 },
+    ]);
+  });
+
+  it("is only included in usage while the quota is exhausted", async () => {
+    const [first] = await rejections(userId);
+    expect((await getUsageForUser(userId))?.quotaRejections.total).toBe(first.total_rejected);
+
+    const { error } = await admin.from("users").update({ requests_used: 10 }).eq("id", userId);
+    if (error) throw error;
+
+    expect((await getUsageForUser(userId))?.quotaRejections).toEqual({
+      total: 0,
+      endpointCount: 0,
+      endpoints: [],
+    });
+  });
+});
+
+describe("get_quota_rejections access", () => {
+  const anonKey = process.env.SUPABASE_ANON_KEY ?? process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+
+  it.skipIf(!anonKey)("is not callable by anon or authenticated clients", async () => {
+    const anon = createClient(SUPABASE_URL, anonKey!, {
+      auth: { autoRefreshToken: false, persistSession: false },
+    });
+    const { error } = await anon.rpc("get_quota_rejections", {
+      p_user_id: "00000000-0000-0000-0000-000000000000",
+      p_limit: 1,
+    });
+    expect(error).not.toBeNull();
+  });
+});
diff --git a/supabase/migrations/00060_quota_rejections.sql b/supabase/migrations/00060_quota_rejections.sql
new file mode 100644
index 000000000..f449775aa
--- /dev/null
+++ b/supabase/migrations/00060_quota_rejections.sql
@@ -0,0 +1,71 @@
+-- ============================================================================
+-- 00060: quota rejections per endpoint for the current period
+-- ============================================================================
+-- The quota-exhausted email and the dashboard banner told a capped user that
+-- their webhooks were being rejected, but not how many or on which endpoints.
+-- endpoint_daily_stats (migration 00041) already counts a quota_rejected per
+-- endpoint per UTC day; get_quota_rejections() reads it back for one user.
+--
+-- Scope of the count:
+--   * Days from the UTC date of users.period_start onward. The table is kept
+--     per day, so the first day can include a few rejections from before the
+--     period began; a user with no period_start is read from today only.
+--   * Endpoints the user owns that are not billed to a subscribed team.
+--     Rejections on a team-billed endpoint came from the team's quota, which
+--     the owner's email and banner say is unaffected.
+--   * Endpoints that still exist: the slug is read from public.endpoints.
+--
+-- One row per endpoint (most rejected first, ties by slug), limited to
+-- p_limit. total_rejected and endpoint_count are computed before the limit,
+-- so they describe every affected endpoint, not just the rows returned.
+--
+-- Service role only, like the rest of the quota functions: the web app calls
+-- it with the admin client.
+-- ============================================================================
+
+create or replace function public.get_quota_rejections(
+  p_user_id uuid,
+  p_limit   integer default 5
+)
+returns table (
+  slug            text,
+  quota_rejected  bigint,
+  total_rejected  bigint,
+  endpoint_count  bigint
+)
+language sql
+stable
+set search_path = ''
+as $$
+  with since as (
+    select coalesce(
+             (u.period_start at time zone 'utc')::date,
+             (now() at time zone 'utc')::date
+           ) as day
+      from public.users u
+     where u.id = p_user_id
+  ),
+  per_endpoint as (
+    select e.slug, sum(s.quota_rejected)::bigint as rejected
+      from public.endpoints e
+      join public.endpoint_daily_stats s on s.endpoint_id = e.id
+      cross join since
+     where e.user_id = p_user_id
+       and s.day >= since.day
+       and s.quota_rejected > 0
+       and not public.is_team_billed_endpoint(e.id)
+     group by e.id, e.slug
+  )
+  select p.slug,
+         p.rejected,
+         (sum(p.rejected) over ())::bigint,
+         (count(*) over ())::bigint
+    from per_endpoint p
+   order by p.rejected desc, p.slug
+   limit greatest(p_limit, 0);
+$$;
+
+revoke all on function public.get_quota_rejections(uuid, integer) from public;
+revoke all on function public.get_quota_rejections(uuid, integer) from anon;
+revoke all on function public.get_quota_rejections(uuid, integer) from authenticated;
+grant execute on function public.get_quota_rejections(uuid, integer) to service_role;