diff --git a/src/app/hooks/useRegistrationInvites.ts b/src/app/hooks/useRegistrationInvites.ts
new file mode 100644
index 00000000..b2b0a528
--- /dev/null
+++ b/src/app/hooks/useRegistrationInvites.ts
@@ -0,0 +1,42 @@
+import { useCallback, useEffect, useState } from 'react';
+import { useMatrixClient } from './useMatrixClient';
+import { AsyncStatus, useAsyncCallback } from './useAsyncCallback';
+import {
+  RegistrationBotConfig,
+  RegistrationInvite,
+  RegistrationInvitesResult,
+  requestRegistrationInvites,
+} from '../plugins/registration-bot';
+
+/**
+ * The registration links the bot has generated for the current user, loaded on mount.
+ * `refresh` reloads them (e.g. after minting a new one) while keeping the last list
+ * on screen until the new one arrives.
+ */
+export const useRegistrationInvites = (botConfig: RegistrationBotConfig) => {
+  const mx = useMatrixClient();
+  const [invites, setInvites] = useState<RegistrationInvite[]>();
+
+  const [state, refresh] = useAsyncCallback<RegistrationInvitesResult, Error, []>(
+    useCallback(() => requestRegistrationInvites(mx, botConfig), [mx, botConfig])
+  );
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+
+  useEffect(() => {
+    if (state.status === AsyncStatus.Success && state.data.success) {
+      setInvites(state.data.invites);
+    }
+  }, [state]);
+
+  const loading = state.status === AsyncStatus.Idle || state.status === AsyncStatus.Loading;
+
+  let error: string | undefined;
+  if (state.status === AsyncStatus.Error) error = state.error.message;
+  else if (state.status === AsyncStatus.Success && !state.data.success) {
+    error = state.data.error.message;
+  }
+
+  return { invites, loading, error, refresh };
+};
diff --git a/src/app/pages/app-shell/InviteFlow.css.ts b/src/app/pages/app-shell/InviteFlow.css.ts
index b8741f81..61745d3c 100644
--- a/src/app/pages/app-shell/InviteFlow.css.ts
+++ b/src/app/pages/app-shell/InviteFlow.css.ts
@@ -150,6 +150,9 @@ export const Error = style({
 
 export const Actions = style({
   marginTop: 'auto',
+  // Stays in view while a long invite list scrolls underneath.
+  position: 'sticky',
+  bottom: 0,
   display: 'flex',
   flexDirection: 'column',
   flexShrink: 0,
@@ -191,3 +194,81 @@ export const SubmitButton = style({
     },
   },
 });
+
+export const ListHeader = style({
+  display: 'flex',
+  alignItems: 'baseline',
+  justifyContent: 'space-between',
+  gap: '12px',
+});
+
+export const ListSummary = style({
+  fontSize: '13px',
+  fontWeight: 600,
+  color: '#7c8d97',
+});
+
+export const ListEmpty = style({
+  fontSize: '14px',
+  fontWeight: 500,
+  color: '#7c8d97',
+});
+
+export const InviteList = style({
+  listStyle: 'none',
+  margin: 0,
+  padding: 0,
+  display: 'flex',
+  flexDirection: 'column',
+  gap: '10px',
+});
+
+export const InviteCard = style({
+  background: '#fff',
+  borderRadius: '16px',
+  padding: '12px 16px',
+  boxShadow: '0 1px 2px rgba(30, 42, 50, 0.05), 0 10px 24px rgba(30, 42, 50, 0.05)',
+  display: 'flex',
+  flexDirection: 'column',
+  gap: '4px',
+  minWidth: 0,
+});
+
+export const InviteRow = style({
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'space-between',
+  gap: '10px',
+  minWidth: 0,
+});
+
+export const InviteDetail = style({
+  fontSize: '14px',
+  fontWeight: 500,
+  color: '#2b3a43',
+  overflowWrap: 'anywhere',
+});
+
+export const Badge = style({
+  flexShrink: 0,
+  borderRadius: '999px',
+  padding: '3px 10px',
+  fontSize: '12px',
+  fontWeight: 700,
+  whiteSpace: 'nowrap',
+});
+
+export const BadgePositive = style({
+  background: '#e3f4ea',
+  color: '#1e7a45',
+});
+
+export const BadgeNeutral = style({
+  background: '#e2f1f9',
+  color: '#1273a0',
+});
+
+export const BadgeMuted = style({
+  background: '#edf0f2',
+  color: '#6b7a83',
+});
diff --git a/src/app/pages/app-shell/InviteFlow.tsx b/src/app/pages/app-shell/InviteFlow.tsx
index c0f04855..cd652a96 100644
--- a/src/app/pages/app-shell/InviteFlow.tsx
+++ b/src/app/pages/app-shell/InviteFlow.tsx
@@ -1,8 +1,10 @@
-import React from 'react';
+import React, { useEffect } from 'react';
 import FocusTrap from 'focus-trap-react';
 import { QRCodeSVG } from 'qrcode.react';
 import { RegistrationBotConfig } from '../../plugins/registration-bot';
 import { useRegistrationLink } from '../../hooks/useRegistrationLink';
+import { useRegistrationInvites } from '../../hooks/useRegistrationInvites';
+import { describeInvite, summarizeInvites } from './inviteList';
 import { stopPropagation } from '../../utils/keyboard';
 import * as css from './InviteFlow.css';
 
@@ -36,6 +38,64 @@ const LINK_ICON = (
   </svg>
 );
 
+const formatTime = (ms: number): string =>
+  new Date(ms).toLocaleString(undefined, { dateStyle: 'medium', timeStyle: 'short' });
+
+const TONE_CLASS = {
+  positive: css.BadgePositive,
+  neutral: css.BadgeNeutral,
+  muted: css.BadgeMuted,
+};
+
+function InviteList({ botConfig, link }: { botConfig: RegistrationBotConfig; link?: string }) {
+  const { invites, loading, error, refresh } = useRegistrationInvites(botConfig);
+
+  // A newly generated link belongs in the list, so reload it once one arrives.
+  useEffect(() => {
+    if (link) refresh();
+  }, [link, refresh]);
+
+  return (
+    <section className={css.Field} aria-labelledby="invite-list-title">
+      <div className={css.ListHeader}>
+        <span className={css.Label} id="invite-list-title">
+          Your Invites
+        </span>
+        {invites && invites.length > 0 && (
+          <span className={css.ListSummary}>{summarizeInvites(invites)}</span>
+        )}
+      </div>
+      {error && <span className={css.Error}>{error}</span>}
+      {!invites && loading && <span className={css.ListEmpty}>Loading invites…</span>}
+      {invites && invites.length === 0 && (
+        <span className={css.ListEmpty}>You haven&apos;t generated any invite links yet.</span>
+      )}
+      {invites && invites.length > 0 && (
+        <ul className={css.InviteList}>
+          {invites.map((invite) => {
+            const { label, tone, detail } = describeInvite(invite, formatTime);
+            return (
+              <li key={invite.tokenSha256} className={css.InviteCard}>
+                <div className={css.InviteRow}>
+                  <span className={css.OptionTitle}>
+                    {invite.issuedAt === null ? 'Unknown date' : formatTime(invite.issuedAt)}
+                  </span>
+                  <span className={`${css.Badge} ${TONE_CLASS[tone]}`}>{label}</span>
+                </div>
+                {detail && <div className={css.InviteDetail}>{detail}</div>}
+                <div className={css.OptionSubtitle}>
+                  {invite.clientId && `${invite.clientId} · `}
+                  {`Link ${invite.tokenSha256.slice(0, 8)}…`}
+                </div>
+              </li>
+            );
+          })}
+        </ul>
+      )}
+    </section>
+  );
+}
+
 type InviteFlowProps = {
   open: boolean;
   botConfig: RegistrationBotConfig;
@@ -85,7 +145,7 @@ function InviteForm({ botConfig, onClose }: Omit<InviteFlowProps, 'open'>) {
         <div className={css.Body}>
           <p className={css.Description}>
             Get a single-use link you can send to someone to invite them to create an account on
-            this server.
+            this server, and see who has used the links you already sent.
           </p>
           {clients && clients.length > 1 && !link && (
             <div className={css.Field}>
@@ -129,6 +189,7 @@ function InviteForm({ botConfig, onClose }: Omit<InviteFlowProps, 'open'>) {
               </button>
             </div>
           )}
+          <InviteList botConfig={botConfig} link={link} />
           <div className={css.Actions}>
             {link ? (
               <button type="button" className={css.SubmitButton} onClick={onClose}>
diff --git a/src/app/pages/app-shell/inviteList.test.ts b/src/app/pages/app-shell/inviteList.test.ts
new file mode 100644
index 00000000..8911d3ff
--- /dev/null
+++ b/src/app/pages/app-shell/inviteList.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import type { RegistrationInvite } from '../../plugins/registration-bot';
+import { describeInvite, summarizeInvites } from './inviteList';
+
+const invite = (overrides: Partial<RegistrationInvite> = {}): RegistrationInvite => ({
+  tokenSha256: 'abc',
+  status: 'unused',
+  clientId: null,
+  issuedAt: 1,
+  expiresAt: null,
+  registeredUserId: null,
+  registeredAt: null,
+  ...overrides,
+});
+
+const formatTime = (ms: number) => `t${ms}`;
+
+describe('describeInvite', () => {
+  it('names who used a link and when', () => {
+    expect(
+      describeInvite(
+        invite({ status: 'used', registeredUserId: '@carol:example.org', registeredAt: 5 }),
+        formatTime
+      )
+    ).toEqual({ label: 'Used', tone: 'positive', detail: 'Used by @carol:example.org on t5' });
+  });
+
+  it('leaves out the date when the registration time is unknown', () => {
+    expect(
+      describeInvite(invite({ status: 'used', registeredUserId: '@carol:example.org' }), formatTime)
+        .detail
+    ).toBe('Used by @carol:example.org');
+  });
+
+  it('has no detail for a used link with no known user', () => {
+    expect(describeInvite(invite({ status: 'used' }), formatTime)).toEqual({
+      label: 'Used',
+      tone: 'positive',
+    });
+  });
+
+  it('shows when an unused link expires', () => {
+    expect(describeInvite(invite({ expiresAt: 9 }), formatTime).detail).toBe('Expires t9');
+    expect(describeInvite(invite(), formatTime).detail).toBe('Never expires');
+  });
+
+  it('mutes expired and revoked links', () => {
+    expect(describeInvite(invite({ status: 'expired' }), formatTime)).toEqual({
+      label: 'Expired',
+      tone: 'muted',
+    });
+    expect(describeInvite(invite({ status: 'revoked' }), formatTime)).toEqual({
+      label: 'Revoked',
+      tone: 'muted',
+    });
+  });
+
+  it('describes a pending link', () => {
+    expect(describeInvite(invite({ status: 'pending' }), formatTime).label).toBe('In progress');
+  });
+});
+
+describe('summarizeInvites', () => {
+  it('counts invites and used ones', () => {
+    expect(summarizeInvites([invite(), invite({ status: 'used' })])).toBe('2 invites · 1 used');
+    expect(summarizeInvites([invite()])).toBe('1 invite · 0 used');
+  });
+});
diff --git a/src/app/pages/app-shell/inviteList.ts b/src/app/pages/app-shell/inviteList.ts
new file mode 100644
index 00000000..8433c794
--- /dev/null
+++ b/src/app/pages/app-shell/inviteList.ts
@@ -0,0 +1,59 @@
+import { RegistrationInvite, RegistrationInviteStatus } from '../../plugins/registration-bot';
+
+export type InviteTone = 'positive' | 'neutral' | 'muted';
+
+export type InviteDescription = {
+  /** Short badge text, e.g. "Used". */
+  label: string;
+  tone: InviteTone;
+  /** A line of detail under the invite, e.g. "Used by @carol:example.org on …". */
+  detail?: string;
+};
+
+const LABELS: Record<RegistrationInviteStatus, string> = {
+  unused: 'Not used yet',
+  pending: 'In progress',
+  used: 'Used',
+  expired: 'Expired',
+  revoked: 'Revoked',
+};
+
+const TONES: Record<RegistrationInviteStatus, InviteTone> = {
+  unused: 'neutral',
+  pending: 'neutral',
+  used: 'positive',
+  expired: 'muted',
+  revoked: 'muted',
+};
+
+/** How to show an invite's status. `formatTime` turns a millisecond timestamp into text. */
+export const describeInvite = (
+  invite: RegistrationInvite,
+  formatTime: (ms: number) => string
+): InviteDescription => {
+  const label = LABELS[invite.status];
+  const tone = TONES[invite.status];
+
+  switch (invite.status) {
+    case 'used': {
+      if (invite.registeredUserId === null) return { label, tone };
+      const when = invite.registeredAt === null ? '' : ` on ${formatTime(invite.registeredAt)}`;
+      return { label, tone, detail: `Used by ${invite.registeredUserId}${when}` };
+    }
+    case 'pending':
+      return { label, tone, detail: 'Someone is registering with this link now' };
+    case 'unused':
+      return invite.expiresAt === null
+        ? { label, tone, detail: 'Never expires' }
+        : { label, tone, detail: `Expires ${formatTime(invite.expiresAt)}` };
+    default:
+      return { label, tone };
+  }
+};
+
+/** "3 invites · 1 used" — a one-line summary above the list. */
+export const summarizeInvites = (invites: RegistrationInvite[]): string => {
+  const used = invites.filter((invite) => invite.status === 'used').length;
+  const total = `${invites.length} ${invites.length === 1 ? 'invite' : 'invites'}`;
+  return `${total} · ${used} used`;
+};
diff --git a/src/app/plugins/registration-bot.test.ts b/src/app/plugins/registration-bot.test.ts
index 948ed598..e8e6c565 100644
--- a/src/app/plugins/registration-bot.test.ts
+++ b/src/app/plugins/registration-bot.test.ts
@@ -2,12 +2,15 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 import type { MatrixClient } from 'matrix-js-sdk';
 import {
   buildRegistrationClientsUrl,
+  buildRegistrationInvitesUrl,
   buildRegistrationLinkRequestBody,
   buildRegistrationLinkUrl,
   isOpenIdTokenFresh,
   parseRegistrationClientsResponse,
+  parseRegistrationInvitesResponse,
   parseRegistrationLinkResponse,
   requestRegistrationClients,
+  requestRegistrationInvites,
   requestRegistrationLink,
 } from './registration-bot';
 
@@ -39,6 +42,100 @@ describe('buildRegistrationClientsUrl', () => {
   });
 });
 
+describe('buildRegistrationInvitesUrl', () => {
+  it('has no query for your own invites', () => {
+    expect(buildRegistrationInvitesUrl('https://bot.example.org/')).toBe(
+      'https://bot.example.org/api/invites'
+    );
+  });
+
+  it('encodes user_id into the query', () => {
+    expect(buildRegistrationInvitesUrl('https://bot.example.org', '@a:b.org')).toBe(
+      'https://bot.example.org/api/invites?user_id=%40a%3Ab.org'
+    );
+  });
+});
+
+describe('parseRegistrationInvitesResponse', () => {
+  const wireInvite = {
+    token_sha256: '9cb4aa',
+    status: 'used',
+    client_id: 'element',
+    issued_at: 1790181986000,
+    expires_at: null,
+    registered_user_id: '@carol:example.org',
+    registered_at: 1790182013010,
+  };
+
+  it('parses invites into camelCase', () => {
+    expect(parseRegistrationInvitesResponse({ success: true, invites: [wireInvite] })).toEqual({
+      success: true,
+      invites: [
+        {
+          tokenSha256: '9cb4aa',
+          status: 'used',
+          clientId: 'element',
+          issuedAt: 1790181986000,
+          expiresAt: null,
+          registeredUserId: '@carol:example.org',
+          registeredAt: 1790182013010,
+        },
+      ],
+    });
+  });
+
+  it('treats missing optional fields as null', () => {
+    expect(
+      parseRegistrationInvitesResponse({
+        success: true,
+        invites: [{ token_sha256: 'x', status: 'unused' }],
+      })
+    ).toEqual({
+      success: true,
+      invites: [
+        {
+          tokenSha256: 'x',
+          status: 'unused',
+          clientId: null,
+          issuedAt: null,
+          expiresAt: null,
+          registeredUserId: null,
+          registeredAt: null,
+        },
+      ],
+    });
+  });
+
+  it('drops malformed or unknown-status entries but keeps the rest', () => {
+    const result = parseRegistrationInvitesResponse({
+      success: true,
+      invites: [
+        wireInvite,
+        { ...wireInvite, token_sha256: 'y', status: 'someday' },
+        { ...wireInvite, token_sha256: 'z', issued_at: 'yesterday' },
+        'nope',
+      ],
+    });
+    expect(result.success && result.invites.map((i) => i.tokenSha256)).toEqual(['9cb4aa']);
+  });
+
+  it("passes on the bot's refusal", () => {
+    expect(
+      parseRegistrationInvitesResponse({
+        success: false,
+        error: { code: 'upstream_error', message: 'module missing' },
+      })
+    ).toEqual({ success: false, error: { code: 'upstream_error', message: 'module missing' } });
+  });
+
+  it('falls back to a generic message', () => {
+    expect(parseRegistrationInvitesResponse({ success: true })).toEqual({
+      success: false,
+      error: { code: undefined, message: 'The registration bot could not list invites.' },
+    });
+  });
+});
+
 describe('buildRegistrationLinkRequestBody', () => {
   it('is empty when no client is given', () => {
     expect(buildRegistrationLinkRequestBody({})).toEqual({});
@@ -259,6 +356,21 @@ describe('requesting over HTTP', () => {
     expect(fetchMock.mock.calls[1][1].headers.Authorization).toBe('Bearer fresh');
   });
 
+  it('lists invites with a GET to /api/invites', async () => {
+    const { mx } = fakeClient('openid-1');
+    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(200, { success: true, invites: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    await expect(requestRegistrationInvites(mx, botConfig)).resolves.toEqual({
+      success: true,
+      invites: [],
+    });
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe('https://bot.example.org/api/invites');
+    expect(init.method).toBe('GET');
+    expect(init.headers.Authorization).toBe('Bearer openid-1');
+  });
+
   it("surfaces the bot's refusal", async () => {
     const { mx } = fakeClient('openid-1');
     vi.stubGlobal(
diff --git a/src/app/plugins/registration-bot.ts b/src/app/plugins/registration-bot.ts
index 1bfeae41..bf742f31 100644
--- a/src/app/plugins/registration-bot.ts
+++ b/src/app/plugins/registration-bot.ts
@@ -1,11 +1,13 @@
 /**
  * Client for the registration bot's HTTP API, from
- * https://github.com/HelloAOLab/matrix-bots/pull/45:
+ * https://github.com/HelloAOLab/matrix-bots/pull/45 and
+ * https://github.com/HelloAOLab/matrix-bots/pull/48:
  *
  *   POST <apiUrl>/api/registration-link   { "client_id"?: string }
  *   GET  <apiUrl>/api/clients[?client_id=<id>]
+ *   GET  <apiUrl>/api/invites[?user_id=<user>]
  *
- * Both are authenticated with `Authorization: Bearer <access_token>`, where the token
+ * All are authenticated with `Authorization: Bearer <access_token>`, where the token
  * is an OpenID token we get from our own homeserver
  * (`POST /_matrix/client/v3/user/{userId}/openid/request_token`). Only its
  * `access_token` is sent — the bot verifies it against the one homeserver it lives on,
@@ -64,8 +66,46 @@ export type RegistrationClientsFailure = {
 
 export type RegistrationClientsResult = RegistrationClientsSuccess | RegistrationClientsFailure;
 
+export const REGISTRATION_INVITE_STATUSES = [
+  'unused',
+  'pending',
+  'used',
+  'expired',
+  'revoked',
+] as const;
+
+export type RegistrationInviteStatus = typeof REGISTRATION_INVITE_STATUSES[number];
+
+/**
+ * A registration link the bot generated for someone. The token itself is never
+ * returned — only the hex SHA-256 of it — since an unused one would still work.
+ * Timestamps are milliseconds since the epoch.
+ */
+export type RegistrationInvite = {
+  tokenSha256: string;
+  status: RegistrationInviteStatus;
+  clientId: string | null;
+  issuedAt: number | null;
+  expiresAt: number | null;
+  registeredUserId: string | null;
+  registeredAt: number | null;
+};
+
+export type RegistrationInvitesSuccess = {
+  success: true;
+  invites: RegistrationInvite[];
+};
+
+export type RegistrationInvitesFailure = {
+  success: false;
+  error: RegistrationError;
+};
+
+export type RegistrationInvitesResult = RegistrationInvitesSuccess | RegistrationInvitesFailure;
+
 const LINK_FALLBACK_MESSAGE = 'The registration bot could not create a link.';
 const CLIENTS_FALLBACK_MESSAGE = 'The registration bot could not list clients.';
+const INVITES_FALLBACK_MESSAGE = 'The registration bot could not list invites.';
 
 const joinUrl = (apiUrl: string, path: string): string => `${apiUrl.replace(/\/+$/, '')}${path}`;
 
@@ -77,6 +117,12 @@ export const buildRegistrationClientsUrl = (apiUrl: string, clientId?: string):
   return clientId ? `${url}?client_id=${encodeURIComponent(clientId)}` : url;
 };
 
+/** `userId` asks for someone else's invites, which the bot only allows admins. */
+export const buildRegistrationInvitesUrl = (apiUrl: string, userId?: string): string => {
+  const url = joinUrl(apiUrl, '/api/invites');
+  return userId ? `${url}?user_id=${encodeURIComponent(userId)}` : url;
+};
+
 export const buildRegistrationLinkRequestBody = (params: {
   clientId?: string;
 }): RegistrationLinkRequestBody => {
@@ -136,14 +182,64 @@ export const parseRegistrationClientsResponse = (value: unknown): RegistrationCl
   return { success: false, error: parseError(body, CLIENTS_FALLBACK_MESSAGE) };
 };
 
+const isInviteStatus = (value: unknown): value is RegistrationInviteStatus =>
+  typeof value === 'string' && (REGISTRATION_INVITE_STATUSES as readonly string[]).includes(value);
+
+const optionalString = (value: unknown): string | null | undefined => {
+  if (value === null || value === undefined) return null;
+  return typeof value === 'string' ? value : undefined;
+};
+
+const optionalNumber = (value: unknown): number | null | undefined => {
+  if (value === null || value === undefined) return null;
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+};
+
+const asInvite = (entry: unknown): RegistrationInvite | undefined => {
+  const record = asRecord(entry);
+  if (!record) return undefined;
+  const { token_sha256: tokenSha256, status } = record;
+  if (typeof tokenSha256 !== 'string' || !isInviteStatus(status)) return undefined;
+  const clientId = optionalString(record.client_id);
+  const issuedAt = optionalNumber(record.issued_at);
+  const expiresAt = optionalNumber(record.expires_at);
+  const registeredUserId = optionalString(record.registered_user_id);
+  const registeredAt = optionalNumber(record.registered_at);
+  if (
+    clientId === undefined ||
+    issuedAt === undefined ||
+    expiresAt === undefined ||
+    registeredUserId === undefined ||
+    registeredAt === undefined
+  ) {
+    return undefined;
+  }
+  return { tokenSha256, status, clientId, issuedAt, expiresAt, registeredUserId, registeredAt };
+};
+
+/**
+ * Entries that don't parse (e.g. a status added to the bot after this client) are
+ * dropped rather than failing the whole list, so the rest can still be shown.
+ */
+export const parseRegistrationInvitesResponse = (value: unknown): RegistrationInvitesResult => {
+  const body = asRecord(value);
+  if (body?.success === true && Array.isArray(body.invites)) {
+    const invites = body.invites
+      .map(asInvite)
+      .filter((invite): invite is RegistrationInvite => invite !== undefined);
+    return { success: true, invites };
+  }
+  return { success: false, error: parseError(body, INVITES_FALLBACK_MESSAGE) };
+};
+
 type CachedOpenIdToken = { accessToken: string; expiresAt: number };
 
 export const isOpenIdTokenFresh = (cached: CachedOpenIdToken | undefined, now: number): boolean =>
   cached !== undefined && cached.expiresAt - OPENID_TOKEN_EXPIRY_MARGIN_MS > now;
 
 /**
- * OpenID tokens last about an hour, and one UI open asks the bot at least twice (list
- * clients, then mint), so reuse a token until shortly before it expires.
+ * OpenID tokens last about an hour, and one UI open asks the bot several times (list
+ * clients and invites, then mint), so reuse a token until shortly before it expires.
  */
 const openIdTokenCache = new WeakMap<MatrixClient, CachedOpenIdToken>();
 
@@ -252,3 +348,21 @@ export const requestRegistrationClients = (
     timeoutMs,
     parseRegistrationClientsResponse
   );
+
+/**
+ * Ask the registration bot for the links it generated for the current user (or, for
+ * an admin, for `userId`), newest first, with each one's status.
+ */
+export const requestRegistrationInvites = (
+  mx: MatrixClient,
+  botConfig: RegistrationBotConfig,
+  userId?: string,
+  timeoutMs = DEFAULT_TIMEOUT_MS
+): Promise<RegistrationInvitesResult> =>
+  callRegistrationApi(
+    mx,
+    buildRegistrationInvitesUrl(botConfig.apiUrl, userId),
+    { method: 'GET' },
+    timeoutMs,
+    parseRegistrationInvitesResponse
+  );