diff --git a/src/features/monitoring/accountOverviewState.test.ts b/src/features/monitoring/accountOverviewState.test.ts
index 03f5413ca..0f9e3e663 100644
--- a/src/features/monitoring/accountOverviewState.test.ts
+++ b/src/features/monitoring/accountOverviewState.test.ts
@@ -69,8 +69,13 @@ const createEventRow = (overrides: Partial<MonitoringEventRow> = {}): Monitoring
   channelHost: overrides.channelHost ?? 'localhost',
   channelDisabled: overrides.channelDisabled ?? false,
   failed: overrides.failed ?? false,
+  requestCount: overrides.requestCount ?? 1,
+  successCalls: overrides.successCalls ?? (overrides.failed ? 0 : 1),
+  failureCalls: overrides.failureCalls ?? (overrides.failed ? 1 : 0),
   statsIncluded: overrides.statsIncluded ?? true,
   latencyMs: overrides.latencyMs ?? 120,
+  latencySumMs: overrides.latencySumMs ?? (overrides.latencyMs ?? 120),
+  latencyCount: overrides.latencyCount ?? 1,
   inputTokens: overrides.inputTokens ?? 10,
   outputTokens: overrides.outputTokens ?? 5,
   reasoningTokens: overrides.reasoningTokens ?? 0,
diff --git a/src/features/monitoring/hooks/useMonitoringData.test.ts b/src/features/monitoring/hooks/useMonitoringData.test.ts
index f6748405e..a108cb2fb 100644
--- a/src/features/monitoring/hooks/useMonitoringData.test.ts
+++ b/src/features/monitoring/hooks/useMonitoringData.test.ts
@@ -3,6 +3,7 @@ import {
   buildAccountRows,
   buildApiKeyRows,
   buildApiKeyDisplayMap,
+  buildMonitoringFilterFacetsFromSummary,
   buildRangeFilteredRows,
   buildMonitoringAuthMetaMap,
   type MonitoringEventRow,
@@ -40,8 +41,13 @@ const createMonitoringEventRow = (
   channelHost: overrides.channelHost ?? 'example.com',
   channelDisabled: overrides.channelDisabled ?? false,
   failed: overrides.failed ?? false,
+  requestCount: overrides.requestCount ?? 1,
+  successCalls: overrides.successCalls ?? (overrides.failed ? 0 : 1),
+  failureCalls: overrides.failureCalls ?? (overrides.failed ? 1 : 0),
   statsIncluded: overrides.statsIncluded ?? true,
   latencyMs: overrides.latencyMs ?? 1200,
+  latencySumMs: overrides.latencySumMs ?? overrides.latencyMs ?? 1200,
+  latencyCount: overrides.latencyCount ?? 1,
   inputTokens: overrides.inputTokens ?? 10,
   outputTokens: overrides.outputTokens ?? 5,
   reasoningTokens: overrides.reasoningTokens ?? 0,
@@ -152,6 +158,22 @@ describe('buildRangeFilteredRows', () => {
     expect(rows).toHaveLength(1);
     expect(rows[0].apiKeyHash).toBe('hash-b');
   });
+
+  it('matches text search when the derived api key hash does not match', () => {
+    const rows = buildRangeFilteredRows(
+      [
+        createMonitoringEventRow({ apiKeyHash: 'hash-a', searchText: 'kongwenpeng codex' }),
+        createMonitoringEventRow({ id: 'row-2', apiKeyHash: 'hash-b', searchText: 'other alias' }),
+      ],
+      'all',
+      null,
+      'KongWenpeng',
+      sha256Hex('KongWenpeng')
+    );
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0].apiKeyHash).toBe('hash-a');
+  });
 });
 
 describe('buildMonitoringAuthMetaMap', () => {
@@ -195,3 +217,24 @@ describe('buildApiKeyDisplayMap', () => {
     expect(map.get(apiKeyHash)?.label).not.toContain('ghp_1234567890abcdef');
   });
 });
+
+describe('buildMonitoringFilterFacetsFromSummary', () => {
+  it('reads summary facets without requiring detail rows', () => {
+    const facets = buildMonitoringFilterFacetsFromSummary({
+      apis: {},
+      facets: {
+        providers: ['codex'],
+        accounts: [{ value: 'alice@example.com', label: 'Alice' }],
+        models: ['gpt-5'],
+        channels: ['codex'],
+        api_keys: [{ value: 'hash-a', label: 'Team A' }],
+      },
+    });
+
+    expect(facets.providers).toEqual(['codex']);
+    expect(facets.accounts).toEqual([{ value: 'alice@example.com', label: 'Alice' }]);
+    expect(facets.models).toEqual(['gpt-5']);
+    expect(facets.channels).toEqual(['codex']);
+    expect(facets.apiKeys).toEqual([{ value: 'hash-a', label: 'Team A' }]);
+  });
+});
diff --git a/src/features/monitoring/hooks/useMonitoringData.ts b/src/features/monitoring/hooks/useMonitoringData.ts
index e418dc0e6..ae4099c26 100644
--- a/src/features/monitoring/hooks/useMonitoringData.ts
+++ b/src/features/monitoring/hooks/useMonitoringData.ts
@@ -119,6 +119,55 @@ const readString = (value: unknown) => {
   return text;
 };
 
+const readFiniteNumber = (value: unknown) => {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+};
+
+const normalizeFacetStrings = (value: unknown) => {
+  if (!Array.isArray(value)) return [];
+  return Array.from(new Set(value.map(readString).filter(Boolean))).sort((left, right) =>
+    left.localeCompare(right)
+  );
+};
+
+const normalizeFacetOptions = (
+  value: unknown,
+  displayMap?: Map<string, ApiKeyDisplayInfo>
+): MonitoringFilterOption[] => {
+  if (!Array.isArray(value)) return [];
+  const options = new Map<string, string>();
+  value.forEach((item) => {
+    const record = isRecord(item) ? item : null;
+    const rawValue = record ? record.value : item;
+    const optionValue = readString(rawValue);
+    if (!optionValue || options.has(optionValue)) return;
+    const display = displayMap?.get(optionValue.toLowerCase());
+    const fallbackLabel = record ? readString(record.label) : optionValue;
+    options.set(
+      optionValue,
+      sanitizeApiKeyDisplayText(display?.label || fallbackLabel || optionValue, optionValue)
+    );
+  });
+  return Array.from(options.entries())
+    .map(([value, label]) => ({ value, label }))
+    .sort((left, right) => left.label.localeCompare(right.label));
+};
+
+export const buildMonitoringFilterFacetsFromSummary = (
+  payload: unknown,
+  apiKeyDisplayMap?: Map<string, ApiKeyDisplayInfo>
+): MonitoringFilterFacets => {
+  const facets = isRecord(payload) && isRecord(payload.facets) ? payload.facets : {};
+  return {
+    providers: normalizeFacetStrings(facets.providers),
+    accounts: normalizeFacetOptions(facets.accounts),
+    models: normalizeFacetStrings(facets.models),
+    channels: normalizeFacetStrings(facets.channels),
+    apiKeys: normalizeFacetOptions(facets.api_keys ?? facets.apiKeys, apiKeyDisplayMap),
+  };
+};
+
 const extractArrayPayload = (payload: unknown, key: string): unknown[] => {
   if (Array.isArray(payload)) return payload;
   if (!isRecord(payload)) return [];
@@ -168,7 +217,7 @@ const sanitizeApiKeyDisplayText = (value: string, fallback = '') => {
   return maskSensitiveText(trimmed) || fallback;
 };
 
-type ApiKeyDisplayInfo = {
+export type ApiKeyDisplayInfo = {
   label: string;
   masked: string;
 };
@@ -381,8 +430,13 @@ export type MonitoringEventRow = {
   channelHost: string;
   channelDisabled: boolean;
   failed: boolean;
+  requestCount: number;
+  successCalls: number;
+  failureCalls: number;
   statsIncluded: boolean;
   latencyMs: number | null;
+  latencySumMs: number;
+  latencyCount: number;
   inputTokens: number;
   outputTokens: number;
   reasoningTokens: number;
@@ -478,6 +532,19 @@ export type MonitoringApiKeyRow = {
   models: MonitoringApiKeyModelSpendRow[];
 };
 
+export type MonitoringFilterOption = {
+  value: string;
+  label: string;
+};
+
+export type MonitoringFilterFacets = {
+  providers: string[];
+  accounts: MonitoringFilterOption[];
+  models: string[];
+  channels: string[];
+  apiKeys: MonitoringFilterOption[];
+};
+
 export type MonitoringRealtimeRow = {
   id: string;
   account: string;
@@ -517,6 +584,12 @@ export type MonitoringMetadata = {
 
 export interface UseMonitoringDataParams {
   usage: unknown;
+  usagePages?: {
+    accounts?: { usage?: unknown } | null;
+    apiKeys?: { usage?: unknown } | null;
+    realtime?: { usage?: unknown } | null;
+    models?: { usage?: unknown } | null;
+  } | null;
   config: Config | null | undefined;
   modelPrices: Record<string, ModelPrice>;
   apiKeyAliases?: ApiKeyAlias[];
@@ -544,6 +617,10 @@ export interface UseMonitoringDataReturn {
   taskBuckets: MonitoringTaskBucketRow[];
   recentFailures: MonitoringFailureRow[];
   filteredRows: MonitoringEventRow[];
+  accountPageRows: MonitoringAccountRow[] | null;
+  apiKeyPageRows: MonitoringApiKeyRow[] | null;
+  realtimePageRows: MonitoringEventRow[] | null;
+  filterFacets: MonitoringFilterFacets;
   refreshMeta: (showLoading?: boolean) => Promise<void>;
 }
 
@@ -670,12 +747,14 @@ export const buildRangeFilteredRows = (
       return false;
     }
 
-    if (normalizedSearchApiKeyHash && row.apiKeyHash !== normalizedSearchApiKeyHash) {
-      return false;
-    }
-
-    if (normalizedQuery && !row.searchText.includes(normalizedQuery)) {
-      return false;
+    if (normalizedQuery || normalizedSearchApiKeyHash) {
+      const matchesText = normalizedQuery ? row.searchText.includes(normalizedQuery) : false;
+      const matchesAPIKeyHash = normalizedSearchApiKeyHash
+        ? row.apiKeyHash === normalizedSearchApiKeyHash
+        : false;
+      if (!matchesText && !matchesAPIKeyHash) {
+        return false;
+      }
     }
 
     return true;
@@ -698,7 +777,7 @@ const buildTimeline = (
     rows.forEach((row) => {
       const bucket = map.get(row.hourLabel);
       if (!bucket) return;
-      bucket.requests += 1;
+      bucket.requests += row.requestCount;
       bucket.tokens += row.totalTokens;
       bucket.cost += row.totalCost;
     });
@@ -715,7 +794,7 @@ const buildTimeline = (
       tokens: 0,
       cost: 0,
     };
-    existing.requests += 1;
+    existing.requests += row.requestCount;
     existing.tokens += row.totalTokens;
     existing.cost += row.totalCost;
     grouped.set(row.dayKey, existing);
@@ -743,7 +822,7 @@ const buildHourlyDistribution = (rows: MonitoringEventRow[]) => {
     const hour = Number(row.hourLabel.slice(0, 2));
     const bucket = Number.isFinite(hour) ? buckets[hour] : null;
     if (!bucket) return;
-    bucket.requests += 1;
+    bucket.requests += row.requestCount;
     bucket.tokens += row.totalTokens;
     bucket.cost += row.totalCost;
   });
@@ -760,8 +839,8 @@ const buildRecentPattern = (rows: MonitoringEventRow[], limit = 10) =>
     .map((row) => !row.failed);
 
 export const buildMonitoringSummary = (rows: MonitoringEventRow[]): MonitoringSummary => {
-  const totalCalls = rows.length;
-  const failureCalls = rows.filter((row) => row.failed).length;
+  const totalCalls = rows.reduce((sum, row) => sum + row.requestCount, 0);
+  const failureCalls = rows.reduce((sum, row) => sum + row.failureCalls, 0);
   const successCalls = Math.max(totalCalls - failureCalls, 0);
   const inputTokens = rows.reduce((sum, row) => sum + row.inputTokens, 0);
   const outputTokens = rows.reduce((sum, row) => sum + row.outputTokens, 0);
@@ -773,9 +852,8 @@ export const buildMonitoringSummary = (rows: MonitoringEventRow[]): MonitoringSu
   let latencySum = 0;
   let latencyCount = 0;
   rows.forEach((row) => {
-    if (row.latencyMs === null) return;
-    latencySum += row.latencyMs;
-    latencyCount += 1;
+    latencySum += row.latencySumMs;
+    latencyCount += row.latencyCount;
   });
 
   const taskMap = new Map<string, boolean>();
@@ -795,6 +873,7 @@ export const buildMonitoringSummary = (rows: MonitoringEventRow[]): MonitoringSu
   const recentRows = rows.filter(
     (row) => row.timestampMs >= windowStart && row.timestampMs <= nowMs
   );
+  const recentCalls = recentRows.reduce((sum, row) => sum + row.requestCount, 0);
   const recentTokens = recentRows.reduce((sum, row) => sum + row.totalTokens, 0);
 
   return {
@@ -809,7 +888,7 @@ export const buildMonitoringSummary = (rows: MonitoringEventRow[]): MonitoringSu
     totalTokens,
     totalCost,
     averageLatencyMs: latencyCount > 0 ? latencySum / latencyCount : null,
-    rpm30m: recentRows.length / 30,
+    rpm30m: recentCalls / 30,
     tpm30m: recentTokens / 30,
     avgDailyRequests: totalCalls / activeDayCount,
     avgDailyTokens: totalTokens / activeDayCount,
@@ -817,11 +896,57 @@ export const buildMonitoringSummary = (rows: MonitoringEventRow[]): MonitoringSu
     approxTaskFailures,
     approxTaskSuccessRate:
       approxTasks > 0 ? Math.max(approxTasks - approxTaskFailures, 0) / approxTasks : 1,
-    zeroTokenCalls: zeroTokenRows.length,
+    zeroTokenCalls: zeroTokenRows.reduce((sum, row) => sum + row.requestCount, 0),
     zeroTokenModels: Array.from(new Set(zeroTokenRows.map((row) => row.model))).sort(),
   };
 };
 
+const buildAggregateMonitoringSummary = (
+  usage: unknown,
+  modelRows: MonitoringEventRow[] | null,
+  fallbackRows: MonitoringEventRow[]
+): MonitoringSummary => {
+  const rowsSummary = buildMonitoringSummary(modelRows ?? fallbackRows);
+  if (!modelRows || !isRecord(usage)) {
+    return rowsSummary;
+  }
+
+  const tokens = isRecord(usage.tokens) ? usage.tokens : {};
+  const totalCalls = readFiniteNumber(usage.total_requests);
+  const successCalls = readFiniteNumber(usage.success_count);
+  const failureCalls = readFiniteNumber(usage.failure_count);
+  const inputTokens = readFiniteNumber(tokens.input_tokens);
+  const outputTokens = readFiniteNumber(tokens.output_tokens);
+  const reasoningTokens = readFiniteNumber(tokens.reasoning_tokens);
+  const cachedTokens = Math.max(
+    readFiniteNumber(tokens.cached_tokens),
+    readFiniteNumber(tokens.cache_tokens)
+  );
+  const totalTokens = readFiniteNumber(usage.total_tokens ?? tokens.total_tokens);
+  const latencyCount = readFiniteNumber(usage.latency_count);
+  const latencySum = readFiniteNumber(usage.latency_sum_ms);
+  const averageLatencyMs =
+    latencyCount > 0
+      ? latencySum / latencyCount
+      : Number.isFinite(Number(usage.latency_ms))
+        ? Number(usage.latency_ms)
+        : null;
+
+  return {
+    ...rowsSummary,
+    totalCalls,
+    successCalls,
+    failureCalls,
+    successRate: totalCalls > 0 ? successCalls / totalCalls : 1,
+    inputTokens,
+    outputTokens,
+    reasoningTokens,
+    cachedTokens,
+    totalTokens,
+    averageLatencyMs,
+  };
+};
+
 export const buildAccountRows = (rows: MonitoringEventRow[]): MonitoringAccountRow[] => {
   const grouped = new Map<
     string,
@@ -890,9 +1015,9 @@ export const buildAccountRows = (rows: MonitoringEventRow[]): MonitoringAccountR
     existing.authLabels.add(row.authLabel);
     existing.authIndices.add(row.authIndex);
     existing.channels.add(row.channel);
-    existing.totalCalls += 1;
-    existing.successCalls += row.failed ? 0 : 1;
-    existing.failureCalls += row.failed ? 1 : 0;
+    existing.totalCalls += row.requestCount;
+    existing.successCalls += row.successCalls;
+    existing.failureCalls += row.failureCalls;
     existing.inputTokens += row.inputTokens;
     existing.outputTokens += row.outputTokens;
     existing.cachedTokens += row.cachedTokens;
@@ -901,8 +1026,8 @@ export const buildAccountRows = (rows: MonitoringEventRow[]): MonitoringAccountR
     existing.lastSeenAt = Math.max(existing.lastSeenAt, row.timestampMs);
 
     if (row.latencyMs !== null) {
-      existing.latencySum += row.latencyMs;
-      existing.latencyCount += 1;
+      existing.latencySum += row.latencySumMs;
+      existing.latencyCount += row.latencyCount;
     }
 
     const modelEntry = existing.modelMap.get(row.model) ?? {
@@ -918,9 +1043,9 @@ export const buildAccountRows = (rows: MonitoringEventRow[]): MonitoringAccountR
       lastSeenAt: 0,
     };
 
-    modelEntry.totalCalls += 1;
-    modelEntry.successCalls += row.failed ? 0 : 1;
-    modelEntry.failureCalls += row.failed ? 1 : 0;
+    modelEntry.totalCalls += row.requestCount;
+    modelEntry.successCalls += row.successCalls;
+    modelEntry.failureCalls += row.failureCalls;
     modelEntry.inputTokens += row.inputTokens;
     modelEntry.outputTokens += row.outputTokens;
     modelEntry.cachedTokens += row.cachedTokens;
@@ -1061,9 +1186,9 @@ export const buildApiKeyRows = (rows: MonitoringEventRow[]): MonitoringApiKeyRow
     existing.sourceLabels.add(row.sourceMasked || row.source);
     existing.channels.add(row.channel);
 
-    existing.totalCalls += 1;
-    existing.successCalls += row.failed ? 0 : 1;
-    existing.failureCalls += row.failed ? 1 : 0;
+    existing.totalCalls += row.requestCount;
+    existing.successCalls += row.successCalls;
+    existing.failureCalls += row.failureCalls;
     existing.inputTokens += row.inputTokens;
     existing.outputTokens += row.outputTokens;
     existing.cachedTokens += row.cachedTokens;
@@ -1072,8 +1197,8 @@ export const buildApiKeyRows = (rows: MonitoringEventRow[]): MonitoringApiKeyRow
     existing.lastSeenAt = Math.max(existing.lastSeenAt, row.timestampMs);
 
     if (row.latencyMs !== null) {
-      existing.latencySum += row.latencyMs;
-      existing.latencyCount += 1;
+      existing.latencySum += row.latencySumMs;
+      existing.latencyCount += row.latencyCount;
     }
 
     const modelEntry = existing.modelMap.get(row.model) ?? {
@@ -1089,9 +1214,9 @@ export const buildApiKeyRows = (rows: MonitoringEventRow[]): MonitoringApiKeyRow
       lastSeenAt: 0,
     };
 
-    modelEntry.totalCalls += 1;
-    modelEntry.successCalls += row.failed ? 0 : 1;
-    modelEntry.failureCalls += row.failed ? 1 : 0;
+    modelEntry.totalCalls += row.requestCount;
+    modelEntry.successCalls += row.successCalls;
+    modelEntry.failureCalls += row.failureCalls;
     modelEntry.inputTokens += row.inputTokens;
     modelEntry.outputTokens += row.outputTokens;
     modelEntry.cachedTokens += row.cachedTokens;
@@ -1207,8 +1332,8 @@ export const buildRealtimeMonitorRows = (rows: MonitoringEventRow[]): Monitoring
     };
 
     existing.rows.push(row);
-    existing.successCalls += row.failed ? 0 : 1;
-    existing.failureCalls += row.failed ? 1 : 0;
+    existing.successCalls += row.successCalls;
+    existing.failureCalls += row.failureCalls;
     existing.inputTokens += row.inputTokens;
     existing.outputTokens += row.outputTokens;
     existing.cachedTokens += row.cachedTokens;
@@ -1222,8 +1347,8 @@ export const buildRealtimeMonitorRows = (rows: MonitoringEventRow[]): Monitoring
     }
 
     if (row.latencyMs !== null) {
-      existing.latencySum += row.latencyMs;
-      existing.latencyCount += 1;
+      existing.latencySum += row.latencySumMs;
+      existing.latencyCount += row.latencyCount;
     }
 
     grouped.set(key, existing);
@@ -1310,8 +1435,8 @@ const buildModelShareRows = (rows: MonitoringEventRow[]) => {
       totalTokens: 0,
       totalCost: 0,
     };
-    existing.requests += 1;
-    existing.failures += row.failed ? 1 : 0;
+    existing.requests += row.requestCount;
+    existing.failures += row.failureCalls;
     existing.totalTokens += row.totalTokens;
     existing.totalCost += row.totalCost;
     grouped.set(row.model, existing);
@@ -1373,13 +1498,13 @@ const buildChannelRows = (rows: MonitoringEventRow[]) => {
       existing.planTypes.add(row.planType);
     }
     existing.models.add(row.model);
-    existing.requests += 1;
-    existing.failures += row.failed ? 1 : 0;
+    existing.requests += row.requestCount;
+    existing.failures += row.failureCalls;
     existing.totalTokens += row.totalTokens;
     existing.totalCost += row.totalCost;
     if (row.latencyMs !== null) {
-      existing.latencySum += row.latencyMs;
-      existing.latencyCount += 1;
+      existing.latencySum += row.latencySumMs;
+      existing.latencyCount += row.latencyCount;
     }
     grouped.set(key, existing);
   });
@@ -1434,15 +1559,15 @@ const buildModelRows = (rows: MonitoringEventRow[]) => {
       channels: new Set<string>(),
     };
 
-    existing.requests += 1;
-    existing.failures += row.failed ? 1 : 0;
+    existing.requests += row.requestCount;
+    existing.failures += row.failureCalls;
     existing.totalTokens += row.totalTokens;
     existing.totalCost += row.totalCost;
     existing.sources.add(row.source);
     existing.channels.add(row.channel);
     if (row.latencyMs !== null) {
-      existing.latencySum += row.latencyMs;
-      existing.latencyCount += 1;
+      existing.latencySum += row.latencySumMs;
+      existing.latencyCount += row.latencyCount;
     }
 
     grouped.set(row.model, existing);
@@ -1491,13 +1616,13 @@ const buildFailureSourceRows = (rows: MonitoringEventRow[]) => {
       latencyCount: 0,
     };
 
-    existing.totalRequests += 1;
+    existing.totalRequests += row.requestCount;
     existing.lastSeenAt = Math.max(existing.lastSeenAt, row.timestampMs);
     if (row.failed) {
-      existing.failures += 1;
+      existing.failures += row.failureCalls;
       if (row.latencyMs !== null) {
-        existing.latencySum += row.latencyMs;
-        existing.latencyCount += 1;
+        existing.latencySum += row.latencySumMs;
+        existing.latencyCount += row.latencyCount;
       }
     }
 
@@ -1564,15 +1689,15 @@ const buildTaskBuckets = (rows: MonitoringEventRow[]) => {
       maxLatencyMs: null,
     };
 
-    existing.calls += 1;
-    existing.failedCalls += row.failed ? 1 : 0;
+    existing.calls += row.requestCount;
+    existing.failedCalls += row.failureCalls;
     existing.models.add(row.model);
     existing.endpoints.add(row.endpointPath || row.endpoint);
     existing.totalTokens += row.totalTokens;
     existing.totalCost += row.totalCost;
     if (row.latencyMs !== null) {
-      existing.latencySum += row.latencyMs;
-      existing.latencyCount += 1;
+      existing.latencySum += row.latencySumMs;
+      existing.latencyCount += row.latencyCount;
       existing.maxLatencyMs = Math.max(existing.maxLatencyMs ?? 0, row.latencyMs);
     }
 
@@ -1692,6 +1817,22 @@ const buildEventRows = (
         Number(detail.tokens?.total_tokens) || 0,
         extractTotalTokens(detail)
       );
+      const requestCount = Math.max(Number(detail.request_count) || 1, 1);
+      const successCalls = Math.max(
+        Number(detail.success_count) || (detail.failed === true ? 0 : requestCount),
+        0
+      );
+      const failureCalls = Math.max(
+        Number(detail.failure_count) || (detail.failed === true ? requestCount : 0),
+        0
+      );
+      const latencyCount = Math.max(Number(detail.latency_count) || 0, 0);
+      const latencySumMs =
+        latencyCount > 0
+          ? Math.max(Number(detail.latency_sum_ms) || 0, 0)
+          : typeof detail.latency_ms === 'number'
+            ? detail.latency_ms
+            : 0;
       const totalCost = calculateCost(detail, modelPriceIndex);
       const statsIncluded = detail.failed === true || inputTokens > 0 || outputTokens > 0;
       const dayKey = buildLocalDayKey(timestampMs);
@@ -1728,8 +1869,14 @@ const buildEventRows = (
         channelHost: channelMeta?.host || '-',
         channelDisabled: channelMeta?.disabled || false,
         failed: detail.failed === true,
+        requestCount,
+        successCalls,
+        failureCalls,
         statsIncluded,
         latencyMs: typeof detail.latency_ms === 'number' ? detail.latency_ms : null,
+        latencySumMs,
+        latencyCount:
+          latencyCount > 0 ? latencyCount : typeof detail.latency_ms === 'number' ? 1 : 0,
         inputTokens,
         outputTokens,
         reasoningTokens,
@@ -1804,6 +1951,7 @@ const loadMonitoringMetaPayload = async (
 
 export function useMonitoringData({
   usage,
+  usagePages,
   config,
   modelPrices,
   apiKeyAliases,
@@ -1903,37 +2051,140 @@ export function useMonitoringData({
     return buildApiKeyDisplayMap(config?.apiKeys || [], apiKeyAliases || []);
   }, [apiKeyAliases, config?.apiKeys]);
 
+  const summaryFilterFacets = useMemo(
+    () => buildMonitoringFilterFacetsFromSummary(usage, apiKeyDisplayMap),
+    [apiKeyDisplayMap, usage]
+  );
+
   const modelPriceIndex = useMemo(() => buildModelPriceIndex(modelPrices), [modelPrices]);
 
+  const buildRowsForUsage = useCallback(
+    (payload: unknown) => {
+      const details = collectUsageDetailsWithEndpoint(payload);
+      return buildEventRows(
+        details,
+        authMetaMap,
+        authFileMap,
+        sourceInfoMap,
+        channelByAuthIndex,
+        modelPriceIndex,
+        apiKeyDisplayMap
+      ).sort((left, right) => right.timestampMs - left.timestampMs);
+    },
+    [apiKeyDisplayMap, authFileMap, authMetaMap, channelByAuthIndex, modelPriceIndex, sourceInfoMap]
+  );
+
   const allRows = useMemo(() => {
-    const details = collectUsageDetailsWithEndpoint(usage);
-    return buildEventRows(
-      details,
-      authMetaMap,
-      authFileMap,
-      sourceInfoMap,
-      channelByAuthIndex,
-      modelPriceIndex,
-      apiKeyDisplayMap
-    ).sort((left, right) => right.timestampMs - left.timestampMs);
+    return buildRowsForUsage(usage);
+  }, [buildRowsForUsage, usage]);
+
+  const accountPageRows = useMemo(() => {
+    const pageUsage = usagePages?.accounts?.usage;
+    if (!pageUsage) return null;
+    const rows = buildRangeFilteredRows(
+      buildRowsForUsage(pageUsage),
+      timeRange,
+      customTimeRange,
+      searchQuery,
+      searchApiKeyHash
+    );
+    return buildAccountRows(rows);
   }, [
-    apiKeyDisplayMap,
-    authFileMap,
-    authMetaMap,
-    channelByAuthIndex,
-    modelPriceIndex,
-    sourceInfoMap,
-    usage,
+    buildRowsForUsage,
+    customTimeRange,
+    searchApiKeyHash,
+    searchQuery,
+    timeRange,
+    usagePages?.accounts?.usage,
   ]);
 
+  const apiKeyPageRows = useMemo(() => {
+    const pageUsage = usagePages?.apiKeys?.usage;
+    if (!pageUsage) return null;
+    const rows = buildRangeFilteredRows(
+      buildRowsForUsage(pageUsage),
+      timeRange,
+      customTimeRange,
+      searchQuery,
+      searchApiKeyHash
+    );
+    return buildApiKeyRows(rows);
+  }, [
+    buildRowsForUsage,
+    customTimeRange,
+    searchApiKeyHash,
+    searchQuery,
+    timeRange,
+    usagePages?.apiKeys?.usage,
+  ]);
+
+  const realtimePageRows = useMemo(() => {
+    const pageUsage = usagePages?.realtime?.usage;
+    if (!pageUsage) return null;
+    return buildRangeFilteredRows(
+      buildRowsForUsage(pageUsage),
+      timeRange,
+      customTimeRange,
+      searchQuery,
+      searchApiKeyHash
+    );
+  }, [
+    buildRowsForUsage,
+    customTimeRange,
+    searchApiKeyHash,
+    searchQuery,
+    timeRange,
+    usagePages?.realtime?.usage,
+  ]);
+
+  const modelAggregateRows = useMemo(() => {
+    const pageUsage = usagePages?.models?.usage;
+    if (!pageUsage) return null;
+    return buildRowsForUsage(pageUsage).filter(shouldIncludeInStats);
+  }, [buildRowsForUsage, usagePages?.models?.usage]);
+
   const filteredRows = useMemo(
     () =>
       buildRangeFilteredRows(allRows, timeRange, customTimeRange, searchQuery, searchApiKeyHash),
     [allRows, customTimeRange, searchApiKeyHash, searchQuery, timeRange]
   );
+  const filterFacets = useMemo<MonitoringFilterFacets>(() => {
+    if (
+      summaryFilterFacets.providers.length > 0 ||
+      summaryFilterFacets.accounts.length > 0 ||
+      summaryFilterFacets.models.length > 0 ||
+      summaryFilterFacets.channels.length > 0 ||
+      summaryFilterFacets.apiKeys.length > 0
+    ) {
+      return summaryFilterFacets;
+    }
+
+    const apiKeyOptions = new Map<string, string>();
+    filteredRows.forEach((row) => {
+      if (!row.apiKeyHash || apiKeyOptions.has(row.apiKeyHash)) return;
+      apiKeyOptions.set(row.apiKeyHash, row.apiKeyLabel || row.apiKeyMasked || row.apiKeyHash);
+    });
+
+    return {
+      providers: Array.from(new Set(filteredRows.map((row) => row.provider))).filter(Boolean),
+      accounts: buildAccountRows(filteredRows).map((row) => ({
+        value: row.account,
+        label:
+          row.displayAccount && row.displayAccount !== row.account
+            ? `${row.displayAccount} / ${row.account}`
+            : row.account,
+      })),
+      models: Array.from(new Set(filteredRows.map((row) => row.model))).filter(Boolean),
+      channels: Array.from(new Set(filteredRows.map((row) => row.channel))).filter(Boolean),
+      apiKeys: Array.from(apiKeyOptions.entries()).map(([value, label]) => ({ value, label })),
+    };
+  }, [filteredRows, summaryFilterFacets]);
   const statsRows = useMemo(() => filteredRows.filter(shouldIncludeInStats), [filteredRows]);
 
-  const summary = useMemo(() => buildMonitoringSummary(statsRows), [statsRows]);
+  const summary = useMemo(
+    () => buildAggregateMonitoringSummary(usage, modelAggregateRows, statsRows),
+    [modelAggregateRows, statsRows, usage]
+  );
   const timelineData = useMemo(
     () => buildTimeline(statsRows, timeRange, customTimeRange),
     [customTimeRange, statsRows, timeRange]
@@ -1985,6 +2236,10 @@ export function useMonitoringData({
     taskBuckets,
     recentFailures,
     filteredRows,
+    accountPageRows,
+    apiKeyPageRows,
+    realtimePageRows,
+    filterFacets,
     refreshMeta,
   };
 }
diff --git a/src/features/monitoring/hooks/useUsageData.test.ts b/src/features/monitoring/hooks/useUsageData.test.ts
new file mode 100644
index 000000000..86dc206c4
--- /dev/null
+++ b/src/features/monitoring/hooks/useUsageData.test.ts
@@ -0,0 +1,125 @@
+import { act, createElement, useEffect } from 'react';
+import { create, type ReactTestRenderer } from 'react-test-renderer';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useUsageData } from './useUsageData';
+
+const { mocks } = vi.hoisted(() => {
+  return {
+    mocks: {
+      getModelPrices: vi.fn(),
+      saveModelPrices: vi.fn(),
+      getApiKeyAliases: vi.fn(),
+      getUsage: vi.fn(),
+      loadStoredModelPrices: vi.fn(),
+      clearModelPrices: vi.fn(),
+      saveStoredModelPrices: vi.fn(),
+    },
+  };
+});
+
+vi.mock('@/stores', () => ({
+  useAuthStore: (selector: (state: { apiBase: string; managementKey: string }) => unknown) =>
+    selector({ apiBase: 'http://cpa.local', managementKey: 'management-key' }),
+  useUsageServiceStore: (selector: (state: { enabled: boolean; serviceBase: string }) => unknown) =>
+    selector({ enabled: true, serviceBase: 'http://usage.local' }),
+}));
+
+vi.mock('@/services/api/usageService', () => ({
+  isUsageServiceId: (value: string) => value === 'usage-service',
+  normalizeUsageServiceBase: (value: string) => value.replace(/\/+$/, ''),
+  usageServiceApi: {
+    getModelPrices: mocks.getModelPrices,
+    saveModelPrices: mocks.saveModelPrices,
+    getApiKeyAliases: mocks.getApiKeyAliases,
+    getUsage: mocks.getUsage,
+  },
+}));
+
+vi.mock('@/utils/connection', () => ({
+  detectApiBaseFromLocation: () => '',
+}));
+
+vi.mock('@/utils/usage', () => ({
+  clearModelPrices: mocks.clearModelPrices,
+  loadModelPrices: mocks.loadStoredModelPrices,
+  saveModelPrices: mocks.saveStoredModelPrices,
+}));
+
+type UseUsageDataHarness = {
+  getCurrent: () => ReturnType<typeof useUsageData>;
+  unmount: () => void;
+};
+
+const flushPromises = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+const mountUseUsageData = async (): Promise<UseUsageDataHarness> => {
+  let hook: ReturnType<typeof useUsageData> | null = null;
+  let renderer: ReactTestRenderer | null = null;
+
+  function HookHarness() {
+    const current = useUsageData();
+    useEffect(() => {
+      hook = current;
+    });
+    return null;
+  }
+
+  await act(async () => {
+    renderer = create(createElement(HookHarness));
+    await flushPromises();
+  });
+
+  return {
+    getCurrent: () => {
+      if (!hook) {
+        throw new Error('Failed to mount useUsageData test harness');
+      }
+      return hook;
+    },
+    unmount: () => {
+      if (!renderer) return;
+      act(() => {
+        renderer?.unmount();
+      });
+    },
+  };
+};
+
+beforeEach(() => {
+  mocks.getModelPrices.mockReset();
+  mocks.saveModelPrices.mockReset();
+  mocks.getApiKeyAliases.mockReset();
+  mocks.getUsage.mockReset();
+  mocks.loadStoredModelPrices.mockReset();
+  mocks.clearModelPrices.mockReset();
+  mocks.saveStoredModelPrices.mockReset();
+
+  mocks.getApiKeyAliases.mockResolvedValue({ items: [] });
+  mocks.getUsage.mockResolvedValue({});
+  mocks.loadStoredModelPrices.mockReturnValue({});
+});
+
+describe('useUsageData', () => {
+  it('reloads model prices when loadModelPrices is called again', async () => {
+    mocks.getModelPrices
+      .mockResolvedValueOnce({ prices: { 'gpt-initial': { prompt: 1, completion: 2, cache: 0 } } })
+      .mockResolvedValueOnce({ prices: { 'gpt-refreshed': { prompt: 3, completion: 4, cache: 0 } } });
+
+    const harness = await mountUseUsageData();
+
+    expect(harness.getCurrent().modelPrices).toEqual({
+      'gpt-initial': { prompt: 1, completion: 2, cache: 0 },
+    });
+
+    await act(async () => {
+      await harness.getCurrent().loadModelPrices();
+    });
+
+    expect(harness.getCurrent().modelPrices).toEqual({
+      'gpt-refreshed': { prompt: 3, completion: 4, cache: 0 },
+    });
+    expect(mocks.getModelPrices).toHaveBeenCalledTimes(2);
+
+    harness.unmount();
+  });
+});
diff --git a/src/features/monitoring/hooks/useUsageData.ts b/src/features/monitoring/hooks/useUsageData.ts
index ab2b16bf2..07a63d550 100644
--- a/src/features/monitoring/hooks/useUsageData.ts
+++ b/src/features/monitoring/hooks/useUsageData.ts
@@ -7,12 +7,20 @@ import {
   type ApiKeyAliasesResponse,
   type ModelPricesResponse,
   type ModelPriceSyncResponse,
+  type UsagePageQuery,
+  type UsagePageResponse,
+  type UsageQuery,
   type UsageExportResponse,
   type UsageImportResponse,
 } from '@/services/api/usageService';
 import { useAuthStore, useUsageServiceStore } from '@/stores';
 import { detectApiBaseFromLocation } from '@/utils/connection';
-import { clearModelPrices, loadModelPrices, saveModelPrices, type ModelPrice } from '@/utils/usage';
+import {
+  clearModelPrices,
+  loadModelPrices as loadStoredModelPrices,
+  saveModelPrices,
+  type ModelPrice,
+} from '@/utils/usage';
 
 export interface UsagePayload {
   total_requests?: number;
@@ -23,8 +31,23 @@ export interface UsagePayload {
   [key: string]: unknown;
 }
 
+export type UsagePageQueries = {
+  accounts?: UsagePageQuery;
+  apiKeys?: UsagePageQuery;
+  realtime?: UsagePageQuery;
+  models?: UsagePageQuery;
+};
+
+export type UsagePages = {
+  accounts?: UsagePageResponse;
+  apiKeys?: UsagePageResponse;
+  realtime?: UsagePageResponse;
+  models?: UsagePageResponse;
+};
+
 export interface UseUsageDataReturn {
   usage: UsagePayload | null;
+  usagePages: UsagePages | null;
   loading: boolean;
   error: string;
   lastRefreshedAt: Date | null;
@@ -32,19 +55,55 @@ export interface UseUsageDataReturn {
   apiKeyAliases: ApiKeyAlias[];
   usageServiceAvailable: boolean;
   setModelPrices: (prices: Record<string, ModelPrice>) => Promise<void>;
+  loadModelPrices: () => Promise<void>;
   loadApiKeyAliases: () => Promise<void>;
   syncModelPrices: (models?: string[]) => Promise<ModelPriceSyncResponse>;
   exportUsage: () => Promise<UsageExportResponse>;
   importUsage: (file: File) => Promise<UsageImportResponse>;
-  loadUsage: () => Promise<void>;
+  loadUsage: (queryOverride?: UsageQuery) => Promise<void>;
 }
 
-export function useUsageData(): UseUsageDataReturn {
+const isUsagePageFallbackError = (error: unknown) => {
+  if (!(error instanceof Error)) return false;
+  const status = (error as { status?: number }).status;
+  const code = (error as { code?: string }).code;
+  return status === 404 || status === 405 || code === 'method_not_allowed';
+};
+
+const mergeUsagePayloads = (payloads: UsagePayload[]): UsagePayload => {
+  const merged: UsagePayload = { apis: {} };
+  payloads.forEach((payload) => {
+    merged.total_requests = Number(merged.total_requests || 0) + Number(payload.total_requests || 0);
+    merged.success_count = Number(merged.success_count || 0) + Number(payload.success_count || 0);
+    merged.failure_count = Number(merged.failure_count || 0) + Number(payload.failure_count || 0);
+    merged.total_tokens = Number(merged.total_tokens || 0) + Number(payload.total_tokens || 0);
+    if (payload.apis && typeof payload.apis === 'object') {
+      Object.entries(payload.apis).forEach(([endpoint, api]) => {
+        if (!api || typeof api !== 'object' || Array.isArray(api)) return;
+        const sourceModels = (api as { models?: unknown }).models;
+        if (!sourceModels || typeof sourceModels !== 'object' || Array.isArray(sourceModels)) return;
+        const mergedApis = merged.apis as Record<string, { models: Record<string, unknown> }>;
+        const target = mergedApis[endpoint] ?? { models: {} };
+        Object.entries(sourceModels).forEach(([model, aggregate]) => {
+          target.models[model] = aggregate;
+        });
+        mergedApis[endpoint] = target;
+      });
+    }
+  });
+  return merged;
+};
+
+export function useUsageData(
+  usageQuery?: UsageQuery,
+  usagePageQueries?: UsagePageQueries
+): UseUsageDataReturn {
   const apiBase = useAuthStore((state) => state.apiBase);
   const managementKey = useAuthStore((state) => state.managementKey);
   const usageServiceEnabled = useUsageServiceStore((state) => state.enabled);
   const usageServiceBase = useUsageServiceStore((state) => state.serviceBase);
   const [usage, setUsage] = useState<UsagePayload | null>(null);
+  const [usagePages, setUsagePages] = useState<UsagePages | null>(null);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState('');
   const [lastRefreshedAt, setLastRefreshedAt] = useState<Date | null>(null);
@@ -138,8 +197,8 @@ export function useUsageData(): UseUsageDataReturn {
     [managementKey, resolveUsageServiceBase]
   );
 
-  const loadModelPricesFromStorage = useCallback(async () => {
-    const fallbackPrices = loadModelPrices();
+  const loadModelPrices = useCallback(async () => {
+    const fallbackPrices = loadStoredModelPrices();
     try {
       const response = await getModelPricesFromApi();
       const apiPrices = response.prices ?? {};
@@ -160,6 +219,95 @@ export function useUsageData(): UseUsageDataReturn {
     }
   }, [getModelPricesFromApi, saveModelPricesToApi]);
 
+  const loadUsagePages = useCallback(
+    async (serviceBase: string, queryOverride?: UsageQuery): Promise<UsagePages | null> => {
+      if (!usagePageQueries) return null;
+      const activeUsageQuery = queryOverride ?? usageQuery;
+      try {
+        const loadModelPages = async () => {
+          if (!usagePageQueries.models) return undefined;
+          const first = await usageServiceApi.getUsagePage(
+            serviceBase,
+            managementKey,
+            'models',
+            activeUsageQuery,
+            usagePageQueries.models
+          );
+          const totalItems = Math.max(0, Math.trunc(Number(first.total_items) || 0));
+          const pageSize = Math.max(1, Math.trunc(Number(first.page_size) || 1));
+          const pageCount = Math.ceil(totalItems / pageSize);
+          if (pageCount <= 1) return first;
+
+          const rest = await Promise.all(
+            Array.from({ length: pageCount - 1 }, (_, index) =>
+              usageServiceApi.getUsagePage(serviceBase, managementKey, 'models', activeUsageQuery, {
+                ...usagePageQueries.models,
+                page: index + 2,
+                pageSize,
+              })
+            )
+          );
+          return {
+            ...first,
+            page: 1,
+            usage: mergeUsagePayloads([first, ...rest].map((page) => page.usage)),
+          };
+        };
+
+        const [accounts, apiKeys, realtime, models] = await Promise.all([
+          usagePageQueries.accounts
+            ? usageServiceApi.getUsagePage(
+                serviceBase,
+                managementKey,
+                'accounts',
+                activeUsageQuery,
+                usagePageQueries.accounts
+              )
+            : Promise.resolve(undefined),
+          usagePageQueries.apiKeys
+            ? usageServiceApi.getUsagePage(
+                serviceBase,
+                managementKey,
+                'api-keys',
+                activeUsageQuery,
+                usagePageQueries.apiKeys
+              )
+            : Promise.resolve(undefined),
+          usagePageQueries.realtime
+            ? usageServiceApi.getUsagePage(
+                serviceBase,
+                managementKey,
+                'realtime',
+                activeUsageQuery,
+                usagePageQueries.realtime
+              )
+            : Promise.resolve(undefined),
+          loadModelPages(),
+        ]);
+        return { accounts, apiKeys, realtime, models };
+      } catch (error) {
+        if (isUsagePageFallbackError(error)) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    [
+      managementKey,
+      usagePageQueries?.accounts?.page,
+      usagePageQueries?.accounts?.pageSize,
+      usagePageQueries?.accounts?.sortDirection,
+      usagePageQueries?.accounts?.sortKey,
+      usagePageQueries?.apiKeys?.page,
+      usagePageQueries?.apiKeys?.pageSize,
+      usagePageQueries?.realtime?.page,
+      usagePageQueries?.realtime?.pageSize,
+      usagePageQueries?.models?.page,
+      usagePageQueries?.models?.pageSize,
+      usageQuery,
+    ]
+  );
+
   const loadApiKeyAliases = useCallback(async () => {
     const requestId = aliasRequestIdRef.current + 1;
     aliasRequestIdRef.current = requestId;
@@ -173,7 +321,7 @@ export function useUsageData(): UseUsageDataReturn {
     }
   }, [getApiKeyAliasesFromApi]);
 
-  const loadUsage = useCallback(async () => {
+  const loadUsage = useCallback(async (queryOverride?: UsageQuery) => {
     const requestId = requestIdRef.current + 1;
     requestIdRef.current = requestId;
     setLoading(true);
@@ -184,13 +332,19 @@ export function useUsageData(): UseUsageDataReturn {
       if (!serviceBase) {
         setUsageServiceAvailable(false);
         setUsage(null);
+        setUsagePages(null);
         setLastRefreshedAt(null);
         return;
       }
       setUsageServiceAvailable(true);
-      const payload = await usageServiceApi.getUsage(serviceBase, managementKey);
+      const activeUsageQuery = queryOverride ?? usageQuery;
+      const [payload, pages] = await Promise.all([
+        usageServiceApi.getUsage(serviceBase, managementKey, activeUsageQuery),
+        loadUsagePages(serviceBase, activeUsageQuery),
+      ]);
       if (requestIdRef.current !== requestId) return;
       setUsage(payload ?? null);
+      setUsagePages(pages);
       setLastRefreshedAt(new Date());
     } catch (err) {
       if (requestIdRef.current !== requestId) return;
@@ -200,13 +354,27 @@ export function useUsageData(): UseUsageDataReturn {
         setLoading(false);
       }
     }
-  }, [managementKey, resolveUsageServiceBase]);
+  }, [
+    loadUsagePages,
+    managementKey,
+    resolveUsageServiceBase,
+    usageQuery?.account,
+    usageQuery?.apiKeyHash,
+    usageQuery?.channel,
+    usageQuery?.endMs,
+    usageQuery?.model,
+    usageQuery?.provider,
+    usageQuery?.search,
+    usageQuery?.searchApiKeyHash,
+    usageQuery?.startMs,
+    usageQuery?.status,
+  ]);
 
   useEffect(() => {
-    void loadModelPricesFromStorage();
+    void loadModelPrices();
     void loadApiKeyAliases();
     void loadUsage();
-  }, [loadApiKeyAliases, loadModelPricesFromStorage, loadUsage]);
+  }, [loadApiKeyAliases, loadModelPrices, loadUsage]);
 
   const setModelPrices = useCallback(
     async (prices: Record<string, ModelPrice>) => {
@@ -234,6 +402,7 @@ export function useUsageData(): UseUsageDataReturn {
 
   return {
     usage,
+    usagePages,
     loading,
     error,
     lastRefreshedAt,
@@ -241,6 +410,7 @@ export function useUsageData(): UseUsageDataReturn {
     apiKeyAliases,
     usageServiceAvailable,
     setModelPrices,
+    loadModelPrices,
     loadApiKeyAliases,
     syncModelPrices,
     exportUsage: exportUsageFromApi,
diff --git a/src/pages/MonitoringCenterPage.tsx b/src/pages/MonitoringCenterPage.tsx
index b019d7aeb..2289f83ba 100644
--- a/src/pages/MonitoringCenterPage.tsx
+++ b/src/pages/MonitoringCenterPage.tsx
@@ -44,7 +44,6 @@ import {
 import {
   buildAccountRows,
   buildApiKeyRows,
-  buildMonitoringSummary,
   buildRealtimeMonitorRows,
   getRangeBounds,
   type MonitoringAccountModelSpendRow,
@@ -269,6 +268,25 @@ const buildPaginationState = <T,>(
   };
 };
 
+const buildRemotePaginationState = <T,>(
+  items: readonly T[],
+  page: number,
+  pageSize: number,
+  count: number
+): PaginationState<T> => {
+  const safePageSize = Math.max(1, pageSize);
+  const totalPages = Math.max(1, Math.ceil(Math.max(0, count) / safePageSize));
+  const currentPage = Math.min(Math.max(1, page), totalPages);
+  const startItem = count > 0 ? (currentPage - 1) * safePageSize + 1 : 0;
+  return {
+    currentPage,
+    totalPages,
+    pageItems: [...items],
+    startItem,
+    endItem: count > 0 ? Math.min(startItem + items.length - 1, count) : 0,
+  };
+};
+
 const parsePageSize = (value: string, fallback: number) => {
   const parsed = Number.parseInt(value, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -318,13 +336,6 @@ const buildAccountSecondaryText = (row: MonitoringAccountRow) => {
   return '';
 };
 
-const buildAccountOptionLabel = (row: MonitoringAccountRow) => {
-  if (!row.displayAccount || row.displayAccount === row.account) {
-    return row.account;
-  }
-  return `${row.displayAccount} / ${row.account}`;
-};
-
 const buildAccountSummaryMetrics = (
   row: MonitoringAccountRow,
   hasPrices: boolean,
@@ -1956,8 +1967,74 @@ export function MonitoringCenterPage() {
     return '';
   }, [customDraftEndMs, customDraftStartMs, t]);
 
+  const buildUsageQuery = useCallback(
+    (nowMs: number) => {
+      const bounds = getRangeBounds(timeRange, nowMs, customTimeRange);
+      if (!bounds) return undefined;
+      return {
+        startMs: Number.isFinite(bounds.startMs) ? bounds.startMs : undefined,
+        endMs: Number.isFinite(bounds.endMs) ? bounds.endMs : undefined,
+        account: selectedAccount !== 'all' ? selectedAccount : undefined,
+        provider: selectedProvider !== 'all' ? selectedProvider : undefined,
+        model: selectedModel !== 'all' ? selectedModel : undefined,
+        channel: selectedChannel !== 'all' ? selectedChannel : undefined,
+        apiKeyHash: selectedApiKeyHash !== 'all' ? selectedApiKeyHash : undefined,
+        status: selectedStatus !== 'all' ? selectedStatus : undefined,
+        search: deferredSearch.trim() || undefined,
+        searchApiKeyHash: deferredSearch.trim() ? deferredSearchApiKeyHash : undefined,
+      };
+    },
+    [
+      customTimeRange,
+      deferredSearch,
+      deferredSearchApiKeyHash,
+      selectedAccount,
+      selectedApiKeyHash,
+      selectedChannel,
+      selectedModel,
+      selectedProvider,
+      selectedStatus,
+      timeRange,
+    ]
+  );
+  const usageQuery = useMemo(() => buildUsageQuery(Date.now()), [buildUsageQuery]);
+
+  const usagePageQueries = useMemo(
+    () => ({
+      accounts: {
+        page: accountPage,
+        pageSize: accountPageSize,
+        sortKey: accountSort.key,
+        sortDirection: accountSort.direction,
+      },
+      apiKeys: {
+        page: apiKeyPage,
+        pageSize: apiKeyPageSize,
+      },
+      realtime: {
+        page: realtimePage,
+        pageSize: realtimePageSize,
+      },
+      models: {
+        page: 1,
+        pageSize: 500,
+      },
+    }),
+    [
+      accountPage,
+      accountPageSize,
+      accountSort.direction,
+      accountSort.key,
+      apiKeyPage,
+      apiKeyPageSize,
+      realtimePage,
+      realtimePageSize,
+    ]
+  );
+
   const {
     usage,
+    usagePages,
     loading: usageLoading,
     error: usageError,
     lastRefreshedAt,
@@ -1965,21 +2042,28 @@ export function MonitoringCenterPage() {
     apiKeyAliases,
     usageServiceAvailable,
     setModelPrices,
+    loadModelPrices,
     loadApiKeyAliases,
     syncModelPrices,
     exportUsage,
     importUsage,
     loadUsage,
-  } = useUsageData();
+  } = useUsageData(usageQuery, usagePageQueries);
 
   const {
     loading: monitoringLoading,
     error: monitoringError,
     authFiles,
     filteredRows,
+    accountPageRows,
+    apiKeyPageRows,
+    realtimePageRows,
+    filterFacets,
     refreshMeta,
+    summary: monitoringSummary,
   } = useMonitoringData({
     usage,
+    usagePages,
     config,
     modelPrices,
     apiKeyAliases,
@@ -1990,8 +2074,13 @@ export function MonitoringCenterPage() {
   });
 
   const refreshAll = useCallback(async () => {
-    await Promise.all([loadUsage(), loadApiKeyAliases(), refreshMeta(false)]);
-  }, [loadApiKeyAliases, loadUsage, refreshMeta]);
+    await Promise.all([
+      loadUsage(buildUsageQuery(Date.now())),
+      loadModelPrices(),
+      loadApiKeyAliases(),
+      refreshMeta(false),
+    ]);
+  }, [buildUsageQuery, loadApiKeyAliases, loadModelPrices, loadUsage, refreshMeta]);
 
   const setCurrentAccountPage = useCallback(
     (page: number) => {
@@ -2091,57 +2180,53 @@ export function MonitoringCenterPage() {
   const providerOptions = useMemo(
     () => [
       { value: 'all', label: t('monitoring.filter_all_providers') },
-      ...Array.from(new Set(filteredRows.map((row) => row.provider)))
+      ...Array.from(new Set(filterFacets.providers))
         .filter(Boolean)
         .sort((left, right) => left.localeCompare(right))
         .map((value) => ({ value, label: value })),
     ],
-    [filteredRows, t]
+    [filterFacets.providers, t]
   );
 
-  const accountOptionRows = useMemo(() => buildAccountRows(filteredRows), [filteredRows]);
-
   const accountOptions = useMemo(
     () => [
       { value: 'all', label: t('monitoring.filter_all_accounts') },
       ...Array.from(
-        new Map(
-          accountOptionRows.map((row) => [row.account, buildAccountOptionLabel(row)])
-        ).entries()
+        new Map(filterFacets.accounts.map((item) => [item.value, item.label])).entries()
       )
         .sort((left, right) => left[1].localeCompare(right[1]))
         .map(([value, label]) => ({ value, label })),
     ],
-    [accountOptionRows, t]
+    [filterFacets.accounts, t]
   );
 
   const modelOptions = useMemo(
     () => [
       { value: 'all', label: t('monitoring.filter_all_models') },
-      ...Array.from(new Set(filteredRows.map((row) => row.model)))
+      ...Array.from(new Set(filterFacets.models))
         .filter(Boolean)
         .sort((left, right) => left.localeCompare(right))
         .map((value) => ({ value, label: value })),
     ],
-    [filteredRows, t]
+    [filterFacets.models, t]
   );
 
   const channelOptions = useMemo(
     () => [
       { value: 'all', label: t('monitoring.filter_all_channels') },
-      ...Array.from(new Set(filteredRows.map((row) => row.channel)))
+      ...Array.from(new Set(filterFacets.channels))
         .filter(Boolean)
         .sort((left, right) => left.localeCompare(right))
         .map((value) => ({ value, label: value })),
     ],
-    [filteredRows, t]
+    [filterFacets.channels, t]
   );
 
   const apiKeyOptions = useMemo(() => {
     const optionMap = new Map<string, string>();
-    filteredRows.forEach((row) => {
-      if (!row.apiKeyHash || optionMap.has(row.apiKeyHash)) return;
-      optionMap.set(row.apiKeyHash, row.apiKeyLabel || row.apiKeyMasked || row.apiKeyHash);
+    filterFacets.apiKeys.forEach((item) => {
+      if (!item.value || optionMap.has(item.value)) return;
+      optionMap.set(item.value, item.label || item.value);
     });
 
     return [
@@ -2150,7 +2235,7 @@ export function MonitoringCenterPage() {
         .sort((left, right) => left[1].localeCompare(right[1]))
         .map(([value, label]) => ({ value, label })),
     ];
-  }, [filteredRows, t]);
+  }, [filterFacets.apiKeys, t]);
 
   const statusOptions = useMemo(
     () => [
@@ -2237,7 +2322,7 @@ export function MonitoringCenterPage() {
     [accountStatusBounds, i18n.language, t]
   );
 
-  const scopedSummary = useMemo(() => buildMonitoringSummary(scopedStatsRows), [scopedStatsRows]);
+  const scopedSummary = monitoringSummary;
   const accountRows = useMemo(() => buildAccountRows(scopedRows), [scopedRows]);
   const apiKeyRows = useMemo(() => buildApiKeyRows(scopedRows), [scopedRows]);
   const accountStatusDataByRowId = useMemo(
@@ -2256,22 +2341,80 @@ export function MonitoringCenterPage() {
     () => sortAccountRows(accountRows, accountSort),
     [accountRows, accountSort]
   );
+  const displayedAccountRows = useMemo(
+    () => (accountPageRows ? sortAccountRows(accountPageRows, accountSort) : sortedAccountRows),
+    [accountPageRows, accountSort, sortedAccountRows]
+  );
+  const accountTotalCount =
+    accountPageRows && usagePages?.accounts
+      ? Math.max(0, usagePages.accounts.total_items)
+      : sortedAccountRows.length;
   const groupedRealtimeRows = useMemo(
     () => buildRealtimeMonitorRows(scopedStatsRows),
     [scopedStatsRows]
   );
-  const realtimeLogRows = useMemo(() => buildRealtimeLogRows(scopedRows), [scopedRows]);
+  const displayedApiKeyRows = apiKeyPageRows ?? apiKeyRows;
+  const apiKeyTotalCount =
+    apiKeyPageRows && usagePages?.apiKeys
+      ? Math.max(0, usagePages.apiKeys.total_items)
+      : apiKeyRows.length;
+  const realtimeLogRows = useMemo(
+    () => buildRealtimeLogRows(realtimePageRows ?? scopedRows),
+    [realtimePageRows, scopedRows]
+  );
+  const realtimeTotalCount =
+    realtimePageRows && usagePages?.realtime
+      ? Math.max(0, usagePages.realtime.total_items)
+      : realtimeLogRows.length;
   const accountPagination = useMemo(
-    () => buildPaginationState(sortedAccountRows, accountPage, accountPageSize),
-    [accountPage, accountPageSize, sortedAccountRows]
+    () =>
+      accountPageRows && usagePages?.accounts
+        ? buildRemotePaginationState(
+            displayedAccountRows,
+            usagePages.accounts.page,
+            usagePages.accounts.page_size,
+            usagePages.accounts.total_items
+          )
+        : buildPaginationState(sortedAccountRows, accountPage, accountPageSize),
+    [
+      accountPage,
+      accountPageRows,
+      accountPageSize,
+      displayedAccountRows,
+      sortedAccountRows,
+      usagePages?.accounts,
+    ]
   );
   const apiKeyPagination = useMemo(
-    () => buildPaginationState(apiKeyRows, apiKeyPage, apiKeyPageSize),
-    [apiKeyPage, apiKeyPageSize, apiKeyRows]
+    () =>
+      apiKeyPageRows && usagePages?.apiKeys
+        ? buildRemotePaginationState(
+            displayedApiKeyRows,
+            usagePages.apiKeys.page,
+            usagePages.apiKeys.page_size,
+            usagePages.apiKeys.total_items
+          )
+        : buildPaginationState(apiKeyRows, apiKeyPage, apiKeyPageSize),
+    [
+      apiKeyPage,
+      apiKeyPageRows,
+      apiKeyPageSize,
+      apiKeyRows,
+      displayedApiKeyRows,
+      usagePages?.apiKeys,
+    ]
   );
   const realtimePagination = useMemo(
-    () => buildPaginationState(realtimeLogRows, realtimePage, realtimePageSize),
-    [realtimeLogRows, realtimePage, realtimePageSize]
+    () =>
+      realtimePageRows && usagePages?.realtime
+        ? buildRemotePaginationState(
+            realtimeLogRows,
+            usagePages.realtime.page,
+            usagePages.realtime.page_size,
+            usagePages.realtime.total_items
+          )
+        : buildPaginationState(realtimeLogRows, realtimePage, realtimePageSize),
+    [realtimeLogRows, realtimePage, realtimePageRows, realtimePageSize, usagePages?.realtime]
   );
   const accountPageResetState = useMemo<AccountOverviewPageResetState>(
     () => ({
@@ -3511,7 +3654,7 @@ export function MonitoringCenterPage() {
                     </Fragment>
                   );
                 })}
-                {sortedAccountRows.length === 0 ? (
+                {accountTotalCount === 0 ? (
                   <tr>
                     <td colSpan={accountOverviewColumns.length}>{renderMonitoringEmptyState()}</td>
                   </tr>
@@ -3519,7 +3662,7 @@ export function MonitoringCenterPage() {
               </tbody>
             </table>
           </div>
-        ) : sortedAccountRows.length > 0 ? (
+        ) : accountPagination.pageItems.length > 0 ? (
           <div className={styles.accountOverviewCardGrid}>
             {accountPagination.pageItems.map((row) => {
               const authState = accountAuthStateByRowId.get(row.id) ?? EMPTY_ACCOUNT_AUTH_STATE;
@@ -3550,7 +3693,7 @@ export function MonitoringCenterPage() {
           renderMonitoringEmptyState()
         )}
         <PaginationControls
-          count={sortedAccountRows.length}
+          count={accountTotalCount}
           currentPage={accountPagination.currentPage}
           totalPages={accountPagination.totalPages}
           startItem={accountPagination.startItem}
@@ -3580,7 +3723,7 @@ export function MonitoringCenterPage() {
         className={styles.apiKeyPanel}
         extra={
           <div className={styles.inlineMetrics}>
-            <span>{t('monitoring.api_key_summary_keys_count', { count: apiKeyRows.length })}</span>
+            <span>{t('monitoring.api_key_summary_keys_count', { count: apiKeyTotalCount })}</span>
           </div>
         }
       >
@@ -3647,7 +3790,7 @@ export function MonitoringCenterPage() {
                   </Fragment>
                 );
               })}
-              {apiKeyRows.length === 0 ? (
+              {apiKeyTotalCount === 0 ? (
                 <tr>
                   <td colSpan={apiKeyOverviewColumns.length}>{renderMonitoringEmptyState()}</td>
                 </tr>
@@ -3656,7 +3799,7 @@ export function MonitoringCenterPage() {
           </table>
         </div>
         <PaginationControls
-          count={apiKeyRows.length}
+          count={apiKeyTotalCount}
           currentPage={apiKeyPagination.currentPage}
           totalPages={apiKeyPagination.totalPages}
           startItem={apiKeyPagination.startItem}
@@ -3675,7 +3818,7 @@ export function MonitoringCenterPage() {
         className={styles.realtimePanel}
         extra={
           <div className={`${styles.inlineMetrics} ${styles.realtimeHeaderActions}`}>
-            <span>{`${t('monitoring.log_rows')}: ${realtimeLogRows.length}`}</span>
+            <span>{`${t('monitoring.log_rows')}: ${realtimeTotalCount}`}</span>
             <span>{`${t('monitoring.recent_failures')}: ${scopedFailureCount}`}</span>
             <button
               type="button"
@@ -3789,7 +3932,7 @@ export function MonitoringCenterPage() {
                   </tr>
                 );
               })}
-              {realtimeLogRows.length === 0 ? (
+              {realtimeTotalCount === 0 ? (
                 <tr>
                   <td colSpan={10}>{renderMonitoringEmptyState()}</td>
                 </tr>
@@ -3798,7 +3941,7 @@ export function MonitoringCenterPage() {
           </table>
         </div>
         <PaginationControls
-          count={realtimeLogRows.length}
+          count={realtimeTotalCount}
           currentPage={realtimePagination.currentPage}
           totalPages={realtimePagination.totalPages}
           startItem={realtimePagination.startItem}
diff --git a/src/services/api/usageService.test.ts b/src/services/api/usageService.test.ts
new file mode 100644
index 000000000..40f9a6c80
--- /dev/null
+++ b/src/services/api/usageService.test.ts
@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import axios from 'axios';
+import { getUsageServiceErrorCode, usageServiceApi } from './usageService';
+
+vi.mock('axios', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+    isAxiosError: vi.fn(() => false),
+  },
+}));
+
+const mockedAxios = vi.mocked(axios);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockedAxios.isAxiosError.mockReturnValue(false);
+});
+
+describe('usageServiceApi usage pages', () => {
+  it('requests independent endpoints for each paginated monitoring section', async () => {
+    mockedAxios.get.mockResolvedValue({
+      data: { page: 2, page_size: 12, total_items: 24, usage: { apis: {} } },
+    });
+
+    await usageServiceApi.getUsagePage(
+      'https://manage.example',
+      'management-key',
+      'accounts',
+      { startMs: 1000, endMs: 2000, search: 'codex' },
+      { page: 2, pageSize: 12, sortKey: 'lastSeenAt', sortDirection: 'desc' }
+    );
+    await usageServiceApi.getUsagePage(
+      'https://manage.example',
+      'management-key',
+      'api-keys',
+      { startMs: 1000, endMs: 2000 },
+      { page: 1, pageSize: 20 }
+    );
+    await usageServiceApi.getUsagePage(
+      'https://manage.example',
+      'management-key',
+      'realtime',
+      { status: 'failed' },
+      { page: 3, pageSize: 50 }
+    );
+
+    expect(mockedAxios.get).toHaveBeenNthCalledWith(
+      1,
+      'https://manage.example/v0/management/usage/accounts?start_ms=1000&end_ms=2000&search=codex&page=2&page_size=12&sort_key=lastSeenAt&sort_direction=desc',
+      expect.objectContaining({
+        headers: { Authorization: 'Bearer management-key' },
+      })
+    );
+    expect(mockedAxios.get).toHaveBeenNthCalledWith(
+      2,
+      'https://manage.example/v0/management/usage/api-keys?start_ms=1000&end_ms=2000&page=1&page_size=20',
+      expect.any(Object)
+    );
+    expect(mockedAxios.get).toHaveBeenNthCalledWith(
+      3,
+      'https://manage.example/v0/management/usage/realtime?status=failed&page=3&page_size=50',
+      expect.any(Object)
+    );
+  });
+
+  it('falls back to legacy usage payload when summary is missing on old backends', async () => {
+    mockedAxios.isAxiosError.mockReturnValue(true);
+    mockedAxios.get
+      .mockRejectedValueOnce({ response: { status: 404, data: { error: 'not found' } } })
+      .mockResolvedValueOnce({ data: { total_requests: 2, apis: {} } });
+
+    const payload = await usageServiceApi.getUsage(
+      'https://manage.example',
+      'management-key',
+      { startMs: 1000, endMs: 2000, search: 'codex' }
+    );
+
+    expect(payload.total_requests).toBe(2);
+    expect(mockedAxios.get).toHaveBeenNthCalledWith(
+      1,
+      'https://manage.example/v0/management/usage/summary?start_ms=1000&end_ms=2000&search=codex',
+      expect.any(Object)
+    );
+    expect(mockedAxios.get).toHaveBeenNthCalledWith(
+      2,
+      'https://manage.example/v0/management/usage',
+      expect.objectContaining({
+        headers: { Authorization: 'Bearer management-key' },
+      })
+    );
+  });
+
+  it('preserves 404 status from missing paginated APIs so callers can use legacy fallback', async () => {
+    mockedAxios.isAxiosError.mockReturnValue(true);
+    mockedAxios.get.mockRejectedValueOnce({
+      response: { status: 404, data: { error: 'not found' } },
+    });
+
+    await expect(
+      usageServiceApi.getUsagePage(
+        'https://manage.example',
+        'management-key',
+        'accounts',
+        { startMs: 1000 },
+        { page: 1, pageSize: 12 }
+      )
+    ).rejects.toMatchObject({
+      status: 404,
+    });
+  });
+});
+
+describe('getUsageServiceErrorCode', () => {
+  it('maps old-backend method-not-allowed page responses for fallback detection', () => {
+    mockedAxios.isAxiosError.mockReturnValue(true);
+
+    expect(getUsageServiceErrorCode({ response: { status: 405 } })).toBe('method_not_allowed');
+  });
+});
diff --git a/src/services/api/usageService.ts b/src/services/api/usageService.ts
index e19cd5ef5..1d35dfd0c 100644
--- a/src/services/api/usageService.ts
+++ b/src/services/api/usageService.ts
@@ -31,6 +31,35 @@ export interface UsageServiceApiError extends Error {
   data?: unknown;
 }
 
+export interface UsageQuery {
+  startMs?: number;
+  endMs?: number;
+  account?: string;
+  provider?: string;
+  model?: string;
+  channel?: string;
+  apiKeyHash?: string;
+  status?: 'success' | 'failed';
+  search?: string;
+  searchApiKeyHash?: string;
+}
+
+export type UsagePageKind = 'accounts' | 'api-keys' | 'realtime' | 'models';
+
+export interface UsagePageQuery {
+  page: number;
+  pageSize: number;
+  sortKey?: string;
+  sortDirection?: 'asc' | 'desc';
+}
+
+export interface UsagePageResponse {
+  page: number;
+  page_size: number;
+  total_items: number;
+  usage: UsagePayload;
+}
+
 export interface UsageServiceInfo {
   service?: string;
   mode?: string;
@@ -270,6 +299,25 @@ const parseContentDispositionFilename = (value: string): string => {
   return plainMatch?.[1]?.trim() || '';
 };
 
+const appendUsageQueryParams = (params: URLSearchParams, query?: UsageQuery) => {
+  const startMs = query?.startMs;
+  const endMs = query?.endMs;
+  if (Number.isFinite(startMs)) {
+    params.set('start_ms', String(Math.trunc(startMs as number)));
+  }
+  if (Number.isFinite(endMs)) {
+    params.set('end_ms', String(Math.trunc(endMs as number)));
+  }
+  if (query?.account) params.set('account', query.account);
+  if (query?.provider) params.set('provider', query.provider);
+  if (query?.model) params.set('model', query.model);
+  if (query?.channel) params.set('channel', query.channel);
+  if (query?.apiKeyHash) params.set('api_key_hash', query.apiKeyHash);
+  if (query?.status) params.set('status', query.status);
+  if (query?.search) params.set('search', query.search);
+  if (query?.searchApiKeyHash) params.set('search_api_key_hash', query.searchApiKeyHash);
+};
+
 export const usageServiceApi = {
   getInfo: async (base: string): Promise<UsageServiceInfo> => {
     return withUsageServiceError(async () => {
@@ -332,16 +380,61 @@ export const usageServiceApi = {
     });
   },
 
-  getUsage: async (base: string, managementKey?: string): Promise<UsagePayload> => {
+  getUsage: async (
+    base: string,
+    managementKey?: string,
+    query?: UsageQuery
+  ): Promise<UsagePayload> => {
     return withUsageServiceError(async () => {
+      const headers = authHeaders(managementKey);
+      const params = new URLSearchParams();
+      appendUsageQueryParams(params, query);
+      const summaryPath = `/v0/management/usage/summary${params.size > 0 ? `?${params}` : ''}`;
+      try {
+        const response = await axios.get<UsagePayload>(buildUrl(base, summaryPath), {
+          timeout: USAGE_SERVICE_TIMEOUT_MS,
+          headers,
+        });
+        return response.data;
+      } catch (error) {
+        const status = axios.isAxiosError(error) ? error.response?.status : undefined;
+        if (status && status !== 404 && status !== 405) {
+          throw error;
+        }
+      }
       const response = await axios.get<UsagePayload>(buildUrl(base, '/v0/management/usage'), {
         timeout: USAGE_SERVICE_TIMEOUT_MS,
-        headers: authHeaders(managementKey),
+        headers,
       });
       return response.data;
     });
   },
 
+  getUsagePage: async (
+    base: string,
+    managementKey: string | undefined,
+    kind: UsagePageKind,
+    query: UsageQuery | undefined,
+    pageQuery: UsagePageQuery
+  ): Promise<UsagePageResponse> => {
+    return withUsageServiceError(async () => {
+      const params = new URLSearchParams();
+      appendUsageQueryParams(params, query);
+      params.set('page', String(Math.max(1, Math.trunc(pageQuery.page))));
+      params.set('page_size', String(Math.max(1, Math.trunc(pageQuery.pageSize))));
+      if (pageQuery.sortKey) params.set('sort_key', pageQuery.sortKey);
+      if (pageQuery.sortDirection) params.set('sort_direction', pageQuery.sortDirection);
+      const response = await axios.get<UsagePageResponse>(
+        buildUrl(base, `/v0/management/usage/${kind}?${params}`),
+        {
+          timeout: USAGE_SERVICE_TIMEOUT_MS,
+          headers: authHeaders(managementKey),
+        }
+      );
+      return response.data;
+    });
+  },
+
   getModelPrices: async (base: string, managementKey?: string): Promise<ModelPricesResponse> => {
     return withUsageServiceError(async () => {
       const response = await axios.get<ModelPricesResponse>(
diff --git a/src/utils/usage.ts b/src/utils/usage.ts
index 02b110973..bd839f1c8 100644
--- a/src/utils/usage.ts
+++ b/src/utils/usage.ts
@@ -41,6 +41,11 @@ export interface UsageDetail {
   latency_ms?: number;
   tokens: UsageTokens;
   failed: boolean;
+  request_count?: number;
+  success_count?: number;
+  failure_count?: number;
+  latency_sum_ms?: number;
+  latency_count?: number;
   __modelName?: string;
   __resolvedModel?: string;
   __timestampMs?: number;
@@ -289,6 +294,11 @@ export function collectUsageDetails(usageData: unknown): UsageDetail[] {
           latency_ms: latencyMs ?? undefined,
           tokens: readTokens(detailRaw),
           failed: detailRaw.failed === true,
+          request_count: toPositiveNumber(detailRaw.request_count ?? detailRaw.requestCount),
+          success_count: toPositiveNumber(detailRaw.success_count ?? detailRaw.successCount),
+          failure_count: toPositiveNumber(detailRaw.failure_count ?? detailRaw.failureCount),
+          latency_sum_ms: toPositiveNumber(detailRaw.latency_sum_ms ?? detailRaw.latencySumMs),
+          latency_count: toPositiveNumber(detailRaw.latency_count ?? detailRaw.latencyCount),
           __modelName: modelName,
           __resolvedModel: readDetailString(detailRaw.resolved_model ?? detailRaw.resolvedModel),
           __timestampMs: Number.isNaN(timestampMs) ? 0 : timestampMs,
@@ -359,6 +369,11 @@ export function collectUsageDetailsWithEndpoint(usageData: unknown): UsageDetail
           latency_ms: latencyMs ?? undefined,
           tokens: readTokens(detailRaw),
           failed: detailRaw.failed === true,
+          request_count: toPositiveNumber(detailRaw.request_count ?? detailRaw.requestCount),
+          success_count: toPositiveNumber(detailRaw.success_count ?? detailRaw.successCount),
+          failure_count: toPositiveNumber(detailRaw.failure_count ?? detailRaw.failureCount),
+          latency_sum_ms: toPositiveNumber(detailRaw.latency_sum_ms ?? detailRaw.latencySumMs),
+          latency_count: toPositiveNumber(detailRaw.latency_count ?? detailRaw.latencyCount),
           __modelName: modelName,
           __resolvedModel: readDetailString(detailRaw.resolved_model ?? detailRaw.resolvedModel),
           __endpoint: endpoint,
diff --git a/usage-service/internal/httpapi/server.go b/usage-service/internal/httpapi/server.go
index bb9886312..4634c0d89 100644
--- a/usage-service/internal/httpapi/server.go
+++ b/usage-service/internal/httpapi/server.go
@@ -889,6 +889,26 @@ func (s *Server) handleUsage(w http.ResponseWriter, r *http.Request) {
 			s.handleUsageExport(w, r)
 			return
 		}
+		if strings.HasSuffix(r.URL.Path, "/summary") {
+			s.handleUsageSummary(w, r)
+			return
+		}
+		if strings.HasSuffix(r.URL.Path, "/accounts") {
+			s.handleUsageBreakdownPage(w, r, store.UsageBreakdownAccounts)
+			return
+		}
+		if strings.HasSuffix(r.URL.Path, "/api-keys") {
+			s.handleUsageBreakdownPage(w, r, store.UsageBreakdownAPIKeys)
+			return
+		}
+		if strings.HasSuffix(r.URL.Path, "/realtime") {
+			s.handleUsageBreakdownPage(w, r, store.UsageBreakdownRealtime)
+			return
+		}
+		if strings.HasSuffix(r.URL.Path, "/models") {
+			s.handleUsageBreakdownPage(w, r, store.UsageBreakdownModels)
+			return
+		}
 		events, err := s.store.RecentEvents(r.Context(), s.cfg.QueryLimit)
 		if err != nil {
 			writeError(w, http.StatusInternalServerError, err)
@@ -906,6 +926,104 @@ func (s *Server) handleUsage(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func (s *Server) handleUsageSummary(w http.ResponseWriter, r *http.Request) {
+	filter, err := parseUsageSummaryFilter(r)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err)
+		return
+	}
+	summary, err := s.store.UsageSummary(r.Context(), filter)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, summary)
+}
+
+func (s *Server) handleUsageBreakdownPage(w http.ResponseWriter, r *http.Request, kind store.UsageBreakdownKind) {
+	filter, err := parseUsageSummaryFilter(r)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err)
+		return
+	}
+	pageFilter, err := parseUsagePageFilter(r)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err)
+		return
+	}
+	page, err := s.store.UsageBreakdownPage(r.Context(), kind, filter, pageFilter)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, page)
+}
+
+func parseUsageSummaryFilter(r *http.Request) (store.UsageSummaryFilter, error) {
+	query := r.URL.Query()
+	var filter store.UsageSummaryFilter
+	if raw := strings.TrimSpace(query.Get("start_ms")); raw != "" {
+		value, err := strconv.ParseInt(raw, 10, 64)
+		if err != nil {
+			return filter, fmt.Errorf("invalid start_ms")
+		}
+		filter.StartMS = &value
+	}
+	if raw := strings.TrimSpace(query.Get("end_ms")); raw != "" {
+		value, err := strconv.ParseInt(raw, 10, 64)
+		if err != nil {
+			return filter, fmt.Errorf("invalid end_ms")
+		}
+		filter.EndMS = &value
+	}
+	if filter.StartMS != nil && filter.EndMS != nil && *filter.StartMS > *filter.EndMS {
+		return filter, fmt.Errorf("start_ms must be less than or equal to end_ms")
+	}
+	filter.Account = strings.TrimSpace(query.Get("account"))
+	filter.Provider = strings.TrimSpace(query.Get("provider"))
+	filter.Model = strings.TrimSpace(query.Get("model"))
+	filter.Channel = strings.TrimSpace(query.Get("channel"))
+	filter.APIKeyHash = strings.TrimSpace(query.Get("api_key_hash"))
+	filter.Search = strings.TrimSpace(query.Get("search"))
+	filter.SearchAPIKeyHash = strings.TrimSpace(query.Get("search_api_key_hash"))
+	filter.Status = strings.TrimSpace(query.Get("status"))
+	if filter.Status != "" && filter.Status != "success" && filter.Status != "failed" {
+		return filter, fmt.Errorf("invalid status")
+	}
+	return filter, nil
+}
+
+func parseUsagePageFilter(r *http.Request) (store.UsagePageFilter, error) {
+	query := r.URL.Query()
+	var filter store.UsagePageFilter
+	if raw := strings.TrimSpace(query.Get("page")); raw != "" {
+		value, err := strconv.Atoi(raw)
+		if err != nil || value <= 0 {
+			return filter, fmt.Errorf("invalid page")
+		}
+		filter.Page = value
+	}
+	if raw := strings.TrimSpace(query.Get("page_size")); raw != "" {
+		value, err := strconv.Atoi(raw)
+		if err != nil || value <= 0 {
+			return filter, fmt.Errorf("invalid page_size")
+		}
+		if value > store.MaxUsagePageSize {
+			return filter, fmt.Errorf("page_size must be less than or equal to %d", store.MaxUsagePageSize)
+		}
+		filter.PageSize = value
+	}
+	filter.SortKey = strings.TrimSpace(query.Get("sort_key"))
+	if filter.SortKey != "" && !store.IsUsageSortKey(filter.SortKey) {
+		return filter, fmt.Errorf("invalid sort_key")
+	}
+	filter.SortDirection = strings.TrimSpace(query.Get("sort_direction"))
+	if filter.SortDirection != "" && filter.SortDirection != "asc" && filter.SortDirection != "desc" {
+		return filter, fmt.Errorf("invalid sort_direction")
+	}
+	return filter, nil
+}
+
 func (s *Server) handleUsageExport(w http.ResponseWriter, r *http.Request) {
 	data, err := s.store.ExportJSONL(r.Context())
 	if err != nil {
diff --git a/usage-service/internal/httpapi/server_test.go b/usage-service/internal/httpapi/server_test.go
index 4dfb9436f..eb1220d0a 100644
--- a/usage-service/internal/httpapi/server_test.go
+++ b/usage-service/internal/httpapi/server_test.go
@@ -205,6 +205,157 @@ func TestUsageImportAcceptsLegacyExportAndSkipsDuplicates(t *testing.T) {
 	}
 }
 
+func TestUsageSummaryReturnsAggregatesWithoutDetails(t *testing.T) {
+	handler := newTestHandler(t, "http://example.test", true)
+	payload := `{
+	  "version": 1,
+	  "exported_at": "2026-01-02T03:04:05Z",
+	  "usage": {
+	    "apis": {
+	      "POST /v1/chat/completions": {
+	        "models": {
+	          "gpt-4o": {
+	            "details": [
+	              {
+	                "timestamp": "2026-01-02T03:04:05Z",
+	                "source": "alice@example.com",
+	                "tokens": {"input_tokens": 10, "output_tokens": 20, "total_tokens": 30},
+	                "failed": false
+	              }
+	            ]
+	          }
+	        }
+	      }
+	    }
+	  }
+	}`
+	postUsageImport(t, handler, payload)
+
+	req := httptest.NewRequest(http.MethodGet, "/v0/management/usage/summary", nil)
+	req.Header.Set("Authorization", "Bearer management-key")
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+	if rr.Code != http.StatusOK {
+		t.Fatalf("summary status = %d, body = %s", rr.Code, rr.Body.String())
+	}
+
+	var response struct {
+		TotalRequests int64          `json:"total_requests"`
+		SuccessCount  int64          `json:"success_count"`
+		FailureCount  int64          `json:"failure_count"`
+		TotalTokens   int64          `json:"total_tokens"`
+		LatencySumMS  int64          `json:"latency_sum_ms"`
+		LatencyCount  int64          `json:"latency_count"`
+		APIs          map[string]any `json:"apis"`
+	}
+	if err := json.Unmarshal(rr.Body.Bytes(), &response); err != nil {
+		t.Fatalf("decode summary: %v", err)
+	}
+	if response.TotalRequests != 1 || response.SuccessCount != 1 || response.FailureCount != 0 || response.TotalTokens != 30 {
+		t.Fatalf("summary = %#v", response)
+	}
+	if response.LatencySumMS != 0 || response.LatencyCount != 0 {
+		t.Fatalf("summary latency = sum:%d count:%d", response.LatencySumMS, response.LatencyCount)
+	}
+	if len(response.APIs) != 0 {
+		t.Fatalf("summary APIs len = %d, want no detail aggregates", len(response.APIs))
+	}
+}
+
+func TestUsageBreakdownPageEndpointsReturnPagination(t *testing.T) {
+	handler := newTestHandler(t, "http://example.test", true)
+	payload := `{
+	  "version": 1,
+	  "exported_at": "2026-01-02T03:04:05Z",
+	  "usage": {
+	    "apis": {
+	      "POST /v1/chat/completions": {
+	        "models": {
+	          "gpt-4o": {
+	            "details": [
+	              {
+	                "timestamp": "2026-01-02T03:04:05Z",
+	                "source": "alice@example.com",
+	                "auth_index": "auth-1",
+	                "api_key_hash": "key-a",
+	                "account_snapshot": "alice@example.com",
+	                "tokens": {"input_tokens": 10, "output_tokens": 20, "total_tokens": 30},
+	                "failed": false
+	              },
+	              {
+	                "timestamp": "2026-01-02T03:04:06Z",
+	                "source": "bob@example.com",
+	                "auth_index": "auth-2",
+	                "api_key_hash": "key-b",
+	                "account_snapshot": "bob@example.com",
+	                "tokens": {"input_tokens": 15, "output_tokens": 25, "total_tokens": 40},
+	                "failed": false
+	              }
+	            ]
+	          }
+	        }
+	      }
+	    }
+	  }
+	}`
+	postUsageImport(t, handler, payload)
+
+	for _, path := range []string{
+		"/v0/management/usage/accounts?page=1&page_size=1",
+		"/v0/management/usage/api-keys?page=1&page_size=1",
+		"/v0/management/usage/realtime?page=1&page_size=1",
+		"/v0/management/usage/models?page=1&page_size=1",
+	} {
+		t.Run(path, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, path, nil)
+			req.Header.Set("Authorization", "Bearer management-key")
+			rr := httptest.NewRecorder()
+			handler.ServeHTTP(rr, req)
+			if rr.Code != http.StatusOK {
+				t.Fatalf("status = %d, body = %s", rr.Code, rr.Body.String())
+			}
+
+			var response struct {
+				Page       int             `json:"page"`
+				PageSize   int             `json:"page_size"`
+				TotalItems int64           `json:"total_items"`
+				Usage      json.RawMessage `json:"usage"`
+			}
+			if err := json.Unmarshal(rr.Body.Bytes(), &response); err != nil {
+				t.Fatalf("decode response: %v", err)
+			}
+			wantTotalItems := int64(2)
+			if strings.Contains(path, "/models") {
+				wantTotalItems = 1
+			}
+			if response.Page != 1 || response.PageSize != 1 || response.TotalItems != wantTotalItems {
+				t.Fatalf("pagination response = %#v", response)
+			}
+			if len(response.Usage) == 0 || string(response.Usage) == "null" {
+				t.Fatalf("missing usage payload: %#v", response)
+			}
+		})
+	}
+}
+
+func TestUsageBreakdownPageRejectsUnsafePageFilters(t *testing.T) {
+	handler := newTestHandler(t, "http://example.test", true)
+	for _, path := range []string{
+		"/v0/management/usage/accounts?page=1&page_size=501",
+		"/v0/management/usage/accounts?page=1&page_size=1&sort_key=timestamp_ms%20desc",
+	} {
+		t.Run(path, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, path, nil)
+			req.Header.Set("Authorization", "Bearer management-key")
+			rr := httptest.NewRecorder()
+			handler.ServeHTTP(rr, req)
+			if rr.Code != http.StatusBadRequest {
+				t.Fatalf("status = %d, body = %s", rr.Code, rr.Body.String())
+			}
+		})
+	}
+}
+
 func postUsageImport(t *testing.T, handler http.Handler, payload string) struct {
 	Format      string   `json:"format"`
 	Added       int      `json:"added"`
@@ -778,19 +929,19 @@ func closeFloat(left float64, right float64) bool {
 
 func TestSelectModelPricesMatchesByPriorityAndReportsUnmatched(t *testing.T) {
 	prices := map[string]store.ModelPrice{
-		"gpt-4o-2024-08-06":                   {Prompt: 2.5, Completion: 10},
-		"anthropic/claude-3.5-sonnet":         {Prompt: 3, Completion: 15},
+		"gpt-4o-2024-08-06":                      {Prompt: 2.5, Completion: 10},
+		"anthropic/claude-3.5-sonnet":            {Prompt: 3, Completion: 15},
 		"openrouter/anthropic/claude-3.5-sonnet": {Prompt: 3.1, Completion: 15.1},
-		"gemini/gemini-2.5-flash":             {Prompt: 0.075, Completion: 0.3},
-		"claude-sonnet-4-5-20250929":          {Prompt: 3.2, Completion: 16},
+		"gemini/gemini-2.5-flash":                {Prompt: 0.075, Completion: 0.3},
+		"claude-sonnet-4-5-20250929":             {Prompt: 3.2, Completion: 16},
 	}
 
 	models := []string{
-		"gpt-4o-2024-08-06",         // 精确
-		"GEMINI/Gemini-2.5-Flash",   // 大小写不敏感
-		"claude-3.5-sonnet",         // basename：应选最短 anthropic/* 而非 openrouter/*
-		"claude-sonnet-4-5",         // 剥离日期后缀
-		"unknown-model-xyz",         // unmatched
+		"gpt-4o-2024-08-06",       // 精确
+		"GEMINI/Gemini-2.5-Flash", // 大小写不敏感
+		"claude-3.5-sonnet",       // basename：应选最短 anthropic/* 而非 openrouter/*
+		"claude-sonnet-4-5",       // 剥离日期后缀
+		"unknown-model-xyz",       // unmatched
 	}
 
 	selected, unmatched := selectModelPrices(prices, models)
@@ -836,14 +987,14 @@ func TestSelectModelPricesEmptyModelsReturnsAll(t *testing.T) {
 
 func TestExtractProxyURLFromBodyAcceptsMultipleShapes(t *testing.T) {
 	cases := map[string]string{
-		`"http://proxy:8080"`:                  "http://proxy:8080",
-		`{"proxy-url":"http://a:1"}`:           "http://a:1",
-		`{"proxyUrl":"http://b:2"}`:            "http://b:2",
-		`{"proxy_url":"http://c:3"}`:           "http://c:3",
-		`{"value":"http://d:4"}`:               "http://d:4",
-		`{"unrelated":"x"}`:                    "",
-		`{"proxy-url":" http://e:5 "}`:         "http://e:5",
-		``:                                     "",
+		`"http://proxy:8080"`:          "http://proxy:8080",
+		`{"proxy-url":"http://a:1"}`:   "http://a:1",
+		`{"proxyUrl":"http://b:2"}`:    "http://b:2",
+		`{"proxy_url":"http://c:3"}`:   "http://c:3",
+		`{"value":"http://d:4"}`:       "http://d:4",
+		`{"unrelated":"x"}`:            "",
+		`{"proxy-url":" http://e:5 "}`: "http://e:5",
+		``:                             "",
 	}
 	for body, want := range cases {
 		if got := extractProxyURLFromBody([]byte(body)); got != want {
diff --git a/usage-service/internal/store/store.go b/usage-service/internal/store/store.go
index debf1f22a..95c0e000b 100644
--- a/usage-service/internal/store/store.go
+++ b/usage-service/internal/store/store.go
@@ -9,6 +9,7 @@ import (
 	"math"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"time"
 
@@ -187,6 +188,9 @@ func (s *Store) init() error {
 	if err := s.ensureUsageEventSnapshotColumns(); err != nil {
 		return err
 	}
+	if err := s.ensureUsageSearchIndex(); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -242,6 +246,116 @@ func (s *Store) ensureUsageEventSnapshotColumns() error {
 	return nil
 }
 
+func (s *Store) ensureUsageSearchIndex() error {
+	statements := []string{
+		`create virtual table if not exists usage_events_fts using fts5(
+			event_id unindexed,
+			account_snapshot,
+			auth_label_snapshot,
+			auth_file_snapshot,
+			auth_provider_snapshot,
+			auth_project_id_snapshot,
+			auth_index,
+			source,
+			api_key_hash,
+			provider,
+			model,
+			requested_model,
+			resolved_model,
+			endpoint,
+			method,
+			path,
+			tokenize='unicode61'
+		)`,
+		`create virtual table if not exists api_key_aliases_fts using fts5(
+			api_key_hash unindexed,
+			alias,
+			tokenize='unicode61'
+		)`,
+		`create trigger if not exists usage_events_fts_ai after insert on usage_events begin
+			insert into usage_events_fts (
+				event_id, account_snapshot, auth_label_snapshot, auth_file_snapshot,
+				auth_provider_snapshot, auth_project_id_snapshot, auth_index, source,
+				api_key_hash, provider, model, requested_model, resolved_model, endpoint,
+				method, path
+			) values (
+				new.id, new.account_snapshot, new.auth_label_snapshot, new.auth_file_snapshot,
+				new.auth_provider_snapshot, new.auth_project_id_snapshot, new.auth_index, new.source,
+				new.api_key_hash, new.provider, new.model, new.requested_model, new.resolved_model,
+				new.endpoint, new.method, new.path
+			);
+		end`,
+		`create trigger if not exists api_key_aliases_fts_ai after insert on api_key_aliases begin
+			insert into api_key_aliases_fts (api_key_hash, alias)
+			values (new.api_key_hash, new.alias);
+		end`,
+		`create trigger if not exists api_key_aliases_fts_au after update on api_key_aliases begin
+			delete from api_key_aliases_fts where api_key_hash = old.api_key_hash;
+			insert into api_key_aliases_fts (api_key_hash, alias)
+			values (new.api_key_hash, new.alias);
+		end`,
+		`create trigger if not exists api_key_aliases_fts_ad after delete on api_key_aliases begin
+			delete from api_key_aliases_fts where api_key_hash = old.api_key_hash;
+		end`,
+		`insert into api_key_aliases_fts (api_key_hash, alias)
+		select api_key_hash, alias from api_key_aliases
+		where not exists (
+			select 1 from api_key_aliases_fts where api_key_aliases_fts.api_key_hash = api_key_aliases.api_key_hash
+		)`,
+	}
+	for _, statement := range statements {
+		if _, err := s.db.Exec(statement); err != nil {
+			return err
+		}
+	}
+	return s.backfillUsageEventsFTS()
+}
+
+func (s *Store) backfillUsageEventsFTS() error {
+	var eventCount, ftsCount int64
+	if err := s.db.QueryRow(`select count(*) from usage_events`).Scan(&eventCount); err != nil {
+		return err
+	}
+	if err := s.db.QueryRow(`select count(*) from usage_events_fts`).Scan(&ftsCount); err != nil {
+		return err
+	}
+	if ftsCount >= eventCount {
+		return nil
+	}
+
+	statements := []string{
+		`create temporary table if not exists usage_events_fts_existing_ids (
+			event_id integer primary key
+		)`,
+		`delete from usage_events_fts_existing_ids`,
+		`insert or ignore into usage_events_fts_existing_ids (event_id)
+			select event_id from usage_events_fts`,
+		`insert into usage_events_fts (
+			event_id, account_snapshot, auth_label_snapshot, auth_file_snapshot,
+			auth_provider_snapshot, auth_project_id_snapshot, auth_index, source,
+			api_key_hash, provider, model, requested_model, resolved_model, endpoint,
+			method, path
+		)
+		select
+			usage_events.id, usage_events.account_snapshot, usage_events.auth_label_snapshot,
+			usage_events.auth_file_snapshot, usage_events.auth_provider_snapshot,
+			usage_events.auth_project_id_snapshot, usage_events.auth_index, usage_events.source,
+			usage_events.api_key_hash, usage_events.provider, usage_events.model,
+			usage_events.requested_model, usage_events.resolved_model, usage_events.endpoint,
+			usage_events.method, usage_events.path
+		from usage_events
+		left join usage_events_fts_existing_ids on usage_events_fts_existing_ids.event_id = usage_events.id
+		where usage_events_fts_existing_ids.event_id is null`,
+		`delete from usage_events_fts_existing_ids`,
+	}
+	for _, statement := range statements {
+		if _, err := s.db.Exec(statement); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (s *Store) SaveSetup(ctx context.Context, setup Setup) error {
 	if setup.CPAUpstreamURL == "" || setup.ManagementKey == "" {
 		return errors.New("cpaBaseUrl and managementKey are required")
@@ -755,10 +869,865 @@ func (s *Store) AddDeadLetter(ctx context.Context, payload string, parseErr erro
 	return err
 }
 
+type UsageSummaryFilter struct {
+	StartMS          *int64
+	EndMS            *int64
+	Account          string
+	Provider         string
+	Model            string
+	Channel          string
+	APIKeyHash       string
+	Status           string
+	Search           string
+	SearchAPIKeyHash string
+}
+
+type UsageBreakdownKind string
+
+const (
+	UsageBreakdownAccounts UsageBreakdownKind = "accounts"
+	UsageBreakdownAPIKeys  UsageBreakdownKind = "api-keys"
+	UsageBreakdownRealtime UsageBreakdownKind = "realtime"
+	UsageBreakdownModels   UsageBreakdownKind = "models"
+)
+
+const MaxUsagePageSize = 500
+
+const defaultUsageSortKey = "lastSeenAt"
+
+var usageSortKeys = map[string]struct{}{
+	"totalCalls":   {},
+	"successCalls": {},
+	"failureCalls": {},
+	"successRate":  {},
+	"totalTokens":  {},
+	"totalCost":    {},
+	"inputTokens":  {},
+	"outputTokens": {},
+	"cachedTokens": {},
+	"lastSeenAt":   {},
+}
+
+type UsagePageFilter struct {
+	Page          int
+	PageSize      int
+	SortKey       string
+	SortDirection string
+}
+
+type UsagePage struct {
+	Page       int           `json:"page"`
+	PageSize   int           `json:"page_size"`
+	TotalItems int64         `json:"total_items"`
+	Usage      usage.Payload `json:"usage"`
+}
+
+type usageBreakdownDetail struct {
+	Endpoint    string
+	Model       string
+	TimestampMS int64
+	Detail      usage.Detail
+}
+
+type usageBreakdownGroup struct {
+	Key             string
+	Details         []usageBreakdownDetail
+	TotalCalls      int64
+	SuccessCalls    int64
+	FailureCalls    int64
+	InputTokens     int64
+	OutputTokens    int64
+	CachedTokens    int64
+	TotalTokens     int64
+	LatestTimestamp int64
+}
+
+func (filter UsageSummaryFilter) whereClause() (string, []any) {
+	clauses := make([]string, 0, 10)
+	args := make([]any, 0, 16)
+	if filter.StartMS != nil {
+		clauses = append(clauses, "timestamp_ms >= ?")
+		args = append(args, *filter.StartMS)
+	}
+	if filter.EndMS != nil {
+		clauses = append(clauses, "timestamp_ms <= ?")
+		args = append(args, *filter.EndMS)
+	}
+	if filter.Model != "" {
+		clauses = append(clauses, "model = ?")
+		args = append(args, filter.Model)
+	}
+	if filter.APIKeyHash != "" {
+		clauses = append(clauses, "lower(coalesce(api_key_hash, '')) = ?")
+		args = append(args, strings.ToLower(filter.APIKeyHash))
+	}
+	if filter.Status == "success" {
+		clauses = append(clauses, "failed = 0")
+	}
+	if filter.Status == "failed" {
+		clauses = append(clauses, "failed != 0")
+	}
+	if filter.Account != "" {
+		value := strings.ToLower(filter.Account)
+		clauses = append(clauses, `(lower(coalesce(account_snapshot, '')) = ? or lower(coalesce(auth_label_snapshot, '')) = ? or lower(coalesce(source, '')) = ? or lower(coalesce(auth_index, '')) = ?)`)
+		args = append(args, value, value, value, value)
+	}
+	if filter.Provider != "" {
+		value := strings.ToLower(filter.Provider)
+		clauses = append(clauses, `(lower(coalesce(provider, '')) = ? or lower(coalesce(auth_provider_snapshot, '')) = ?)`)
+		args = append(args, value, value)
+	}
+	if filter.Channel != "" {
+		value := strings.ToLower(filter.Channel)
+		clauses = append(clauses, `(lower(coalesce(auth_provider_snapshot, '')) = ? or lower(coalesce(provider, '')) = ? or lower(coalesce(source, '')) = ?)`)
+		args = append(args, value, value, value)
+	}
+	searchClause, searchArgs := filter.searchClause()
+	if searchClause != "" {
+		clauses = append(clauses, searchClause)
+		args = append(args, searchArgs...)
+	}
+	if len(clauses) == 0 {
+		return "", args
+	}
+	return " where " + strings.Join(clauses, " and "), args
+}
+
+func (filter UsageSummaryFilter) searchClause() (string, []any) {
+	searchQuery := buildFTSQuery(filter.Search)
+	apiKeyHash := strings.ToLower(strings.TrimSpace(filter.SearchAPIKeyHash))
+	clauses := make([]string, 0, 3)
+	args := make([]any, 0, 3)
+	if searchQuery != "" {
+		clauses = append(clauses, `id in (
+			select event_id from usage_events_fts where usage_events_fts match ?
+		)`)
+		args = append(args, searchQuery)
+		clauses = append(clauses, `api_key_hash in (
+			select api_key_hash from api_key_aliases_fts where api_key_aliases_fts match ?
+		)`)
+		args = append(args, searchQuery)
+	}
+	if apiKeyHash != "" {
+		clauses = append(clauses, "lower(coalesce(api_key_hash, '')) = ?")
+		args = append(args, apiKeyHash)
+	}
+	if len(clauses) == 0 {
+		return "", nil
+	}
+	return "(" + strings.Join(clauses, " or ") + ")", args
+}
+
+func buildFTSQuery(search string) string {
+	terms := strings.Fields(search)
+	if len(terms) == 0 {
+		return ""
+	}
+	quoted := make([]string, 0, len(terms))
+	for _, term := range terms {
+		term = strings.TrimSpace(term)
+		if term == "" {
+			continue
+		}
+		quoted = append(quoted, `"`+strings.ReplaceAll(term, `"`, `""`)+`"`)
+	}
+	return strings.Join(quoted, " AND ")
+}
+
+func (s *Store) UsageSummary(ctx context.Context, filter UsageSummaryFilter) (usage.Payload, error) {
+	return s.usageSummary(ctx, filter, false)
+}
+
+func (s *Store) usageSummary(ctx context.Context, filter UsageSummaryFilter, includeDetails bool) (usage.Payload, error) {
+	summary := usage.Payload{APIs: map[string]*usage.APIAggregate{}}
+	whereClause, args := filter.whereClause()
+	err := s.db.QueryRowContext(ctx, `select
+		count(*),
+		coalesce(sum(case when failed = 0 then 1 else 0 end), 0),
+		coalesce(sum(case when failed != 0 then 1 else 0 end), 0),
+		coalesce(sum(input_tokens), 0),
+		coalesce(sum(output_tokens), 0),
+		coalesce(sum(reasoning_tokens), 0),
+		coalesce(sum(cached_tokens), 0),
+		coalesce(sum(cache_tokens), 0),
+		coalesce(sum(total_tokens), 0),
+		coalesce(sum(latency_ms), 0),
+		count(latency_ms)
+		from usage_events`+whereClause, args...).Scan(
+		&summary.TotalRequests,
+		&summary.SuccessCount,
+		&summary.FailureCount,
+		&summary.Tokens.InputTokens,
+		&summary.Tokens.OutputTokens,
+		&summary.Tokens.ReasoningTokens,
+		&summary.Tokens.CachedTokens,
+		&summary.Tokens.CacheTokens,
+		&summary.TotalTokens,
+		&summary.LatencySumMS,
+		&summary.LatencyCount,
+	)
+	if err != nil {
+		return usage.Payload{}, err
+	}
+	summary.Tokens.TotalTokens = summary.TotalTokens
+	if summary.LatencyCount > 0 {
+		averageLatency := summary.LatencySumMS / summary.LatencyCount
+		summary.LatencyMS = &averageLatency
+	}
+	if !includeDetails {
+		facets, err := s.usageFacets(ctx, whereClause, args)
+		if err != nil {
+			return usage.Payload{}, err
+		}
+		summary.Facets = facets
+		return summary, nil
+	}
+
+	rows, err := s.db.QueryContext(ctx, `select
+		coalesce(nullif(endpoint, ''), '-'),
+		coalesce(nullif(model, ''), '-'),
+		coalesce(source, ''),
+		coalesce(auth_index, ''),
+		coalesce(api_key_hash, ''),
+		coalesce(account_snapshot, ''),
+		coalesce(auth_label_snapshot, ''),
+		coalesce(auth_file_snapshot, ''),
+		coalesce(auth_provider_snapshot, ''),
+		coalesce(auth_project_id_snapshot, ''),
+		coalesce(resolved_model, ''),
+		failed,
+		max(timestamp_ms),
+		coalesce(max(auth_snapshot_at_ms), 0),
+		count(*),
+		coalesce(sum(case when failed = 0 then 1 else 0 end), 0),
+		coalesce(sum(case when failed != 0 then 1 else 0 end), 0),
+		coalesce(sum(input_tokens), 0),
+		coalesce(sum(output_tokens), 0),
+		coalesce(sum(reasoning_tokens), 0),
+		coalesce(sum(cached_tokens), 0),
+		coalesce(sum(cache_tokens), 0),
+		coalesce(sum(total_tokens), 0),
+		coalesce(sum(latency_ms), 0),
+		count(latency_ms)
+		from usage_events`+whereClause+`
+		group by coalesce(nullif(endpoint, ''), '-'), coalesce(nullif(model, ''), '-'),
+			coalesce(source, ''), coalesce(auth_index, ''), coalesce(api_key_hash, ''),
+			coalesce(account_snapshot, ''), coalesce(auth_label_snapshot, ''),
+			coalesce(auth_file_snapshot, ''), coalesce(auth_provider_snapshot, ''),
+			coalesce(auth_project_id_snapshot, ''), coalesce(resolved_model, ''), failed
+		order by max(timestamp_ms) desc`, args...)
+	if err != nil {
+		return usage.Payload{}, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var endpoint, model, source, authIndex, apiKeyHash, accountSnapshot, authLabelSnapshot, authFileSnapshot, authProviderSnapshot, authProjectIDSnapshot, resolvedModel string
+		var failed int
+		var latestTimestampMS, authSnapshotAtMS int64
+		var latencySumMS, latencyCount int64
+		detail := usage.Detail{}
+		if err := rows.Scan(
+			&endpoint,
+			&model,
+			&source,
+			&authIndex,
+			&apiKeyHash,
+			&accountSnapshot,
+			&authLabelSnapshot,
+			&authFileSnapshot,
+			&authProviderSnapshot,
+			&authProjectIDSnapshot,
+			&resolvedModel,
+			&failed,
+			&latestTimestampMS,
+			&authSnapshotAtMS,
+			&detail.RequestCount,
+			&detail.SuccessCount,
+			&detail.FailureCount,
+			&detail.Tokens.InputTokens,
+			&detail.Tokens.OutputTokens,
+			&detail.Tokens.ReasoningTokens,
+			&detail.Tokens.CachedTokens,
+			&detail.Tokens.CacheTokens,
+			&detail.Tokens.TotalTokens,
+			&latencySumMS,
+			&latencyCount,
+		); err != nil {
+			return usage.Payload{}, err
+		}
+		detail.Timestamp = time.UnixMilli(latestTimestampMS).UTC().Format(time.RFC3339Nano)
+		detail.Source = source
+		detail.AuthIndex = authIndex
+		detail.APIKeyHash = apiKeyHash
+		detail.AccountSnapshot = accountSnapshot
+		detail.AuthLabelSnapshot = authLabelSnapshot
+		detail.AuthFileSnapshot = authFileSnapshot
+		detail.AuthProviderSnapshot = authProviderSnapshot
+		detail.AuthProjectIDSnapshot = authProjectIDSnapshot
+		detail.AuthSnapshotAtMS = authSnapshotAtMS
+		detail.ResolvedModel = resolvedModel
+		detail.Failed = failed != 0
+		detail.LatencySumMS = latencySumMS
+		detail.LatencyCount = latencyCount
+		if latencyCount > 0 {
+			averageLatency := latencySumMS / latencyCount
+			detail.LatencyMS = &averageLatency
+		}
+		apiSummary := summary.APIs[endpoint]
+		if apiSummary == nil {
+			apiSummary = &usage.APIAggregate{Models: map[string]*usage.ModelAggregate{}}
+			summary.APIs[endpoint] = apiSummary
+		}
+		modelSummary := apiSummary.Models[model]
+		if modelSummary == nil {
+			modelSummary = &usage.ModelAggregate{}
+			apiSummary.Models[model] = modelSummary
+		}
+		modelSummary.Details = append(modelSummary.Details, detail)
+	}
+	if err := rows.Err(); err != nil {
+		return usage.Payload{}, err
+	}
+	return summary, nil
+}
+
+func (s *Store) usageFacets(ctx context.Context, whereClause string, args []any) (usage.Facets, error) {
+	providers, err := s.usageStringFacet(ctx, `coalesce(nullif(auth_provider_snapshot, ''), nullif(provider, ''))`, whereClause, args)
+	if err != nil {
+		return usage.Facets{}, err
+	}
+	models, err := s.usageStringFacet(ctx, `coalesce(nullif(resolved_model, ''), nullif(model, ''))`, whereClause, args)
+	if err != nil {
+		return usage.Facets{}, err
+	}
+	channels, err := s.usageStringFacet(ctx, `coalesce(nullif(auth_provider_snapshot, ''), nullif(provider, ''), nullif(source, ''))`, whereClause, args)
+	if err != nil {
+		return usage.Facets{}, err
+	}
+	accounts, err := s.usageAccountFacet(ctx, whereClause, args)
+	if err != nil {
+		return usage.Facets{}, err
+	}
+	apiKeys, err := s.usageAPIKeyFacet(ctx, whereClause, args)
+	if err != nil {
+		return usage.Facets{}, err
+	}
+	return usage.Facets{
+		Providers: providers,
+		Accounts:  accounts,
+		Models:    models,
+		Channels:  channels,
+		APIKeys:   apiKeys,
+	}, nil
+}
+
+func (s *Store) usageStringFacet(ctx context.Context, expression string, whereClause string, args []any) ([]string, error) {
+	rows, err := s.db.QueryContext(ctx, `select value from (
+			select distinct `+expression+` as value from usage_events`+whereClause+`
+		)
+		where value is not null and trim(value) != ''
+		order by lower(value)`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	values := []string{}
+	for rows.Next() {
+		var value string
+		if err := rows.Scan(&value); err != nil {
+			return nil, err
+		}
+		values = append(values, value)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return values, nil
+}
+
+func (s *Store) usageAccountFacet(ctx context.Context, whereClause string, args []any) ([]usage.FacetOption, error) {
+	rows, err := s.db.QueryContext(ctx, `select
+		value,
+		coalesce(nullif(account_snapshot, ''), nullif(auth_label_snapshot, ''), value) as label
+		from (
+			select distinct
+				coalesce(nullif(account_snapshot, ''), nullif(auth_label_snapshot, ''), nullif(source, ''), nullif(auth_index, '')) as value,
+				account_snapshot,
+				auth_label_snapshot
+			from usage_events`+whereClause+`
+		)
+		where value is not null and trim(value) != ''
+		order by lower(label), lower(value)`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	options := []usage.FacetOption{}
+	seen := map[string]struct{}{}
+	for rows.Next() {
+		var option usage.FacetOption
+		if err := rows.Scan(&option.Value, &option.Label); err != nil {
+			return nil, err
+		}
+		key := strings.ToLower(option.Value)
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		options = append(options, option)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return options, nil
+}
+
+func (s *Store) usageAPIKeyFacet(ctx context.Context, whereClause string, args []any) ([]usage.FacetOption, error) {
+	rows, err := s.db.QueryContext(ctx, `select
+		keys.api_key_hash,
+		coalesce(nullif(api_key_aliases.alias, ''), keys.api_key_hash) as label
+		from (
+			select distinct lower(api_key_hash) as api_key_hash
+			from usage_events`+whereClause+`
+		) keys
+		left join api_key_aliases on lower(api_key_aliases.api_key_hash) = keys.api_key_hash
+		where keys.api_key_hash is not null and trim(keys.api_key_hash) != ''
+		order by lower(label), keys.api_key_hash`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	options := []usage.FacetOption{}
+	for rows.Next() {
+		var option usage.FacetOption
+		if err := rows.Scan(&option.Value, &option.Label); err != nil {
+			return nil, err
+		}
+		options = append(options, option)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return options, nil
+}
+
+func (s *Store) UsageBreakdownPage(ctx context.Context, kind UsageBreakdownKind, filter UsageSummaryFilter, pageFilter UsagePageFilter) (UsagePage, error) {
+	page, pageSize := normalizeUsagePageFilter(pageFilter)
+	switch kind {
+	case UsageBreakdownRealtime:
+		return s.usageRealtimePage(ctx, filter, page, pageSize)
+	case UsageBreakdownModels:
+		return s.usageModelPage(ctx, filter, page, pageSize)
+	}
+
+	summary, err := s.usageSummary(ctx, filter, true)
+	if err != nil {
+		return UsagePage{}, err
+	}
+
+	details := flattenUsagePayload(summary)
+	switch kind {
+	case UsageBreakdownAccounts:
+		return buildGroupedUsagePage(details, page, pageSize, pageFilter, accountBreakdownKey), nil
+	case UsageBreakdownAPIKeys:
+		return buildGroupedUsagePage(details, page, pageSize, pageFilter, apiKeyBreakdownKey), nil
+	default:
+		return UsagePage{}, fmt.Errorf("unknown usage breakdown kind %q", kind)
+	}
+}
+
+func (s *Store) usageModelPage(ctx context.Context, filter UsageSummaryFilter, page int, pageSize int) (UsagePage, error) {
+	whereClause, args := filter.whereClause()
+	var totalItems int64
+	if err := s.db.QueryRowContext(ctx, `select count(*) from (
+		select 1 from usage_events`+whereClause+`
+		group by coalesce(nullif(endpoint, ''), '-'), coalesce(nullif(model, ''), '-'),
+			coalesce(resolved_model, ''), failed
+	)`, args...).Scan(&totalItems); err != nil {
+		return UsagePage{}, err
+	}
+	rows, err := s.db.QueryContext(ctx, `select
+		coalesce(nullif(endpoint, ''), '-'),
+		coalesce(nullif(model, ''), '-'),
+		coalesce(resolved_model, ''),
+		failed,
+		max(timestamp_ms),
+		count(*),
+		coalesce(sum(case when failed = 0 then 1 else 0 end), 0),
+		coalesce(sum(case when failed != 0 then 1 else 0 end), 0),
+		coalesce(sum(input_tokens), 0),
+		coalesce(sum(output_tokens), 0),
+		coalesce(sum(reasoning_tokens), 0),
+		coalesce(sum(cached_tokens), 0),
+		coalesce(sum(cache_tokens), 0),
+		coalesce(sum(total_tokens), 0),
+		coalesce(sum(latency_ms), 0),
+		count(latency_ms)
+		from usage_events`+whereClause+`
+		group by coalesce(nullif(endpoint, ''), '-'), coalesce(nullif(model, ''), '-'),
+			coalesce(resolved_model, ''), failed
+		order by max(timestamp_ms) desc
+		limit ? offset ?`, append(args, pageSize, (page-1)*pageSize)...)
+	if err != nil {
+		return UsagePage{}, err
+	}
+	defer rows.Close()
+
+	details := make([]usageBreakdownDetail, 0)
+	for rows.Next() {
+		var endpoint, model, resolvedModel string
+		var failed int
+		var latestTimestampMS int64
+		var latencySumMS, latencyCount int64
+		detail := usage.Detail{}
+		if err := rows.Scan(
+			&endpoint,
+			&model,
+			&resolvedModel,
+			&failed,
+			&latestTimestampMS,
+			&detail.RequestCount,
+			&detail.SuccessCount,
+			&detail.FailureCount,
+			&detail.Tokens.InputTokens,
+			&detail.Tokens.OutputTokens,
+			&detail.Tokens.ReasoningTokens,
+			&detail.Tokens.CachedTokens,
+			&detail.Tokens.CacheTokens,
+			&detail.Tokens.TotalTokens,
+			&latencySumMS,
+			&latencyCount,
+		); err != nil {
+			return UsagePage{}, err
+		}
+		detail.Timestamp = time.UnixMilli(latestTimestampMS).UTC().Format(time.RFC3339Nano)
+		detail.ResolvedModel = resolvedModel
+		detail.Failed = failed != 0
+		detail.LatencySumMS = latencySumMS
+		detail.LatencyCount = latencyCount
+		if latencyCount > 0 {
+			averageLatency := latencySumMS / latencyCount
+			detail.LatencyMS = &averageLatency
+		}
+		details = append(details, usageBreakdownDetail{
+			Endpoint:    endpoint,
+			Model:       model,
+			TimestampMS: latestTimestampMS,
+			Detail:      detail,
+		})
+	}
+	if err := rows.Err(); err != nil {
+		return UsagePage{}, err
+	}
+	return UsagePage{
+		Page:       page,
+		PageSize:   pageSize,
+		TotalItems: totalItems,
+		Usage:      payloadFromBreakdownDetails(details),
+	}, nil
+}
+
+func (s *Store) usageRealtimePage(ctx context.Context, filter UsageSummaryFilter, page int, pageSize int) (UsagePage, error) {
+	whereClause, args := filter.whereClause()
+	var totalItems int64
+	if err := s.db.QueryRowContext(ctx, `select count(*) from usage_events`+whereClause, args...).Scan(&totalItems); err != nil {
+		return UsagePage{}, err
+	}
+	events, err := s.queryEvents(ctx, whereClause, args, pageSize, (page-1)*pageSize)
+	if err != nil {
+		return UsagePage{}, err
+	}
+	return UsagePage{
+		Page:       page,
+		PageSize:   pageSize,
+		TotalItems: totalItems,
+		Usage:      usage.BuildPayload(events),
+	}, nil
+}
+
+func normalizeUsagePageFilter(filter UsagePageFilter) (int, int) {
+	page := filter.Page
+	if page <= 0 {
+		page = 1
+	}
+	pageSize := filter.PageSize
+	if pageSize <= 0 {
+		pageSize = 20
+	}
+	if pageSize > MaxUsagePageSize {
+		pageSize = MaxUsagePageSize
+	}
+	return page, pageSize
+}
+
+func IsUsageSortKey(sortKey string) bool {
+	_, ok := usageSortKeys[strings.TrimSpace(sortKey)]
+	return ok
+}
+
+func flattenUsagePayload(payload usage.Payload) []usageBreakdownDetail {
+	details := make([]usageBreakdownDetail, 0)
+	for endpoint, api := range payload.APIs {
+		if api == nil {
+			continue
+		}
+		for model, aggregate := range api.Models {
+			if aggregate == nil {
+				continue
+			}
+			for _, detail := range aggregate.Details {
+				details = append(details, usageBreakdownDetail{
+					Endpoint:    endpoint,
+					Model:       model,
+					TimestampMS: usageDetailTimestampMS(detail),
+					Detail:      detail,
+				})
+			}
+		}
+	}
+	return details
+}
+
+func usageDetailTimestampMS(detail usage.Detail) int64 {
+	if detail.Timestamp == "" {
+		return 0
+	}
+	parsed, err := time.Parse(time.RFC3339Nano, detail.Timestamp)
+	if err != nil {
+		return 0
+	}
+	return parsed.UnixMilli()
+}
+
+func buildGroupedUsagePage(details []usageBreakdownDetail, page int, pageSize int, pageFilter UsagePageFilter, keyFunc func(usage.Detail) string) UsagePage {
+	groupMap := make(map[string]*usageBreakdownGroup)
+	for _, item := range details {
+		key := keyFunc(item.Detail)
+		group := groupMap[key]
+		if group == nil {
+			group = &usageBreakdownGroup{Key: key}
+			groupMap[key] = group
+		}
+		group.Details = append(group.Details, item)
+		group.TotalCalls += item.Detail.RequestCount
+		group.SuccessCalls += item.Detail.SuccessCount
+		group.FailureCalls += item.Detail.FailureCount
+		group.InputTokens += item.Detail.Tokens.InputTokens
+		group.OutputTokens += item.Detail.Tokens.OutputTokens
+		group.CachedTokens += maxInt64(item.Detail.Tokens.CachedTokens, item.Detail.Tokens.CacheTokens)
+		group.TotalTokens += item.Detail.Tokens.TotalTokens
+		if item.TimestampMS > group.LatestTimestamp {
+			group.LatestTimestamp = item.TimestampMS
+		}
+	}
+
+	groups := make([]*usageBreakdownGroup, 0, len(groupMap))
+	for _, group := range groupMap {
+		sortBreakdownDetails(group.Details)
+		groups = append(groups, group)
+	}
+	sortBreakdownGroups(groups, pageFilter)
+
+	start, end := pageBounds(len(groups), page, pageSize)
+	pageDetails := make([]usageBreakdownDetail, 0)
+	for _, group := range groups[start:end] {
+		pageDetails = append(pageDetails, group.Details...)
+	}
+
+	return UsagePage{
+		Page:       page,
+		PageSize:   pageSize,
+		TotalItems: int64(len(groups)),
+		Usage:      payloadFromBreakdownDetails(pageDetails),
+	}
+}
+
+func accountBreakdownKey(detail usage.Detail) string {
+	return firstNonEmpty(detail.AccountSnapshot, detail.AuthLabelSnapshot, detail.Source, detail.AuthIndex, "-")
+}
+
+func apiKeyBreakdownKey(detail usage.Detail) string {
+	if detail.APIKeyHash != "" {
+		return strings.ToLower(detail.APIKeyHash)
+	}
+	return "unknown:" + strings.Join([]string{detail.Source, detail.AuthIndex, detail.AuthProviderSnapshot}, ":")
+}
+
+func sortBreakdownDetails(details []usageBreakdownDetail) {
+	sort.SliceStable(details, func(i, j int) bool {
+		if details[i].TimestampMS != details[j].TimestampMS {
+			return details[i].TimestampMS > details[j].TimestampMS
+		}
+		if details[i].Endpoint != details[j].Endpoint {
+			return details[i].Endpoint < details[j].Endpoint
+		}
+		return details[i].Model < details[j].Model
+	})
+}
+
+func sortBreakdownGroups(groups []*usageBreakdownGroup, filter UsagePageFilter) {
+	direction := strings.ToLower(strings.TrimSpace(filter.SortDirection))
+	ascending := direction == "asc"
+	sortKey := normalizeUsageSortKey(filter.SortKey)
+
+	sort.SliceStable(groups, func(i, j int) bool {
+		left := groups[i]
+		right := groups[j]
+		compare := compareBreakdownGroup(left, right, sortKey)
+		if compare == 0 {
+			compare = compareBreakdownGroup(left, right, defaultUsageSortKey)
+		}
+		if compare == 0 {
+			compare = strings.Compare(left.Key, right.Key)
+		}
+		if ascending {
+			return compare < 0
+		}
+		return compare > 0
+	})
+}
+
+func normalizeUsageSortKey(sortKey string) string {
+	sortKey = strings.TrimSpace(sortKey)
+	if IsUsageSortKey(sortKey) {
+		return sortKey
+	}
+	return defaultUsageSortKey
+}
+
+func compareBreakdownGroup(left *usageBreakdownGroup, right *usageBreakdownGroup, sortKey string) int {
+	switch sortKey {
+	case "totalCalls":
+		return compareInt64(left.TotalCalls, right.TotalCalls)
+	case "successCalls":
+		return compareInt64(left.SuccessCalls, right.SuccessCalls)
+	case "failureCalls":
+		return compareInt64(left.FailureCalls, right.FailureCalls)
+	case "successRate":
+		return compareFloat64(successRate(left), successRate(right))
+	case "totalTokens", "totalCost":
+		return compareInt64(left.TotalTokens, right.TotalTokens)
+	case "inputTokens":
+		return compareInt64(left.InputTokens, right.InputTokens)
+	case "outputTokens":
+		return compareInt64(left.OutputTokens, right.OutputTokens)
+	case "cachedTokens":
+		return compareInt64(left.CachedTokens, right.CachedTokens)
+	case "lastSeenAt":
+		return compareInt64(left.LatestTimestamp, right.LatestTimestamp)
+	default:
+		return compareInt64(left.LatestTimestamp, right.LatestTimestamp)
+	}
+}
+
+func successRate(group *usageBreakdownGroup) float64 {
+	if group.TotalCalls <= 0 {
+		return 1
+	}
+	return float64(group.SuccessCalls) / float64(group.TotalCalls)
+}
+
+func compareInt64(left int64, right int64) int {
+	if left < right {
+		return -1
+	}
+	if left > right {
+		return 1
+	}
+	return 0
+}
+
+func compareFloat64(left float64, right float64) int {
+	if left < right {
+		return -1
+	}
+	if left > right {
+		return 1
+	}
+	return 0
+}
+
+func maxInt64(left int64, right int64) int64 {
+	if left > right {
+		return left
+	}
+	return right
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func sliceBreakdownDetails(details []usageBreakdownDetail, page int, pageSize int) []usageBreakdownDetail {
+	start, end := pageBounds(len(details), page, pageSize)
+	return details[start:end]
+}
+
+func pageBounds(length int, page int, pageSize int) (int, int) {
+	start := (page - 1) * pageSize
+	if start > length {
+		start = length
+	}
+	end := start + pageSize
+	if end > length {
+		end = length
+	}
+	return start, end
+}
+
+func payloadFromBreakdownDetails(details []usageBreakdownDetail) usage.Payload {
+	payload := usage.Payload{APIs: map[string]*usage.APIAggregate{}}
+	for _, item := range details {
+		detail := item.Detail
+		payload.TotalRequests += detail.RequestCount
+		payload.SuccessCount += detail.SuccessCount
+		payload.FailureCount += detail.FailureCount
+		payload.Tokens.InputTokens += detail.Tokens.InputTokens
+		payload.Tokens.OutputTokens += detail.Tokens.OutputTokens
+		payload.Tokens.ReasoningTokens += detail.Tokens.ReasoningTokens
+		payload.Tokens.CachedTokens += detail.Tokens.CachedTokens
+		payload.Tokens.CacheTokens += detail.Tokens.CacheTokens
+		payload.Tokens.TotalTokens += detail.Tokens.TotalTokens
+		payload.TotalTokens += detail.Tokens.TotalTokens
+		payload.LatencySumMS += detail.LatencySumMS
+		payload.LatencyCount += detail.LatencyCount
+
+		apiSummary := payload.APIs[item.Endpoint]
+		if apiSummary == nil {
+			apiSummary = &usage.APIAggregate{Models: map[string]*usage.ModelAggregate{}}
+			payload.APIs[item.Endpoint] = apiSummary
+		}
+		modelSummary := apiSummary.Models[item.Model]
+		if modelSummary == nil {
+			modelSummary = &usage.ModelAggregate{}
+			apiSummary.Models[item.Model] = modelSummary
+		}
+		modelSummary.Details = append(modelSummary.Details, detail)
+	}
+	if payload.LatencyCount > 0 {
+		averageLatency := payload.LatencySumMS / payload.LatencyCount
+		payload.LatencyMS = &averageLatency
+	}
+	return payload
+}
+
 func (s *Store) RecentEvents(ctx context.Context, limit int) ([]usage.Event, error) {
 	if limit <= 0 {
 		limit = 50000
 	}
+	return s.queryEvents(ctx, "", nil, limit, 0)
+}
+
+func (s *Store) queryEvents(ctx context.Context, whereClause string, args []any, limit int, offset int) ([]usage.Event, error) {
 	rows, err := s.db.QueryContext(ctx, `select
 		request_id, event_hash, timestamp_ms, timestamp, provider, model, endpoint, method, path,
 		auth_type, auth_index, source, source_hash, api_key_hash,
@@ -766,9 +1735,9 @@ func (s *Store) RecentEvents(ctx context.Context, limit int) ([]usage.Event, err
 		requested_model, resolved_model,
 		input_tokens, output_tokens, reasoning_tokens, cached_tokens, cache_tokens, total_tokens,
 		latency_ms, failed, raw_json, created_at_ms
-		from usage_events
+		from usage_events`+whereClause+`
 		order by timestamp_ms desc, id desc
-		limit ?`, limit)
+		limit ? offset ?`, append(args, limit, offset)...)
 	if err != nil {
 		return nil, err
 	}
diff --git a/usage-service/internal/store/store_test.go b/usage-service/internal/store/store_test.go
index ba135cbb0..7b7a4e05b 100644
--- a/usage-service/internal/store/store_test.go
+++ b/usage-service/internal/store/store_test.go
@@ -3,11 +3,16 @@ package store
 import (
 	"context"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/seakee/cpa-manager/usage-service/internal/usage"
 )
 
+func ptrInt64(value int64) *int64 {
+	return &value
+}
+
 func TestStorePersistsAccountSnapshot(t *testing.T) {
 	db, err := Open(filepath.Join(t.TempDir(), "usage.sqlite"))
 	if err != nil {
@@ -124,6 +129,420 @@ func TestStorePersistsRequestedAndResolvedModels(t *testing.T) {
 	}
 }
 
+func TestStoreUsageSummaryAggregatesEventsWithoutDetails(t *testing.T) {
+	db, err := Open(filepath.Join(t.TempDir(), "usage.sqlite"))
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = db.Close()
+	})
+
+	hashA := strings.Repeat("a", 64)
+	hashB := strings.Repeat("b", 64)
+	_, err = db.InsertEvents(context.Background(), []usage.Event{
+		{
+			EventHash:            "summary-success",
+			TimestampMS:          1_778_000_003_000,
+			Timestamp:            "2026-05-06T00:00:03Z",
+			Model:                "gpt-test",
+			Endpoint:             "POST /v1/chat/completions",
+			AuthIndex:            "auth-1",
+			APIKeyHash:           hashA,
+			AccountSnapshot:      "alice@example.com",
+			AuthProviderSnapshot: "codex",
+			InputTokens:          10,
+			OutputTokens:         20,
+			TotalTokens:          30,
+			LatencyMS:            ptrInt64(123),
+			RawJSON:              `{"large":"detail"}`,
+			CreatedAtMS:          1_778_000_003_100,
+		},
+		{
+			EventHash:            "summary-failure",
+			TimestampMS:          1_778_000_004_000,
+			Timestamp:            "2026-05-06T00:00:04Z",
+			Model:                "gpt-test",
+			Endpoint:             "POST /v1/chat/completions",
+			AuthIndex:            "auth-2",
+			APIKeyHash:           hashB,
+			AccountSnapshot:      "bob@example.com",
+			AuthProviderSnapshot: "gemini",
+			InputTokens:          5,
+			ReasoningTokens:      7,
+			TotalTokens:          12,
+			Failed:               true,
+			CreatedAtMS:          1_778_000_004_100,
+		},
+	})
+	if err != nil {
+		t.Fatalf("insert events: %v", err)
+	}
+	if err := db.UpsertAPIKeyAliases(context.Background(), []APIKeyAlias{
+		{APIKeyHash: hashA, Alias: "Team Alpha"},
+	}, nil); err != nil {
+		t.Fatalf("upsert api key alias: %v", err)
+	}
+
+	summary, err := db.UsageSummary(context.Background(), UsageSummaryFilter{})
+	if err != nil {
+		t.Fatalf("usage summary: %v", err)
+	}
+	if summary.TotalRequests != 2 || summary.SuccessCount != 1 || summary.FailureCount != 1 || summary.TotalTokens != 42 {
+		t.Fatalf("summary totals = %#v", summary)
+	}
+	if summary.Tokens.InputTokens != 15 || summary.Tokens.OutputTokens != 20 || summary.Tokens.ReasoningTokens != 7 || summary.Tokens.TotalTokens != 42 {
+		t.Fatalf("summary token totals = %#v", summary.Tokens)
+	}
+	if summary.LatencySumMS != 123 || summary.LatencyCount != 1 || summary.LatencyMS == nil || *summary.LatencyMS != 123 {
+		t.Fatalf("summary latency = sum:%d count:%d avg:%v", summary.LatencySumMS, summary.LatencyCount, summary.LatencyMS)
+	}
+	if len(summary.APIs) != 0 {
+		t.Fatalf("summary APIs len = %d, want no detail aggregates", len(summary.APIs))
+	}
+	if !stringSliceContains(summary.Facets.Providers, "codex") || !stringSliceContains(summary.Facets.Providers, "gemini") {
+		t.Fatalf("summary provider facets = %#v", summary.Facets.Providers)
+	}
+	if !stringSliceContains(summary.Facets.Models, "gpt-test") {
+		t.Fatalf("summary model facets = %#v", summary.Facets.Models)
+	}
+	if !stringSliceContains(summary.Facets.Channels, "codex") || !stringSliceContains(summary.Facets.Channels, "gemini") {
+		t.Fatalf("summary channel facets = %#v", summary.Facets.Channels)
+	}
+	if !facetOptionsContain(summary.Facets.Accounts, "alice@example.com", "alice@example.com") ||
+		!facetOptionsContain(summary.Facets.Accounts, "bob@example.com", "bob@example.com") {
+		t.Fatalf("summary account facets = %#v", summary.Facets.Accounts)
+	}
+	if !facetOptionsContain(summary.Facets.APIKeys, hashA, "Team Alpha") ||
+		!facetOptionsContain(summary.Facets.APIKeys, hashB, hashB) {
+		t.Fatalf("summary api key facets = %#v", summary.Facets.APIKeys)
+	}
+
+	startMS := int64(1_778_000_004_000)
+	filtered, err := db.UsageSummary(context.Background(), UsageSummaryFilter{StartMS: &startMS})
+	if err != nil {
+		t.Fatalf("filtered usage summary: %v", err)
+	}
+	if filtered.TotalRequests != 1 || filtered.SuccessCount != 0 || filtered.FailureCount != 1 || filtered.TotalTokens != 12 {
+		t.Fatalf("filtered summary = %#v", filtered)
+	}
+
+	apiKeyFiltered, err := db.UsageSummary(context.Background(), UsageSummaryFilter{APIKeyHash: hashA, Status: "success", Search: "alice"})
+	if err != nil {
+		t.Fatalf("api key filtered usage summary: %v", err)
+	}
+	if apiKeyFiltered.TotalRequests != 1 || apiKeyFiltered.SuccessCount != 1 || apiKeyFiltered.FailureCount != 0 || apiKeyFiltered.TotalTokens != 30 {
+		t.Fatalf("api key filtered summary = %#v", apiKeyFiltered)
+	}
+}
+
+func TestStoreUsageSearchUsesFTSAndAPIKeyAlias(t *testing.T) {
+	db, err := Open(filepath.Join(t.TempDir(), "usage.sqlite"))
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = db.Close()
+	})
+
+	hashA := strings.Repeat("a", 64)
+	hashB := strings.Repeat("b", 64)
+	_, err = db.InsertEvents(context.Background(), []usage.Event{
+		{
+			EventHash:       "search-alias-a",
+			TimestampMS:     1_778_000_001_000,
+			Timestamp:       "2026-05-06T00:00:01Z",
+			Model:           "gpt-test",
+			Endpoint:        "POST /v1/chat/completions",
+			APIKeyHash:      hashA,
+			AccountSnapshot: "alice@example.com",
+			TotalTokens:     10,
+		},
+		{
+			EventHash:       "search-alias-b",
+			TimestampMS:     1_778_000_002_000,
+			Timestamp:       "2026-05-06T00:00:02Z",
+			Model:           "gemini-test",
+			Endpoint:        "POST /v1/chat/completions",
+			APIKeyHash:      hashB,
+			AccountSnapshot: "bob@example.com",
+			TotalTokens:     20,
+		},
+	})
+	if err != nil {
+		t.Fatalf("insert events: %v", err)
+	}
+	if err := db.UpsertAPIKeyAliases(context.Background(), []APIKeyAlias{
+		{APIKeyHash: hashA, Alias: "KongWenpeng"},
+	}, nil); err != nil {
+		t.Fatalf("upsert alias: %v", err)
+	}
+
+	summary, err := db.UsageSummary(context.Background(), UsageSummaryFilter{
+		Search:           "KongWenpeng",
+		SearchAPIKeyHash: strings.Repeat("f", 64),
+	})
+	if err != nil {
+		t.Fatalf("alias search summary: %v", err)
+	}
+	if summary.TotalRequests != 1 || summary.TotalTokens != 10 {
+		t.Fatalf("alias search summary = %#v", summary)
+	}
+
+	summary, err = db.UsageSummary(context.Background(), UsageSummaryFilter{
+		Search: "gemini-test",
+	})
+	if err != nil {
+		t.Fatalf("model search summary: %v", err)
+	}
+	if summary.TotalRequests != 1 || summary.TotalTokens != 20 {
+		t.Fatalf("model search summary = %#v", summary)
+	}
+}
+
+func TestStoreUsageBreakdownPagePaginatesAccountGroups(t *testing.T) {
+	db, err := Open(filepath.Join(t.TempDir(), "usage.sqlite"))
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = db.Close()
+	})
+
+	_, err = db.InsertEvents(context.Background(), []usage.Event{
+		{
+			EventHash:       "account-page-alice",
+			TimestampMS:     1_778_000_001_000,
+			Timestamp:       "2026-05-06T00:00:01Z",
+			Model:           "gpt-test",
+			Endpoint:        "POST /v1/chat/completions",
+			AuthIndex:       "auth-alice",
+			AccountSnapshot: "alice@example.com",
+			TotalTokens:     10,
+		},
+		{
+			EventHash:       "account-page-bob",
+			TimestampMS:     1_778_000_003_000,
+			Timestamp:       "2026-05-06T00:00:03Z",
+			Model:           "gpt-test",
+			Endpoint:        "POST /v1/chat/completions",
+			AuthIndex:       "auth-bob",
+			AccountSnapshot: "bob@example.com",
+			TotalTokens:     30,
+		},
+		{
+			EventHash:       "account-page-carol",
+			TimestampMS:     1_778_000_002_000,
+			Timestamp:       "2026-05-06T00:00:02Z",
+			Model:           "gpt-test",
+			Endpoint:        "POST /v1/chat/completions",
+			AuthIndex:       "auth-carol",
+			AccountSnapshot: "carol@example.com",
+			TotalTokens:     20,
+		},
+	})
+	if err != nil {
+		t.Fatalf("insert events: %v", err)
+	}
+
+	page, err := db.UsageBreakdownPage(context.Background(), UsageBreakdownAccounts, UsageSummaryFilter{}, UsagePageFilter{
+		Page:     2,
+		PageSize: 1,
+	})
+	if err != nil {
+		t.Fatalf("usage account page: %v", err)
+	}
+	if page.TotalItems != 3 || page.Page != 2 || page.PageSize != 1 {
+		t.Fatalf("pagination = %#v", page)
+	}
+	details := collectTestDetails(page.Usage)
+	if len(details) != 1 {
+		t.Fatalf("details len = %d, want 1", len(details))
+	}
+	if details[0].AccountSnapshot != "carol@example.com" {
+		t.Fatalf("account page detail account = %q, want carol", details[0].AccountSnapshot)
+	}
+}
+
+func TestNormalizeUsagePageFilterCapsPageSize(t *testing.T) {
+	page, pageSize := normalizeUsagePageFilter(UsagePageFilter{
+		Page:     0,
+		PageSize: MaxUsagePageSize + 1,
+	})
+	if page != 1 || pageSize != MaxUsagePageSize {
+		t.Fatalf("normalize page = %d, pageSize = %d", page, pageSize)
+	}
+}
+
+func TestNormalizeUsageSortKeyUsesWhitelist(t *testing.T) {
+	if got := normalizeUsageSortKey("totalTokens"); got != "totalTokens" {
+		t.Fatalf("valid sort key = %q", got)
+	}
+	if got := normalizeUsageSortKey("timestamp_ms desc"); got != defaultUsageSortKey {
+		t.Fatalf("invalid sort key = %q, want %q", got, defaultUsageSortKey)
+	}
+}
+
+func TestStoreUsageBreakdownPagePaginatesApiKeyGroups(t *testing.T) {
+	db, err := Open(filepath.Join(t.TempDir(), "usage.sqlite"))
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = db.Close()
+	})
+
+	_, err = db.InsertEvents(context.Background(), []usage.Event{
+		{
+			EventHash:   "api-key-page-a",
+			TimestampMS: 1_778_000_001_000,
+			Timestamp:   "2026-05-06T00:00:01Z",
+			Model:       "gpt-test",
+			Endpoint:    "POST /v1/chat/completions",
+			APIKeyHash:  "key-a",
+			TotalTokens: 10,
+		},
+		{
+			EventHash:   "api-key-page-b",
+			TimestampMS: 1_778_000_002_000,
+			Timestamp:   "2026-05-06T00:00:02Z",
+			Model:       "gpt-test",
+			Endpoint:    "POST /v1/chat/completions",
+			APIKeyHash:  "key-b",
+			TotalTokens: 20,
+		},
+	})
+	if err != nil {
+		t.Fatalf("insert events: %v", err)
+	}
+
+	page, err := db.UsageBreakdownPage(context.Background(), UsageBreakdownAPIKeys, UsageSummaryFilter{}, UsagePageFilter{
+		Page:     1,
+		PageSize: 1,
+	})
+	if err != nil {
+		t.Fatalf("usage api-key page: %v", err)
+	}
+	if page.TotalItems != 2 {
+		t.Fatalf("total items = %d, want 2", page.TotalItems)
+	}
+	details := collectTestDetails(page.Usage)
+	if len(details) != 1 || details[0].APIKeyHash != "key-b" {
+		t.Fatalf("api-key page details = %#v, want key-b", details)
+	}
+}
+
+func TestStoreUsageBreakdownPagePaginatesRealtimeRows(t *testing.T) {
+	db, err := Open(filepath.Join(t.TempDir(), "usage.sqlite"))
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = db.Close()
+	})
+
+	_, err = db.InsertEvents(context.Background(), []usage.Event{
+		{
+			EventHash:   "realtime-page-old",
+			TimestampMS: 1_778_000_001_000,
+			Timestamp:   "2026-05-06T00:00:01Z",
+			Model:       "gpt-test",
+			Endpoint:    "POST /v1/chat/completions",
+			TotalTokens: 10,
+		},
+		{
+			EventHash:   "realtime-page-new",
+			TimestampMS: 1_778_000_002_000,
+			Timestamp:   "2026-05-06T00:00:02Z",
+			Model:       "gpt-test",
+			Endpoint:    "POST /v1/chat/completions",
+			TotalTokens: 20,
+		},
+	})
+	if err != nil {
+		t.Fatalf("insert events: %v", err)
+	}
+
+	page, err := db.UsageBreakdownPage(context.Background(), UsageBreakdownRealtime, UsageSummaryFilter{}, UsagePageFilter{
+		Page:     2,
+		PageSize: 1,
+	})
+	if err != nil {
+		t.Fatalf("usage realtime page: %v", err)
+	}
+	if page.TotalItems != 2 || page.Page != 2 {
+		t.Fatalf("pagination = %#v", page)
+	}
+	details := collectTestDetails(page.Usage)
+	if len(details) != 1 || details[0].Tokens.TotalTokens != 10 {
+		t.Fatalf("realtime page details = %#v, want oldest row", details)
+	}
+}
+
+func TestStoreUsageBreakdownPagePaginatesModelGroupsWithFilters(t *testing.T) {
+	db, err := Open(filepath.Join(t.TempDir(), "usage.sqlite"))
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = db.Close()
+	})
+
+	_, err = db.InsertEvents(context.Background(), []usage.Event{
+		{
+			EventHash:            "model-page-codex",
+			TimestampMS:          1_778_000_001_000,
+			Timestamp:            "2026-05-06T00:00:01Z",
+			Provider:             "codex",
+			Model:                "gpt-test",
+			Endpoint:             "POST /v1/chat/completions",
+			ResolvedModel:        "gpt-test-resolved",
+			InputTokens:          10,
+			OutputTokens:         20,
+			TotalTokens:          30,
+			AuthProviderSnapshot: "codex",
+		},
+		{
+			EventHash:            "model-page-other",
+			TimestampMS:          1_778_000_002_000,
+			Timestamp:            "2026-05-06T00:00:02Z",
+			Provider:             "gemini",
+			Model:                "gemini-test",
+			Endpoint:             "POST /v1/chat/completions",
+			TotalTokens:          40,
+			AuthProviderSnapshot: "gemini",
+		},
+	})
+	if err != nil {
+		t.Fatalf("insert events: %v", err)
+	}
+
+	page, err := db.UsageBreakdownPage(context.Background(), UsageBreakdownModels, UsageSummaryFilter{Provider: "codex"}, UsagePageFilter{
+		Page:     1,
+		PageSize: 10,
+	})
+	if err != nil {
+		t.Fatalf("usage model page: %v", err)
+	}
+	if page.TotalItems != 1 || page.Usage.TotalRequests != 1 || page.Usage.TotalTokens != 30 {
+		t.Fatalf("model page = %#v", page)
+	}
+	details := collectTestDetails(page.Usage)
+	if len(details) != 1 || details[0].ResolvedModel != "gpt-test-resolved" || details[0].Tokens.TotalTokens != 30 {
+		t.Fatalf("model page details = %#v", details)
+	}
+}
+
+func collectTestDetails(payload usage.Payload) []usage.Detail {
+	details := make([]usage.Detail, 0)
+	for _, api := range payload.APIs {
+		for _, model := range api.Models {
+			details = append(details, model.Details...)
+		}
+	}
+	return details
+}
+
 func TestStoreAPIKeyAliases(t *testing.T) {
 	db, err := Open(filepath.Join(t.TempDir(), "usage.sqlite"))
 	if err != nil {
@@ -242,3 +661,21 @@ func TestStoreAPIKeyAliasesActiveHashesMigration(t *testing.T) {
 		t.Fatalf("active conflict should be rejected, got err = %v", err)
 	}
 }
+
+func stringSliceContains(values []string, target string) bool {
+	for _, value := range values {
+		if value == target {
+			return true
+		}
+	}
+	return false
+}
+
+func facetOptionsContain(options []usage.FacetOption, value string, label string) bool {
+	for _, option := range options {
+		if option.Value == value && option.Label == label {
+			return true
+		}
+	}
+	return false
+}
diff --git a/usage-service/internal/usage/event.go b/usage-service/internal/usage/event.go
index 3068c25ed..35c6fb80c 100644
--- a/usage-service/internal/usage/event.go
+++ b/usage-service/internal/usage/event.go
@@ -70,6 +70,11 @@ type Detail struct {
 	ResolvedModel         string `json:"resolved_model,omitempty"`
 	Tokens                Tokens `json:"tokens"`
 	Failed                bool   `json:"failed"`
+	RequestCount          int64  `json:"request_count"`
+	SuccessCount          int64  `json:"success_count"`
+	FailureCount          int64  `json:"failure_count"`
+	LatencySumMS          int64  `json:"latency_sum_ms"`
+	LatencyCount          int64  `json:"latency_count"`
 }
 
 type ModelAggregate struct {
@@ -80,12 +85,30 @@ type APIAggregate struct {
 	Models map[string]*ModelAggregate `json:"models"`
 }
 
+type FacetOption struct {
+	Value string `json:"value"`
+	Label string `json:"label,omitempty"`
+}
+
+type Facets struct {
+	Providers []string      `json:"providers,omitempty"`
+	Accounts  []FacetOption `json:"accounts,omitempty"`
+	Models    []string      `json:"models,omitempty"`
+	Channels  []string      `json:"channels,omitempty"`
+	APIKeys   []FacetOption `json:"api_keys,omitempty"`
+}
+
 type Payload struct {
 	TotalRequests int64                    `json:"total_requests"`
 	SuccessCount  int64                    `json:"success_count"`
 	FailureCount  int64                    `json:"failure_count"`
 	TotalTokens   int64                    `json:"total_tokens"`
+	LatencySumMS  int64                    `json:"latency_sum_ms,omitempty"`
+	LatencyCount  int64                    `json:"latency_count,omitempty"`
+	LatencyMS     *int64                   `json:"latency_ms,omitempty"`
+	Tokens        Tokens                   `json:"tokens,omitempty"`
 	APIs          map[string]*APIAggregate `json:"apis"`
+	Facets        Facets                   `json:"facets,omitempty"`
 }
 
 var endpointPattern = regexp.MustCompile(`^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s+(\S+)`)
@@ -193,6 +216,16 @@ func BuildPayload(events []Event) Payload {
 			payload.SuccessCount++
 		}
 		payload.TotalTokens += event.TotalTokens
+		payload.Tokens.InputTokens += event.InputTokens
+		payload.Tokens.OutputTokens += event.OutputTokens
+		payload.Tokens.ReasoningTokens += event.ReasoningTokens
+		payload.Tokens.CachedTokens += event.CachedTokens
+		payload.Tokens.CacheTokens += event.CacheTokens
+		payload.Tokens.TotalTokens += event.TotalTokens
+		if event.LatencyMS != nil {
+			payload.LatencySumMS += *event.LatencyMS
+			payload.LatencyCount++
+		}
 
 		endpoint := event.Endpoint
 		if endpoint == "" {
@@ -236,6 +269,10 @@ func BuildPayload(events []Event) Payload {
 			},
 		})
 	}
+	if payload.LatencyCount > 0 {
+		averageLatency := payload.LatencySumMS / payload.LatencyCount
+		payload.LatencyMS = &averageLatency
+	}
 	return payload
 }