diff --git a/frontend/src/components/search/SearchFilterAccordion/SearchFilterAccordion.tsx b/frontend/src/components/search/SearchFilterAccordion/SearchFilterAccordion.tsx
index e719de3d9..4fb845cdf 100644
--- a/frontend/src/components/search/SearchFilterAccordion/SearchFilterAccordion.tsx
+++ b/frontend/src/components/search/SearchFilterAccordion/SearchFilterAccordion.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import { camelCase } from "lodash";
 import { QueryContext } from "src/app/[locale]/search/QueryProvider";
 import { useSearchParamUpdater } from "src/hooks/useSearchParamUpdater";
 import { QueryParamKey } from "src/types/search/searchResponseTypes";
@@ -43,6 +44,20 @@ export interface FilterOptionWithChildren {
   children: FilterOption[];
 }
 
+const isSectionAllSelected = (
+  allSelected: Set<string>,
+  query: Set<string>,
+): boolean => {
+  return areSetsEqual(allSelected, query);
+};
+
+const isSectionNoneSelected = (query: Set<string>): boolean => {
+  return query.size === 0;
+};
+
+const areSetsEqual = (a: Set<string>, b: Set<string>) =>
+  a.size === b.size && [...a].every((value) => b.has(value));
+
 export function SearchFilterAccordion({
   filterOptions,
   title,
@@ -50,13 +65,21 @@ export function SearchFilterAccordion({
   query,
 }: SearchFilterAccordionProps) {
   const { queryTerm } = useContext(QueryContext);
-  const { updateQueryParams } = useSearchParamUpdater();
+  const { updateQueryParams, searchParams } = useSearchParamUpdater();
+
   const totalCheckedCount = query.size;
-  // These are all of the available selectedable options.
-  const allOptionValues = filterOptions.map((options) => options.value);
-  // This is the setting if all are selected.
+  // all top level selectable filter options
+  const allOptionValues = filterOptions.reduce((values: string[], option) => {
+    if (option.children) {
+      return values;
+    }
+    values.push(option.value);
+    return values;
+  }, []);
+
   const allSelected = new Set(allOptionValues);
 
+  // SPLIT ME INTO MY OWN COMPONENT
   const getAccordionTitle = () => (
     <>
       {title}
@@ -68,29 +91,25 @@ export function SearchFilterAccordion({
     </>
   );
 
-  const toggleSelectAll = (all: boolean, allSelected: Set<string>): void => {
-    if (all) {
-      updateQueryParams(allSelected, queryParamKey, queryTerm);
+  // need to add any existing relevant search params to the passed in set
+  const toggleSelectAll = (all: boolean, newSelections?: Set<string>): void => {
+    if (all && newSelections) {
+      // get existing current selected options for this accordion from url
+      const currentSelections = new Set(
+        searchParams.get(camelCase(title))?.split(","),
+      );
+      // add existing to newly selected section
+      const sectionPlusCurrent = new Set([
+        ...currentSelections,
+        ...newSelections,
+      ]);
+      updateQueryParams(sectionPlusCurrent, queryParamKey, queryTerm);
     } else {
-      const noneSelected = new Set<string>();
-      updateQueryParams(noneSelected, queryParamKey, queryTerm);
+      const clearedSelections = newSelections || new Set<string>();
+      updateQueryParams(clearedSelections, queryParamKey, queryTerm);
     }
   };
 
-  const isSectionAllSelected = (
-    allSelected: Set<string>,
-    query: Set<string>,
-  ): boolean => {
-    return areSetsEqual(allSelected, query);
-  };
-
-  const isSectionNoneSelected = (query: Set<string>): boolean => {
-    return query.size === 0;
-  };
-
-  const areSetsEqual = (a: Set<string>, b: Set<string>) =>
-    a.size === b.size && [...a].every((value) => b.has(value));
-
   const toggleOptionChecked = (value: string, isChecked: boolean) => {
     const updated = new Set(query);
     isChecked ? updated.add(value) : updated.delete(value);
@@ -99,11 +118,12 @@ export function SearchFilterAccordion({
 
   const isExpanded = !!query.size;
 
+  // SPLIT ME INTO MY OWN COMPONENT
   const getAccordionContent = () => (
     <>
       <SearchFilterToggleAll
         onSelectAll={() => toggleSelectAll(true, allSelected)}
-        onClearAll={() => toggleSelectAll(false, allSelected)}
+        onClearAll={() => toggleSelectAll(false)}
         isAllSelected={isSectionAllSelected(allSelected, query)}
         isNoneSelected={isSectionNoneSelected(query)}
       />
@@ -138,12 +158,13 @@ export function SearchFilterAccordion({
     </>
   );
 
+  // MEMOIZE ME
   const accordionOptions: AccordionItemProps[] = [
     {
       title: getAccordionTitle(),
       content: getAccordionContent(),
       expanded: isExpanded,
-      id: `funding-instrument-filter-${queryParamKey}`,
+      id: `opportunity-filter-${queryParamKey}`,
       headingLevel: "h2",
     },
   ];
diff --git a/frontend/src/components/search/SearchFilterAccordion/SearchFilterSection/SearchFilterSection.tsx b/frontend/src/components/search/SearchFilterAccordion/SearchFilterSection/SearchFilterSection.tsx
index 87ed677bb..1a3385247 100644
--- a/frontend/src/components/search/SearchFilterAccordion/SearchFilterSection/SearchFilterSection.tsx
+++ b/frontend/src/components/search/SearchFilterAccordion/SearchFilterSection/SearchFilterSection.tsx
@@ -1,6 +1,9 @@
 "use client";
 
-import { useState } from "react";
+import { camelCase } from "lodash";
+
+import { useSearchParams } from "next/navigation";
+import { useCallback, useMemo, useState } from "react";
 
 import { FilterOptionWithChildren } from "src/components/search/SearchFilterAccordion/SearchFilterAccordion";
 import SearchFilterCheckbox from "src/components/search/SearchFilterAccordion/SearchFilterCheckbox";
@@ -11,7 +14,7 @@ import SearchFilterToggleAll from "src/components/search/SearchFilterAccordion/S
 interface SearchFilterSectionProps {
   option: FilterOptionWithChildren;
   updateCheckedOption: (optionId: string, isChecked: boolean) => void;
-  toggleSelectAll: (all: boolean, allSelected: Set<string>) => void;
+  toggleSelectAll: (all: boolean, allSelected?: Set<string>) => void;
   accordionTitle: string;
   isSectionAllSelected: (
     allSelected: Set<string>,
@@ -33,6 +36,7 @@ const SearchFilterSection: React.FC<SearchFilterSectionProps> = ({
   value,
 }) => {
   const [childrenVisible, setChildrenVisible] = useState<boolean>(false);
+  const searchParams = useSearchParams();
 
   const sectionQuery = new Set<string>();
   query.forEach((queryValue) => {
@@ -42,16 +46,26 @@ const SearchFilterSection: React.FC<SearchFilterSectionProps> = ({
       sectionQuery.add(queryValue);
     }
   });
-  const allSectionOptionValues = option.children.map(
-    (options) => options.value,
+  const allSectionOptions = useMemo(
+    () => new Set(option.children.map((options) => options.value)),
+    [option],
   );
-  const sectionAllSelected = new Set(allSectionOptionValues);
 
   const sectionCount = sectionQuery.size;
 
   const getHiddenName = (name: string) =>
     accordionTitle === "Agency" ? `agency-${name}` : name;
 
+  const clearSection = useCallback(() => {
+    const currentSelections = new Set(
+      searchParams.get(camelCase(accordionTitle))?.split(","),
+    );
+    allSectionOptions.forEach((option) => {
+      currentSelections.delete(option);
+    });
+    toggleSelectAll(false, currentSelections);
+  }, [toggleSelectAll, accordionTitle, searchParams, allSectionOptions]);
+
   return (
     <div>
       <button
@@ -69,10 +83,10 @@ const SearchFilterSection: React.FC<SearchFilterSectionProps> = ({
       {childrenVisible ? (
         <div className="padding-y-1">
           <SearchFilterToggleAll
-            onSelectAll={() => toggleSelectAll(true, sectionAllSelected)}
-            onClearAll={() => toggleSelectAll(false, sectionAllSelected)}
+            onSelectAll={() => toggleSelectAll(true, allSectionOptions)}
+            onClearAll={() => clearSection()}
             isAllSelected={isSectionAllSelected(
-              sectionAllSelected,
+              allSectionOptions,
               sectionQuery,
             )}
             isNoneSelected={isSectionNoneSelected(sectionQuery)}
diff --git a/frontend/tests/components/search/SearchFilterAccordion/SearchFilterAccordion.test.tsx b/frontend/tests/components/search/SearchFilterAccordion/SearchFilterAccordion.test.tsx
index c547f5c99..dd5b9f945 100644
--- a/frontend/tests/components/search/SearchFilterAccordion/SearchFilterAccordion.test.tsx
+++ b/frontend/tests/components/search/SearchFilterAccordion/SearchFilterAccordion.test.tsx
@@ -119,10 +119,10 @@ describe("SearchFilterAccordion", () => {
     );
 
     const accordionToggleButton = screen.getByTestId(
-      "accordionButton_funding-instrument-filter-status",
+      "accordionButton_opportunity-filter-status",
     );
     const contentDiv = screen.getByTestId(
-      "accordionItem_funding-instrument-filter-status",
+      "accordionItem_opportunity-filter-status",
     );
     expect(contentDiv).toHaveAttribute("hidden");
 
diff --git a/frontend/tests/e2e/search/search-no-results.spec.ts b/frontend/tests/e2e/search/search-no-results.spec.ts
index 7c63ec5b6..b51a8f054 100644
--- a/frontend/tests/e2e/search/search-no-results.spec.ts
+++ b/frontend/tests/e2e/search/search-no-results.spec.ts
@@ -2,7 +2,7 @@ import { expect, Page, test } from "@playwright/test";
 import { BrowserContextOptions } from "playwright-core";
 
 import {
-  expectURLContainsQueryParam,
+  expectURLContainsQueryParamValue,
   fillSearchInputAndSubmit,
   generateRandomString,
 } from "./searchSpecUtil";
@@ -23,7 +23,7 @@ test.describe("Search page tests", () => {
 
     await fillSearchInputAndSubmit(searchTerm, page);
     await new Promise((resolve) => setTimeout(resolve, 3250));
-    expectURLContainsQueryParam(page, "query", searchTerm);
+    expectURLContainsQueryParamValue(page, "query", searchTerm);
 
     // eslint-disable-next-line testing-library/prefer-screen-queries
     const resultsHeading = page.getByRole("heading", {
diff --git a/frontend/tests/e2e/search/search.spec.ts b/frontend/tests/e2e/search/search.spec.ts
index 147c514a6..be17f674a 100644
--- a/frontend/tests/e2e/search/search.spec.ts
+++ b/frontend/tests/e2e/search/search.spec.ts
@@ -1,4 +1,5 @@
 import { expect, test } from "@playwright/test";
+import { camelCase } from "lodash";
 import { PageProps } from "tests/e2e/playwrightUtils";
 import {
   clickAccordionWithTitle,
@@ -6,17 +7,22 @@ import {
   clickPaginationPageNumber,
   expectCheckboxIDIsChecked,
   expectSortBy,
-  expectURLContainsQueryParam,
+  expectURLContainsQueryParamValue,
   fillSearchInputAndSubmit,
   getFirstSearchResultTitle,
   getLastSearchResultTitle,
   getNumberOfOpportunitySearchResults,
   getSearchInput,
   refreshPageWithCurrentURL,
+  selectAllTopLevelFilterOptions,
   selectSortBy,
   toggleCheckboxes,
   toggleMobileSearchFilters,
+  validateTopLevelAndNestedSelectedFilterCounts,
+  waitForAnyURLChange,
   waitForSearchResultsInitialLoad,
+  waitForUrl,
+  waitForURLContainsQueryParam,
 } from "tests/e2e/search/searchSpecUtil";
 
 test.describe("Search page tests", () => {
@@ -144,7 +150,7 @@ test.describe("Search page tests", () => {
     await expect(currentPageButton).toHaveAttribute("aria-label", "Page 1");
 
     // It should not have a page query param set
-    expectURLContainsQueryParam(page, "page", "1", false);
+    expectURLContainsQueryParamValue(page, "page", "1", false);
   });
 
   test("last result becomes first result when flipping sort order", async ({
@@ -170,7 +176,7 @@ test.describe("Search page tests", () => {
     page,
   }, { project }) => {
     await page.goto("/search?status=none");
-    const initialNumberOfOpportunityResults =
+    const initialSearchResultsCount =
       await getNumberOfOpportunitySearchResults(page);
 
     // check all 4 boxes
@@ -187,11 +193,288 @@ test.describe("Search page tests", () => {
 
     await toggleCheckboxes(page, statusCheckboxes, "status");
 
-    const updatedNumberOfOpportunityResults =
+    const updatedSearchResultsCount =
       await getNumberOfOpportunitySearchResults(page);
 
-    expect(initialNumberOfOpportunityResults).toBe(
-      updatedNumberOfOpportunityResults,
-    );
+    expect(initialSearchResultsCount).toBe(updatedSearchResultsCount);
+  });
+  test.describe("selecting and clearing filters", () => {
+    const filterTypes = [
+      "Funding instrument",
+      "Eligibility",
+      "Category",
+      "Agency",
+    ];
+
+    filterTypes.forEach((filterType) => {
+      test(`correctly clears and selects all for ${filterType} filters`, async ({
+        page,
+      }, { project }) => {
+        const camelCaseFilterType = camelCase(filterType);
+        // load search page
+        await page.goto("/search");
+
+        const initialSearchResultsCount =
+          await getNumberOfOpportunitySearchResults(page);
+
+        // open accordion for filter type
+        if (project.name.match(/[Mm]obile/)) {
+          await toggleMobileSearchFilters(page);
+        }
+
+        await clickAccordionWithTitle(page, filterType);
+
+        const numberOfFilterOptions = await selectAllTopLevelFilterOptions(
+          page,
+          camelCaseFilterType,
+        );
+
+        // validate that new search results are returned
+        let updatedSearchResultsCount =
+          await getNumberOfOpportunitySearchResults(page);
+        expect(initialSearchResultsCount).not.toBe(updatedSearchResultsCount);
+
+        // validate that checkboxes are checked
+        let checkboxes = await page
+          .locator(
+            `#opportunity-filter-${camelCaseFilterType} > ul > li > div > input`,
+          )
+          .all();
+
+        await Promise.all(
+          checkboxes.map((checkbox) => expect(checkbox).toBeChecked()),
+        );
+
+        // validate that the correct number of filter options is displayed
+        const accordionButton = page.locator(
+          `button[data-testid="accordionButton_opportunity-filter-${camelCaseFilterType}"]`,
+        );
+
+        await expect(accordionButton).toHaveText(
+          `${filterType}${numberOfFilterOptions}`,
+        );
+
+        // click clear all
+        await page
+          .locator(
+            `#opportunity-filter-${camelCaseFilterType} button:has-text("Clear All")`,
+          )
+          .first()
+          .click();
+
+        // validate that url is updated
+        await waitForUrl(page, "http://127.0.0.1:3000/search");
+
+        // validate that new search results are returned
+        updatedSearchResultsCount =
+          await getNumberOfOpportunitySearchResults(page);
+        expect(initialSearchResultsCount).toBe(updatedSearchResultsCount);
+
+        // validate that checkboxes are not checked
+        checkboxes = await page
+          .locator(
+            `#opportunity-filter-${camelCaseFilterType} > ul > li > div > input`,
+          )
+          .all();
+
+        await Promise.all(
+          checkboxes.map((checkbox) => expect(checkbox).not.toBeChecked()),
+        );
+
+        // validate that the correct number of filter options is displayed
+        await expect(accordionButton).toHaveText(filterType);
+      });
+    });
+
+    /*
+      Scenarios
+
+      - click select all agencies -> click select all nested agency
+      - click clear all
+      - click select all nested agency -> click select all agencies
+      - click clear all nested agency
+    */
+    test("selects and clears nested agency filters", async ({ page }, {
+      project,
+    }) => {
+      const nestedFilterCheckboxesSelector =
+        "#opportunity-filter-agency > ul > li:first-child > div > div input";
+
+      await page.goto("/search");
+
+      const initialSearchResultsCount =
+        await getNumberOfOpportunitySearchResults(page);
+
+      // open accordion for filter type
+      if (project.name.match(/[Mm]obile/)) {
+        await toggleMobileSearchFilters(page);
+      }
+
+      await clickAccordionWithTitle(page, "Agency");
+
+      // gather number of (top level) filter options
+      // and select all top level filter options
+      const numberOfTopLevelFilterOptions =
+        await selectAllTopLevelFilterOptions(page, "agency");
+
+      const topLevelSelectedNumberOfSearchResults =
+        await getNumberOfOpportunitySearchResults(page);
+
+      // open first nested agency and get number of nested options
+      const firstExpander = page
+        .locator('#opportunity-filter-agency svg[aria-label="Expand section"]')
+        .first();
+      await firstExpander.click();
+
+      const numberOfNestedFilterOptions = await page
+        .locator(nestedFilterCheckboxesSelector)
+        .count();
+
+      let urlBeforeInteraction = page.url();
+
+      // click first nested select all
+      const selectAllNestedButton = page
+        .locator('#opportunity-filter-agency button:has-text("Select All")')
+        .nth(1);
+      await selectAllNestedButton.click();
+
+      await waitForAnyURLChange(page, urlBeforeInteraction);
+
+      // validate that new search results are returned
+      const topLevelAndNestedSelectedNumberOfSearchResults =
+        await getNumberOfOpportunitySearchResults(page);
+
+      expect(
+        topLevelAndNestedSelectedNumberOfSearchResults,
+      ).toBeLessThanOrEqual(topLevelSelectedNumberOfSearchResults);
+
+      // validate that nested checkboxes are checked
+      let checkboxes = await page.locator(nestedFilterCheckboxesSelector).all();
+
+      await Promise.all(
+        checkboxes.map((checkbox) => expect(checkbox).toBeChecked()),
+      );
+
+      // validate that the correct number of filter options is displayed
+      const accordionButton = page.locator(
+        'button[data-testid="accordionButton_opportunity-filter-agency"]',
+      );
+
+      await expect(accordionButton).toHaveText(
+        `Agency${numberOfTopLevelFilterOptions + numberOfNestedFilterOptions}`,
+      );
+
+      const expanderButton = page.locator(
+        "#opportunity-filter-agency > ul > li:first-child > div > button",
+      );
+
+      await expect(expanderButton).toContainText(
+        `${numberOfNestedFilterOptions}`,
+      );
+
+      await validateTopLevelAndNestedSelectedFilterCounts(
+        page,
+        "Agency",
+        numberOfTopLevelFilterOptions,
+        numberOfNestedFilterOptions,
+      );
+
+      // click clear all
+      await page
+        .locator(`#opportunity-filter-agency button:has-text("Clear All")`)
+        .first()
+        .click();
+
+      // validate that url is updated
+      await waitForUrl(page, "http://127.0.0.1:3000/search");
+
+      // validate that new search results are returned
+      const fullyClearedSearchResultsCount =
+        await getNumberOfOpportunitySearchResults(page);
+      expect(initialSearchResultsCount).toBe(fullyClearedSearchResultsCount);
+
+      // validate that nested checkboxes are not checked
+      checkboxes = await page.locator(nestedFilterCheckboxesSelector).all();
+
+      await Promise.all(
+        checkboxes.map((checkbox) => expect(checkbox).not.toBeChecked()),
+      );
+
+      // validate that the correct number of filter options is displayed
+      await expect(accordionButton).toHaveText("Agency");
+
+      // select all nested
+      await selectAllNestedButton.click();
+
+      await waitForURLContainsQueryParam(page, "agency");
+
+      // validate that new search results are returned, and correct counts displayed
+      const nestedSelectedNumberOfSearchResults =
+        await getNumberOfOpportunitySearchResults(page);
+
+      expect(nestedSelectedNumberOfSearchResults).toBeGreaterThanOrEqual(
+        topLevelAndNestedSelectedNumberOfSearchResults,
+      );
+
+      await validateTopLevelAndNestedSelectedFilterCounts(
+        page,
+        "Agency",
+        0,
+        numberOfNestedFilterOptions,
+      );
+
+      // select all top level
+      urlBeforeInteraction = page.url();
+      await selectAllTopLevelFilterOptions(page, "agency");
+
+      await waitForAnyURLChange(page, urlBeforeInteraction);
+
+      const newTopLevelAndNestedSelectedNumberOfSearchResults =
+        await getNumberOfOpportunitySearchResults(page);
+
+      expect(newTopLevelAndNestedSelectedNumberOfSearchResults).toEqual(
+        topLevelAndNestedSelectedNumberOfSearchResults,
+      );
+
+      await validateTopLevelAndNestedSelectedFilterCounts(
+        page,
+        "Agency",
+        numberOfTopLevelFilterOptions,
+        numberOfNestedFilterOptions,
+      );
+
+      urlBeforeInteraction = page.url();
+      // clear nested
+      await page
+        .locator(`#opportunity-filter-agency button:has-text("Clear All")`)
+        .nth(1)
+        .click();
+
+      // validate that url is updated
+
+      await waitForAnyURLChange(page, urlBeforeInteraction);
+
+      // validate that new search results are returned
+      const partiallyClearedSearchResultsCount =
+        await getNumberOfOpportunitySearchResults(page);
+      expect(partiallyClearedSearchResultsCount).toBeGreaterThanOrEqual(
+        topLevelAndNestedSelectedNumberOfSearchResults,
+      );
+
+      // validate that checkboxes are not checked
+      checkboxes = await page.locator(nestedFilterCheckboxesSelector).all();
+
+      await Promise.all(
+        checkboxes.map((checkbox) => expect(checkbox).not.toBeChecked()),
+      );
+
+      // validate that the correct number of filter options is displayed
+      await validateTopLevelAndNestedSelectedFilterCounts(
+        page,
+        "Agency",
+        numberOfTopLevelFilterOptions,
+        0,
+      );
+    });
   });
 });
diff --git a/frontend/tests/e2e/search/searchSpecUtil.ts b/frontend/tests/e2e/search/searchSpecUtil.ts
index d44dcdd2c..3768123b0 100644
--- a/frontend/tests/e2e/search/searchSpecUtil.ts
+++ b/frontend/tests/e2e/search/searchSpecUtil.ts
@@ -3,6 +3,7 @@
 // =========================
 
 import { expect, Locator, Page } from "@playwright/test";
+import { camelCase } from "lodash";
 
 export function getSearchInput(page: Page) {
   return page.locator("#query");
@@ -34,7 +35,7 @@ export const generateRandomString = (desiredPattern: number[]) => {
   }, "");
 };
 
-export function expectURLContainsQueryParam(
+export function expectURLContainsQueryParamValue(
   page: Page,
   queryParamName: string,
   queryParamValue: string,
@@ -50,29 +51,84 @@ export function expectURLContainsQueryParam(
   }
 }
 
-export async function waitForURLContainsQueryParam(
+export function expectURLContainsQueryParam(
   page: Page,
   queryParamName: string,
-  queryParamValue: string,
-  timeout = 30000, // query params get set after a debounce period
+) {
+  const currentURL = page.url();
+  expect(currentURL).toContain(queryParamName);
+}
+
+export async function waitForURLChange(
+  page: Page,
+  changeCheck: (url: string) => boolean,
+  timeout = 30000, // query params get set after a debounce period)
 ) {
   const endTime = Date.now() + timeout;
 
   while (Date.now() < endTime) {
-    const url = new URL(page.url());
-    const params = new URLSearchParams(url.search);
-    const actualValue = params.get(queryParamName);
-
-    if (actualValue === queryParamValue) {
+    const changeComplete = changeCheck(page.url());
+    if (changeComplete) {
       return;
     }
 
     await page.waitForTimeout(500);
   }
 
-  throw new Error(
-    `URL did not contain query parameter ${queryParamName}=${queryParamValue} within ${timeout}ms`,
-  );
+  throw new Error(`URL did not update as expected within ${timeout}ms`);
+}
+
+export async function waitForURLContainsQueryParamValue(
+  page: Page,
+  queryParamName: string,
+  queryParamValue: string,
+  timeout = 30000, // query params get set after a debounce period
+) {
+  const changeCheck = (pageUrl: string): boolean => {
+    const url = new URL(pageUrl);
+    const params = new URLSearchParams(url.search);
+    const actualValue = params.get(queryParamName);
+
+    return actualValue === queryParamValue;
+  };
+  await waitForURLChange(page, changeCheck, timeout);
+}
+
+export async function waitForUrl(
+  page: Page,
+  url: string,
+  timeout = 30000, // query params get set after a debounce period
+) {
+  const changeCheck = (pageUrl: string): boolean => {
+    return pageUrl === url;
+  };
+  await waitForURLChange(page, changeCheck, timeout);
+}
+
+export async function waitForURLContainsQueryParam(
+  page: Page,
+  queryParamName: string,
+  timeout = 30000, // query params get set after a debounce period
+) {
+  const changeCheck = (pageUrl: string): boolean => {
+    const url = new URL(pageUrl);
+    const params = new URLSearchParams(url.search);
+    const actualValue = params.get(queryParamName);
+
+    return !!actualValue;
+  };
+  await waitForURLChange(page, changeCheck, timeout);
+}
+
+export async function waitForAnyURLChange(
+  page: Page,
+  initialUrl: string,
+  timeout = 30000, // query params get set after a debounce period
+) {
+  const changeCheck = (pageUrl: string): boolean => {
+    return pageUrl !== initialUrl;
+  };
+  await waitForURLChange(page, changeCheck, timeout);
 }
 
 export function getMobileMenuButton(page: Page) {
@@ -108,7 +164,7 @@ export async function toggleCheckboxes(
     runningQueryParams += runningQueryParams
       ? `,${queryParamValue}`
       : queryParamValue;
-    await waitForURLContainsQueryParam(
+    await waitForURLContainsQueryParamValue(
       page,
       queryParamName,
       runningQueryParams,
@@ -234,3 +290,48 @@ export async function toggleMobileSearchFilters(page: Page) {
   );
   await toggleButton.click();
 }
+// returns the number of options available to be selected
+export const selectAllTopLevelFilterOptions = async (
+  page: Page,
+  filterType: string,
+): Promise<number> => {
+  // gather number of (top level) filter options for filter type
+  const numberOfFilterOptions = await page
+    .locator(`#opportunity-filter-${filterType} > ul > li > div > input`)
+    .count();
+
+  // click select all for filter type
+  const selectAllButton = page
+    .locator(`#opportunity-filter-${filterType} button:has-text("Select All")`)
+    .first();
+  await selectAllButton.click();
+
+  // validate that url is updated
+  await waitForURLContainsQueryParam(page, filterType);
+
+  return numberOfFilterOptions;
+};
+
+export const validateTopLevelAndNestedSelectedFilterCounts = async (
+  page: Page,
+  filterName: string,
+  expectedTopLevelCount: number,
+  expectedNestedCount: number,
+) => {
+  // validate that the correct number of filter options is displayed
+  const accordionButton = page.locator(
+    `button[data-testid="accordionButton_opportunity-filter-${camelCase(filterName)}"]`,
+  );
+
+  await expect(accordionButton).toHaveText(
+    `${filterName}${expectedTopLevelCount + expectedNestedCount}`,
+  );
+
+  const expanderButton = page.locator(
+    `#opportunity-filter-${camelCase(filterName)} > ul > li:first-child > div > button`,
+  );
+
+  if (expectedNestedCount) {
+    await expect(expanderButton).toContainText(`${expectedNestedCount}`);
+  }
+};
diff --git a/frontend/tests/e2e/search/searchUtil.ts b/frontend/tests/e2e/search/searchUtil.ts
index b61ed8893..af69665a8 100644
--- a/frontend/tests/e2e/search/searchUtil.ts
+++ b/frontend/tests/e2e/search/searchUtil.ts
@@ -12,10 +12,10 @@ export async function fillSearchInputAndSubmit(term: string, page: Page) {
   const searchInput = getSearchInput(page);
   await searchInput.fill(term);
   await page.click(".usa-search >> button[type='submit']");
-  expectURLContainsQueryParam(page, "query", term);
+  expectURLContainsQueryParamValue(page, "query", term);
 }
 
-export function expectURLContainsQueryParam(
+export function expectURLContainsQueryParamValue(
   page: Page,
   queryParamName: string,
   queryParamValue: string,
@@ -24,7 +24,7 @@ export function expectURLContainsQueryParam(
   expect(currentURL).toContain(`${queryParamName}=${queryParamValue}`);
 }
 
-export async function waitForURLContainsQueryParam(
+export async function waitForURLContainsQueryParamValue(
   page: Page,
   queryParamName: string,
   queryParamValue: string,
@@ -85,7 +85,7 @@ export async function toggleCheckboxes(
     runningQueryParams += runningQueryParams
       ? `,${queryParamValue}`
       : queryParamValue;
-    await waitForURLContainsQueryParam(
+    await waitForURLContainsQueryParamValue(
       page,
       queryParamName,
       runningQueryParams,