diff --git a/.changeset/search-filters-by-name.md b/.changeset/search-filters-by-name.md
new file mode 100644
index 0000000000..751380076e
--- /dev/null
+++ b/.changeset/search-filters-by-name.md
@@ -0,0 +1,7 @@
+---
+'@hyperdx/app': patch
+---
+
+feat: search filters by name in the search page sidebar
+
+Teams with a wide schema had no way to reach a filter that wasn't in the sidebar's default list, which shows low-cardinality columns and map sub-fields only. The new search box filters what is already rendered as you type, and runs a second query for matching fields the browse list never loaded, so a high-cardinality column is reachable by name.
diff --git a/packages/app/src/components/DBSearchPageFilters.tsx b/packages/app/src/components/DBSearchPageFilters.tsx
index 67a154aae7..b800fbd3de 100644
--- a/packages/app/src/components/DBSearchPageFilters.tsx
+++ b/packages/app/src/components/DBSearchPageFilters.tsx
@@ -31,6 +31,7 @@ import {
   Tooltip,
   UnstyledButton,
 } from '@mantine/core';
+import { useDebouncedValue } from '@mantine/hooks';
 import { notifications } from '@mantine/notifications';
 import {
   IconArrowBarToLeft,
@@ -65,6 +66,7 @@ import {
 import { useSource } from '@/source';
 import { useLocalStorage } from '@/utils';
 
+import { FilterKeySearch } from './DBSearchPageFilters/FilterKeySearch';
 import { FilterSettingsPanel } from './DBSearchPageFilters/FilterSettingsPopover';
 import { useFetchFacets } from './DBSearchPageFilters/hooks';
 import { NestedFilterGroup } from './DBSearchPageFilters/NestedFilterGroup';
@@ -73,6 +75,7 @@ import {
   PinShareMenu,
 } from './DBSearchPageFilters/PinShareMenu';
 import { SharedFiltersSection } from './DBSearchPageFilters/SharedFilters';
+import { useGroupExpansion } from './DBSearchPageFilters/useGroupExpansion';
 import {
   getFilterStateEntry,
   groupFacetsByBaseName,
@@ -88,6 +91,9 @@ const INITIAL_MAX_VALUES_DISPLAYED = 10;
 /* The maximum number of values per filter to render at once after loading more */
 const SHOW_MORE_MAX_VALUES_DISPLAYED = 50;
 
+/* How long typing in the filter-name search settles before it queries */
+const SEARCH_DEBOUNCE_MS = 300;
+
 // This function will clean json string attributes specifically. It will turn a string like
 // 'toString(ResourceAttributes.`hdx`.`sdk`.`version`)' into 'ResourceAttributes.hdx.sdk.version'.
 export function cleanedFacetName(key: string): string {
@@ -400,6 +406,12 @@ export type FilterGroupProps = {
   loadMoreLoading: boolean;
   hasLoadedMore: boolean;
   isDefaultExpanded?: boolean;
+  /**
+   * Holds the group open for as long as it is true, without touching the
+   * user's own expand/collapse state — so a filter-name search can reveal
+   * matches and the group snaps back when the search is cleared.
+   */
+  isForceExpanded?: boolean;
   showFilterCounts?: boolean;
   'data-testid'?: string;
   chartConfig: BuilderChartConfigWithDateRange;
@@ -898,6 +910,7 @@ export const FilterGroup = ({
   loadMoreLoading,
   hasLoadedMore,
   isDefaultExpanded,
+  isForceExpanded,
   showFilterCounts,
   'data-testid': dataTestId,
   chartConfig,
@@ -905,7 +918,10 @@ export const FilterGroup = ({
   distributionKey,
   onRangeChange,
 }: FilterGroupProps) => {
-  const [isExpanded, setExpanded] = useState(isDefaultExpanded ?? false);
+  const [expanded, setExpanded, expandBrowse] = useGroupExpansion(
+    isDefaultExpanded ?? false,
+    isForceExpanded,
+  );
   const [showDistributions, setShowDistributions] = useState(false);
   const [isFetchingDistribution, setIsFetchingDistribution] = useState(false);
 
@@ -923,7 +939,7 @@ export const FilterGroup = ({
       }
       return !prev;
     });
-  }, []);
+  }, [setExpanded]);
 
   const onDistributionError = useCallback(() => {
     setShowDistributions(false);
@@ -931,9 +947,9 @@ export const FilterGroup = ({
 
   useEffect(() => {
     if (isDefaultExpanded) {
-      setExpanded(true);
+      expandBrowse();
     }
-  }, [isDefaultExpanded]);
+  }, [isDefaultExpanded, expandBrowse]);
 
   const totalAppliedFiltersSize =
     selectedValues.included.size +
@@ -951,7 +967,7 @@ export const FilterGroup = ({
       variant="unstyled"
       chevronPosition="left"
       classNames={{ chevron: classes.chevron }}
-      value={isExpanded ? displayName : null}
+      value={expanded ? displayName : null}
       onChange={v => {
         setExpanded(v === displayName);
       }}
@@ -1024,7 +1040,7 @@ export const FilterGroup = ({
                 onRangeChange={onRangeChange}
               />
             ) : (
-              isExpanded && (
+              expanded && (
                 <FilterGroupBody
                   name={name}
                   options={options}
@@ -1170,10 +1186,16 @@ const DBSearchPageFiltersComponent = ({
   );
 
   const [showMoreFields, setShowMoreFields] = useState(false);
+  const [filterSearch, setFilterSearch] = useState('');
+  const [debouncedFilterSearch] = useDebouncedValue(
+    filterSearch.trim(),
+    SEARCH_DEBOUNCE_MS,
+  );
   const {
     data: fetchFacetsData,
     isLoading: isFacetsLoading,
     isFetching: isFacetsFetching,
+    isSearchFetching,
     error,
     loadMoreFacetsForKey,
     loadMoreLoadingKeys,
@@ -1185,6 +1207,7 @@ const DBSearchPageFiltersComponent = ({
     mode: showAllValues ? 'all' : 'exact',
     filterState,
     showMoreFields,
+    searchQuery: debouncedFilterSearch,
   });
   const facets = fetchFacetsData.keyValues;
 
@@ -1342,6 +1365,34 @@ const DBSearchPageFiltersComponent = ({
     sharedFilterKeys,
   ]);
 
+  // Applied against the raw input, not the debounced value: filtering what is
+  // already on screen costs nothing, so it should keep up with typing even
+  // while the query behind it is still settling.
+  const isSearching = filterSearch.trim().length > 0;
+  // The debounce has not fired yet, so no query is in flight for what is
+  // currently typed. Without this the sidebar answers "No matching filters"
+  // for 300ms before it has asked anything.
+  const isSearchPending =
+    isSearching && filterSearch.trim() !== debouncedFilterSearch;
+  const isSearchBusy = isSearchPending || isSearchFetching;
+  const matchesFilterSearch = useCallback(
+    (key: string) => {
+      const needle = filterSearch.trim().toLowerCase();
+      if (!needle) return true;
+      return cleanedFacetName(key).toLowerCase().includes(needle);
+    },
+    [filterSearch],
+  );
+
+  const visibleFacets = useMemo(
+    () => shownFacets.filter(facet => matchesFilterSearch(facet.key)),
+    [shownFacets, matchesFilterSearch],
+  );
+  const visibleSharedFacets = useMemo(
+    () => sharedFacets.filter(facet => matchesFilterSearch(facet.key)),
+    [sharedFacets, matchesFilterSearch],
+  );
+
   // Check if shared facets have active selections
   const showSharedClearButton = useMemo(
     () =>
@@ -1421,10 +1472,17 @@ const DBSearchPageFiltersComponent = ({
   const renderFacetList = useCallback(
     (
       facets: { key: string; value: (string | boolean)[] }[],
-      options?: { keyPrefix?: string; isDefaultExpanded?: boolean },
+      options?: {
+        keyPrefix?: string;
+        isDefaultExpanded?: boolean;
+        isForceExpanded?: boolean;
+      },
     ) => {
-      const { keyPrefix = '', isDefaultExpanded: forceExpanded } =
-        options ?? {};
+      const {
+        keyPrefix = '',
+        isDefaultExpanded: forceExpanded,
+        isForceExpanded,
+      } = options ?? {};
       const { grouped, nonGrouped } = groupFacetsByBaseName(facets);
 
       const makeValuePins = (key: string): ValuePinHandlers => ({
@@ -1516,6 +1574,7 @@ const DBSearchPageFiltersComponent = ({
                   );
                 })
               }
+              isForceExpanded={isForceExpanded}
               chartConfig={chartConfig}
               isLive={isLive}
             />
@@ -1571,6 +1630,7 @@ const DBSearchPageFiltersComponent = ({
                           entry.range != null)))
                   );
                 })()}
+                isForceExpanded={isForceExpanded}
                 chartConfig={chartConfig}
                 isLive={isLive}
                 onRangeChange={range => setFilterRange(facet.key, range)}
@@ -1690,7 +1750,7 @@ const DBSearchPageFiltersComponent = ({
 
           {isSharedFiltersVisible && (
             <SharedFiltersSection
-              hasSharedFacets={sharedFacets.length > 0}
+              hasSharedFacets={visibleSharedFacets.length > 0}
               opened={isSharedFiltersExpanded}
               onToggle={() =>
                 setSharedFiltersExpanded(!isSharedFiltersExpanded)
@@ -1698,7 +1758,7 @@ const DBSearchPageFiltersComponent = ({
               showClearButton={showSharedClearButton}
               onClearSelections={clearSharedSelections}
             >
-              {renderFacetList(sharedFacets, {
+              {renderFacetList(visibleSharedFacets, {
                 keyPrefix: 'shared-',
                 isDefaultExpanded: true,
               })}
@@ -1706,7 +1766,7 @@ const DBSearchPageFiltersComponent = ({
           )}
 
           {/* Divider between shared and regular filters */}
-          {isSharedFiltersVisible && sharedFacets.length > 0 && (
+          {isSharedFiltersVisible && visibleSharedFacets.length > 0 && (
             <Divider color="dark.4" />
           )}
 
@@ -1827,17 +1887,35 @@ const DBSearchPageFiltersComponent = ({
                     />
                   )}
 
+                <FilterKeySearch
+                  value={filterSearch}
+                  onChange={setFilterSearch}
+                  isFetching={isSearchBusy}
+                />
+
                 {isFacetsLoading ? (
                   <Flex align="center" justify="center">
                     <Loader size="xs" color="gray" />
                   </Flex>
                 ) : (
-                  shownFacets.length === 0 && (
+                  visibleFacets.length === 0 &&
+                  (isSearching ? (
+                    <Text size="xxs">
+                      {isSearchBusy
+                        ? 'Searching filters…'
+                        : 'No matching filters'}
+                    </Text>
+                  ) : (
                     <Text size="xxs">No filters available</Text>
-                  )
+                  ))
                 )}
                 {/* Show facets even when loading to ensure pinned filters are visible while loading */}
-                {renderFacetList(shownFacets)}
+                {renderFacetList(visibleFacets, {
+                  // A match buried in a collapsed group is a match the user
+                  // cannot see, which defeats searching for it. Transient, so
+                  // clearing the search restores the browse view as it was.
+                  isForceExpanded: isSearching,
+                })}
 
                 <Button
                   variant="secondary"
diff --git a/packages/app/src/components/DBSearchPageFilters/FilterKeySearch.tsx b/packages/app/src/components/DBSearchPageFilters/FilterKeySearch.tsx
new file mode 100644
index 0000000000..3159271825
--- /dev/null
+++ b/packages/app/src/components/DBSearchPageFilters/FilterKeySearch.tsx
@@ -0,0 +1,49 @@
+import { CloseButton, Loader, TextInput } from '@mantine/core';
+import { IconSearch } from '@tabler/icons-react';
+
+/**
+ * Search box for the filter sidebar, matching on filter (column) names rather
+ * than their values. Matches already on screen filter instantly; `isFetching`
+ * covers the query that goes looking for fields the browse list never loaded.
+ */
+export function FilterKeySearch({
+  value,
+  onChange,
+  isFetching,
+}: {
+  value: string;
+  onChange: (value: string) => void;
+  isFetching: boolean;
+}) {
+  return (
+    <TextInput
+      size="xs"
+      placeholder="Search filter column/properties"
+      aria-label="Search filter column/properties"
+      data-testid="filter-key-search"
+      value={value}
+      onChange={event => onChange(event.currentTarget.value)}
+      onKeyDown={event => {
+        if (event.key === 'Escape' && value) {
+          // Stop it bubbling to whatever else listens for Escape on the page;
+          // clearing the search is the more specific intent here.
+          event.stopPropagation();
+          onChange('');
+        }
+      }}
+      leftSection={<IconSearch size={12} stroke={2} />}
+      leftSectionWidth={24}
+      rightSection={
+        isFetching ? (
+          <Loader size={12} color="gray" />
+        ) : value ? (
+          <CloseButton
+            size="xs"
+            aria-label="Clear filter search"
+            onClick={() => onChange('')}
+          />
+        ) : null
+      }
+    />
+  );
+}
diff --git a/packages/app/src/components/DBSearchPageFilters/NestedFilterGroup.tsx b/packages/app/src/components/DBSearchPageFilters/NestedFilterGroup.tsx
index 4145d8e917..6fe437a57a 100644
--- a/packages/app/src/components/DBSearchPageFilters/NestedFilterGroup.tsx
+++ b/packages/app/src/components/DBSearchPageFilters/NestedFilterGroup.tsx
@@ -1,10 +1,12 @@
-import { useMemo, useRef, useState } from 'react';
+import { useMemo, useRef } from 'react';
 import { FilterState } from '@hyperdx/common-utils/dist/filters';
 import { Accordion, Group, Text, Tooltip, UnstyledButton } from '@mantine/core';
 import { useVirtualizer } from '@tanstack/react-virtual';
 
 import { FilterGroup } from '@/components/DBSearchPageFilters';
 
+import { useGroupExpansion } from './useGroupExpansion';
+
 import classes from '@styles/SearchPage.module.scss';
 
 type NestedFilterGroupProps = {
@@ -38,6 +40,12 @@ type NestedFilterGroupProps = {
   loadMoreLoading: Record<string, boolean>;
   hasLoadedMore: Record<string, boolean>;
   isDefaultExpanded?: boolean;
+  /**
+   * Holds the group open for as long as it is true, without touching the
+   * user's own expand/collapse state — so a filter-name search can reveal
+   * matching children and the group snaps back when the search is cleared.
+   */
+  isForceExpanded?: boolean;
   'data-testid'?: string;
   chartConfig: any; // Using any to avoid importing ChartConfigWithDateRange
   isLive?: boolean;
@@ -69,6 +77,7 @@ export const NestedFilterGroup = ({
   loadMoreLoading,
   hasLoadedMore,
   isDefaultExpanded,
+  isForceExpanded,
   'data-testid': dataTestId,
   chartConfig,
   isLive,
@@ -88,18 +97,24 @@ export const NestedFilterGroup = ({
   );
 
   const hasSelections = totalFiltersSize > 0;
-  const [isExpanded, setExpanded] = useState(
+  const [expanded, setExpanded] = useGroupExpansion(
     isDefaultExpanded ?? hasSelections,
+    isForceExpanded,
   );
 
   const scrollContainerRef = useRef<HTMLDivElement>(null);
 
   const rowVirtualizer = useVirtualizer({
-    count: isExpanded ? childFilters.length : 0,
+    count: expanded ? childFilters.length : 0,
     getScrollElement: () => scrollContainerRef.current,
     estimateSize: () => VIRTUAL_ITEM_HEIGHT_ESTIMATE,
     overscan: 10,
     getItemKey: index => childFilters[index]?.key ?? index,
+    // Collapsing the whole Filters section measures every row at 0 while it is
+    // hidden; that zero is cached, so the total size stays 0 and the group
+    // reopens empty. Fall back to the estimate rather than cache a zero.
+    measureElement: el =>
+      el.getBoundingClientRect().height || VIRTUAL_ITEM_HEIGHT_ESTIMATE,
   });
 
   return (
@@ -107,7 +122,7 @@ export const NestedFilterGroup = ({
       variant="unstyled"
       chevronPosition="left"
       classNames={{ chevron: classes.chevron }}
-      value={isExpanded ? name : null}
+      value={expanded ? name : null}
       onChange={v => setExpanded(v === name)}
     >
       <Accordion.Item value={name} data-testid={dataTestId}>
diff --git a/packages/app/src/components/DBSearchPageFilters/__tests__/useGroupExpansion.test.ts b/packages/app/src/components/DBSearchPageFilters/__tests__/useGroupExpansion.test.ts
new file mode 100644
index 0000000000..635e07d19c
--- /dev/null
+++ b/packages/app/src/components/DBSearchPageFilters/__tests__/useGroupExpansion.test.ts
@@ -0,0 +1,90 @@
+import { act, renderHook } from '@testing-library/react';
+
+import { useGroupExpansion } from '@/components/DBSearchPageFilters/useGroupExpansion';
+
+const render = (defaultExpanded: boolean, isForceExpanded?: boolean) =>
+  renderHook(
+    (props: { defaultExpanded: boolean; isForceExpanded?: boolean }) =>
+      useGroupExpansion(props.defaultExpanded, props.isForceExpanded),
+    { initialProps: { defaultExpanded, isForceExpanded } },
+  );
+
+describe('useGroupExpansion', () => {
+  it('follows its own state when no search is active', () => {
+    const { result } = render(false);
+    expect(result.current[0]).toBe(false);
+
+    act(() => result.current[1](true));
+    expect(result.current[0]).toBe(true);
+  });
+
+  it('opens while a search forces it, and can still be closed', () => {
+    const { result, rerender } = render(false);
+    rerender({ defaultExpanded: false, isForceExpanded: true });
+    expect(result.current[0]).toBe(true);
+
+    act(() => result.current[1](false));
+    expect(result.current[0]).toBe(false);
+
+    act(() => result.current[1](true));
+    expect(result.current[0]).toBe(true);
+  });
+
+  it('restores the browse state when the search ends', () => {
+    const { result, rerender } = render(false);
+
+    rerender({ defaultExpanded: false, isForceExpanded: true });
+    act(() => result.current[1](true));
+    expect(result.current[0]).toBe(true);
+
+    // Closing the search must not leave the group stuck open.
+    rerender({ defaultExpanded: false, isForceExpanded: false });
+    expect(result.current[0]).toBe(false);
+  });
+
+  it('leaves an expanded group expanded after a search closes it', () => {
+    const { result, rerender } = render(false);
+    act(() => result.current[1](true));
+
+    rerender({ defaultExpanded: false, isForceExpanded: true });
+    act(() => result.current[1](false));
+    expect(result.current[0]).toBe(false);
+
+    rerender({ defaultExpanded: false, isForceExpanded: false });
+    expect(result.current[0]).toBe(true);
+  });
+
+  it('reopens on a fresh search after the previous one was closed', () => {
+    const { result, rerender } = render(false);
+
+    rerender({ defaultExpanded: false, isForceExpanded: true });
+    act(() => result.current[1](false));
+    expect(result.current[0]).toBe(false);
+
+    rerender({ defaultExpanded: false, isForceExpanded: false });
+    rerender({ defaultExpanded: false, isForceExpanded: true });
+    expect(result.current[0]).toBe(true);
+  });
+
+  it('keeps a default-expansion signal raised during a search', () => {
+    const { result, rerender } = render(false);
+    rerender({ defaultExpanded: false, isForceExpanded: true });
+
+    // The group gains a selection mid-search, so the caller's
+    // default-expansion effect fires. That describes the browse state.
+    act(() => result.current[2]());
+
+    rerender({ defaultExpanded: true, isForceExpanded: false });
+    expect(result.current[0]).toBe(true);
+  });
+
+  it('keeps the setter identity stable so callers can memoize on it', () => {
+    const { result, rerender } = render(false);
+    const setter = result.current[1];
+
+    rerender({ defaultExpanded: false, isForceExpanded: true });
+    act(() => result.current[1](false));
+
+    expect(result.current[1]).toBe(setter);
+  });
+});
diff --git a/packages/app/src/components/DBSearchPageFilters/hooks.test.tsx b/packages/app/src/components/DBSearchPageFilters/hooks.test.tsx
index a3c567233e..4a5ec47a10 100644
--- a/packages/app/src/components/DBSearchPageFilters/hooks.test.tsx
+++ b/packages/app/src/components/DBSearchPageFilters/hooks.test.tsx
@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
 import React from 'react';
 import { enableMapSet } from 'immer';
+import { JSDataType } from '@hyperdx/common-utils/dist/clickhouse';
+import type { Field } from '@hyperdx/common-utils/dist/core/metadata';
 import { FilterState } from '@hyperdx/common-utils/dist/filters';
 import {
   BuilderChartConfigWithDateRange,
@@ -10,6 +12,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { act, renderHook, waitFor } from '@testing-library/react';
 
 import api from '@/api';
+import type { Facet } from '@/hooks/useMetadata';
 import * as useMetadataModule from '@/hooks/useMetadata';
 import * as searchFiltersModule from '@/searchFilters';
 import * as sourceModule from '@/source';
@@ -83,6 +86,11 @@ const useMapColumns = jest.mocked(useMetadataModule.useMapColumns);
 const useAllFields = jest.mocked(useMetadataModule.useAllFields);
 const useGetKeyValues = jest.mocked(useMetadataModule.useGetKeyValues);
 
+// Each render issues two `useGetKeyValues` calls: the browse list, then the
+// filter-name search.
+const lastBrowseCall = () => useGetKeyValues.mock.calls.at(-2);
+const lastSearchCall = () => useGetKeyValues.mock.calls.at(-1);
+
 const CHART_CONFIG: BuilderChartConfigWithDateRange = {
   connection: 'conn1',
   from: { databaseName: 'db', tableName: 'logs' },
@@ -130,6 +138,24 @@ const mockSourceQuery = (data: SourceQueryResult['data']) =>
 const mockMetadata = (metadata: Partial<MetadataWithSettings>) =>
   useMetadataWithSettings.mockReturnValue(metadata as MetadataWithSettings);
 
+type AllFieldsResult = ReturnType<typeof useMetadataModule.useAllFields>;
+type MapColumnsResult = ReturnType<typeof useMetadataModule.useMapColumns>;
+type KeyValuesResult = ReturnType<typeof useMetadataModule.useGetKeyValues>;
+
+const mockAllFields = (data: Field[]) =>
+  useAllFields.mockReturnValue({ data } as AllFieldsResult);
+
+const mockMapColumns = (data: string[]) =>
+  useMapColumns.mockReturnValue({ data } as MapColumnsResult);
+
+const settledKeyValues = (data: Facet[]) =>
+  ({
+    data,
+    isLoading: false,
+    isFetching: false,
+    error: null,
+  }) as KeyValuesResult;
+
 function makeWrapper() {
   const queryClient = new QueryClient({
     defaultOptions: { queries: { retry: false } },
@@ -214,7 +240,7 @@ describe('useFetchFacets', () => {
         { wrapper },
       );
 
-      const call = useGetKeyValues.mock.calls.at(-1);
+      const call = lastBrowseCall();
       expect(call?.[0]?.mode).toBe('exact');
       expect(call?.[1]?.enabled).toBe(true);
     });
@@ -234,7 +260,7 @@ describe('useFetchFacets', () => {
         { wrapper },
       );
 
-      const call = useGetKeyValues.mock.calls.at(-1);
+      const call = lastBrowseCall();
       expect(call?.[0]?.mode).toBe('all');
       expect(call?.[1]?.enabled).toBe(true);
     });
@@ -254,7 +280,7 @@ describe('useFetchFacets', () => {
         { wrapper },
       );
 
-      const call = useGetKeyValues.mock.calls.at(-1);
+      const call = lastBrowseCall();
       expect(call?.[0]?.mode).toBe('exact');
     });
   });
@@ -280,7 +306,7 @@ describe('useFetchFacets', () => {
         { wrapper },
       );
 
-      const call = useGetKeyValues.mock.calls.at(-1);
+      const call = lastBrowseCall();
       expect(call?.[1]?.enabled).toBe(false);
     });
 
@@ -300,7 +326,7 @@ describe('useFetchFacets', () => {
         { wrapper },
       );
 
-      const call = useGetKeyValues.mock.calls.at(-1);
+      const call = lastBrowseCall();
       expect(call?.[1]?.enabled).toBe(true);
     });
 
@@ -1145,4 +1171,190 @@ describe('useFetchFacets', () => {
       expect(result.current.extraFacetKeys.size).toBe(0);
     });
   });
+
+  // The filter-name search runs as a second query so the browse list survives
+  // typing untouched, and it looks at every string field rather than the
+  // low-cardinality subset the browse list narrows to.
+  describe('searchQuery', () => {
+    const FIELDS: Field[] = [
+      {
+        path: ['ServiceName'],
+        type: 'LowCardinality(String)',
+        jsType: JSDataType.String,
+      },
+      { path: ['TraceId'], type: 'String', jsType: JSDataType.String },
+      { path: ['SpanId'], type: 'String', jsType: JSDataType.String },
+      { path: ['Duration'], type: 'UInt64', jsType: JSDataType.Number },
+      {
+        path: ['LogAttributes', 'service.version'],
+        type: 'String',
+        jsType: JSDataType.String,
+      },
+    ];
+
+    const renderWithSearch = (searchQuery?: string) => {
+      setupDefaultMocks({ withMVs: false });
+      mockAllFields(FIELDS);
+      mockMapColumns(['LogAttributes']);
+      const { wrapper } = makeWrapper();
+      return renderHook(
+        () =>
+          useFetchFacets({
+            chartConfig: CHART_CONFIG,
+            sourceId: 'source1',
+            dateRange: DATE_RANGE,
+            mode: 'all',
+            searchQuery,
+          }),
+        { wrapper },
+      );
+    };
+
+    it('does not query when there is no search', () => {
+      renderWithSearch();
+
+      expect(lastSearchCall()?.[0]?.keys).toEqual([]);
+      expect(lastSearchCall()?.[1]?.enabled).toBe(false);
+    });
+
+    it('does not query for a single character', () => {
+      renderWithSearch('s');
+
+      expect(lastSearchCall()?.[1]?.enabled).toBe(false);
+    });
+
+    it('reaches fields the browse list never requests', () => {
+      renderWithSearch('trace');
+
+      expect(lastBrowseCall()?.[0]?.keys).not.toContain('TraceId');
+      expect(lastSearchCall()?.[0]?.keys).toEqual(['TraceId']);
+      expect(lastSearchCall()?.[1]?.enabled).toBe(true);
+    });
+
+    it('matches map sub-fields and ranks prefix matches first', () => {
+      renderWithSearch('service');
+
+      expect(lastSearchCall()?.[0]?.keys).toEqual([
+        'ServiceName',
+        "LogAttributes['service.version']",
+      ]);
+    });
+
+    it('leaves the browse query untouched while searching', () => {
+      renderWithSearch();
+      const browseKeys = lastBrowseCall()?.[0]?.keys;
+
+      jest.clearAllMocks();
+      renderWithSearch('trace');
+
+      expect(lastBrowseCall()?.[0]?.keys).toEqual(browseKeys);
+      expect(lastBrowseCall()?.[1]?.enabled).toBe(true);
+    });
+
+    it('does not re-request keys the browse query already answered', () => {
+      setupDefaultMocks({ withMVs: false });
+      mockAllFields(FIELDS);
+      // Browse answered for ServiceName, so searching for it must not ask
+      // again; TraceId is absent from the browse page and still must.
+      useGetKeyValues.mockImplementation(({ keys }) =>
+        settledKeyValues(
+          keys.includes('ServiceName')
+            ? [{ key: 'ServiceName', value: ['api'] }]
+            : [],
+        ),
+      );
+
+      const { wrapper } = makeWrapper();
+      const { rerender } = renderHook(
+        (props: { searchQuery: string }) =>
+          useFetchFacets({
+            chartConfig: CHART_CONFIG,
+            sourceId: 'source1',
+            dateRange: DATE_RANGE,
+            mode: 'all',
+            searchQuery: props.searchQuery,
+          }),
+        { wrapper, initialProps: { searchQuery: 'ServiceName' } },
+      );
+
+      expect(lastSearchCall()?.[0]?.keys).toEqual([]);
+      expect(lastSearchCall()?.[1]?.enabled).toBe(false);
+
+      rerender({ searchQuery: 'trace' });
+
+      expect(lastSearchCall()?.[0]?.keys).toEqual(['TraceId']);
+      expect(lastSearchCall()?.[1]?.enabled).toBe(true);
+    });
+
+    it('drops the last search page once the search is cleared', () => {
+      setupDefaultMocks({ withMVs: false });
+      mockAllFields(FIELDS);
+      // Browse answers with ServiceName; the search query answers with
+      // TraceId and keeps doing so after it is disabled, standing in for
+      // `keepPreviousData` still serving the last page. Distinct facets, so
+      // dropping the guard fails this test rather than passing by overlap.
+      useGetKeyValues.mockImplementation(({ keys }) =>
+        settledKeyValues(
+          keys.includes('ServiceName')
+            ? [{ key: 'ServiceName', value: ['api'] }]
+            : [{ key: 'TraceId', value: ['abc'] }],
+        ),
+      );
+
+      const { wrapper } = makeWrapper();
+      const { result, rerender } = renderHook(
+        (props: { searchQuery?: string }) =>
+          useFetchFacets({
+            chartConfig: CHART_CONFIG,
+            sourceId: 'source1',
+            dateRange: DATE_RANGE,
+            mode: 'all',
+            searchQuery: props.searchQuery,
+          }),
+        { wrapper, initialProps: { searchQuery: 'trace' } },
+      );
+
+      expect(result.current.data.keyValues).toEqual([
+        { key: 'ServiceName', value: ['api'] },
+        { key: 'TraceId', value: ['abc'] },
+      ]);
+
+      rerender({ searchQuery: '' });
+
+      expect(result.current.data.keyValues).toEqual([
+        { key: 'ServiceName', value: ['api'] },
+      ]);
+      expect(lastSearchCall()?.[1]?.enabled).toBe(false);
+    });
+
+    it('unions search results into the facet list without duplicating keys', () => {
+      setupDefaultMocks({ withMVs: false });
+      mockAllFields(FIELDS);
+      useGetKeyValues.mockImplementation(({ keys }) =>
+        settledKeyValues(
+          keys.includes('TraceId')
+            ? [{ key: 'TraceId', value: ['abc'] }]
+            : [{ key: 'ServiceName', value: ['api'] }],
+        ),
+      );
+
+      const { wrapper } = makeWrapper();
+      const { result } = renderHook(
+        () =>
+          useFetchFacets({
+            chartConfig: CHART_CONFIG,
+            sourceId: 'source1',
+            dateRange: DATE_RANGE,
+            mode: 'all',
+            searchQuery: 'trace',
+          }),
+        { wrapper },
+      );
+
+      expect(result.current.data.keyValues).toEqual([
+        { key: 'ServiceName', value: ['api'] },
+        { key: 'TraceId', value: ['abc'] },
+      ]);
+    });
+  });
 });
diff --git a/packages/app/src/components/DBSearchPageFilters/hooks.ts b/packages/app/src/components/DBSearchPageFilters/hooks.ts
index be73a26336..a96cc0b802 100644
--- a/packages/app/src/components/DBSearchPageFilters/hooks.ts
+++ b/packages/app/src/components/DBSearchPageFilters/hooks.ts
@@ -35,6 +35,15 @@ const INITIAL_LOAD_LIMIT = 20;
 /* The maximum number of values per filter to load when "Load More" is clicked */
 const LOAD_MORE_LOAD_LIMIT = 10000;
 
+/* The maximum number of matched fields a filter-name search fetches values for */
+const SEARCH_MAX_KEYS = 50;
+
+/* Shorter than this matches most of the schema, so it isn't worth a query */
+const MIN_SEARCH_LENGTH = 2;
+
+/* Free-text bodies and the timestamp are never useful as faceted filters */
+const NON_FACET_PATHS = ['body', 'timestamp', '_hdx_body'];
+
 /**
  * Decide which table key-value discovery reads from.
  *
@@ -68,6 +77,7 @@ function useFacets({
   dateRange,
   filterState,
   showMoreFields,
+  searchQuery,
   enabled,
   disableValues,
 }: {
@@ -82,6 +92,8 @@ function useFacets({
   dateRange: [Date, Date];
   filterState?: FilterState;
   showMoreFields?: boolean;
+  /** Debounced filter-name search; fetches values for fields matching it. */
+  searchQuery?: string;
   enabled?: boolean;
   disableValues?: boolean;
 }) {
@@ -152,10 +164,7 @@ function useFacets({
           isSharedFieldPinned(field.path), // keep team-shared fields
       )
       .map(({ path }) => path)
-      .filter(
-        path =>
-          !['body', 'timestamp', '_hdx_body'].includes(path.toLowerCase()),
-      );
+      .filter(path => !NON_FACET_PATHS.includes(path.toLowerCase()));
     return strings;
   }, [
     allFields,
@@ -167,21 +176,66 @@ function useFacets({
     isSharedFieldPinned,
   ]);
 
-  const { escapedKeysToFetch, sqlKeyToUiKey } = useMemo(() => {
-    // Don't fetch any keys until the column list is loaded,
-    // since we need the real column names to escape correctly.
-    if (isColumnsLoading) {
-      return { escapedKeysToFetch: [], sqlKeyToUiKey: new Map() };
+  // Searched over every string field rather than `keysToFetch`, which is the
+  // point: the browse list deliberately omits high-cardinality columns, and
+  // those are exactly the filters a user resorts to searching for.
+  const searchKeysToFetch = useMemo(() => {
+    const needle = searchQuery?.trim().toLowerCase() ?? '';
+    if (!allFields || needle.length < MIN_SEARCH_LENGTH) {
+      return [];
     }
+    return allFields
+      .filter(field => field.jsType === 'string')
+      .map(({ path }) => {
+        const merged = mergePath(path, jsonColumns ?? [], mapColumns ?? []);
+        return {
+          path: merged,
+          // JSON sub-paths arrive backtick-quoted (Body.`user`.`id`), which no
+          // one types. Matched against the bare text the sidebar displays.
+          haystack: merged.toLowerCase().replaceAll('`', ''),
+        };
+      })
+      .filter(
+        ({ path, haystack }) =>
+          !NON_FACET_PATHS.includes(path.toLowerCase()) &&
+          haystack.includes(needle),
+      )
+      .sort((a, b) => {
+        // SEARCH_MAX_KEYS is a hard cutoff, so this order decides which matches
+        // get values at all — prefix matches are the likelier intent.
+        const aPrefix = a.haystack.startsWith(needle);
+        const bPrefix = b.haystack.startsWith(needle);
+        if (aPrefix !== bPrefix) return aPrefix ? -1 : 1;
+        return a.path.localeCompare(b.path);
+      })
+      .slice(0, SEARCH_MAX_KEYS)
+      .map(({ path }) => path);
+  }, [allFields, jsonColumns, mapColumns, searchQuery]);
 
-    const sqlKeyToUiKey = new Map<string, string>();
-    const escapedKeysToFetch = keysToFetch.map(key => {
-      const sqlKey = toQuotedClickHouseKeyExpression(key, knownColumns);
-      sqlKeyToUiKey.set(sqlKey, key);
-      return sqlKey;
-    });
-    return { escapedKeysToFetch, sqlKeyToUiKey };
-  }, [isColumnsLoading, keysToFetch, knownColumns]);
+  const { escapedKeysToFetch, escapedSearchMatches, sqlKeyToUiKey } =
+    useMemo(() => {
+      // Don't fetch any keys until the column list is loaded,
+      // since we need the real column names to escape correctly.
+      if (isColumnsLoading) {
+        return {
+          escapedKeysToFetch: [],
+          escapedSearchMatches: [],
+          sqlKeyToUiKey: new Map(),
+        };
+      }
+
+      const sqlKeyToUiKey = new Map<string, string>();
+      const escape = (key: string) => {
+        const sqlKey = toQuotedClickHouseKeyExpression(key, knownColumns);
+        sqlKeyToUiKey.set(sqlKey, key);
+        return sqlKey;
+      };
+      return {
+        escapedKeysToFetch: keysToFetch.map(escape),
+        escapedSearchMatches: searchKeysToFetch.map(escape),
+        sqlKeyToUiKey,
+      };
+    }, [isColumnsLoading, keysToFetch, searchKeysToFetch, knownColumns]);
 
   const facetsChartConfig = useMemo(
     () =>
@@ -201,15 +255,70 @@ function useFacets({
     { enabled: enabled && !disableValues },
   );
 
-  // Map the (escaped) result keys back to the original UI keys.
-  const facets = useMemo<Facet[] | undefined>(
-    () =>
-      rawFacets?.map(f => ({
-        ...f,
-        key: sqlKeyToUiKey.get(f.key) ?? f.key,
-      })),
-    [rawFacets, sqlKeyToUiKey],
+  // Whatever browse already returned needs no second lookup — same keys, same
+  // limit, same scope. Without this, searching for a field that is already on
+  // screen costs a round trip that answers with what we are holding, which is
+  // the most common search there is. Keyed off what came back rather than what
+  // was asked for: the browse query truncates at `maxKeys`, so "we requested
+  // it" does not mean "we have it".
+  const browseKeys = useMemo(
+    () => new Set((rawFacets ?? []).map(facet => facet.key)),
+    [rawFacets],
   );
+  const escapedSearchKeys = useMemo(
+    () => escapedSearchMatches.filter(key => !browseKeys.has(key)),
+    [escapedSearchMatches, browseKeys],
+  );
+
+  // A second query rather than widening the one above: the browse list must
+  // survive typing untouched, so clearing the search costs nothing and each
+  // search term caches on its own.
+  const {
+    data: lastSearchFacets,
+    isFetching: isSearchFetching,
+    error: searchError,
+  } = useGetKeyValues(
+    {
+      chartConfig: facetsChartConfig,
+      limit: INITIAL_LOAD_LIMIT,
+      keys: escapedSearchKeys,
+      mode,
+    },
+    { enabled: enabled && !disableValues && escapedSearchKeys.length > 0 },
+  );
+
+  // `keepPreviousData` keeps serving the last search's page even once the query
+  // is disabled, which would leave fields the browse list never asked for
+  // sitting in the sidebar after the search box is cleared.
+  const rawSearchFacets =
+    escapedSearchKeys.length > 0 ? lastSearchFacets : undefined;
+
+  // Map the (escaped) result keys back to the original UI keys, and union the
+  // search results in. Search and browse can ask for the same key, and while a
+  // new search is in flight `rawSearchFacets` still holds the previous term's
+  // page — harmless, since the caller filters by the typed text anyway.
+  const facets = useMemo<Facet[] | undefined>(() => {
+    if (rawFacets === undefined && rawSearchFacets === undefined) {
+      return undefined;
+    }
+    const byKey = new Map<string, Facet>();
+    for (const facet of [...(rawFacets ?? []), ...(rawSearchFacets ?? [])]) {
+      const key = sqlKeyToUiKey.get(facet.key) ?? facet.key;
+      const existing = byKey.get(key);
+      if (!existing) {
+        byKey.set(key, { key, value: [...facet.value] });
+        continue;
+      }
+      const seen = new Set(existing.value);
+      for (const value of facet.value) {
+        if (!seen.has(value)) {
+          seen.add(value);
+          existing.value.push(value);
+        }
+      }
+    }
+    return [...byKey.values()];
+  }, [rawFacets, rawSearchFacets, sqlKeyToUiKey]);
 
   const metadata = useMetadataWithSettings();
   const loadMoreFacetsForKey = useCallback(
@@ -289,9 +398,13 @@ function useFacets({
 
   return {
     ...rest,
-    error: allFieldsError ?? rest.error,
+    // A failed search must not read as "no matching filters": the caller
+    // reports this, so a field that exists but could not be looked up is
+    // distinguishable from one that genuinely has no values.
+    error: allFieldsError ?? rest.error ?? searchError,
     data: { keys: allFields, keyValues: facets },
     isLoading: isAllFieldsLoading || rest.isLoading,
+    isSearchFetching,
     loadMoreFacetsForKey,
   };
 }
@@ -304,6 +417,7 @@ export function useFetchFacets({
   mode,
   filterState,
   showMoreFields,
+  searchQuery,
   disableValues,
 }: {
   chartConfig: BuilderChartConfigWithDateRange;
@@ -317,6 +431,8 @@ export function useFetchFacets({
   mode: 'all' | 'exact';
   filterState?: FilterState;
   showMoreFields?: boolean;
+  /** Debounced filter-name search; fetches values for fields matching it. */
+  searchQuery?: string;
   disableValues?: boolean;
 }) {
   const facetsQuery = useFacets({
@@ -327,6 +443,7 @@ export function useFetchFacets({
     dateRange,
     filterState,
     showMoreFields,
+    searchQuery,
     enabled: true,
     disableValues,
   });
diff --git a/packages/app/src/components/DBSearchPageFilters/useGroupExpansion.ts b/packages/app/src/components/DBSearchPageFilters/useGroupExpansion.ts
new file mode 100644
index 0000000000..631e98456d
--- /dev/null
+++ b/packages/app/src/components/DBSearchPageFilters/useGroupExpansion.ts
@@ -0,0 +1,56 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+/**
+ * Expansion state for a filter group, with a filter-name search override.
+ *
+ * A search opens every matching group so the match is actually visible, but
+ * the user still has to be able to close one while the search is open. So the
+ * override is held separately from the user's own browse state: toggling
+ * during a search moves the override, leaving the browse state to be restored
+ * when the search ends rather than the group staying stuck open.
+ *
+ * The override resets whenever a search starts or ends, so each search begins
+ * from "matches are visible" again.
+ *
+ * `expandBrowse` is for the caller's default-expansion signal — a group gaining
+ * a selection or a pin. That describes the browse state, so it has to bypass
+ * the override: routing it through `setExpanded` during a search would leave
+ * the browse state stale and collapse the group the moment the search cleared.
+ */
+export function useGroupExpansion(
+  defaultExpanded: boolean,
+  isForceExpanded?: boolean,
+): [boolean, (expanded: boolean) => void, () => void] {
+  const [browseExpanded, setBrowseExpanded] = useState(defaultExpanded);
+  const [searchExpanded, setSearchExpanded] = useState<boolean | null>(null);
+
+  // Reset during render rather than in an effect — this is the "adjust state
+  // when a prop changes" case, and an effect would render the stale override
+  // for a frame first.
+  const [lastForced, setLastForced] = useState(isForceExpanded);
+  if (lastForced !== isForceExpanded) {
+    setLastForced(isForceExpanded);
+    setSearchExpanded(null);
+  }
+
+  const expanded = isForceExpanded ? (searchExpanded ?? true) : browseExpanded;
+
+  // Read through a ref so the setter keeps a stable identity: callers hold it
+  // in `useCallback([])` and in effect deps, and a fresh function each render
+  // would either go stale or retrigger them.
+  const forcedRef = useRef(isForceExpanded);
+  useEffect(() => {
+    forcedRef.current = isForceExpanded;
+  }, [isForceExpanded]);
+  const setExpanded = useCallback((next: boolean) => {
+    if (forcedRef.current) {
+      setSearchExpanded(next);
+    } else {
+      setBrowseExpanded(next);
+    }
+  }, []);
+
+  const expandBrowse = useCallback(() => setBrowseExpanded(true), []);
+
+  return [expanded, setExpanded, expandBrowse];
+}