diff --git a/apps/admin-x-framework/src/api/member-activity-pagination.ts b/apps/admin-x-framework/src/api/member-activity-pagination.ts
new file mode 100644
index 00000000000..9b59bbb75c1
--- /dev/null
+++ b/apps/admin-x-framework/src/api/member-activity-pagination.ts
@@ -0,0 +1,200 @@
+import { escapeNqlString } from '@tryghost/nql-string';
+import type { MemberActivityEvent, MemberActivityFeedResponseType } from './members';
+
+type OlderCursor = { kind: 'older'; before?: string };
+type BoundaryCursor = {
+  kind: 'boundary';
+  timestamp: string;
+  seen: string[];
+  completedTypes: string[];
+  currentType?: string;
+  beforeId?: string;
+};
+
+export type MemberActivityCursor = OlderCursor | BoundaryCursor;
+export interface MemberActivityPage extends MemberActivityFeedResponseType {
+  nextCursor?: MemberActivityCursor;
+}
+
+type ReadEvents = (params: Record<string, string>) => Promise<MemberActivityFeedResponseType>;
+
+const eventKey = (event: MemberActivityEvent) => `${event.type}:${event.data.id}`;
+
+// Older Core filters this source as "complained" but returns "complaint".
+// Include both spellings so this also works after the server fixes the alias.
+const filterTypes = (type: string): string[] =>
+  type === 'email_complaint_event' ? ['email_complaint_event', 'email_complained_event'] : [type];
+
+function eventTimestamp(event: MemberActivityEvent): string {
+  const timestamp = event.data.created_at;
+  if (!timestamp || !Number.isFinite(Date.parse(timestamp))) {
+    throw new Error('Member activity returned an event without a valid timestamp.');
+  }
+  // SQLite compares Ghost's second-precision timestamps as text. Omit a zero
+  // fraction to match those rows, but retain nonzero milliseconds for precision.
+  return new Date(timestamp)
+    .toISOString()
+    .replace('T', ' ')
+    .replace(/(?:\.000)?Z$/, '');
+}
+
+function validateEvents(events: MemberActivityEvent[]): void {
+  for (const event of events) {
+    eventTimestamp(event);
+    if (typeof event.data.id !== 'string' || !event.data.id || !event.type) {
+      throw new Error('Member activity returned an event without a valid identity.');
+    }
+  }
+}
+
+function hasMore(response: MemberActivityFeedResponseType, limit: number): boolean {
+  const total = response.meta?.pagination.total;
+  // The total also catches a server applying a lower page limit. Never silently
+  // treat a clamped response as the end of the feed.
+  return typeof total === 'number'
+    ? total > response.events.length
+    : response.events.length >= limit;
+}
+
+/**
+ * The older events API has no cursor or offset and merges several event tables.
+ * Its same-timestamp ordering is not globally ID-ordered, so adding id < lastId
+ * to the merged feed would still skip events. Complete its final timestamp one
+ * event type at a time, where the server's ID-descending order is unambiguous.
+ * Discover types through the API instead of maintaining a second event catalog.
+ *
+ * Requests and returned pages stay bounded by limit. Cursor memory is bounded
+ * by one page's initial boundary identities and the number of event types,
+ * regardless of the size of a newsletter send. Shared recipient IDs belonging
+ * to distinct email event types remain distinct events.
+ */
+export async function loadMemberActivityPage({
+  read,
+  filter = '',
+  limit,
+  cursor = { kind: 'older' },
+  signal,
+}: {
+  read: ReadEvents;
+  filter?: string;
+  limit: number;
+  cursor?: MemberActivityCursor;
+  signal?: AbortSignal;
+}): Promise<MemberActivityPage> {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error('Member activity page size must be a positive integer.');
+  }
+  // A failed request must leave the previous page's cursor untouched so a retry
+  // starts from exactly the same position.
+  let state: MemberActivityCursor =
+    cursor.kind === 'boundary'
+      ? { ...cursor, seen: [...cursor.seen], completedTypes: [...cursor.completedTypes] }
+      : { ...cursor };
+  const events: MemberActivityEvent[] = [];
+
+  const request = async (parts: string[], requestLimit: number) => {
+    signal?.throwIfAborted();
+    const response = await read({
+      // Core requires event-type constraints at the root AND level. Wrapping
+      // the base filter in parentheses would make mixed type/member filters fail.
+      filter: [filter, ...parts].filter(Boolean).join('+'),
+      limit: String(requestLimit),
+    });
+    // useFetchApi owns the in-flight network request. Stop any following drain
+    // requests when React Query cancels this query after navigation/filtering.
+    signal?.throwIfAborted();
+    validateEvents(response.events);
+    if (
+      response.events.length > requestLimit ||
+      (!response.events.length && hasMore(response, requestLimit))
+    ) {
+      throw new Error('Member activity pagination did not make progress.');
+    }
+    return response;
+  };
+
+  while (events.length < limit) {
+    const remaining = limit - events.length;
+    if (state.kind === 'older') {
+      const before = state.before;
+      const response = await request(
+        before ? [`data.created_at:<${escapeNqlString(before)}`] : [],
+        remaining,
+      );
+      if (before && response.events.some((event) => eventTimestamp(event) >= before)) {
+        throw new Error('Member activity returned events outside the requested time range.');
+      }
+      events.push(...response.events);
+      if (!hasMore(response, remaining)) {
+        return { events, meta: response.meta };
+      }
+      const timestamp = eventTimestamp(response.events[response.events.length - 1]);
+      state = {
+        kind: 'boundary',
+        timestamp,
+        seen: response.events.filter((event) => eventTimestamp(event) === timestamp).map(eventKey),
+        completedTypes: [],
+      };
+      if (events.length === limit) {
+        return { events, meta: response.meta, nextCursor: state };
+      }
+      continue;
+    }
+
+    const timestampFilter = `data.created_at:${escapeNqlString(state.timestamp)}`;
+    if (!state.currentType) {
+      const typeFilter = state.completedTypes.length
+        ? [`type:-[${state.completedTypes.flatMap(filterTypes).map(escapeNqlString).join(',')}]`]
+        : [];
+      const discovery = await request([timestampFilter, ...typeFilter], 1);
+      const event = discovery.events[0];
+      if (
+        !event ||
+        (!state.completedTypes.length && discovery.meta?.pagination.total === state.seen.length)
+      ) {
+        state = { kind: 'older', before: state.timestamp };
+        continue;
+      }
+      if (eventTimestamp(event) !== state.timestamp || state.completedTypes.includes(event.type)) {
+        throw new Error('Member activity returned events outside the requested type or timestamp.');
+      }
+      state.currentType = event.type;
+    }
+
+    const beforeId = state.beforeId;
+    const currentType = state.currentType;
+    const timestamp = state.timestamp;
+    const response = await request(
+      [
+        timestampFilter,
+        `type:[${filterTypes(currentType).map(escapeNqlString).join(',')}]`,
+        ...(beforeId ? [`id:<${escapeNqlString(beforeId)}`] : []),
+      ],
+      remaining,
+    );
+    if (
+      response.events.some(
+        (event) =>
+          event.type !== currentType ||
+          eventTimestamp(event) !== timestamp ||
+          (beforeId && String(event.data.id) >= beforeId),
+      )
+    ) {
+      throw new Error('Member activity returned events outside the requested cursor.');
+    }
+    const seen = new Set(state.seen);
+    events.push(...response.events.filter((event) => !seen.has(eventKey(event))));
+
+    if (hasMore(response, remaining)) {
+      // The single-type response is ID-descending. Use the minimum defensively
+      // so the cursor advances even if an older server returns a shuffled page.
+      state.beforeId = response.events.map((event) => String(event.data.id)).sort()[0];
+    } else {
+      state.completedTypes.push(state.currentType);
+      state.currentType = undefined;
+      state.beforeId = undefined;
+    }
+  }
+
+  return { events, nextCursor: state };
+}
diff --git a/apps/admin-x-framework/src/api/member-activity.ts b/apps/admin-x-framework/src/api/member-activity.ts
new file mode 100644
index 00000000000..854858c4aef
--- /dev/null
+++ b/apps/admin-x-framework/src/api/member-activity.ts
@@ -0,0 +1,72 @@
+import { useEffect, useMemo } from 'react';
+import { useInfiniteQuery } from '@tanstack/react-query';
+import { escapeNqlString } from '@tryghost/nql-string';
+import useHandleError from '../hooks/use-handle-error';
+import { apiUrl, useFetchApi } from '../utils/api/fetch-api';
+import { loadMemberActivityPage, type MemberActivityCursor } from './member-activity-pagination';
+import type { MemberActivityFeedResponseType } from './members';
+
+export interface BrowseMemberActivityOptions {
+  memberId?: string;
+  excludedEvents?: string[];
+  limit?: number;
+  enabled?: boolean;
+  defaultErrorHandler?: boolean;
+}
+
+/** Full, paginated activity feed. The member detail preview keeps its five-row query. */
+export function useBrowseMemberActivityFeed({
+  memberId,
+  excludedEvents = [],
+  limit = 50,
+  enabled = true,
+  defaultErrorHandler = true,
+}: BrowseMemberActivityOptions = {}) {
+  const fetchApi = useFetchApi();
+  const handleError = useHandleError();
+  // Accept the Activity page's domain filters, not arbitrary NQL. Core splits
+  // type selectors from row filters, so root-OR expressions cannot safely be
+  // combined with a timestamp or per-type pagination cursor.
+  const baseFilter = [
+    excludedEvents.length && `type:-[${excludedEvents.map(escapeNqlString).join(',')}]`,
+    memberId && `data.member_id:${escapeNqlString(memberId)}`,
+  ]
+    .filter(Boolean)
+    .join('+');
+  const result = useInfiniteQuery({
+    queryKey: [
+      'MemberActivityFeedResponseType',
+      apiUrl('/members/events/', { filter: baseFilter, limit: String(limit) }),
+      'timeline',
+    ],
+    enabled,
+    initialPageParam: { kind: 'older' } as MemberActivityCursor,
+    queryFn: ({ pageParam, signal }) =>
+      loadMemberActivityPage({
+        read: (params) =>
+          fetchApi<MemberActivityFeedResponseType>(apiUrl('/members/events/', params)),
+        filter: baseFilter,
+        limit,
+        cursor: pageParam,
+        signal,
+      }),
+    getNextPageParam: (page) => page.nextCursor,
+  });
+  const data = useMemo(
+    () =>
+      result.data && {
+        events: result.data.pages.flatMap((page) => page.events),
+        meta: result.data.pages[0]?.meta,
+        isEnd: !result.data.pages[result.data.pages.length - 1]?.nextCursor,
+      },
+    [result.data],
+  );
+
+  useEffect(() => {
+    if (result.error && defaultErrorHandler) {
+      handleError(result.error);
+    }
+  }, [result.error, handleError, defaultErrorHandler]);
+
+  return { ...result, data };
+}
diff --git a/apps/admin-x-framework/src/api/members.ts b/apps/admin-x-framework/src/api/members.ts
index fe1ade0350a..e3108006af1 100644
--- a/apps/admin-x-framework/src/api/members.ts
+++ b/apps/admin-x-framework/src/api/members.ts
@@ -13,6 +13,8 @@ import { useCurrentUser } from './current-user';
 import { canManageMembers } from './users';
 import { FREE_SEGMENT, PAID_SEGMENT } from '../utils/recipient-filter';
 
+export { useBrowseMemberActivityFeed, type BrowseMemberActivityOptions } from './member-activity';
+
 export type MemberLabel = {
   id: string;
   name: string;
@@ -857,11 +859,11 @@ const MEMBER_ACTIVITY_LIMIT = '20';
 // last event of the previous page (events are ordered created_at desc).
 //
 // KNOWN LIMITATION: the cursor is `created_at`-only, without the id tie-breaker
-// Ember's version added (`+id:<'<lastId>'`). Two events emitted in the same
+// required for reliable pagination. Two events emitted in the same
 // second on a page boundary can be skipped from the paginated list. The current
 // consumer (`MemberActivityFeed` in `apps/admin`) only fetches 5 events and
-// never calls `fetchNextPage`, so this is not exploitable today; add an id
-// secondary cursor before another screen starts paginating.
+// never calls `fetchNextPage`. Paginated consumers must use
+// useBrowseMemberActivityFeed, which drains timestamp boundaries by event type.
 function memberEventsCursor(events: MemberActivityEvent[]): string | undefined {
   const createdAt = events[events.length - 1]?.data?.created_at;
   if (!createdAt) {
diff --git a/apps/admin-x-framework/test/unit/api/member-activity-pagination.test.ts b/apps/admin-x-framework/test/unit/api/member-activity-pagination.test.ts
new file mode 100644
index 00000000000..1a09f32430f
--- /dev/null
+++ b/apps/admin-x-framework/test/unit/api/member-activity-pagination.test.ts
@@ -0,0 +1,268 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  loadMemberActivityPage,
+  type MemberActivityCursor,
+} from '../../../src/api/member-activity-pagination';
+import type { MemberActivityEvent, MemberActivityFeedResponseType } from '../../../src/api/members';
+
+const timestamp = '2026-09-14T10:00:00.000Z';
+const olderTimestamp = '2026-09-14T09:59:59.000Z';
+
+function event(
+  id: number,
+  type = 'email_delivered_event',
+  createdAt = timestamp,
+  memberId = 'member-1',
+): MemberActivityEvent {
+  return {
+    type,
+    data: { id: String(id).padStart(24, '0'), created_at: createdAt, member_id: memberId },
+  };
+}
+
+const identity = (value: MemberActivityEvent) => `${value.type}:${value.data.id}`;
+const serverFilterType = (value: MemberActivityEvent) =>
+  value.type === 'email_complaint_event' ? 'email_complained_event' : value.type;
+
+/** A legacy server: only filter+limit, timestamp order, and per-type ID order.
+ * Mixed types deliberately use type priority ahead of ID, as Core does. */
+function legacyServer(
+  source: MemberActivityEvent[],
+  { metadata = true, maxLimit = Infinity, textTimestamps = false } = {},
+) {
+  return vi.fn(
+    async ({ filter, limit }: Record<string, string>): Promise<MemberActivityFeedResponseType> => {
+      let matching = [...source];
+      for (const match of filter.matchAll(/data\.created_at:(<)?'([^']+)'/g)) {
+        const cursor = textTimestamps ? match[2] : Date.parse(match[2].replace(' ', 'T') + 'Z');
+        matching = matching.filter((value) => {
+          // SQLite compares the second-precision text Ghost stores, without
+          // converting the filter value to a date as MySQL does.
+          const stored = textTimestamps
+            ? value.data.created_at!.replace('T', ' ').replace(/\.000Z$/, '')
+            : Date.parse(value.data.created_at!);
+          return match[1] ? stored < cursor : stored === cursor;
+        });
+      }
+      for (const match of filter.matchAll(/type:-\[([^\]]+)\]/g)) {
+        const excluded = match[1].replaceAll("'", '').split(',');
+        matching = matching.filter((value) => !excluded.includes(serverFilterType(value)));
+      }
+      for (const match of filter.matchAll(/type:'([^']+)'/g)) {
+        matching = matching.filter((value) => serverFilterType(value) === match[1]);
+      }
+      for (const match of filter.matchAll(/type:\[([^\]]+)\]/g)) {
+        const included = match[1].replaceAll("'", '').split(',');
+        matching = matching.filter((value) => included.includes(serverFilterType(value)));
+      }
+      for (const match of filter.matchAll(/data\.member_id:'([^']+)'/g)) {
+        matching = matching.filter((value) => value.data.member_id === match[1]);
+      }
+      for (const match of filter.matchAll(/(?:^|\+)id:<'([^']+)'/g)) {
+        matching = matching.filter((value) => String(value.data.id) < match[1]);
+      }
+      matching.sort(
+        (a, b) =>
+          Date.parse(b.data.created_at!) - Date.parse(a.data.created_at!) ||
+          a.type.localeCompare(b.type) ||
+          String(b.data.id).localeCompare(String(a.data.id)),
+      );
+      const pageLimit = Math.min(Number(limit), maxLimit);
+      return {
+        events: matching.slice(0, pageLimit),
+        ...(metadata
+          ? {
+              meta: {
+                pagination: {
+                  limit: pageLimit,
+                  total: matching.length,
+                  page: 1,
+                  pages: Math.ceil(matching.length / pageLimit),
+                  next: null,
+                  prev: null,
+                },
+              },
+            }
+          : {}),
+      };
+    },
+  );
+}
+
+async function browseAll(
+  read: ReturnType<typeof legacyServer>,
+  options: { limit?: number; filter?: string } = {},
+) {
+  let cursor: MemberActivityCursor | undefined;
+  const events: MemberActivityEvent[] = [];
+  for (let pageCount = 0; pageCount < 1000; pageCount++) {
+    const page = await loadMemberActivityPage({ read, limit: 50, ...options, cursor });
+    expect(page.events.length).toBeLessThanOrEqual(options.limit ?? 50);
+    events.push(...page.events);
+    cursor = page.nextCursor;
+    if (!cursor) {
+      return events;
+    }
+  }
+  throw new Error('Pagination failed to finish.');
+}
+
+describe('member activity pagination against the legacy endpoint', () => {
+  it('returns every event in a large same-second send with bounded requests and no duplicate identities', async () => {
+    const source = [
+      ...Array.from({ length: 2500 }, (_, index) => event(index + 1)),
+      ...Array.from({ length: 60 }, (_, index) =>
+        event(index + 2501, 'email_delivered_event', olderTimestamp),
+      ),
+    ];
+    const read = legacyServer(source);
+    const result = await browseAll(read);
+
+    expect(result.map(identity)).toEqual(
+      [...source]
+        .sort(
+          (a, b) =>
+            Date.parse(b.data.created_at!) - Date.parse(a.data.created_at!) ||
+            String(b.data.id).localeCompare(String(a.data.id)),
+        )
+        .map(identity),
+    );
+    expect(new Set(result.map(identity)).size).toBe(source.length);
+    expect(read.mock.calls.every(([params]) => Number(params.limit) <= 50)).toBe(true);
+    expect(Math.max(...read.mock.calls.map(([params]) => params.filter.length))).toBeLessThan(250);
+  });
+
+  it('keeps events of different types with the same recipient ID and discovers unknown types', async () => {
+    const source = [
+      ...Array.from({ length: 80 }, (_, index) => event(index + 1, 'email_delivered_event')),
+      ...Array.from({ length: 80 }, (_, index) => event(index + 1, 'email_opened_event')),
+      ...Array.from({ length: 70 }, (_, index) => event(index + 1, 'future_server_event')),
+      event(900, 'signup_event', olderTimestamp),
+    ];
+    const result = await browseAll(legacyServer(source), { limit: 7 });
+
+    expect(result.map(identity).sort()).toEqual(source.map(identity).sort());
+    expect(result[result.length - 1]).toEqual(source[source.length - 1]);
+    expect(new Set(result.map(identity)).size).toBe(source.length);
+  });
+
+  it('preserves exclusions and member constraints for every boundary request', async () => {
+    const source = [
+      ...Array.from({ length: 70 }, (_, index) => event(index + 1)),
+      ...Array.from({ length: 70 }, (_, index) => event(index + 1, 'email_opened_event')),
+      ...Array.from({ length: 70 }, (_, index) =>
+        event(index + 1, 'email_delivered_event', timestamp, 'member-2'),
+      ),
+    ];
+    const filter = "type:-[email_opened_event]+data.member_id:'member-1'";
+    const read = legacyServer(source);
+    const result = await browseAll(read, { limit: 10, filter });
+
+    expect(result.map(identity).sort()).toEqual(source.slice(0, 70).map(identity).sort());
+    expect(read.mock.calls.every(([params]) => params.filter.startsWith(filter))).toBe(true);
+  });
+
+  it('drains spam complaints when Core uses a different type name in its filter', async () => {
+    const source = [
+      ...Array.from({ length: 70 }, (_, index) => event(index + 1, 'email_complaint_event')),
+      ...Array.from({ length: 70 }, (_, index) => event(index + 1, 'email_opened_event')),
+    ];
+    const result = await browseAll(legacyServer(source), { limit: 7 });
+    expect(result.map(identity).sort()).toEqual(source.map(identity).sort());
+  });
+
+  it('does not require pagination metadata from an older backend', async () => {
+    const source = Array.from({ length: 105 }, (_, index) => event(index + 1));
+    expect(
+      (await browseAll(legacyServer(source, { metadata: false }))).map(identity).sort(),
+    ).toEqual(source.map(identity).sort());
+  });
+
+  it('continues when a server clamps the requested page size', async () => {
+    const source = Array.from({ length: 105 }, (_, index) => event(index + 1));
+    expect((await browseAll(legacyServer(source, { maxLimit: 7 }))).map(identity).sort()).toEqual(
+      source.map(identity).sort(),
+    );
+  });
+
+  it.each([1, 75])(
+    'paginates SQLite text timestamps with %s events at the boundary',
+    async (boundaryCount) => {
+      const source = [
+        ...Array.from({ length: boundaryCount }, (_, index) => event(index + 1)),
+        event(100, 'login_event', olderTimestamp),
+      ];
+      const result = await browseAll(legacyServer(source, { textTimestamps: true }), {
+        limit: Math.min(boundaryCount, 50),
+      });
+
+      expect(result.map(identity).sort()).toEqual(source.map(identity).sort());
+      expect(result[result.length - 1]).toEqual(source[source.length - 1]);
+      expect(new Set(result.map(identity)).size).toBe(source.length);
+    },
+  );
+
+  it('keeps sub-second timestamp precision across page boundaries', async () => {
+    const source = [
+      event(3, 'login_event', '2026-09-14T10:00:00.900Z'),
+      event(2, 'login_event', '2026-09-14T10:00:00.500Z'),
+      event(1, 'login_event', '2026-09-14T10:00:00.100Z'),
+      event(0, 'login_event', '2026-09-14T10:00:00.000Z'),
+    ];
+    expect(await browseAll(legacyServer(source), { limit: 1 })).toEqual(source);
+  });
+
+  it('retries a failed boundary request from the unchanged cursor', async () => {
+    const source = Array.from({ length: 125 }, (_, index) => event(index + 1));
+    const read = legacyServer(source);
+    const first = await loadMemberActivityPage({ read, limit: 50 });
+    const savedCursor = JSON.stringify(first.nextCursor);
+    const reliableRead = read.getMockImplementation()!;
+    read.mockImplementationOnce(reliableRead).mockRejectedValueOnce(new Error('Connection lost'));
+
+    await expect(
+      loadMemberActivityPage({ read, limit: 50, cursor: first.nextCursor }),
+    ).rejects.toThrow('Connection lost');
+    expect(JSON.stringify(first.nextCursor)).toBe(savedCursor);
+    const second = await loadMemberActivityPage({ read, limit: 50, cursor: first.nextCursor });
+    const third = await loadMemberActivityPage({ read, limit: 50, cursor: second.nextCursor });
+    expect([...first.events, ...second.events, ...third.events].map(identity).sort()).toEqual(
+      source.map(identity).sort(),
+    );
+  });
+
+  it('stops subsequent boundary requests when a filter change cancels the query', async () => {
+    const source = Array.from({ length: 125 }, (_, index) => event(index + 1));
+    const read = legacyServer(source);
+    const first = await loadMemberActivityPage({ read, limit: 50 });
+    const controller = new AbortController();
+    const reliableRead = read.getMockImplementation()!;
+    read.mockImplementationOnce(async (params) => {
+      const response = await reliableRead(params);
+      controller.abort();
+      return response;
+    });
+    const beforeCalls = read.mock.calls.length;
+
+    await expect(
+      loadMemberActivityPage({
+        read,
+        limit: 50,
+        cursor: first.nextCursor,
+        signal: controller.signal,
+      }),
+    ).rejects.toMatchObject({ name: 'AbortError' });
+    expect(read.mock.calls.length - beforeCalls).toBe(1);
+  });
+
+  it('fails visibly instead of ending pagination when a response cannot advance', async () => {
+    const read = legacyServer([event(1)]);
+    read.mockResolvedValueOnce({
+      events: [],
+      meta: { pagination: { page: 1, pages: 2, limit: 50, total: 100, next: null, prev: null } },
+    });
+    await expect(loadMemberActivityPage({ read, limit: 50 })).rejects.toThrow(
+      'did not make progress',
+    );
+  });
+});
diff --git a/apps/admin/src/layout/app-sidebar/nav-content.tsx b/apps/admin/src/layout/app-sidebar/nav-content.tsx
index e4446672206..492eb2a9d40 100644
--- a/apps/admin/src/layout/app-sidebar/nav-content.tsx
+++ b/apps/admin/src/layout/app-sidebar/nav-content.tsx
@@ -88,6 +88,7 @@ function NavContent({ ...props }: React.ComponentProps<typeof SidebarGroup>) {
   const routing = useEmberRouting();
   const automationsEnabled = useFeatureFlag('automations');
   const isMembersRouteActive = useIsActiveLink({ path: 'members', activeOnSubpath: true });
+  const isMemberActivityActive = useIsActiveLink({ path: 'members-activity' });
 
   const showTags = currentUser && canManageTags(currentUser);
   const showMembers = currentUser && canManageMembers(currentUser);
@@ -101,7 +102,7 @@ function NavContent({ ...props }: React.ComponentProps<typeof SidebarGroup>) {
   const membersExpanded = savedMembersExpanded;
   const membersNavActive = isMembersRouteActive
     ? !hasActiveMemberView || !membersExpanded
-    : routing.isRouteActive(LEGACY_MEMBERS_ACTIVE_ROUTES);
+    : isMemberActivityActive || routing.isRouteActive(LEGACY_MEMBERS_ACTIVE_ROUTES);
   const postsRoute = postNavigation.mainUrl;
   const postsNavActive = postNavigation.isMainActive || (!postsExpanded && hasActivePostChild);
   return (
diff --git a/apps/admin/src/member-activity-gate.acceptance.test.tsx b/apps/admin/src/member-activity-gate.acceptance.test.tsx
new file mode 100644
index 00000000000..d939a3e8be3
--- /dev/null
+++ b/apps/admin/src/member-activity-gate.acceptance.test.tsx
@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { page } from 'vitest/browser';
+import { configResponse, fakeAdminEndpoint, renderAdminApp } from '@test-utils/acceptance';
+
+describe('Member activity route ownership', () => {
+  it.each([false, undefined])('leaves the page with Ember when the flag is %s', async (enabled) => {
+    const config = configResponse();
+    config.config.labs ??= {};
+    if (enabled === undefined) {
+      delete config.config.labs.membersActivityReact;
+    } else {
+      config.config.labs.membersActivityReact = enabled;
+    }
+    const events = fakeAdminEndpoint('GET', /^\/members\/events\//, { events: [] });
+    await renderAdminApp('/members-activity', {
+      boot: { browseConfig: { response: config } },
+    });
+
+    // There is no Ember runtime in this tier; the shell exposes its host
+    // instead. The real off-flag UI journey is covered by browser E2E.
+    await expect
+      .poll(() => document.getElementById('ember-app')?.parentElement?.hidden)
+      .toBe(false);
+    await expect
+      .element(page.getByRole('heading', { name: 'Member activity' }))
+      .not.toBeInTheDocument();
+    expect(events.requests).toHaveLength(0);
+  });
+});
diff --git a/apps/admin/src/member-activity-gate.tsx b/apps/admin/src/member-activity-gate.tsx
new file mode 100644
index 00000000000..64a370e7b65
--- /dev/null
+++ b/apps/admin/src/member-activity-gate.tsx
@@ -0,0 +1,9 @@
+import { lazy } from 'react';
+import { FlagGatedRoute } from './flag-gated-route';
+import { lazyMemberActivityScreen } from './members/api';
+
+const MemberActivityReact = lazy(lazyMemberActivityScreen);
+
+export function MemberActivityGate() {
+  return <FlagGatedRoute component={MemberActivityReact} flag="membersActivityReact" />;
+}
diff --git a/apps/admin/src/members/activity/activity-email-preview-data.ts b/apps/admin/src/members/activity/activity-email-preview-data.ts
new file mode 100644
index 00000000000..0594ef11edc
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-email-preview-data.ts
@@ -0,0 +1,68 @@
+import type { Config } from '@tryghost/admin-x-framework/api/config';
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function string(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+/** Activity carries historical email objects, occasionally nested in a post. */
+export function activityEmailPreviewData(value: unknown) {
+  const source = record(value);
+  const nested = record(source?.email);
+  const stored = [source, nested].find(
+    (candidate) => string(candidate?.html) && typeof candidate?.subject === 'string',
+  );
+  const newsletter = record(source?.newsletter) ?? record(nested?.newsletter);
+  // An email id is not a post id. Only actual post-shaped objects may fall
+  // back to their own id; welcome/automation ids must never hit this endpoint.
+  const postId =
+    string(source?.post_id) ||
+    string(nested?.post_id) ||
+    (typeof source?.title === 'string' ? string(source.id) : undefined);
+
+  return {
+    stored: stored ? { html: string(stored.html)!, subject: string(stored.subject)! } : undefined,
+    postId,
+    newsletter: newsletter
+      ? {
+          sender_name: string(newsletter.sender_name),
+          sender_email: string(newsletter.sender_email),
+        }
+      : undefined,
+  };
+}
+
+/** Matches Ember's sender-email-address helper, including managed domains. */
+export function activitySenderAddress(
+  sender: string | undefined,
+  defaultAddress: string | undefined,
+  config: Pick<Config, 'hostSettings'> | undefined,
+): string {
+  const managed = config?.hostSettings?.managedEmail;
+  if (
+    managed?.enabled &&
+    (!managed.sendingDomain || sender?.split('@')[1] !== managed.sendingDomain)
+  ) {
+    return defaultAddress || '';
+  }
+  return sender || defaultAddress || '';
+}
+
+/** The document is additionally sandboxed; links in a historical preview are inert. */
+export function activityPreviewDocument(html: string): string {
+  const document = new DOMParser().parseFromString(html, 'text/html');
+  document.querySelectorAll('a, area').forEach((link) => {
+    link.removeAttribute('href');
+    link.removeAttribute('target');
+  });
+  document.querySelectorAll('base, meta[http-equiv], form').forEach((element) => element.remove());
+  const style = document.createElement('style');
+  style.textContent = 'html { scrollbar-width: none; } html::-webkit-scrollbar { display: none; }';
+  document.head.append(style);
+  return `<!DOCTYPE html>${document.documentElement.outerHTML}`;
+}
diff --git a/apps/admin/src/members/activity/activity-email-preview.test.tsx b/apps/admin/src/members/activity/activity-email-preview.test.tsx
new file mode 100644
index 00000000000..882319ac7c6
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-email-preview.test.tsx
@@ -0,0 +1,175 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { useState } from 'react';
+import ActivityEmailPreview from './activity-email-preview';
+import {
+  activityEmailPreviewData,
+  activityPreviewDocument,
+  activitySenderAddress,
+} from './activity-email-preview-data';
+
+const queries = vi.hoisted(() => ({
+  preview: vi.fn(),
+  newsletters: vi.fn(),
+  config: vi.fn(),
+  settings: vi.fn(),
+  retry: vi.fn(),
+}));
+
+vi.mock('@tryghost/admin-x-framework/api/email-previews', () => ({
+  useEmailPreview: queries.preview,
+}));
+vi.mock('@tryghost/admin-x-framework/api/newsletters', () => ({
+  useBrowseNewsletters: queries.newsletters,
+}));
+vi.mock('@tryghost/admin-x-framework/api/config', () => ({ useBrowseConfig: queries.config }));
+vi.mock('@tryghost/admin-x-framework/api/settings', async () => ({
+  ...(await vi.importActual<typeof import('@tryghost/admin-x-framework/api/settings')>(
+    '@tryghost/admin-x-framework/api/settings',
+  )),
+  useBrowseSettings: queries.settings,
+}));
+
+const savedEmail = {
+  html: '<p>Saved body</p><a href="https://example.com" target="_blank">A link</a>',
+  subject: 'Original subject',
+  post_id: 'post-1',
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  queries.preview.mockReturnValue({ isLoading: false, isError: false, refetch: queries.retry });
+  queries.newsletters.mockReturnValue({
+    data: { newsletters: [{ sender_name: 'Newsletter', sender_email: 'news@example.com' }] },
+  });
+  queries.config.mockReturnValue({ data: { config: {} } });
+  queries.settings.mockReturnValue({
+    data: {
+      settings: [
+        { key: 'title', value: 'Publication' },
+        { key: 'default_email_address', value: 'default@example.com' },
+      ],
+    },
+  });
+});
+
+describe('Activity email preview', () => {
+  it('uses stored HTML and subject without generating a new preview, and disables navigation', () => {
+    render(<ActivityEmailPreview email={savedEmail} onClose={vi.fn()} />);
+    expect(screen.getByRole('dialog', { name: 'Email preview' })).toBeTruthy();
+    expect(screen.getByText('Original subject', { exact: false })).toBeTruthy();
+    expect(screen.getByText('Newsletter <news@example.com>', { exact: false })).toBeTruthy();
+    expect(screen.getByText('Jamie Larson <jamie@example.com>', { exact: false })).toBeTruthy();
+    const frame = screen.getByTitle('Email content');
+    expect(frame.getAttribute('sandbox')).toBe('');
+    expect(frame.getAttribute('srcdoc')).toContain('Saved body');
+    expect(frame.getAttribute('srcdoc')).not.toContain('href=');
+    expect(queries.preview).toHaveBeenCalledWith('post-1', { enabled: false });
+    fireEvent.click(screen.getByRole('radio', { name: 'Mobile' }));
+    expect(
+      screen.getByTitle('Email content').closest('[data-device]')?.getAttribute('data-device'),
+    ).toBe('mobile');
+  });
+
+  it('supports keyboard dismissal and the close button', () => {
+    const onClose = vi.fn();
+    render(<ActivityEmailPreview email={savedEmail} onClose={onClose} />);
+    fireEvent.keyDown(document, { key: 'Escape' });
+    expect(onClose).toHaveBeenCalledOnce();
+    fireEvent.click(screen.getByRole('button', { name: 'Close' }));
+    expect(onClose).toHaveBeenCalledTimes(2);
+  });
+
+  it('returns focus to the activity link after closing', async () => {
+    function ActivityLink() {
+      const [open, setOpen] = useState(false);
+      return (
+        <>
+          <button type="button" onClick={() => setOpen(true)}>
+            Preview saved email
+          </button>
+          {open && <ActivityEmailPreview email={savedEmail} onClose={() => setOpen(false)} />}
+        </>
+      );
+    }
+    render(<ActivityLink />);
+    const opener = screen.getByRole('button', { name: 'Preview saved email' });
+    opener.focus();
+    fireEvent.click(opener);
+    fireEvent.click(screen.getByRole('button', { name: 'Close' }));
+    await waitFor(() => expect(window.document.activeElement).toBe(opener));
+  });
+
+  it('loads a missing historical body using the post id and offers retry after a failed request', () => {
+    queries.preview.mockReturnValue({ isLoading: true });
+    const { rerender } = render(
+      <ActivityEmailPreview email={{ post_id: 'post-1' }} onClose={vi.fn()} />,
+    );
+    expect(queries.preview).toHaveBeenCalledWith('post-1', { enabled: true });
+    expect(screen.queryByTitle('Email content')).toBeNull();
+    queries.preview.mockReturnValue({ isLoading: false, isError: true, refetch: queries.retry });
+    rerender(<ActivityEmailPreview email={{ post_id: 'post-1' }} onClose={vi.fn()} />);
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
+    expect(queries.retry).toHaveBeenCalledOnce();
+    queries.preview.mockReturnValue({
+      data: { email_previews: [{ html: '<p>Fallback</p>', subject: 'Rendered subject' }] },
+    });
+    rerender(<ActivityEmailPreview email={{ post_id: 'post-1' }} onClose={vi.fn()} />);
+    expect(screen.getByTitle('Email content').getAttribute('srcdoc')).toContain('Fallback');
+    expect(screen.getByText('Rendered subject', { exact: false })).toBeTruthy();
+  });
+
+  it('does not interpret a deleted email or automated email id as a post id', () => {
+    render(
+      <ActivityEmailPreview email={{ id: 'automated-1', subject: 'Welcome' }} onClose={vi.fn()} />,
+    );
+    expect(queries.preview).toHaveBeenCalledWith('', { enabled: false });
+    expect(screen.getByText('The original email content is no longer available.')).toBeTruthy();
+    expect(screen.queryByRole('button', { name: 'Retry' })).toBeNull();
+  });
+
+  it('keeps the historical body visible and allows retry when sender details fail', () => {
+    queries.settings.mockReturnValue({ isError: true, refetch: queries.retry });
+    queries.config.mockReturnValue({ refetch: queries.retry });
+    queries.newsletters.mockReturnValue({ refetch: queries.retry });
+    render(<ActivityEmailPreview email={savedEmail} onClose={vi.fn()} />);
+    expect(screen.getByTitle('Email content').getAttribute('srcdoc')).toContain('Saved body');
+    expect(screen.getByRole('alert').textContent).toBe('Couldn’t load sender details.');
+    fireEvent.click(screen.getByRole('button', { name: 'Retry sender details' }));
+    expect(queries.retry).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe('Activity email data', () => {
+  it('accepts nested stored emails with an empty subject and does not require a style tag or doctype', () => {
+    expect(
+      activityEmailPreviewData({ email: { html: '<p>Original</p>', subject: '' } }).stored,
+    ).toEqual({ html: '<p>Original</p>', subject: '' });
+    expect(activityEmailPreviewData({ id: 'post-2', title: 'A post' }).postId).toBe('post-2');
+    expect(activityPreviewDocument('<p>Original</p>')).toContain('<p>Original</p>');
+  });
+
+  it('neutralizes refresh redirects, bases, form submission and image-map links', () => {
+    const html = activityPreviewDocument(
+      '<base href="https://example.com"><meta http-equiv="refresh" content="0;url=https://example.com"><form action="https://example.com"><button>Send</button></form><map><area href="https://example.com"></map>',
+    );
+    expect(html).not.toMatch(/<base|http-equiv|<form|href=/);
+  });
+
+  it('preserves managed sender restrictions and falls back to the default address', () => {
+    expect(
+      activitySenderAddress('other@example.com', 'default@managed.com', {
+        hostSettings: { managedEmail: { enabled: true } },
+      }),
+    ).toBe('default@managed.com');
+    expect(
+      activitySenderAddress('other@example.com', 'default@managed.com', {
+        hostSettings: { managedEmail: { enabled: true, sendingDomain: 'managed.com' } },
+      }),
+    ).toBe('default@managed.com');
+    expect(
+      activitySenderAddress('news@managed.com', 'default@managed.com', {
+        hostSettings: { managedEmail: { enabled: true, sendingDomain: 'managed.com' } },
+      }),
+    ).toBe('news@managed.com');
+  });
+});
diff --git a/apps/admin/src/members/activity/activity-email-preview.tsx b/apps/admin/src/members/activity/activity-email-preview.tsx
new file mode 100644
index 00000000000..1e12833219c
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-email-preview.tsx
@@ -0,0 +1,214 @@
+import { useMemo, useState } from 'react';
+import {
+  Button,
+  Dialog,
+  DialogContent,
+  DialogTitle,
+  EmptyIndicator,
+  LoadingIndicator,
+  PreviewChrome,
+  ToggleGroup,
+  ToggleGroupItem,
+} from '@tryghost/shade/components';
+import { Grid, Inline, Stack } from '@tryghost/shade/primitives';
+import { LucideIcon, cn } from '@tryghost/shade/utils';
+import { useBrowseConfig } from '@tryghost/admin-x-framework/api/config';
+import { useEmailPreview } from '@tryghost/admin-x-framework/api/email-previews';
+import { useBrowseNewsletters } from '@tryghost/admin-x-framework/api/newsletters';
+import { getSettingValues, useBrowseSettings } from '@tryghost/admin-x-framework/api/settings';
+import {
+  activityEmailPreviewData,
+  activityPreviewDocument,
+  activitySenderAddress,
+} from './activity-email-preview-data';
+
+interface ActivityEmailPreviewProps {
+  /** The event's email object, a nested email, or a post with its identity. */
+  email: unknown;
+  onClose: () => void;
+}
+
+export default function ActivityEmailPreview({ email, onClose }: ActivityEmailPreviewProps) {
+  const [device, setDevice] = useState<'desktop' | 'mobile'>('desktop');
+  const [opener] = useState(() => window.document.activeElement);
+  const source = activityEmailPreviewData(email);
+  const fallbackEnabled = !source.stored && !!source.postId;
+  const previewQuery = useEmailPreview(source.postId ?? '', { enabled: fallbackEnabled });
+  const newslettersQuery = useBrowseNewsletters({
+    enabled: !source.newsletter,
+    searchParams: { filter: 'status:active', limit: '1' },
+  });
+  const settingsQuery = useBrowseSettings();
+  const configQuery = useBrowseConfig();
+  const [siteTitle, defaultEmailAddress] = getSettingValues<string>(
+    settingsQuery.data?.settings ?? [],
+    ['title', 'default_email_address'],
+  );
+  const newsletter = source.newsletter ?? newslettersQuery.data?.newsletters[0];
+  const senderName = newsletter?.sender_name || siteTitle;
+  const senderAddress = activitySenderAddress(
+    newsletter?.sender_email ?? undefined,
+    defaultEmailAddress,
+    configQuery.data?.config,
+  );
+  const preview =
+    source.stored ??
+    (fallbackEnabled && !previewQuery.isError ? previewQuery.data?.email_previews[0] : undefined);
+  const document = useMemo(
+    () => (preview ? activityPreviewDocument(preview.html) : undefined),
+    [preview?.html],
+  );
+  const metadataError =
+    settingsQuery.isError ||
+    configQuery.isError ||
+    (!source.newsletter && newslettersQuery.isError);
+  const metadataLoading =
+    settingsQuery.isLoading ||
+    configQuery.isLoading ||
+    (!source.newsletter && newslettersQuery.isLoading);
+  const loading = fallbackEnabled && previewQuery.isLoading;
+
+  return (
+    <Dialog
+      open
+      onOpenChange={(open) => {
+        if (!open) {
+          onClose();
+        }
+      }}
+    >
+      <DialogContent
+        aria-describedby={undefined}
+        className="top-0 left-0 h-dvh w-full max-w-none translate-0 grid-rows-[auto_1fr] gap-0 rounded-none border-0 p-0 shadow-none sm:rounded-none"
+        data-testid="activity-email-preview"
+        onCloseAutoFocus={(event) => {
+          if (opener instanceof HTMLElement && opener.isConnected) {
+            event.preventDefault();
+            opener.focus();
+          }
+        }}
+        onInteractOutside={(event) => event.preventDefault()}
+      >
+        <Grid align="center" className="border-b border-border-default p-4" columns={3} gap="md">
+          <DialogTitle>Email preview</DialogTitle>
+          <ToggleGroup
+            className="justify-self-center"
+            type="single"
+            value={device}
+            onValueChange={(value) => {
+              if (value === 'desktop' || value === 'mobile') {
+                setDevice(value);
+              }
+            }}
+          >
+            <ToggleGroupItem aria-label="Desktop" value="desktop">
+              <LucideIcon.Laptop />
+            </ToggleGroupItem>
+            <ToggleGroupItem aria-label="Mobile" value="mobile">
+              <LucideIcon.Smartphone />
+            </ToggleGroupItem>
+          </ToggleGroup>
+          <Button className="justify-self-end" onClick={onClose}>
+            Close
+          </Button>
+        </Grid>
+        <Inline
+          align="start"
+          className="min-h-0 overflow-auto bg-muted p-3 sm:p-6"
+          gap="none"
+          justify="center"
+        >
+          <PreviewChrome
+            className={cn(
+              'max-w-full shrink-0',
+              device === 'desktop'
+                ? 'max-w-[740px] px-0 [&>div]:rounded-2xl [&>div]:shadow-2xl'
+                : 'shadow-2xl',
+            )}
+            data-device={device}
+            device={device}
+          >
+            <Stack className="size-full bg-background" gap="none">
+              <Stack className="border-b border-border-default p-4 text-[13px]" gap="xs">
+                <p className="font-semibold break-words">{preview?.subject}</p>
+                <p>
+                  <span className="text-muted-foreground">From: </span>
+                  {metadataLoading ? (
+                    'Loading sender…'
+                  ) : metadataError ? (
+                    'Sender unavailable'
+                  ) : (
+                    <>
+                      {senderName}
+                      {senderAddress && ` <${senderAddress}>`}
+                    </>
+                  )}
+                </p>
+                <p>
+                  <span className="text-muted-foreground">To: </span>Jamie Larson
+                  &lt;jamie@example.com&gt;
+                </p>
+                {metadataError && (
+                  <Inline gap="sm">
+                    <p role="alert">Couldn’t load sender details.</p>
+                    <Button
+                      size="sm"
+                      variant="outline"
+                      onClick={() => {
+                        void settingsQuery.refetch();
+                        void configQuery.refetch();
+                        if (!source.newsletter) {
+                          void newslettersQuery.refetch();
+                        }
+                      }}
+                    >
+                      Retry sender details
+                    </Button>
+                  </Inline>
+                )}
+              </Stack>
+              {loading ? (
+                <Inline
+                  aria-label="Loading email preview"
+                  className="grow"
+                  gap="none"
+                  justify="center"
+                  role="status"
+                >
+                  <LoadingIndicator size="md" />
+                </Inline>
+              ) : preview ? (
+                <iframe
+                  className="min-h-0 grow border-0"
+                  sandbox=""
+                  srcDoc={document}
+                  title="Email content"
+                />
+              ) : (
+                <EmptyIndicator
+                  actions={
+                    fallbackEnabled ? (
+                      <Button variant="outline" onClick={() => void previewQuery.refetch()}>
+                        Retry
+                      </Button>
+                    ) : undefined
+                  }
+                  className="grow justify-center"
+                  description={
+                    fallbackEnabled
+                      ? 'The email preview could not be loaded.'
+                      : 'The original email content is no longer available.'
+                  }
+                  role="alert"
+                  title="Couldn’t load the email preview"
+                >
+                  <LucideIcon.MailWarning />
+                </EmptyIndicator>
+              )}
+            </Stack>
+          </PreviewChrome>
+        </Inline>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/admin/src/members/activity/activity-event.test.ts b/apps/admin/src/members/activity/activity-event.test.ts
new file mode 100644
index 00000000000..8deffbdbfe9
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-event.test.ts
@@ -0,0 +1,200 @@
+import { describe, expect, it } from 'vitest';
+import { parseActivityEvent } from './activity-event';
+import {
+  parseMemberEvent,
+  type MemberEventContext,
+  type RawMemberEvent,
+} from '@/members/detail/member-event';
+
+const context: MemberEventContext = {
+  hasMultipleNewsletters: false,
+  hasMultipleTiers: false,
+  paidMembersEnabled: true,
+};
+const event = (type: string, data: RawMemberEvent['data'] = {}): RawMemberEvent => ({ type, data });
+
+describe('full Activity event presentation', () => {
+  it.each([
+    ['created', 1200, 'Paid $12/month'],
+    ['created', -1050, 'Paid -$10.5/month'],
+    ['updated', 101, 'MRR +$1.01'],
+    ['updated', -101, 'MRR -$1.01'],
+    ['canceled', -1200, 'MRR -$12'],
+    ['reactivated', 1200, 'MRR +$12'],
+    ['expired', -1200, 'MRR -$12'],
+    ['updated', 100001, 'MRR +$1,000.01'],
+    ['created', 0, undefined],
+    ['updated', 0, undefined],
+  ])('formats %s subscription delta %s', (type, mrrDelta, expected) => {
+    expect(
+      parseActivityEvent(
+        event('subscription_event', { type, mrr_delta: mrrDelta, currency: 'usd' }),
+        context,
+      ).info,
+    ).toBe(expected);
+  });
+
+  it('uses the tier name only when multiple tiers are available, including paid signups', () => {
+    const created = event('subscription_event', {
+      type: 'created',
+      signup: true,
+      mrr_delta: 2500,
+      currency: 'eur',
+      tierName: 'Supporter',
+    });
+    expect(parseActivityEvent(created, context).info).toBe('Paid €25/month');
+    expect(parseActivityEvent(created, { ...context, hasMultipleTiers: true })).toMatchObject({
+      action: 'signed up',
+      info: 'Supporter €25/month',
+    });
+    expect(
+      parseActivityEvent(event('subscription_event', { ...created.data, tierName: null }), {
+        ...context,
+        hasMultipleTiers: true,
+      }).info,
+    ).toBe('Paid €25/month');
+  });
+
+  it.each([
+    [2500, 'usd', '$25'],
+    [2501, 'usd', '$25.01'],
+    [0, 'usd', '$0'],
+    [-1050, 'usd', '$-10.5'],
+    [123456, 'gbp', '£1,234.56'],
+  ])('preserves donation amount %s %s', (amount, currency, expected) => {
+    expect(parseActivityEvent(event('donation_event', { amount, currency }), context).info).toBe(
+      expected,
+    );
+  });
+
+  it.each([
+    { amount: Number.NaN, currency: 'usd' },
+    { amount: Infinity, currency: 'usd' },
+    { amount: '1200', currency: 'usd' },
+    { amount: null, currency: 'usd' },
+    { amount: 1200, currency: 'invalid' },
+    { amount: 1200, currency: null },
+    {},
+  ])(
+    'omits malformed financial values without reporting a zero amount: %j',
+    ({ amount, currency }) => {
+      expect(
+        parseActivityEvent(event('donation_event', { amount, currency }), context).info,
+      ).toBeUndefined();
+      expect(
+        parseActivityEvent(event('subscription_event', { mrr_delta: amount, currency }), context)
+          .info,
+      ).toBeUndefined();
+      expect(
+        parseActivityEvent(
+          event('gift_purchase_event', {
+            amount,
+            currency,
+            tier_name: 'Supporter',
+            duration: 1,
+            cadence: 'month',
+          }),
+          context,
+        ).action,
+      ).toBe('Purchased gift subscription');
+    },
+  );
+
+  it('preserves Ember gift conversion for all currencies and formats duration and fractions', () => {
+    const gift = event('gift_purchase_event', {
+      amount: 123450,
+      currency: 'jpy',
+      tier_name: 'Supporter',
+      duration: 2,
+      cadence: 'month',
+    });
+    expect(parseActivityEvent(gift, context)).toMatchObject({
+      action: 'Purchased gift subscription for ¥1,234.5 (Supporter, 2 months)',
+      actionTitle: 'Purchased gift subscription for ¥1,234.5 (Supporter, 2 months)',
+    });
+    expect(
+      parseActivityEvent(
+        event('gift_purchase_event', { ...gift.data, amount: 1050, currency: 'usd', duration: 1 }),
+        context,
+      ).action,
+    ).toBe('Purchased gift subscription for $10.5 (Supporter, 1 month)');
+  });
+
+  it.each([0, -1, Infinity, Number.NaN, 1.5, null, '1'])(
+    'falls back for invalid gift duration %s',
+    (duration) => {
+      expect(
+        parseActivityEvent(
+          event('gift_purchase_event', {
+            amount: 1000,
+            currency: 'usd',
+            tier_name: 'Supporter',
+            duration,
+            cadence: 'month',
+          }),
+          context,
+        ).action,
+      ).toBe('Purchased gift subscription');
+    },
+  );
+
+  it('cleans click descriptions while retaining destination and unrelated query parameters', () => {
+    const click = event('click_event', {
+      link: {
+        to: 'https://www.example.com/path?ref=newsletter&attribution_id=post&attribution_type=post&utm_source=email#section',
+      },
+      post: { id: 'post-1', title: 'A post', url: 'https://example.com/post' },
+    });
+    expect(parseActivityEvent(click, context)).toMatchObject({
+      description: 'example.com/path?utm_source=email#section',
+      url: 'https://example.com/post',
+      route: '#/posts/analytics/post-1',
+    });
+  });
+
+  it('preserves invalid click URLs as text and omits missing/non-string descriptions', () => {
+    expect(
+      parseActivityEvent(event('click_event', { link: { to: 'not a URL' } }), context).description,
+    ).toBe('not a URL');
+    expect(parseActivityEvent(event('click_event'), context).description).toBeUndefined();
+    expect(
+      parseActivityEvent(event('click_event', { link: { to: 123 } }), context).description,
+    ).toBeUndefined();
+  });
+
+  it('leaves the existing detail parser and raw events unchanged', () => {
+    const cases = [
+      event('subscription_event', { type: 'created', mrr_delta: 1000, currency: 'usd' }),
+      event('donation_event', { amount: 1000, currency: 'usd' }),
+      event('click_event', { link: { to: 'https://example.com/?ref=test' } }),
+      event('gift_purchase_event', {
+        amount: 10000,
+        currency: 'jpy',
+        tier_name: 'Supporter',
+        duration: 1,
+        cadence: 'month',
+      }),
+    ];
+    const originals = structuredClone(cases);
+    const detailBefore = cases.map((value) => parseMemberEvent(value, context));
+    cases.forEach((value) => parseActivityEvent(value, context));
+    expect(cases).toEqual(originals);
+    expect(cases.map((value) => parseMemberEvent(value, context))).toEqual(detailBefore);
+    expect(detailBefore[0].info).toBeUndefined();
+    expect(detailBefore[1].info).toBeUndefined();
+    expect(detailBefore[2].description).toBe('https://example.com/?ref=test');
+    expect(detailBefore[3].action).toBe(
+      'Purchased gift subscription for ¥10,000 (Supporter, 1 month)',
+    );
+  });
+
+  it('preserves unrelated signup and gift-redemption information', () => {
+    expect(parseActivityEvent(event('signup_event'), context).info).toBe('Free');
+    expect(
+      parseActivityEvent(event('signup_event', { created_with_status: 'paid' }), context).info,
+    ).toBeNull();
+    expect(
+      parseActivityEvent(event('gift_redemption_event', { tier_name: 'Supporter' }), context).info,
+    ).toBe('Supporter');
+  });
+});
diff --git a/apps/admin/src/members/activity/activity-event.ts b/apps/admin/src/members/activity/activity-event.ts
new file mode 100644
index 00000000000..6e9a1e22185
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-event.ts
@@ -0,0 +1,95 @@
+import { currencyToDecimal, getSymbol } from '@tryghost/admin-x-framework';
+import { formatNumber } from '@tryghost/shade/utils';
+import { cleanTrackedUrl } from '@/shared/clean-tracked-url';
+import {
+  parseMemberEvent,
+  type MemberEventContext,
+  type ParsedMemberEvent,
+  type RawMemberEvent,
+} from '@/members/detail/member-event';
+
+const amountOptions = { minimumFractionDigits: 0, maximumFractionDigits: 2 };
+
+function eventMoney(amount: unknown, currency: unknown) {
+  if (
+    typeof amount !== 'number' ||
+    !Number.isFinite(amount) ||
+    typeof currency !== 'string' ||
+    !/^[a-z]{3}$/i.test(currency)
+  ) {
+    return undefined;
+  }
+  // Activity's stored monetary values follow Ember's getNonDecimal: divide by
+  // 100 for every currency, including gifts. Do not infer a Stripe exponent.
+  return { value: currencyToDecimal(amount), symbol: getSymbol(currency) };
+}
+
+function subscriptionInfo(event: RawMemberEvent, ctx: MemberEventContext): string | undefined {
+  const money = eventMoney(event.data.mrr_delta, event.data.currency);
+  if (!money || money.value === 0) {
+    return undefined;
+  }
+  const amount = `${money.symbol}${formatNumber(Math.abs(money.value), amountOptions)}`;
+  if (event.data.type === 'created') {
+    const tierName =
+      ctx.hasMultipleTiers && typeof event.data.tierName === 'string' && event.data.tierName.trim()
+        ? event.data.tierName
+        : 'Paid';
+    return `${tierName} ${money.value < 0 ? '-' : ''}${amount}/month`;
+  }
+  return `MRR ${money.value > 0 ? '+' : '-'}${amount}`;
+}
+
+function giftAction(event: RawMemberEvent): string {
+  const money = eventMoney(event.data.amount, event.data.currency);
+  const { tier_name: tierName, duration, cadence } = event.data;
+  if (
+    !money ||
+    typeof tierName !== 'string' ||
+    !tierName.trim() ||
+    typeof duration !== 'number' ||
+    !Number.isInteger(duration) ||
+    duration <= 0 ||
+    typeof cadence !== 'string' ||
+    !cadence.trim()
+  ) {
+    return 'Purchased gift subscription';
+  }
+  const amount = `${money.symbol}${formatNumber(money.value, amountOptions)}`;
+  const cadenceLabel = duration === 1 ? cadence : `${cadence}s`;
+  return `Purchased gift subscription for ${amount} (${tierName}, ${formatNumber(duration)} ${cadenceLabel})`;
+}
+
+/** Full Activity presentation; the existing member-detail preview stays unchanged. */
+export function parseActivityEvent(
+  event: RawMemberEvent,
+  ctx: MemberEventContext,
+): ParsedMemberEvent {
+  // The detail parser formats gifts using a different currency exponent. Ask it
+  // for the generic gift action, then apply Activity's historical format below.
+  const parsed = parseMemberEvent(
+    event.type === 'gift_purchase_event'
+      ? { ...event, data: { ...event.data, amount: undefined } }
+      : event,
+    ctx,
+  );
+
+  if (event.type === 'subscription_event') {
+    parsed.info = subscriptionInfo(event, ctx);
+  }
+  if (event.type === 'donation_event') {
+    const money = eventMoney(event.data.amount, event.data.currency);
+    parsed.info = money ? `${money.symbol}${formatNumber(money.value, amountOptions)}` : undefined;
+  }
+  if (event.type === 'gift_purchase_event') {
+    parsed.action = giftAction(event);
+    parsed.actionTitle = parsed.action;
+  }
+  if (event.type === 'click_event') {
+    parsed.description =
+      typeof parsed.description === 'string'
+        ? cleanTrackedUrl(parsed.description, true)
+        : undefined;
+  }
+  return parsed;
+}
diff --git a/apps/admin/src/members/activity/activity-filters.test.ts b/apps/admin/src/members/activity/activity-filters.test.ts
new file mode 100644
index 00000000000..0d3f1ac057f
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-filters.test.ts
@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import {
+  availableActivityTypes,
+  activityQueryOptions,
+  excludedActivityEvents,
+  toggleActivityType,
+} from './activity-filters';
+
+describe('activity filters', () => {
+  it('keeps email delivery events out of the global feed but available for one member', () => {
+    const global = activityQueryOptions({ settings: {}, excluded: null }).excludedEvents;
+    expect(global).toContain('email_opened_event');
+    expect(global).toContain('email_complained_event');
+    expect(global).not.toContain('automated_email_sent_event');
+    expect(activityQueryOptions({ settings: {}, excluded: null, memberId: 'abc' })).toEqual({
+      memberId: 'abc',
+      excludedEvents: ['aggregated_click_event'],
+    });
+    expect(availableActivityTypes({}, 'abc').map(({ event }) => event)).toContain(
+      'email_opened_event',
+    );
+    expect(availableActivityTypes({}).map(({ event }) => event)).not.toContain(
+      'email_opened_event',
+    );
+  });
+
+  it('excludes the backend complaint alias when the spam filter is switched off', () => {
+    const filter = activityQueryOptions({
+      settings: {},
+      memberId: 'abc',
+      excluded: 'email_complaint_event',
+    }).excludedEvents;
+    expect(filter).toContain('email_complaint_event');
+    expect(filter).toContain('email_complained_event');
+  });
+
+  it('respects disabled newsletters and comments while retaining welcome email events', () => {
+    const settings = { editorDefaultEmailRecipients: 'disabled', commentsEnabled: 'off' };
+    const filter = activityQueryOptions({
+      settings,
+      excluded: null,
+      memberId: 'abc',
+    }).excludedEvents;
+    expect(filter).toContain('newsletter_event');
+    expect(filter).toContain('email_sent_event');
+    expect(filter).toContain('comment_event');
+    expect(filter).not.toContain('automated_email_sent_event');
+    const available = availableActivityTypes(settings, 'abc').map(({ event }) => event);
+    expect(available).not.toContain('newsletter_event');
+    expect(available).not.toContain('comment_event');
+    expect(available).not.toContain('click_event');
+    expect(available).toContain('automated_email_sent_event');
+    expect(availableActivityTypes({ emailTrackClicks: true }).map(({ event }) => event)).toContain(
+      'click_event',
+    );
+  });
+
+  it.each([
+    ['subscription_event', 'gift_redemption_event', 'gift_ended_event'],
+    ['payment_event', 'donation_event', 'gift_purchase_event'],
+  ])(
+    'toggles the related events with %s without changing unrelated exclusions',
+    (event, ...related) => {
+      const excluded = toggleActivityType(event, 'login_event');
+      expect(excludedActivityEvents(excluded)).toEqual(['login_event', event, ...related]);
+      expect(toggleActivityType(event, excluded)).toBe('login_event');
+    },
+  );
+
+  it('preserves valid unknown exclusions without accepting NQL from the URL', () => {
+    expect(
+      excludedActivityEvents('login_event,,future_event,login_event,]+type:signup_event'),
+    ).toEqual(['login_event', 'future_event']);
+    expect(
+      activityQueryOptions({ settings: {}, excluded: 'future_event' }).excludedEvents,
+    ).toContain('future_event');
+  });
+});
diff --git a/apps/admin/src/members/activity/activity-filters.ts b/apps/admin/src/members/activity/activity-filters.ts
new file mode 100644
index 00000000000..195dd578a1a
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-filters.ts
@@ -0,0 +1,150 @@
+export interface ActivitySettings {
+  editorDefaultEmailRecipients?: string;
+  commentsEnabled?: string;
+  emailTrackClicks?: boolean;
+}
+
+const EMAIL_EVENTS = [
+  'email_sent_event',
+  'email_delivered_event',
+  'email_opened_event',
+  'email_failed_event',
+  'email_complaint_event',
+];
+
+const EVENT_TYPES = [
+  { event: 'signup_event', name: 'Signups', group: 'auth', icon: 'event-signed-up' },
+  { event: 'login_event', name: 'Logins', group: 'auth', icon: 'event-logged-in' },
+  {
+    event: 'subscription_event',
+    name: 'Paid subscriptions',
+    group: 'payments',
+    icon: 'event-subscriptions',
+  },
+  { event: 'payment_event', name: 'Payments', group: 'payments', icon: 'event-subscriptions' },
+  {
+    event: 'newsletter_event',
+    name: 'Email subscriptions',
+    group: 'emails',
+    icon: 'event-subscribed-to-email',
+  },
+  {
+    event: 'email_opened_event',
+    name: 'Email opened',
+    group: 'emails',
+    icon: 'event-opened-email',
+  },
+  {
+    event: 'email_delivered_event',
+    name: 'Email received',
+    group: 'emails',
+    icon: 'event-received-email',
+  },
+  {
+    event: 'email_complaint_event',
+    name: 'Email flagged as spam',
+    group: 'emails',
+    icon: 'event-email-delivery-spam',
+  },
+  {
+    event: 'email_failed_event',
+    name: 'Email bounced',
+    group: 'emails',
+    icon: 'event-email-delivery-failed',
+  },
+  {
+    event: 'email_change_event',
+    name: 'Email address changed',
+    group: 'emails',
+    icon: 'event-email-changed',
+  },
+  {
+    event: 'automated_email_sent_event',
+    name: 'Welcome email received',
+    group: 'emails',
+    icon: 'event-sent-email',
+  },
+  { event: 'feedback_event', name: 'Feedback', group: 'others', icon: 'event-more-like-this' },
+];
+
+export function excludedActivityEvents(value: string | null): string[] {
+  // Query parameters are user input. Allow future event names, but never let
+  // an exclusion become an NQL expression of its own.
+  return [...new Set((value ?? '').split(',').filter((event) => /^[a-z_]+$/.test(event)))];
+}
+
+function hiddenActivityEvents(settings: ActivitySettings, memberId?: string): string[] {
+  const hidden = ['aggregated_click_event'];
+  if (!memberId || settings.editorDefaultEmailRecipients === 'disabled') {
+    hidden.push(...EMAIL_EVENTS);
+  }
+  if (settings.editorDefaultEmailRecipients === 'disabled') {
+    hidden.push('newsletter_event');
+  }
+  return hidden;
+}
+
+export function availableActivityTypes(settings: ActivitySettings, memberId?: string) {
+  const types = [...EVENT_TYPES];
+  if (settings.commentsEnabled !== 'off') {
+    types.push({
+      event: 'comment_event',
+      name: 'Comments',
+      group: 'others',
+      icon: 'event-comment',
+    });
+  }
+  if (settings.emailTrackClicks) {
+    types.push({
+      event: 'click_event',
+      name: 'Clicked link in email',
+      group: 'others',
+      icon: 'event-click',
+    });
+  }
+  const hidden = new Set(hiddenActivityEvents(settings, memberId));
+  return types.filter(({ event }) => !hidden.has(event));
+}
+
+export function toggleActivityType(event: string, excluded: string | null): string {
+  const events = new Set(excludedActivityEvents(excluded));
+  const group =
+    event === 'subscription_event'
+      ? [event, 'gift_redemption_event', 'gift_ended_event']
+      : event === 'payment_event'
+        ? [event, 'donation_event', 'gift_purchase_event']
+        : [event];
+  const wasExcluded = events.has(event);
+  for (const item of group) {
+    if (wasExcluded) {
+      events.delete(item);
+    } else {
+      events.add(item);
+    }
+  }
+  return [...events].join(',');
+}
+
+export function activityQueryOptions({
+  settings,
+  memberId,
+  excluded,
+}: {
+  settings: ActivitySettings;
+  memberId?: string;
+  excluded: string | null;
+}) {
+  const events = new Set([
+    ...excludedActivityEvents(excluded),
+    ...hiddenActivityEvents(settings, memberId),
+  ]);
+  // Core selects this source as "complained" but emits "complaint" rows.
+  // Keep the existing URL spelling while excluding both backend spellings.
+  if (events.has('email_complaint_event')) {
+    events.add('email_complained_event');
+  }
+  if (settings.commentsEnabled === 'off') {
+    events.add('comment_event');
+  }
+  return { memberId, excludedEvents: [...events] };
+}
diff --git a/apps/admin/src/members/activity/activity-member-search.tsx b/apps/admin/src/members/activity/activity-member-search.tsx
new file mode 100644
index 00000000000..51ef14a51f0
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-member-search.tsx
@@ -0,0 +1,117 @@
+import { useRef, useState } from 'react';
+import { useDebounce } from 'use-debounce';
+import {
+  Avatar,
+  Button,
+  Command,
+  CommandEmpty,
+  CommandInput,
+  CommandItem,
+  CommandList,
+  LoadingIndicator,
+  Popover,
+  PopoverContent,
+  PopoverAnchor,
+  InputGroup,
+} from '@tryghost/shade/components';
+import { Box, Inline, Stack } from '@tryghost/shade/primitives';
+import { useBrowseMembers } from '@tryghost/admin-x-framework/api/members';
+import { formatMemberName, memberAvatarProps } from '@/members/member-format';
+
+export default function ActivityMemberSearch({ onSelect }: { onSelect: (id: string) => void }) {
+  const [open, setOpen] = useState(false);
+  const anchor = useRef<HTMLDivElement>(null);
+  const [search, setSearch] = useState('');
+  const [debouncedSearch] = useDebounce(search, 300);
+  const { data, isFetching, isError, refetch } = useBrowseMembers({
+    enabled: open && !!debouncedSearch.trim(),
+    searchParams: { search: debouncedSearch, limit: '20' },
+    defaultErrorHandler: false,
+  });
+  const loading = isFetching || search !== debouncedSearch;
+
+  return (
+    <Command className="h-auto w-60 max-w-full min-w-0 overflow-visible" shouldFilter={false}>
+      <Popover open={open && !!search.trim()} onOpenChange={setOpen}>
+        <PopoverAnchor asChild>
+          <Box ref={anchor}>
+            <InputGroup className="[&_[cmdk-input-wrapper]]:w-full [&_[cmdk-input-wrapper]]:border-0">
+              <CommandInput
+                aria-expanded={open && !!search.trim()}
+                aria-label="Search members"
+                className="h-(--control-height) min-w-0 py-0"
+                data-slot="input-group-control"
+                placeholder="Search members..."
+                value={search}
+                onClick={() => setOpen(!!search.trim())}
+                onFocus={() => setOpen(!!search.trim())}
+                onValueChange={(value) => {
+                  setSearch(value);
+                  setOpen(!!value.trim());
+                }}
+              />
+            </InputGroup>
+          </Box>
+        </PopoverAnchor>
+        <PopoverContent
+          align="end"
+          className="w-(--radix-popover-trigger-width) max-w-[calc(100vw-2rem)] p-0"
+          onCloseAutoFocus={(event) => event.preventDefault()}
+          onInteractOutside={(event) => {
+            if (anchor.current?.contains(event.target as Node)) {
+              event.preventDefault();
+            }
+          }}
+          onOpenAutoFocus={(event) => event.preventDefault()}
+        >
+          <CommandList>
+            {loading ? (
+              <Inline aria-label="Loading members" className="p-4" justify="center" role="status">
+                <LoadingIndicator size="sm" />
+              </Inline>
+            ) : isError ? (
+              <Stack className="p-4" gap="sm">
+                <p className="text-sm text-muted-foreground" role="alert">
+                  Couldn’t load members
+                </p>
+                <Button variant="outline" onClick={() => void refetch()}>
+                  Retry
+                </Button>
+              </Stack>
+            ) : (
+              <>
+                <CommandEmpty>No members found</CommandEmpty>
+                {data?.members.map((member) => (
+                  <CommandItem
+                    key={member.id}
+                    value={member.id}
+                    onSelect={() => {
+                      onSelect(member.id);
+                      setOpen(false);
+                      setSearch('');
+                    }}
+                  >
+                    <Avatar {...memberAvatarProps(member)} src={member.avatar_image} />
+                    <Stack className="min-w-0" gap="none">
+                      <span className="truncate font-medium" title={formatMemberName(member)}>
+                        {formatMemberName(member)}
+                      </span>
+                      {member.name?.trim() && (
+                        <span
+                          className="truncate text-sm text-muted-foreground"
+                          title={member.email}
+                        >
+                          {member.email}
+                        </span>
+                      )}
+                    </Stack>
+                  </CommandItem>
+                ))}
+              </>
+            )}
+          </CommandList>
+        </PopoverContent>
+      </Popover>
+    </Command>
+  );
+}
diff --git a/apps/admin/src/members/activity/activity-row.tsx b/apps/admin/src/members/activity/activity-row.tsx
new file mode 100644
index 00000000000..00c16455802
--- /dev/null
+++ b/apps/admin/src/members/activity/activity-row.tsx
@@ -0,0 +1,139 @@
+import moment from 'moment-timezone';
+import { Avatar, TableCell, TableRow } from '@tryghost/shade/components';
+import { Inline, Stack } from '@tryghost/shade/primitives';
+import { cn } from '@tryghost/shade/utils';
+import { Link } from '@tryghost/admin-x-framework';
+import { AdminLink } from '@/shared/admin-link';
+import { EventIcon } from '@/members/detail/member-activity-feed';
+import { isSafeHref } from '@/members/detail/is-safe-href';
+import { memberAvatarProps } from '@/members/member-format';
+import type { ParsedMemberEvent } from '@/members/detail/member-event';
+
+function emailLabel(email: unknown): string | undefined {
+  if (!email || typeof email !== 'object') {
+    return undefined;
+  }
+  const subject = 'subject' in email ? email.subject : undefined;
+  if (typeof subject === 'string' && subject.trim()) {
+    return subject;
+  }
+  if ('email' in email && email.email && typeof email.email === 'object') {
+    return emailLabel(email.email);
+  }
+  return 'Email';
+}
+
+export default function ActivityRow({
+  event,
+  memberHref,
+  hideMember,
+  onPreview,
+}: {
+  event: ParsedMemberEvent;
+  memberHref?: string;
+  hideMember: boolean;
+  onPreview: (email: unknown) => void;
+}) {
+  const subject =
+    typeof event.subject === 'string' && event.subject ? event.subject : 'Unknown member';
+  const memberContent = (
+    <Inline gap="md">
+      <Avatar
+        {...memberAvatarProps(event.member)}
+        className="[&_span]:text-[13px]"
+        src={event.member?.avatar_image}
+      />
+      <Stack className="min-w-0" gap="none">
+        <span className={cn('truncate font-medium', memberHref && 'group-hover/member:underline')}>
+          {subject}
+        </span>
+        {event.member?.name && (
+          <span className="truncate text-muted-foreground">{event.member.email}</span>
+        )}
+      </Stack>
+    </Inline>
+  );
+  const objectHref = isSafeHref(event.route)
+    ? event.route
+    : isSafeHref(event.url)
+      ? event.url
+      : undefined;
+  const hasObject = !!event.object && !!objectHref;
+  const emailSubject = !hasObject && emailLabel(event.email);
+  const action = event.action
+    ? event.action[0].toUpperCase() + event.action.slice(1)
+    : 'Unknown activity';
+  const timestamp = event.timestamp ? moment(event.timestamp).local() : undefined;
+
+  return (
+    <TableRow>
+      {!hideMember && (
+        <TableCell className="group/member w-1/3 max-w-72 min-w-40 py-4">
+          {memberHref ? (
+            <Link className="block hover:no-underline" to={memberHref}>
+              {memberContent}
+            </Link>
+          ) : (
+            memberContent
+          )}
+        </TableCell>
+      )}
+      <TableCell className="min-w-48 py-4">
+        <Inline gap="md">
+          <Inline className="size-8 shrink-0 rounded-full bg-muted" gap="none" justify="center">
+            <EventIcon iconName={event.icon} />
+          </Inline>
+          <Stack className="min-w-0" gap="xs">
+            <p className="leading-relaxed">
+              <span title={event.actionTitle}>{action}</span>
+              {event.info && <span className="ml-1 text-muted-foreground">({event.info})</span>}
+              {hasObject && (
+                <>
+                  <span className="mx-1 text-muted-foreground">{event.join}</span>
+                  {objectHref.startsWith('#/') ? (
+                    <AdminLink className="font-medium hover:underline" to={objectHref.slice(1)}>
+                      {event.object}
+                    </AdminLink>
+                  ) : (
+                    <a
+                      className="font-medium hover:underline"
+                      href={objectHref}
+                      rel="noopener noreferrer"
+                      target="_blank"
+                    >
+                      {event.object}
+                    </a>
+                  )}
+                </>
+              )}
+              {emailSubject && (
+                <>
+                  <span className="mx-1 text-muted-foreground">{event.join}</span>
+                  <button
+                    className="cursor-pointer text-left font-medium hover:underline"
+                    type="button"
+                    onClick={() => onPreview(event.email)}
+                  >
+                    {emailSubject}
+                  </button>
+                </>
+              )}
+            </p>
+            {event.description && (
+              <p className="break-all text-muted-foreground" title={event.description}>
+                {event.description}
+              </p>
+            )}
+          </Stack>
+        </Inline>
+      </TableCell>
+      <TableCell className="w-40 py-4 text-left whitespace-nowrap text-muted-foreground">
+        {timestamp?.isValid() ? (
+          <time dateTime={timestamp.toISOString()}>{timestamp.format('DD MMM YYYY HH:mm')}</time>
+        ) : (
+          '—'
+        )}
+      </TableCell>
+    </TableRow>
+  );
+}
diff --git a/apps/admin/src/members/activity/member-activity.acceptance.test.tsx b/apps/admin/src/members/activity/member-activity.acceptance.test.tsx
new file mode 100644
index 00000000000..5da03cc46ef
--- /dev/null
+++ b/apps/admin/src/members/activity/member-activity.acceptance.test.tsx
@@ -0,0 +1,381 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { page, userEvent } from 'vitest/browser';
+import {
+  currentRoute,
+  currentUserResponse,
+  fakeAdminEndpoint,
+  fakeMembers,
+  fakeNewsletters,
+  fakeTiers,
+  member,
+  newsletter,
+  renderAdminApp,
+  settingsResponse,
+  staffRole,
+  tier,
+  type Member,
+} from '@test-utils/acceptance';
+import type { StaffRoleName } from '@tryghost/test-data';
+import type { MemberActivityEvent } from '@tryghost/admin-x-framework/api/members';
+import { activityScreen as screen } from './member-activity.screen';
+
+const EVENTS = /^\/members\/events\//;
+const labs = { membersActivityReact: true };
+const permittedRoles: StaffRoleName[] = ['Owner', 'Administrator', 'Super Editor'];
+const ada = member({ id: 'ada', name: 'Ada Lovelace', email: 'ada@example.com' });
+const grace = member({ id: 'grace', name: 'Grace Hopper', email: 'grace@example.com' });
+
+function event(
+  id: string,
+  type = 'signup_event',
+  person: Member | null = ada,
+): MemberActivityEvent {
+  return {
+    type,
+    data: {
+      id,
+      member: person ? { ...person, avatar_image: person.avatar_image ?? null } : null,
+      member_id: person?.id,
+      created_at: '2026-09-01T12:00:00.000Z',
+    },
+  };
+}
+
+function world(events: MemberActivityEvent[] = [event('signup')]) {
+  const membersApi = fakeMembers([ada, grace]);
+  fakeAdminEndpoint('GET', '/members/ada/', { members: [ada] });
+  fakeAdminEndpoint('GET', '/members/grace/', { members: [grace] });
+  const eventsApi = fakeAdminEndpoint('GET', EVENTS, { events });
+  return { eventsApi, membersApi };
+}
+
+function firstActivityPage() {
+  return Array.from({ length: 50 }, (_, index) => ({
+    ...event(`event-${index}`),
+    data: {
+      ...event(`event-${index}`).data,
+      created_at: new Date(Date.UTC(2026, 8, 1, 12, 0, 50 - index)).toISOString(),
+    },
+  }));
+}
+
+describe('Member activity', () => {
+  afterEach(async () => {
+    await page.viewport(1280, 800);
+  });
+  it('opens a member from the global table, retains exclusions, and follows browser history', async () => {
+    world();
+    await renderAdminApp('/members-activity?excludedEvents=login_event', { labs });
+
+    await expect.element(screen.heading('Member activity')).toBeVisible();
+    await expect.element(screen.memberColumn()).toBeVisible();
+    await expect.element(screen.text('Signed up')).toBeVisible();
+    await screen.link(/Ada Lovelace/).click();
+
+    await expect.element(screen.heading('Ada Lovelace')).toBeVisible();
+    await expect.element(screen.memberColumn()).not.toBeInTheDocument();
+    await expect.poll(currentRoute).toBe('/members-activity?excludedEvents=login_event&member=ada');
+    await expect
+      .element(screen.link('View member profile →'))
+      .toHaveAttribute('href', '#/members/ada');
+
+    window.history.back();
+    await expect.element(screen.heading('Member activity')).toBeVisible();
+    await expect.element(screen.memberColumn()).toBeVisible();
+    window.history.forward();
+    await expect.element(screen.heading('Ada Lovelace')).toBeVisible();
+    await screen.link('Member activity').click();
+    await expect.element(screen.heading('Member activity')).toBeVisible();
+    await expect.poll(currentRoute).toBe('/members-activity');
+  });
+
+  it('searches the real members endpoint with a debounce and selects a member', async () => {
+    world();
+    const membersApi = fakeMembers(({ search }) => (search === 'Grace' ? [grace] : []));
+    await renderAdminApp('/members-activity', { labs });
+    await expect.element(screen.search()).toBeVisible();
+    await expect.element(page.getByRole('listbox')).not.toBeInTheDocument();
+    await screen.search().fill('Grace');
+    await expect(membersApi).toHaveSentSearch('Grace');
+    await expect.poll(() => membersApi.lastRequest?.limit).toBe(20);
+    await expect.element(screen.memberOption(/Grace Hopper/)).toBeVisible();
+    await expect.element(screen.memberOption(/Ada Lovelace/)).not.toBeInTheDocument();
+    await userEvent.keyboard('{Enter}');
+    await expect.element(screen.heading('Grace Hopper')).toBeVisible();
+    await expect.poll(currentRoute).toBe('/members-activity?member=grace');
+  });
+
+  it('groups gift purchases and donations under Payments and resets all filters', async () => {
+    world();
+    fakeAdminEndpoint('GET', EVENTS, ({ url }) => ({
+      events: new URL(url).searchParams.get('filter')?.includes('payment_event')
+        ? []
+        : [event('signup')],
+    }));
+    await renderAdminApp('/members-activity?member=ada', { labs });
+    await expect.element(screen.text('Signed up')).toBeVisible();
+    await expect.element(screen.filterButton()).toHaveTextContent('All events');
+    await screen.filterButton().click();
+    await expect.element(screen.eventType('Email opened')).toBeVisible();
+    const eventNames = () =>
+      page
+        .getByRole('menuitemcheckbox')
+        .elements()
+        .map((item) => item.textContent);
+    const originalOrder = eventNames();
+    await screen.eventType('Payments').click();
+    await expect.element(screen.eventType('Payments')).toHaveAttribute('aria-checked', 'false');
+    expect(eventNames()).toEqual(originalOrder);
+    await userEvent.keyboard('{Escape}');
+    await expect
+      .element(screen.filterButton())
+      .toHaveTextContent(`${originalOrder.length - 1} events`);
+    await expect.element(screen.heading('No activities match the current filter')).toBeVisible();
+    await expect
+      .poll(currentRoute)
+      .toBe(
+        '/members-activity?member=ada&excludedEvents=payment_event%2Cdonation_event%2Cgift_purchase_event',
+      );
+    await screen.showAll().click();
+    await expect.element(screen.heading('Member activity')).toBeVisible();
+    await expect.poll(currentRoute).toBe('/members-activity');
+  });
+
+  it('omits global email filters and respects disabled newsletters, comments and click tracking', async () => {
+    const { eventsApi } = world([]);
+    await renderAdminApp('/members-activity', {
+      labs,
+      boot: {
+        browseSettings: {
+          response: settingsResponse({
+            settings: {
+              editor_default_email_recipients: 'disabled',
+              comments_enabled: 'off',
+              email_track_clicks: false,
+            },
+          }),
+        },
+      },
+    });
+    await expect.element(screen.heading('No member activity yet')).toBeVisible();
+    await screen.filterButton().click();
+    await expect.element(screen.eventType('Email opened')).not.toBeInTheDocument();
+    await expect.element(screen.eventType('Email subscriptions')).not.toBeInTheDocument();
+    await expect.element(screen.eventType('Comments')).not.toBeInTheDocument();
+    await expect.element(screen.eventType('Clicked link in email')).not.toBeInTheDocument();
+    await expect.element(screen.eventType('Welcome email received')).toBeVisible();
+    await expect
+      .poll(() => new URL(eventsApi.lastRequest!.url).searchParams.get('filter'))
+      .toContain('comment_event');
+  });
+
+  it('renders absent members and unknown event types without unsafe links', async () => {
+    const unknown = event('future', 'future_event', null);
+    const signup = event('unsafe');
+    signup.data.attribution = { title: 'Unsafe source', url: 'javascript:alert(1)' };
+    world([unknown, signup]);
+    await renderAdminApp('/members-activity', { labs });
+    await expect.element(screen.text('Unknown activity')).toBeVisible();
+    await expect.element(screen.text('Unknown member')).toBeVisible();
+    await expect.element(screen.link('Unknown member')).not.toBeInTheDocument();
+    await expect.element(screen.link('Unsafe source')).not.toBeInTheDocument();
+    await expect(screen.rows()).toHaveCount(2);
+  });
+
+  it('shows subscription revenue, one-time payment amounts, and newsletter names', async () => {
+    const subscription = event('paid', 'subscription_event');
+    Object.assign(subscription.data, {
+      type: 'created',
+      mrr_delta: 500,
+      currency: 'usd',
+      tierName: 'Gold',
+    });
+    const donation = event('donation', 'donation_event');
+    Object.assign(donation.data, { amount: 1000, currency: 'usd' });
+    const subscribed = event('newsletter', 'newsletter_event');
+    Object.assign(subscribed.data, { subscribed: true, newsletter: { name: 'Weekly' } });
+    world([subscription, donation, subscribed]);
+    fakeTiers([tier({ name: 'Gold' }), tier({ name: 'Silver' })]);
+    fakeNewsletters([newsletter({ name: 'Daily' }), newsletter({ name: 'Weekly' })]);
+    await renderAdminApp('/members-activity', { labs });
+    await expect.element(screen.text('(Gold $5/month)')).toBeVisible();
+    await expect.element(screen.text('($10)')).toBeVisible();
+    await expect.element(screen.text('Subscribed to Weekly')).toBeVisible();
+  });
+
+  it('shows a missing member state with a way back to global activity', async () => {
+    world();
+    fakeAdminEndpoint(
+      'GET',
+      '/members/missing/',
+      { errors: [{ type: 'NotFoundError', message: 'Member not found' }] },
+      { status: 404 },
+    );
+    await renderAdminApp('/members-activity?member=missing', { labs });
+    await expect.element(screen.heading('Member not found')).toBeVisible();
+    await screen.clearMember().click();
+    await expect.element(screen.heading('Member activity')).toBeVisible();
+    await expect.element(screen.text('Signed up')).toBeVisible();
+  });
+
+  it('clears old rows while a changed filter is loading', async () => {
+    world();
+    let release: (() => void) | undefined;
+    const pending = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    fakeAdminEndpoint('GET', EVENTS, async ({ url }) => {
+      if (new URL(url).searchParams.get('filter')?.includes('signup_event')) {
+        await pending;
+        return { events: [] };
+      }
+      return { events: [event('signup')] };
+    });
+    await renderAdminApp('/members-activity', { labs });
+    await expect.element(screen.text('Signed up')).toBeVisible();
+    await screen.filterButton().click();
+    await screen.eventType('Signups').click();
+    await userEvent.keyboard('{Escape}');
+    await expect.element(screen.text('Signed up')).not.toBeInTheDocument();
+    await expect
+      .element(page.getByRole('status', { name: 'Loading member activity' }))
+      .toBeVisible();
+    release?.();
+    await expect.element(screen.heading('No activities match the current filter')).toBeVisible();
+  });
+
+  it('shows a request error and retries without losing the member filter', async () => {
+    world();
+    fakeAdminEndpoint(
+      'GET',
+      EVENTS,
+      { errors: [{ type: 'ValidationError', message: 'Could not load activity' }] },
+      { status: 422 },
+    );
+    await renderAdminApp('/members-activity?member=ada', { labs });
+    await expect.element(screen.heading('Couldn’t load member activity')).toBeVisible();
+    const retryApi = fakeAdminEndpoint('GET', EVENTS, { events: [event('retry')] });
+    await screen.retry().click();
+    await expect.element(screen.text('Signed up')).toBeVisible();
+    await expect
+      .poll(() => new URL(retryApi.lastRequest!.url).searchParams.get('filter'))
+      .toContain("data.member_id:'ada'");
+  });
+
+  it('loads the next page when the list reaches the end', async () => {
+    const firstPage = firstActivityPage();
+    world();
+    const api = fakeAdminEndpoint('GET', EVENTS, ({ url }) => {
+      const filter = new URL(url).searchParams.get('filter') ?? '';
+      if (filter.includes('data.created_at:<')) {
+        return { events: [event('last', 'login_event', grace)] };
+      }
+      if (filter.includes('data.created_at:')) {
+        return { events: [] };
+      }
+      return { events: firstPage };
+    });
+    await renderAdminApp('/members-activity', { labs });
+    await expect(screen.rows()).toHaveCount(50);
+    screen.scrollToEnd();
+    await expect.element(screen.text('Logged in')).toBeVisible();
+    await expect(screen.rows()).toHaveCount(51);
+    expect(
+      api.requests.some((request) =>
+        new URL(request.url).searchParams.get('filter')?.includes('data.created_at:<'),
+      ),
+    ).toBe(true);
+  });
+
+  it('keeps loaded rows when loading more fails and retries from the same position', async () => {
+    world(firstActivityPage());
+    await renderAdminApp('/members-activity', { labs });
+    await expect(screen.rows()).toHaveCount(50);
+    fakeAdminEndpoint(
+      'GET',
+      EVENTS,
+      { errors: [{ type: 'ValidationError', message: 'Could not load more' }] },
+      { status: 422 },
+    );
+    screen.scrollToEnd();
+    await expect.element(screen.heading('Couldn’t load more activity')).toBeVisible();
+    await expect.element(page.getByRole('alert')).toHaveTextContent('Couldn’t load more activity');
+    await expect(screen.rows()).toHaveCount(50);
+    fakeAdminEndpoint('GET', EVENTS, ({ url }) => ({
+      events: new URL(url).searchParams.get('filter')?.includes('data.created_at:<')
+        ? [event('last', 'login_event', grace)]
+        : [],
+    }));
+    await screen.retry().click();
+    await expect.element(screen.text('Logged in')).toBeVisible();
+    await expect(screen.rows()).toHaveCount(51);
+  });
+
+  it('reports settings failure instead of claiming there is no activity', async () => {
+    const { eventsApi } = world();
+    await renderAdminApp('/members-activity', {
+      labs,
+      boot: {
+        browseSettings: {
+          response: { errors: [{ type: 'ValidationError', message: 'Could not load settings' }] },
+          responseStatus: 422,
+        },
+      },
+    });
+    await expect.element(screen.heading('Couldn’t load activity settings')).toBeVisible();
+    await expect.element(screen.heading('No member activity yet')).not.toBeInTheDocument();
+    expect(eventsApi.requests).toHaveLength(0);
+    fakeAdminEndpoint('GET', /^\/settings\/\?group=/, settingsResponse({ labs }));
+    await screen.retry().click();
+    await expect.element(screen.text('Signed up')).toBeVisible();
+  });
+
+  it.each(permittedRoles)('allows %s to browse activity', async (role) => {
+    world();
+    const me = currentUserResponse();
+    me.users[0].roles = [staffRole({ name: role })];
+    await renderAdminApp('/members-activity', { labs, boot: { browseMe: { response: me } } });
+    await expect.element(screen.text('Signed up')).toBeVisible();
+  });
+
+  it('opens the stored email preview and fits the mobile device at desktop and narrow widths', async () => {
+    const opened = event('open', 'email_opened_event');
+    opened.data.email = {
+      subject: 'Original newsletter',
+      html: '<!doctype html><html><head></head><body>Original email body</body></html>',
+    };
+    world([opened]);
+    fakeNewsletters([newsletter({ name: 'Daily', sender_name: 'Daily sender' })]);
+    await page.viewport(1280, 720);
+    await renderAdminApp('/members-activity?member=ada', { labs });
+    await screen.previewButton('Original newsletter').click();
+    await expect.element(screen.preview()).toBeVisible();
+    await expect
+      .element(screen.preview().getByText('Daily sender', { exact: false }))
+      .toBeVisible();
+    await page.getByRole('radio', { name: 'Mobile', exact: true }).click();
+    await expect
+      .element(screen.preview().getByText('Original newsletter', { exact: true }))
+      .toBeVisible();
+    await page.viewport(375, 720);
+    await expect
+      .poll(() => screen.preview().element().scrollWidth - screen.preview().element().clientWidth)
+      .toBe(0);
+    await page.getByRole('button', { name: 'Close', exact: true }).click();
+    await expect.element(screen.preview()).not.toBeInTheDocument();
+  });
+
+  it('keeps the global filters reachable on a narrow screen', async () => {
+    world();
+    await page.viewport(375, 720);
+    await renderAdminApp('/members-activity', { labs });
+    await expect.element(screen.text('Signed up')).toBeVisible();
+    await expect
+      .poll(() => screen.root().element().scrollWidth - screen.root().element().clientWidth)
+      .toBe(0);
+    await screen.filterButton().click();
+    await expect.element(screen.eventType('Signups')).toBeVisible();
+    await userEvent.keyboard('{Escape}');
+    await expect.element(screen.search()).toBeVisible();
+  });
+});
diff --git a/apps/admin/src/members/activity/member-activity.screen.ts b/apps/admin/src/members/activity/member-activity.screen.ts
new file mode 100644
index 00000000000..c3147633b02
--- /dev/null
+++ b/apps/admin/src/members/activity/member-activity.screen.ts
@@ -0,0 +1,38 @@
+import { page } from 'vitest/browser';
+import { getScrollParent } from '@tryghost/shade/utils';
+import {
+  activityEmailPreview,
+  clearMemberButton,
+  filterEventsButton,
+  memberActivityPage,
+  memberActivityTable,
+  searchMembersLabel,
+  showAllActivityLink,
+} from '@tryghost/test-data/selectors/member-activity';
+
+export const activityScreen = {
+  root: () => page.getByTestId(memberActivityPage),
+  table: () => page.getByRole('table', { name: memberActivityTable }),
+  rows: () =>
+    activityScreen
+      .table()
+      .getByRole('row')
+      .filter({ has: page.getByRole('cell') }),
+  memberColumn: () => page.getByRole('columnheader', { name: 'Member', exact: true }),
+  link: (name: string | RegExp) => page.getByRole('link', { name, exact: true }),
+  heading: (name: string) => page.getByRole('heading', { name, exact: true }),
+  text: (text: string) => page.getByText(text, { exact: true }),
+  filterButton: () => page.getByRole('button', { name: filterEventsButton }),
+  eventType: (name: string) => page.getByRole('menuitemcheckbox', { name, exact: true }),
+  search: () => page.getByRole('combobox', { name: searchMembersLabel }),
+  memberOption: (name: string | RegExp) => page.getByRole('option', { name }),
+  clearMember: () => page.getByRole('button', { name: clearMemberButton }).first(),
+  showAll: () => page.getByRole('link', { name: showAllActivityLink }),
+  retry: () => page.getByRole('button', { name: 'Retry', exact: true }),
+  previewButton: (subject: string) => page.getByRole('button', { name: subject, exact: true }),
+  preview: () => page.getByTestId(activityEmailPreview),
+  scrollToEnd() {
+    const scroller = getScrollParent(activityScreen.root().element());
+    scroller?.scrollTo({ top: scroller.scrollHeight });
+  },
+};
diff --git a/apps/admin/src/members/activity/member-activity.tsx b/apps/admin/src/members/activity/member-activity.tsx
new file mode 100644
index 00000000000..84bdb0238c7
--- /dev/null
+++ b/apps/admin/src/members/activity/member-activity.tsx
@@ -0,0 +1,373 @@
+import { Fragment, useEffect, useRef, useState } from 'react';
+import {
+  Avatar,
+  Breadcrumb,
+  BreadcrumbItem,
+  BreadcrumbLink,
+  BreadcrumbList,
+  BreadcrumbPage,
+  BreadcrumbSeparator,
+  Button,
+  DropdownMenu,
+  DropdownMenuTrigger,
+  DropdownMenuContent,
+  DropdownMenuCheckboxItem,
+  DropdownMenuSeparator,
+  EmptyIndicator,
+  LoadingIndicator,
+  Table,
+  TableBody,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@tryghost/shade/components';
+import { Box, Container, Inline, Stack } from '@tryghost/shade/primitives';
+import { ListPage } from '@tryghost/shade/page-templates';
+import { PageHeader } from '@tryghost/shade/patterns';
+import { LucideIcon, formatNumber, getScrollParent } from '@tryghost/shade/utils';
+import { Link, useSearchParams } from '@tryghost/admin-x-framework';
+import { APIError } from '@tryghost/admin-x-framework/errors';
+import { useBrowseMemberActivityFeed, useMember } from '@tryghost/admin-x-framework/api/members';
+import { useBrowseNewsletters } from '@tryghost/admin-x-framework/api/newsletters';
+import { useBrowseTiers } from '@tryghost/admin-x-framework/api/tiers';
+import { getSettingValue, useBrowseSettings } from '@tryghost/admin-x-framework/api/settings';
+import { formatMemberName, memberAvatarProps } from '@/members/member-format';
+import { parseActivityEvent } from './activity-event';
+import ActivityEmailPreview from './activity-email-preview';
+import ActivityMemberSearch from './activity-member-search';
+import ActivityRow from './activity-row';
+import { EventIcon } from '@/members/detail/member-activity-feed';
+import {
+  availableActivityTypes,
+  activityQueryOptions,
+  excludedActivityEvents,
+  toggleActivityType,
+} from './activity-filters';
+
+function ActivityPage() {
+  const [params, setParams] = useSearchParams();
+  const memberId = params.get('member') || undefined;
+  const excluded = params.get('excludedEvents');
+  const [previewEmail, setPreviewEmail] = useState<unknown>(null);
+  const sentinel = useRef<HTMLDivElement>(null);
+  const settingsQuery = useBrowseSettings({ defaultErrorHandler: false });
+  const settings = settingsQuery.data?.settings ?? [];
+  const activitySettings = {
+    editorDefaultEmailRecipients:
+      getSettingValue<string>(settings, 'editor_default_email_recipients') ?? undefined,
+    commentsEnabled: getSettingValue<string>(settings, 'comments_enabled') ?? undefined,
+    emailTrackClicks: getSettingValue<boolean>(settings, 'email_track_clicks') ?? undefined,
+  };
+  const paidMembersEnabled = getSettingValue<boolean>(settings, 'paid_members_enabled') ?? false;
+  const memberQuery = useMember(memberId ?? '', {
+    enabled: !!memberId,
+    defaultErrorHandler: false,
+  });
+  const member = memberQuery.data?.members[0];
+  const memberMissing =
+    !!memberId &&
+    ((memberQuery.error instanceof APIError && memberQuery.error.response?.status === 404) ||
+      (memberQuery.isSuccess && !member));
+  const memberFailed = !!memberId && memberQuery.isError && !memberMissing;
+  const newslettersQuery = useBrowseNewsletters({
+    searchParams: { filter: 'status:active', limit: '1' },
+  });
+  const tiersQuery = useBrowseTiers({
+    searchParams: { filter: 'type:paid+active:true', limit: 'all' },
+    enabled: paidMembersEnabled,
+  });
+  const feed = useBrowseMemberActivityFeed({
+    ...activityQueryOptions({ settings: activitySettings, memberId, excluded }),
+    enabled: !!settingsQuery.data && !settingsQuery.isError && (!memberId || !!member),
+    defaultErrorHandler: false,
+  });
+  const events = feed.data?.events ?? [];
+  const eventTypes = availableActivityTypes(activitySettings, memberId);
+  const excludedTypes = excludedActivityEvents(excluded);
+  const selectedEventTypes = eventTypes.filter(({ event }) => !excludedTypes.includes(event));
+  const eventFilterLabel =
+    selectedEventTypes.length === eventTypes.length
+      ? 'All events'
+      : selectedEventTypes.length === 1
+        ? selectedEventTypes[0].name
+        : selectedEventTypes.length === 0
+          ? 'No events selected'
+          : `${formatNumber(selectedEventTypes.length)} events`;
+  const loading =
+    settingsQuery.isLoading || (!!memberId && memberQuery.isLoading) || feed.isLoading;
+
+  const updateParam = (key: string, value?: string) => {
+    const next = new URLSearchParams(params);
+    if (value) {
+      next.set(key, value);
+    } else {
+      next.delete(key);
+    }
+    setParams(next);
+  };
+
+  useEffect(() => {
+    const element = sentinel.current;
+    if (!element || !feed.hasNextPage || feed.isFetching || feed.isError) {
+      return;
+    }
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries.some((entry) => entry.isIntersecting)) {
+          void feed.fetchNextPage();
+        }
+      },
+      { root: getScrollParent(element), rootMargin: '250px' },
+    );
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [feed.hasNextPage, feed.isFetching, feed.isError, feed.fetchNextPage]);
+
+  const hasFilter = !!memberId || excludedTypes.length > 0;
+
+  return (
+    <Box className="size-full">
+      <Container className="relative h-full" size="page">
+        <ListPage data-testid="member-activity-page">
+          <ListPage.Header>
+            <PageHeader blurredBackground={false} sticky={false}>
+              <PageHeader.Left>
+                {memberId ? (
+                  <Breadcrumb>
+                    <BreadcrumbList>
+                      <BreadcrumbItem>
+                        <BreadcrumbLink asChild>
+                          <Link to="/members-activity">Member activity</Link>
+                        </BreadcrumbLink>
+                      </BreadcrumbItem>
+                      <BreadcrumbSeparator />
+                      <BreadcrumbItem>
+                        <BreadcrumbPage className="truncate">
+                          {member ? formatMemberName(member) : 'Member'}
+                        </BreadcrumbPage>
+                      </BreadcrumbItem>
+                    </BreadcrumbList>
+                  </Breadcrumb>
+                ) : (
+                  <PageHeader.Title>Member activity</PageHeader.Title>
+                )}
+              </PageHeader.Left>
+              <PageHeader.Actions className="max-w-full min-w-0">
+                <Inline className="max-w-full min-w-0" gap="md" wrap>
+                  {!memberId && (
+                    <ActivityMemberSearch onSelect={(id) => updateParam('member', id)} />
+                  )}
+                  <DropdownMenu>
+                    <DropdownMenuTrigger asChild>
+                      <Button aria-label="Filter events" variant="outline">
+                        <LucideIcon.ListFilter className="size-4" />
+                        {eventFilterLabel}
+                        <LucideIcon.ChevronDown className="size-4 opacity-50" />
+                      </Button>
+                    </DropdownMenuTrigger>
+                    <DropdownMenuContent
+                      align="end"
+                      className="max-h-[70vh] w-64 max-w-[calc(100vw-2rem)] overflow-y-auto"
+                    >
+                      {eventTypes.map((type, index) => (
+                        <Fragment key={type.event}>
+                          {index > 0 && type.group !== eventTypes[index - 1].group && (
+                            <DropdownMenuSeparator />
+                          )}
+                          <DropdownMenuCheckboxItem
+                            checked={!excludedTypes.includes(type.event)}
+                            className="gap-2 pr-8 pl-2 [&>span:first-child]:right-2 [&>span:first-child]:left-auto"
+                            onCheckedChange={() =>
+                              updateParam(
+                                'excludedEvents',
+                                toggleActivityType(type.event, excluded),
+                              )
+                            }
+                            onSelect={(event) => event.preventDefault()}
+                          >
+                            <EventIcon iconName={type.icon} />
+                            {type.name}
+                          </DropdownMenuCheckboxItem>
+                        </Fragment>
+                      ))}
+                    </DropdownMenuContent>
+                  </DropdownMenu>
+                </Inline>
+              </PageHeader.Actions>
+            </PageHeader>
+          </ListPage.Header>
+          <ListPage.Body>
+            {member && (
+              <Inline className="py-6" gap="lg">
+                <Avatar
+                  {...memberAvatarProps(member)}
+                  className="size-12 min-w-12 [&_span]:text-lg"
+                  src={member.avatar_image}
+                />
+                <Stack className="min-w-0" gap="none">
+                  <h2 className="truncate text-xl font-semibold">{formatMemberName(member)}</h2>
+                  {member.name?.trim() && (
+                    <p className="truncate text-muted-foreground">{member.email}</p>
+                  )}
+                  <Link
+                    className="mt-0.5 text-sm font-medium hover:underline"
+                    to={`/members/${encodeURIComponent(member.id)}`}
+                  >
+                    View member profile →
+                  </Link>
+                </Stack>
+              </Inline>
+            )}
+            {settingsQuery.isError ? (
+              <EmptyIndicator
+                actions={
+                  <Button variant="outline" onClick={() => void settingsQuery.refetch()}>
+                    Retry
+                  </Button>
+                }
+                role="alert"
+                title="Couldn’t load activity settings"
+              />
+            ) : memberMissing ? (
+              <EmptyIndicator
+                actions={
+                  <Button variant="outline" onClick={() => updateParam('member')}>
+                    Clear member
+                  </Button>
+                }
+                description="This member may have been deleted."
+                role="alert"
+                title="Member not found"
+              />
+            ) : memberFailed ? (
+              <EmptyIndicator
+                actions={
+                  <Button variant="outline" onClick={() => void memberQuery.refetch()}>
+                    Retry
+                  </Button>
+                }
+                role="alert"
+                title="Couldn’t load member"
+              />
+            ) : loading ? (
+              <Inline
+                aria-label="Loading member activity"
+                className="grow py-10"
+                justify="center"
+                role="status"
+              >
+                <LoadingIndicator size="lg" />
+              </Inline>
+            ) : (
+              <>
+                {events.length > 0 ? (
+                  <Box className="shrink-0 overflow-x-auto">
+                    <Table aria-label="Member activity" className="text-[13px]">
+                      <TableHeader>
+                        <TableRow>
+                          {!memberId && (
+                            <TableHead className="text-[13px]" scope="col">
+                              Member
+                            </TableHead>
+                          )}
+                          <TableHead className="text-[13px]" scope="col">
+                            Event
+                          </TableHead>
+                          <TableHead className="text-[13px]" scope="col">
+                            Time
+                          </TableHead>
+                        </TableRow>
+                      </TableHeader>
+                      <TableBody>
+                        {events.map((raw, index) => {
+                          const event = parseActivityEvent(raw, {
+                            hasMultipleNewsletters:
+                              newslettersQuery.isError ||
+                              (newslettersQuery.data?.meta?.pagination.total ?? 0) > 1,
+                            hasMultipleTiers: (tiersQuery.data?.tiers.length ?? 0) > 1,
+                            paidMembersEnabled,
+                          });
+                          const memberParams = new URLSearchParams(params);
+                          if (event.member?.id) {
+                            memberParams.set('member', event.member.id);
+                          }
+                          return (
+                            <ActivityRow
+                              key={`${raw.type}:${event.id ?? index}`}
+                              event={event}
+                              hideMember={!!memberId}
+                              memberHref={
+                                event.member?.id ? `/members-activity?${memberParams}` : undefined
+                              }
+                              onPreview={setPreviewEmail}
+                            />
+                          );
+                        })}
+                      </TableBody>
+                    </Table>
+                  </Box>
+                ) : (
+                  !feed.isError && (
+                    <EmptyIndicator
+                      actions={
+                        hasFilter ? (
+                          <Button variant="outline" asChild>
+                            <Link to="/members-activity">Show all activity</Link>
+                          </Button>
+                        ) : undefined
+                      }
+                      className="grow"
+                      title={
+                        hasFilter
+                          ? 'No activities match the current filter'
+                          : 'No member activity yet'
+                      }
+                    >
+                      <LucideIcon.Activity />
+                    </EmptyIndicator>
+                  )
+                )}
+                {feed.isError && (
+                  <EmptyIndicator
+                    actions={
+                      <Button
+                        variant="outline"
+                        onClick={() =>
+                          void (feed.isFetchNextPageError ? feed.fetchNextPage() : feed.refetch())
+                        }
+                      >
+                        Retry
+                      </Button>
+                    }
+                    role="alert"
+                    title={
+                      events.length
+                        ? 'Couldn’t load more activity'
+                        : 'Couldn’t load member activity'
+                    }
+                  />
+                )}
+                {feed.isFetchingNextPage && (
+                  <Inline
+                    aria-label="Loading more activity"
+                    className="py-6"
+                    justify="center"
+                    role="status"
+                  >
+                    <LoadingIndicator size="md" />
+                  </Inline>
+                )}
+                <Box ref={sentinel} className="h-px" />
+              </>
+            )}
+          </ListPage.Body>
+        </ListPage>
+      </Container>
+      {!!previewEmail && (
+        <ActivityEmailPreview email={previewEmail} onClose={() => setPreviewEmail(null)} />
+      )}
+    </Box>
+  );
+}
+
+export default ActivityPage;
diff --git a/apps/admin/src/members/api.ts b/apps/admin/src/members/api.ts
index 5f5670fc5ba..b70003bb1e8 100644
--- a/apps/admin/src/members/api.ts
+++ b/apps/admin/src/members/api.ts
@@ -4,6 +4,7 @@
  * else in this domain is internal.
  */
 export { membersRouteChildren } from './routes';
+export const lazyMemberActivityScreen = () => import('./activity/member-activity');
 export { buildMembersUrl } from './member-route';
 export { formatMemberName, getMemberInitials, memberAvatarProps } from './member-format';
 export {
diff --git a/apps/admin/src/members/detail/member-activity-feed.tsx b/apps/admin/src/members/detail/member-activity-feed.tsx
index c5ea049ca4c..d1ca37858ac 100644
--- a/apps/admin/src/members/detail/member-activity-feed.tsx
+++ b/apps/admin/src/members/detail/member-activity-feed.tsx
@@ -22,8 +22,8 @@ interface MemberActivityFeedProps {
 /**
  * Renders a Lucide substitute for Ember's custom SVG icon names
  * (`event-signed-up`, `event-comment`, …). Intentional visual approximation
- * — pixel-perfect rendering lives behind the "View all member activity"
- * link that routes to Ember. Anything unmapped falls back to the generic
+ * — the full table lives behind the "View all member activity" link.
+ * Anything unmapped falls back to the generic
  * `Activity` icon so a new server-side event type never crashes the row.
  *
  * A switch (rather than a `Record<string, React.ComponentType>` map) sidesteps
@@ -32,7 +32,7 @@ interface MemberActivityFeedProps {
  * under that mix. Inline JSX resolves each icon at its use-site, which is what
  * every other member-detail component already does.
  */
-const EventIcon: React.FC<{ iconName: string }> = ({ iconName }) => {
+export const EventIcon: React.FC<{ iconName: string }> = ({ iconName }) => {
   const iconProps = { className: 'shrink-0 text-muted-foreground', size: 16 };
   switch (iconName) {
     case 'event-signed-up':
@@ -75,11 +75,9 @@ const EventIcon: React.FC<{ iconName: string }> = ({ iconName }) => {
 };
 
 /**
- * "View all member activity →" link. Points at Ember's members-activity
- * route (still on Ember post-cutover — the plan calls out that Phase 8 keeps
- * the paginated feed page on Ember for a follow-up). Uses a plain anchor with
- * the `#/…` href so the Ember hash-router picks it up rather than React
- * Router intercepting the click.
+ * "View all member activity →" link. The membersActivityReact experiment
+ * chooses the full feed's owner. A native hash link also notifies Ember when
+ * the experiment is off, while React handles the same URL when it is on.
  */
 const ViewAllLink: React.FC<{ memberId: string }> = ({ memberId }) => (
   <a
@@ -100,9 +98,8 @@ const capitalize = (s?: string) => (s ? s.charAt(0).toUpperCase() + s.slice(1) :
 /**
  * Ember's activity-feed row renders an `EmailPreviewLink` when `event.email`
  * is set on delivery/open/sent rows. We don't have that component in the
- * posts app — surface a plain "Email" label so the admin can at least see
- * the row carries an email object; the "View all" link routes them to Ember
- * for the actual preview.
+ * inline feed — surface a plain "Email" label so the admin can at least see
+ * the row carries an email object; the full activity page provides the preview.
  */
 function getEmailLabel(email: unknown): string | undefined {
   if (email && typeof email === 'object') {
diff --git a/apps/admin/src/members/detail/member-event.ts b/apps/admin/src/members/detail/member-event.ts
index 1738288c5b8..5a7597ef5af 100644
--- a/apps/admin/src/members/detail/member-event.ts
+++ b/apps/admin/src/members/detail/member-event.ts
@@ -33,6 +33,7 @@ export interface RawMemberEvent {
       id?: string;
       name?: string | null;
       email?: string;
+      avatar_image?: string | null;
     } | null;
     name?: string;
     // The Ember helper reads many arbitrary event-specific fields — the
diff --git a/apps/admin/src/posts/analytics/utils/link-helpers.ts b/apps/admin/src/posts/analytics/utils/link-helpers.ts
index fe86600f348..12734be754e 100644
--- a/apps/admin/src/posts/analytics/utils/link-helpers.ts
+++ b/apps/admin/src/posts/analytics/utils/link-helpers.ts
@@ -1,4 +1,7 @@
 import { type LinkResponseType } from '@tryghost/admin-x-framework/api/links';
+import { cleanTrackedUrl } from '@/shared/clean-tracked-url';
+
+export { cleanTrackedUrl } from '@/shared/clean-tracked-url';
 
 export type CleanedLink = {
   count: number;
@@ -12,31 +15,6 @@ export type CleanedLink = {
   };
 };
 
-export const cleanTrackedUrl = (url: string, display = false): string => {
-  try {
-    const removeParams = ['ref', 'attribution_id', 'attribution_type'];
-    const urlObj = new URL(url);
-    for (const param of removeParams) {
-      urlObj.searchParams.delete(param);
-    }
-
-    if (!display) {
-      return urlObj.toString();
-    }
-    // Return URL without protocol
-    const urlWithoutProtocol =
-      urlObj.host +
-      (urlObj.pathname === '/' && !urlObj.search ? '' : urlObj.pathname) +
-      (urlObj.search ? urlObj.search : '') +
-      (urlObj.hash ? urlObj.hash : '');
-    // remove www. from the start of the URL
-    return urlWithoutProtocol.replace(/^www\./, '');
-  } catch {
-    // return the original url if there is an error
-    return url;
-  }
-};
-
 export const getLinkById = (links: CleanedLink[], linkId: string) => {
   return links.find((link) => link.link.link_id === linkId);
 };
diff --git a/apps/admin/src/route-access.acceptance.test.tsx b/apps/admin/src/route-access.acceptance.test.tsx
index afd5b343a27..91b56e66696 100644
--- a/apps/admin/src/route-access.acceptance.test.tsx
+++ b/apps/admin/src/route-access.acceptance.test.tsx
@@ -6,6 +6,7 @@ import {
   currentRoute,
   currentUserResponse,
   fakeTags,
+  fakeAdminEndpoint,
   renderAdminApp,
   staffRole,
   type RenderAdminAppOptions,
@@ -63,6 +64,22 @@ describe('Route access', () => {
     await expect.poll(currentRoute).toBe('/');
   });
 
+  describe.each([true, false])('member activity with React flag %s', (enabled) => {
+    it.each(['Editor', 'Author', 'Contributor'] as const)(
+      'denies %s access before loading events',
+      async (role) => {
+        const events = fakeAdminEndpoint('GET', /^\/members\/events\//, { events: [] });
+        await renderAdminApp('/members-activity?member=abcdef123456abcdef123456', {
+          ...asRole(role),
+          labs: { membersActivityReact: enabled },
+        });
+
+        await expect.poll(currentRoute).toBe('/');
+        expect(events.requests).toHaveLength(0);
+      },
+    );
+  });
+
   it('redirects members to billing during a force upgrade', async () => {
     const config = configResponse();
     config.config.hostSettings = { forceUpgrade: true };
diff --git a/apps/admin/src/routes.tsx b/apps/admin/src/routes.tsx
index b683f07c076..e68ef08385b 100644
--- a/apps/admin/src/routes.tsx
+++ b/apps/admin/src/routes.tsx
@@ -21,6 +21,7 @@ import { EmberListWithGiftLinks } from './gift-link-modal-host';
 import { EditorGate } from './editor-gate';
 import { PagesListGate, PostsListGate } from './posts-list-gate';
 import { TagDetailGate } from './tag-detail-gate';
+import { MemberActivityGate } from './member-activity-gate';
 import { useFlagGatedRouteOwner } from './use-flag-gated-route-owner';
 import { type AccessRouteHandle } from './route-access';
 import { RouteAccessGuard } from './route-access-guard';
@@ -52,7 +53,6 @@ const EMBER_ROUTES: string[] = [
   '/posts/analytics/:postId/debug',
   '/restore',
   '/migrate/*',
-  '/members-activity',
 ];
 
 const emberFallbackHandle = { allowInForceUpgrade: true } satisfies AdminRouteHandle;
@@ -117,6 +117,14 @@ const appRoutes: RouteObject[] = [
     handle: { requiresAccess: canManageMembers } satisfies AccessRouteHandle,
     children: membersRouteChildren,
   },
+  {
+    path: '/members-activity',
+    Component: MemberActivityGate,
+    handle: {
+      ...emberFallbackHandle,
+      requiresAccess: canManageMembers,
+    } satisfies AccessRouteHandle & AdminRouteHandle,
+  },
   {
     path: '/posts/analytics/:postId',
     lazy: lazyPostAnalyticsRoot,
@@ -227,6 +235,7 @@ export function useIsEmberOwnedRoute(pathname: string): boolean {
   const tagDetailOwner = useFlagGatedRouteOwner('tagDetailsReact');
   const postsListOwner = useFlagGatedRouteOwner('postsListReact');
   const editorOwner = useFlagGatedRouteOwner('editorReact');
+  const memberActivityOwner = useFlagGatedRouteOwner('membersActivityReact');
   const leaf = matchRoutes(routes, pathname)?.at(-1)?.route;
   if (!leaf) {
     return true;
@@ -240,5 +249,8 @@ export function useIsEmberOwnedRoute(pathname: string): boolean {
   if (leaf.Component === EditorGate) {
     return editorOwner !== 'react';
   }
+  if (leaf.Component === MemberActivityGate) {
+    return memberActivityOwner !== 'react';
+  }
   return EMBER_ROUTE_COMPONENTS.has(leaf.Component);
 }
diff --git a/apps/admin/src/settings/advanced/labs/private-features.tsx b/apps/admin/src/settings/advanced/labs/private-features.tsx
index 4f342453bc2..ce5c804bc1d 100644
--- a/apps/admin/src/settings/advanced/labs/private-features.tsx
+++ b/apps/admin/src/settings/advanced/labs/private-features.tsx
@@ -122,6 +122,11 @@ const features: Feature[] = [
       'Serves the editor (/editor) from the React app instead of the Ember editor. Gates the migration behind a runtime toggle; the React side is an early placeholder.',
     flag: 'editorReact',
   },
+  {
+    title: 'React member activity',
+    description: 'Preview the new member activity screen.',
+    flag: 'membersActivityReact',
+  },
   {
     title: 'Self-serve archives',
     description:
diff --git a/apps/admin/src/shared/clean-tracked-url.ts b/apps/admin/src/shared/clean-tracked-url.ts
new file mode 100644
index 00000000000..2ee8b9f7325
--- /dev/null
+++ b/apps/admin/src/shared/clean-tracked-url.ts
@@ -0,0 +1,22 @@
+/** Remove Ghost attribution parameters, optionally producing a compact display URL. */
+export const cleanTrackedUrl = (url: string, display = false): string => {
+  try {
+    const removeParams = ['ref', 'attribution_id', 'attribution_type'];
+    const urlObj = new URL(url);
+    for (const param of removeParams) {
+      urlObj.searchParams.delete(param);
+    }
+
+    if (!display) {
+      return urlObj.toString();
+    }
+    const urlWithoutProtocol =
+      urlObj.host +
+      (urlObj.pathname === '/' && !urlObj.search ? '' : urlObj.pathname) +
+      (urlObj.search ? urlObj.search : '') +
+      (urlObj.hash ? urlObj.hash : '');
+    return urlWithoutProtocol.replace(/^www\./, '');
+  } catch {
+    return url;
+  }
+};
diff --git a/apps/ember-admin/app/routes/members-activity.js b/apps/ember-admin/app/routes/members-activity.js
index d257c3a657f..a25e2635dd3 100644
--- a/apps/ember-admin/app/routes/members-activity.js
+++ b/apps/ember-admin/app/routes/members-activity.js
@@ -1,6 +1,49 @@
 import MembersManagementRoute from './members-management';
+import {inject as service} from '@ember/service';
 
 export default class MembersActivityRoute extends MembersManagementRoute {
+    @service feature;
+    @service router;
+
+    beforeModel(transition) {
+        const result = super.beforeModel(...arguments);
+        if (!this.session.user?.canManageMembers || this.feature.membersActivityReact !== true) {
+            return result;
+        }
+
+        transition.abort();
+
+        // Named Ember transitions have not written the hash yet. Preserve the
+        // member and event filters when handing that navigation to React.
+        if (!transition.intent?.url) {
+            const query = new URLSearchParams();
+            for (const [key, value] of Object.entries(transition.to?.queryParams ?? {})) {
+                if (value !== null && value !== undefined && value !== '') {
+                    query.set(key, String(value));
+                }
+            }
+            const search = query.toString();
+            this._navigateToReactRoute(`/members-activity${search ? `?${search}` : ''}`);
+        }
+
+        // Keep Ember's route state in sync so returning to the previous
+        // Ember screen activates it again. Parking must not add history or
+        // overwrite React Router's state and query parameters.
+        const parkedPath = this.router.currentRouteName === 'react-fallback'
+            ? this.router.currentRoute?.params?.path
+            : null;
+        if (parkedPath !== 'members-activity') {
+            // Suppress the parking transition's URL update entirely. Restoring
+            // the hash afterwards with replaceState is too late: React can
+            // observe the queryless URL and keep it after that silent restore.
+            this.router.replaceWith('react-fallback', 'members-activity').method(null);
+        }
+    }
+
+    _navigateToReactRoute(url) {
+        window.location.hash = url;
+    }
+
     buildRouteInfoMetadata() {
         return {
             titleToken: 'Activity',
diff --git a/apps/ember-admin/app/services/feature.js b/apps/ember-admin/app/services/feature.js
index d2ea8a92c83..495cbdc1d02 100644
--- a/apps/ember-admin/app/services/feature.js
+++ b/apps/ember-admin/app/services/feature.js
@@ -101,6 +101,7 @@ export default class FeatureService extends Service {
     @feature('automations') automations;
     @feature('csvContentImporter') csvContentImporter;
     @feature('postsListReact') postsListReact;
+    @feature('membersActivityReact') membersActivityReact;
     @feature('editorReact') editorReact;
     @feature('improveSendingUI') improveSendingUI;
     _user = null;
diff --git a/e2e/tests/admin/members/activity-navigation.test.ts b/e2e/tests/admin/members/activity-navigation.test.ts
new file mode 100644
index 00000000000..67799f39111
--- /dev/null
+++ b/e2e/tests/admin/members/activity-navigation.test.ts
@@ -0,0 +1,84 @@
+import { MemberDetailsPage } from '@/admin-pages';
+import { createMemberFactory } from '@/data-factory';
+import { expect, test } from '@/helpers/playwright';
+
+for (const react of [false, true]) {
+  test.describe(`Ghost Admin - Member activity (${react ? 'React' : 'Ember'})`, () => {
+    test.use({ labs: { membersActivityReact: react } });
+    let createdMemberIds: string[] = [];
+
+    test.afterEach(async ({ page }) => {
+      for (const id of createdMemberIds) {
+        await page.request.delete(`/ghost/api/admin/members/${id}/`);
+      }
+      createdMemberIds = [];
+    });
+
+    test('follows a member from all activity to their profile and preserves activity filters', async ({
+      page,
+    }) => {
+      const memberFactory = createMemberFactory(page.request);
+      const members = await memberFactory.createMany([
+        { name: 'Activity Target', email: 'activity-target@example.com', newsletters: [] },
+        { name: 'Activity Other', email: 'activity-other@example.com', newsletters: [] },
+      ]);
+      createdMemberIds = members.map(({ id }) => id);
+      const [member, otherMember] = members;
+
+      // Signup events are written asynchronously. Wait until both are older
+      // than Activity's second-precision cursor before opening the page.
+      await expect
+        .poll(async () => {
+          const now = new Date().toISOString().replace('T', ' ').substring(0, 19);
+          const response = await page.request.get('/ghost/api/admin/members/events/', {
+            params: {
+              filter: `type:signup_event+data.member_id:[${members.map(({ id }) => id).join(',')}]+data.created_at:<'${now}'`,
+              limit: '50',
+            },
+          });
+          const data = await response.json();
+          return data.events?.length;
+        })
+        .toBe(2);
+
+      await page.goto('/ghost/#/members-activity');
+      await expect(page.getByTestId('member-activity-page')).toBeVisible({ visible: react });
+
+      await expect(
+        page.getByRole('heading', { name: 'Member activity', exact: true }),
+      ).toBeVisible();
+      await expect(page.getByRole('columnheader', { name: 'Member', exact: true })).toBeVisible();
+      await expect(page.getByRole('link', { name: /Activity Other/ })).toBeVisible();
+      await page.getByRole('link', { name: /Activity Target/ }).click();
+
+      await expect(page).toHaveURL(new RegExp(`#/members-activity\\?member=${member.id}$`));
+      await expect(
+        page.getByRole('heading', { name: 'Activity Target', exact: true }),
+      ).toBeVisible();
+      await expect(page.getByRole('columnheader', { name: 'Member', exact: true })).toBeHidden();
+      await expect(page.getByText('Signed up', { exact: true })).toBeVisible();
+      await expect(page.getByText(otherMember.email, { exact: true })).toBeHidden();
+
+      await page.getByRole('link', { name: /View member profile/ }).click();
+      await expect(page).toHaveURL(new RegExp(`#/members/${member.id}$`));
+      await expect(new MemberDetailsPage(page).emailInput).toHaveValue(member.email);
+
+      await page.getByRole('link', { name: /View all member activity/ }).click();
+      await expect(page).toHaveURL(new RegExp(`#/members-activity\\?member=${member.id}$`));
+
+      await page.getByRole('button', { name: 'Filter events' }).click();
+      await page.getByText('Signups', { exact: true }).click();
+      await expect(page).toHaveURL(/excludedEvents=signup_event/);
+      await page.reload();
+
+      await expect(
+        page.getByText('No activities match the current filter', { exact: true }),
+      ).toBeVisible();
+      await page.getByRole('link', { name: 'Show all activity' }).click();
+
+      await expect(page).toHaveURL(/#\/members-activity\/?$/);
+      await expect(page.getByRole('link', { name: /Activity Target/ })).toBeVisible();
+      await expect(page.getByRole('link', { name: /Activity Other/ })).toBeVisible();
+    });
+  });
+}
diff --git a/e2e/tests/admin/members/activity-pagination.test.ts b/e2e/tests/admin/members/activity-pagination.test.ts
new file mode 100644
index 00000000000..bf5e791fcd9
--- /dev/null
+++ b/e2e/tests/admin/members/activity-pagination.test.ts
@@ -0,0 +1,88 @@
+import { MembersImportService, type MembersListResponse } from '@/helpers/services/members-import';
+import { createMemberFactory } from '@/data-factory';
+import { expect, test } from '@/helpers/playwright';
+
+const BOUNDARY_TIMESTAMP = '2025-01-02T10:00:00.000Z';
+const OLDER_TIMESTAMP = '2025-01-02T09:59:59.000Z';
+const BOUNDARY_MEMBERS = 75;
+
+interface SignupEvent {
+  type: string;
+  data: { id: string; member_id: string; created_at: string };
+}
+
+test.describe('Ghost Admin - Member activity pagination', () => {
+  test.use({ labs: { membersActivityReact: true } });
+  let createdMemberIds: string[] = [];
+
+  test.afterEach(async ({ page }) => {
+    for (const id of createdMemberIds) {
+      await page.request.delete(`/ghost/api/admin/members/${id}/`);
+    }
+    createdMemberIds = [];
+  });
+
+  test('shows every signup when more than one page shares a timestamp', async ({ page }) => {
+    test.slow();
+    const memberFactory = createMemberFactory(page.request);
+    // CSV import supports backdated created_at values for signup events;
+    // ordinary member creation ignores that field. This guarantees a full-page
+    // collision independently of machine speed.
+    const members = Array.from({ length: BOUNDARY_MEMBERS + 1 }, (_, index) => {
+      const suffix = String(index + 1).padStart(3, '0');
+      return memberFactory.build({
+        name: `Pagination Member ${suffix}`,
+        email: `pagination-member-${suffix}@example.com`,
+        newsletters: [],
+        created_at: index < BOUNDARY_MEMBERS ? BOUNDARY_TIMESTAMP : OLDER_TIMESTAMP,
+      });
+    });
+    const importService = new MembersImportService(page.request);
+    const importResult = await importService.import(members);
+    const membersResponse = await page.request.get('/ghost/api/admin/members/', {
+      params: { filter: `label:${importResult.meta.import_label.slug}`, limit: '100' },
+    });
+    expect(membersResponse.ok()).toBe(true);
+    const imported = (await membersResponse.json()) as MembersListResponse;
+    createdMemberIds = imported.members.map((member) => member.id);
+    expect(createdMemberIds).toHaveLength(BOUNDARY_MEMBERS + 1);
+
+    const filter = `type:signup_event+data.member_id:[${createdMemberIds.join(',')}]`;
+    let events: SignupEvent[] = [];
+    // Signup events are persisted asynchronously. Verify the actual endpoint's
+    // timestamps before exercising the browser; no mocked API or direct DB writes.
+    await expect
+      .poll(async () => {
+        const response = await page.request.get('/ghost/api/admin/members/events/', {
+          params: { filter, limit: '100' },
+        });
+        const data = await response.json();
+        events = data.events ?? [];
+        return events.map((event) => event.data.member_id).sort();
+      })
+      .toEqual([...createdMemberIds].sort());
+    expect(events.filter((event) => event.data.created_at === BOUNDARY_TIMESTAMP)).toHaveLength(
+      BOUNDARY_MEMBERS,
+    );
+    expect(events.filter((event) => event.data.created_at === OLDER_TIMESTAMP)).toHaveLength(1);
+
+    await page.goto('/ghost/#/members-activity');
+    await expect(page.getByTestId('member-activity-page')).toBeVisible();
+    const table = page.getByRole('table', { name: 'Member activity' });
+    const memberLinks = table.getByRole('link', { name: /Pagination Member/ });
+    await expect(memberLinks).toHaveCount(50);
+
+    await table.getByRole('row').last().scrollIntoViewIfNeeded();
+    await expect(memberLinks).toHaveCount(BOUNDARY_MEMBERS + 1);
+
+    const displayedMemberIds = await memberLinks.evaluateAll((links) =>
+      links.map((link) => {
+        const hash = new URL((link as HTMLAnchorElement).href).hash;
+        return new URLSearchParams(hash.slice(hash.indexOf('?') + 1)).get('member');
+      }),
+    );
+    expect(displayedMemberIds.sort()).toEqual([...createdMemberIds].sort());
+    await expect(table.getByRole('row').last()).toContainText('Pagination Member 076');
+    await expect(page.getByText('Couldn’t load more activity', { exact: true })).toBeHidden();
+  });
+});
diff --git a/e2e/tests/admin/members/activity-session-override.test.ts b/e2e/tests/admin/members/activity-session-override.test.ts
new file mode 100644
index 00000000000..7c0f8be8e13
--- /dev/null
+++ b/e2e/tests/admin/members/activity-session-override.test.ts
@@ -0,0 +1,28 @@
+import { expect, test } from '@/helpers/playwright';
+
+test.describe('Ghost Admin - Member activity session override', () => {
+  test.use({ labs: { membersActivityReact: false } });
+
+  test('keeps the React URL override for the session and returns to Ember after clearing and reloading', async ({
+    page,
+  }) => {
+    const reactPage = page.getByTestId('member-activity-page');
+    const heading = page.getByRole('heading', { name: 'Member activity', exact: true });
+
+    await page.goto('/ghost/#/members-activity?labs=membersActivityReact');
+    await expect(reactPage).toBeVisible();
+    await expect(heading).toBeVisible();
+
+    // A fresh document without the query parameter retains the session choice.
+    await page.goto('/ghost/#/members-activity');
+    await page.reload();
+    await expect(reactPage).toBeVisible();
+    await expect(heading).toBeVisible();
+
+    // Reload after clearing so both routers start with the same ownership state.
+    await page.goto('/ghost/#/members-activity?labs=');
+    await page.reload();
+    await expect(reactPage).toBeHidden();
+    await expect(heading).toBeVisible();
+  });
+});
diff --git a/ghost/core/core/shared/labs.js b/ghost/core/core/shared/labs.js
index 2510efbd5e7..967a0590b68 100644
--- a/ghost/core/core/shared/labs.js
+++ b/ghost/core/core/shared/labs.js
@@ -61,6 +61,7 @@ const PRIVATE_FEATURES = [
   'selfServeArchives',
   'machinePayments',
   'postsListReact',
+  'membersActivityReact',
   'editorReact',
 ];
 
diff --git a/packages/testing/test-data/src/selectors/member-activity.ts b/packages/testing/test-data/src/selectors/member-activity.ts
new file mode 100644
index 00000000000..778252db4dd
--- /dev/null
+++ b/packages/testing/test-data/src/selectors/member-activity.ts
@@ -0,0 +1,8 @@
+/** Member Activity names shared by the screen helper and browser tests. */
+export const memberActivityPage = 'member-activity-page';
+export const memberActivityTable = 'Member activity';
+export const filterEventsButton = 'Filter events';
+export const searchMembersLabel = 'Search members';
+export const clearMemberButton = 'Clear member';
+export const showAllActivityLink = 'Show all activity';
+export const activityEmailPreview = 'activity-email-preview';