diff --git a/apps/docs/src/getting-started/e-commerce/product-listing.md b/apps/docs/src/getting-started/e-commerce/product-listing.md
index 82acced42..c5933d0cd 100644
--- a/apps/docs/src/getting-started/e-commerce/product-listing.md
+++ b/apps/docs/src/getting-started/e-commerce/product-listing.md
@@ -7,7 +7,7 @@ nav:
 
 In this chapter you will learn how to
 
-- Initialize the `useListing` composable
+- Use the modular listing composables (`useListingCore`, `useProductListingFilters`, `useProductListingPagination`, `useProductListingSorting`)
 - Search for products
 - Display products in a listing
 - Implement a pagination
@@ -15,6 +15,60 @@ In this chapter you will learn how to
 - Use the `helpers` package
 - Configure variants presentation for store API
 
+## Modular listing composables
+
+The listing logic is split into focused, modular composables that can be used independently:
+
+| Composable                       | Responsibility                                |
+| -------------------------------- | --------------------------------------------- |
+| `useListingCore`                 | Core state, search, loadMore, initial listing |
+| `useProductListingFilters`       | Filter management (get, set, reset)           |
+| `useProductListingPagination`    | Page navigation                               |
+| `useProductListingSorting`       | Sort order management                         |
+
+These composables work via Vue's `provide`/`inject`. A parent component sets up the listing context, and child components consume specific concerns.
+
+**Parent component** — creates the listing context (e.g. `CmsPage`):
+
+```vue
+<script setup lang="ts">
+import { createCategoryListingContext } from "@shopware/composables";
+
+// Extract listing from CMS page data and provide context to children
+const initialListing = getProductListingFromCmsPage(props.content);
+if (initialListing) {
+  createCategoryListingContext(initialListing);
+}
+</script>
+```
+
+**Child component** — uses the modular composables to access specific concerns:
+
+```vue
+<script setup lang="ts">
+import {
+  useListingCoreContext,
+  useProductListingPagination,
+} from "@shopware/composables";
+
+// Inject core listing state from parent
+const { getElements, loading, setInitialListing } = useListingCoreContext();
+// Use focused composables for specific concerns
+const { changeCurrentPage, getCurrentPage, getTotalPagesCount } =
+  useProductListingPagination();
+</script>
+```
+
+**Search page** — for product search, use the shared composable:
+
+```vue
+<script setup lang="ts">
+import { useProductSearchListing } from "@shopware/composables";
+
+const listing = useProductSearchListing();
+</script>
+```
+
 ## Listing context
 
 Product listing is a structure related to the predefined areas and it has always the same interface: `ProductListingResult`:
@@ -25,6 +79,10 @@ Product listing is a structure related to the predefined areas and it has always
 
 ## Listing type and context
 
+:::warning Deprecated
+`useListing` is deprecated. Use `useListingCore` with the modular composables (`useProductListingFilters`, `useProductListingPagination`, `useProductListingSorting`) instead.
+:::
+
 Before using the composable, define the type related to the context:
 
 - `categoryListing` for navigation/category/cms pages
@@ -105,11 +163,28 @@ search({ // invoke search() method
 
 ## Sorting
 
-Available methods of `useListing` to manage sorting order:
+Available methods to manage sorting order:
+
+- `getSortingOrders` - returns all available sorting options
+- `getCurrentSortingOrder` - returns the current order, available in the response
+- `changeCurrentSortingOrder` - sets the new order, invoking a `search` method internally
+
+Using the modular composable (recommended):
+
+```ts
+// part of <script setup> section
+import { useProductListingSorting } from "@shopware/composables";
+
+// Injects listing context from parent component
+const {
+  getCurrentSortingOrder,
+  getSortingOrders,
+  changeCurrentSortingOrder,
+} = useProductListingSorting();
+```
 
-- `getSortingOrders()` - returns all available sorting options
-- `getCurrentSortingOrder()` - returns the current order, available in the response
-- `changeCurrentSortingOrder()` - sets the new order, invoking a `search` method internally
+<details>
+<summary>Legacy approach (deprecated)</summary>
 
 ```ts{3-5}
 // part of <script setup> section
@@ -126,6 +201,7 @@ const {
   },
 });
 ```
+</details>
 
 Show all available sortings:
 
@@ -186,12 +262,29 @@ Alternative tip - Instead of using `useCart`, you can use `useAddToCart` composa
 
 ## Add pagination
 
-Pagination is available by using three methods from `useListing` composable:
+Pagination is available by using three methods:
 
 - `getCurrentPage`
 - `changeCurrentPage` - invokes `search()` method internally with the provided number of the page
 - `getTotalPagesCount` - calculates the number of available pages depending on products per page parameters (i.e. `limit` in search criteria)
 
+Using the modular composable (recommended):
+
+```ts
+// part of <script setup> section
+import { useProductListingPagination } from "@shopware/composables";
+
+// Injects listing context from parent component
+const {
+    getCurrentPage,
+    changeCurrentPage,
+    getTotalPagesCount,
+} = useProductListingPagination();
+```
+
+<details>
+<summary>Legacy approach (deprecated)</summary>
+
 ```ts{5-7}
 // part of <script setup> section
 const {
@@ -210,6 +303,7 @@ const {
     },
 })
 ```
+</details>
 
 The implementation can look similar to:
 
@@ -257,10 +351,14 @@ Built-in aggregations:
 
 The diagram explains the source of available filters. The API response contains aggregations that are parsed into one interface structure.
 
-In order to get the list of available filters, use the following command:
+In order to get the list of available filters, use the following composable:
 
 ```ts
-const { getAvailableFilters } = useListing(/** parameters omitted */);
+import { useProductListingFilters } from "@shopware/composables";
+
+// Injects listing context from parent component
+const { getAvailableFilters, getCurrentFilters, setCurrentFilters, resetFilters } =
+  useProductListingFilters();
 ```
 
 You can then iterate the filter objects available in the array. The filter object has a [ListingFilter](https://github.com/shopware/frontends/blob/main/packages/types/shopware-6-client/response/ListingResult.d.ts#L19) interface and depending on the `code`, or `displayType`, the handling process can be different. Let us have a closer look at it:
@@ -269,7 +367,7 @@ You can then iterate the filter objects available in the array. The filter objec
 
 ```vue{15,17}
 <script setup lang="ts">
-const { getAvailableFilters, getCurrentFilters, setCurrentFilters } = useListing(/** parameters omitted */)
+const { getAvailableFilters, getCurrentFilters, setCurrentFilters } = useProductListingFilters()
 
 const selectManufacturerAndSearch = (manufacturerId: string) => {
   setCurrentFilters({
@@ -374,7 +472,7 @@ In order to apply a specific filter you need to be aware of:
 
 ```vue
 <script setup lang="ts">
-const { setCurrentFilters } = useListing(/** parameters omitted */);
+const { setCurrentFilters } = useProductListingFilters();
 
 setCurrentFilters({
   code: "properties",
@@ -396,7 +494,7 @@ setCurrentFilters({
 
 ```vue
 <script setup lang="ts">
-const { getCurrentFilters } = useListing(/** parameters omitted */);
+const { getCurrentFilters } = useProductListingFilters();
 </script>
 <template>
   {{ getCurrentFilters.navigationId }}
diff --git a/packages/cms-base-layer/app/components/SwProductListingFilters.vue b/packages/cms-base-layer/app/components/SwProductListingFilters.vue
index f102bba42..5b3001569 100644
--- a/packages/cms-base-layer/app/components/SwProductListingFilters.vue
+++ b/packages/cms-base-layer/app/components/SwProductListingFilters.vue
@@ -3,12 +3,16 @@ import type {
   CmsElementProductListing,
   CmsElementSidebarFilter,
 } from "@shopware/composables";
-import { useCmsTranslations } from "@shopware/composables";
+import {
+  useCmsTranslations,
+  useListingCoreContext,
+  useProductListingFilters,
+  useProductListingSorting,
+} from "@shopware/composables";
 import { defu } from "defu";
 import { computed, reactive } from "vue";
 import type { ComputedRef, UnwrapNestedRefs } from "vue";
 import { type LocationQueryRaw, useRoute, useRouter } from "vue-router";
-import { useCategoryListing } from "#imports";
 import type { Schemas, operations } from "#shopware";
 
 const props = defineProps<{
@@ -46,14 +50,10 @@ translations = defu(useCmsTranslations(), translations) as Translations;
 const route = useRoute();
 const router = useRouter();
 
-const {
-  changeCurrentSortingOrder,
-  getCurrentFilters,
-  getCurrentSortingOrder,
-  getInitialFilters,
-  getSortingOrders,
-  search,
-} = useCategoryListing();
+const { search } = useListingCoreContext();
+const { getInitialFilters, getCurrentFilters } = useProductListingFilters();
+const { getSortingOrders, getCurrentSortingOrder, changeCurrentSortingOrder } =
+  useProductListingSorting();
 
 const sidebarSelectedFilters: UnwrapNestedRefs<FilterState> =
   reactive<FilterState>({
diff --git a/packages/cms-base-layer/app/components/SwProductListingFiltersHorizontal.vue b/packages/cms-base-layer/app/components/SwProductListingFiltersHorizontal.vue
index a2152d6ea..48f5b360b 100644
--- a/packages/cms-base-layer/app/components/SwProductListingFiltersHorizontal.vue
+++ b/packages/cms-base-layer/app/components/SwProductListingFiltersHorizontal.vue
@@ -3,12 +3,16 @@ import type {
   CmsElementProductListing,
   CmsElementSidebarFilter,
 } from "@shopware/composables";
-import { useCmsTranslations } from "@shopware/composables";
+import {
+  useCmsTranslations,
+  useListingCoreContext,
+  useProductListingFilters,
+  useProductListingSorting,
+} from "@shopware/composables";
 import { defu } from "defu";
 import { computed, reactive } from "vue";
 import type { ComputedRef, UnwrapNestedRefs } from "vue";
 import { type LocationQueryRaw, useRoute, useRouter } from "vue-router";
-import { useCategoryListing } from "#imports";
 import type { Schemas, operations } from "#shopware";
 
 const props = defineProps<{
@@ -46,13 +50,10 @@ translations = defu(useCmsTranslations(), translations) as Translations;
 const route = useRoute();
 const router = useRouter();
 
-const {
-  changeCurrentSortingOrder,
-  getCurrentSortingOrder,
-  getInitialFilters,
-  getSortingOrders,
-  search,
-} = useCategoryListing();
+const { search } = useListingCoreContext();
+const { getInitialFilters } = useProductListingFilters();
+const { getSortingOrders, getCurrentSortingOrder, changeCurrentSortingOrder } =
+  useProductListingSorting();
 
 const sidebarSelectedFilters: UnwrapNestedRefs<FilterState> =
   reactive<FilterState>({
diff --git a/packages/cms-base-layer/app/components/public/cms/element/CmsElementProductListing.vue b/packages/cms-base-layer/app/components/public/cms/element/CmsElementProductListing.vue
index c0d174eba..1f1201f9f 100644
--- a/packages/cms-base-layer/app/components/public/cms/element/CmsElementProductListing.vue
+++ b/packages/cms-base-layer/app/components/public/cms/element/CmsElementProductListing.vue
@@ -1,10 +1,14 @@
 <script setup lang="ts">
 import type { CmsElementProductListing } from "@shopware/composables";
-import { useCmsTranslations } from "@shopware/composables";
+import {
+  useCmsTranslations,
+  useListingCoreContext,
+  useProductListingPagination,
+} from "@shopware/composables";
 import { defu } from "defu";
 import { computed, ref, useTemplateRef, watch } from "vue";
 import { useRoute, useRouter } from "vue-router";
-import { useCategoryListing, useCmsElementConfig } from "#imports";
+import { useCmsElementConfig } from "#imports";
 import type { Schemas, operations } from "#shopware";
 
 const props = defineProps<{
@@ -35,14 +39,9 @@ let translations: Translations = {
 };
 translations = defu(useCmsTranslations(), translations) as Translations;
 
-const {
-  changeCurrentPage,
-  getCurrentPage,
-  getElements,
-  getTotalPagesCount,
-  loading,
-  setInitialListing,
-} = useCategoryListing();
+const { getElements, loading, setInitialListing } = useListingCoreContext();
+const { changeCurrentPage, getCurrentPage, getTotalPagesCount } =
+  useProductListingPagination();
 const route = useRoute();
 const router = useRouter();
 const limit = ref(
diff --git a/packages/composables/src/useListing/useListing.ts b/packages/composables/src/useListing/useListing.ts
index 722e58ad7..10f2d208a 100644
--- a/packages/composables/src/useListing/useListing.ts
+++ b/packages/composables/src/useListing/useListing.ts
@@ -1,181 +1,25 @@
-import { getListingFilters } from "@shopware/helpers";
 import { createInjectionState, createSharedComposable } from "@vueuse/core";
-import { computed, inject, provide, ref } from "vue";
-import type { ComputedRef, Ref } from "vue";
+import { computed } from "vue";
 import { useCategory, useShopwareContext } from "#imports";
 import type { Schemas, operations } from "#shopware";
-
-function isObject<T>(item: T): boolean {
-  return item && typeof item === "object" && !Array.isArray(item);
-}
-
-function merge<T extends { [key in keyof T]: unknown }>(
-  target: T,
-  ...sources: T[]
-): T {
-  if (!sources.length) return target;
-  const source = sources.shift();
-
-  if (source === undefined) {
-    return target;
-  }
-
-  if (isObject(target) && isObject(source)) {
-    for (const key in source) {
-      if (isObject(source[key])) {
-        if (!target[key]) Object.assign(target, { [key]: {} });
-        merge(target[key], source[key]);
-      } else {
-        Object.assign(target, { [key]: source[key] });
-      }
-    }
-  }
-
-  return merge(target, ...sources);
-}
-
-export type ListingType = "productSearchListing" | "categoryListing";
-
-export type ShortcutFilterParam<
-  T extends
-    keyof Schemas["ProductListingCriteria"] = keyof Schemas["ProductListingCriteria"],
-> = {
-  code: T;
-  value: Schemas["ProductListingCriteria"][T];
-};
-
-export type UseListingReturn = {
-  /**
-   * Listing that is currently set
-   * {@link ListingResult} object
-   */
-  getInitialListing: ComputedRef<Schemas["ProductListingResult"] | null>;
-  /**
-   * Sets the initial listing - available synchronously
-   * @param {@link initialListing} - initial listing to set
-   * @returns
-   */
-  setInitialListing(
-    initialListing: Schemas["ProductListingResult"],
-  ): Promise<void>;
-  /**
-   * @deprecated - use `search` instead
-   * Searches for the listing based on the criteria
-   * @param criteria {@link Schemas['Criteria']}
-   * @returns
-   */
-  initSearch(
-    criteria: operations["searchPage post /search"]["body"],
-  ): Promise<Schemas["ProductListingResult"]>;
-  /**
-   * Searches for the listing based on the criteria
-   * @param criteria
-   * @returns
-   */
-  search(
-    criteria:
-      | operations["readProductListing post /product-listing/{categoryId}"]["body"]
-      | operations["searchPage post /search"]["body"],
-  ): Promise<void>;
-  /**
-   * Loads more (next page) elements to the listing
-   */
-  loadMore(
-    criteria?: operations["searchPage post /search"]["body"],
-  ): Promise<void>;
-  /**
-   * Listing that is currently set
-   */
-  getCurrentListing: ComputedRef<Schemas["ProductListingResult"] | null>;
-  /**
-   * Listing elements ({@link Product}) that are currently set
-   */
-  getElements: ComputedRef<Schemas["ProductListingResult"]["elements"]>;
-  /**
-   * Available sorting orders
-   */
-  getSortingOrders: ComputedRef<
-    Schemas["ProductSorting"][] | { key: string; label: string }[] | undefined
-  >;
-  /**
-   * Current sorting order
-   */
-  getCurrentSortingOrder: ComputedRef<string | undefined>;
-  /**
-   * Changes the current sorting order
-   * @param order - i.e. "name-asc"
-   * @returns
-   */
-  changeCurrentSortingOrder(
-    order: string,
-    query?: operations["searchPage post /search"]["body"],
-  ): Promise<void>;
-  /**
-   * Current page number
-   */
-  getCurrentPage: ComputedRef<number>;
-  /**
-   * Changes the current page number
-   * @param pageNumber - page number to change to
-   * @returns
-   */
-  changeCurrentPage(
-    page: number,
-    query?: operations["searchPage post /search"]["body"],
-  ): Promise<void>;
-  /**
-   * Total number of elements found for the current search criteria
-   */
-  getTotal: ComputedRef<number>;
-  /**
-   * Total number of pages found for the current search criteria
-   */
-  getTotalPagesCount: ComputedRef<number>;
-  /**
-   * Number of elements per page
-   */
-  getLimit: ComputedRef<number>;
-  /**
-   * Initial filters
-   */
-  getInitialFilters: ComputedRef<ReturnType<typeof getListingFilters>>;
-  /**
-   * All available filters
-   */
-  getAvailableFilters: ComputedRef<ReturnType<typeof getListingFilters>>;
-  /**
-   * Filters that are currently set
-   */
-  getCurrentFilters: ComputedRef<
-    Schemas["ProductListingResult"]["currentFilters"]
-  >;
-  /**
-   * Sets the filters to be applied for the listing
-   * @param filters
-   * @returns
-   */
-  setCurrentFilters(filters: ShortcutFilterParam[]): Promise<void>;
-  /**
-   * Indicates if the listing is being fetched
-   */
-  loading: ComputedRef<boolean>;
-  /**
-   * Indicates if the listing is being fetched via `loadMore` method
-   */
-  loadingMore: ComputedRef<boolean>;
-  /**
-   * Resets the filters - clears the current filters
-   */
-  resetFilters(): Promise<void>;
-  /**
-   * Change selected filters to the query object
-   */
-  filtersToQuery(
-    filters: Schemas["ProductListingCriteria"],
-  ): Record<string, unknown>;
-};
+import { useListingCore } from "./useListingCore";
+import { useProductListingFilters } from "./useProductListingFilters";
+import { useProductListingPagination } from "./useProductListingPagination";
+import { useProductListingSorting } from "./useProductListingSorting";
+
+export type {
+  ListingType,
+  ShortcutFilterParam,
+  UseListingReturn,
+} from "./utils";
+export { useListingCoreContext } from "./useListingCore";
+export { useProductListingPagination } from "./useProductListingPagination";
+export { useProductListingSorting } from "./useProductListingSorting";
+export { useProductListingFilters } from "./useProductListingFilters";
+import type { ListingType, UseListingReturn } from "./utils";
 
 /**
+ * @deprecated Use `useListingCore` with `useProductListingFilters`, `useProductListingPagination`, and `useProductListingSorting` instead.
  * @public
  * @category Product
  */
@@ -291,6 +135,7 @@ export const useProductSearchListing = createSharedComposable(() =>
  * By default you can use useListing composable, which provides you predefined listings for category(cms) listing and product search listing.
  * Using factory you can provide our own compatible search method and use it for example for creating listing of orders in my account.
  *
+ * @deprecated Use `useListingCore` with `useProductListingFilters`, `useProductListingPagination`, and `useProductListingSorting` instead.
  * @public
  */
 export function createListingComposable({
@@ -308,294 +153,60 @@ export function createListingComposable({
   listingKey: string;
   initialListing?: Schemas["ProductListingResult"] | null;
 }): UseListingReturn {
-  // const COMPOSABLE_NAME = "createListingComposable";
-  // const contextName = COMPOSABLE_NAME;
-
-  // const router = useRouter();
-
-  // Handle CMS context to be able to show different breadcrumbs for different CMS pages.
-  // const { isVueComponent } = useVueContext();
-  // const cmsContext = isVueComponent && inject("swCmsContext", null);
-  // const cacheKey = cmsContext
-  //   ? `${contextName}(cms-${cmsContext})`
-  //   : contextName;
-
-  const loading = ref(false);
-  const loadingMore = ref(false);
-
-  // const { sharedRef } = useSharedState();
-  const _storeInitialListing = inject<
-    Ref<Schemas["ProductListingResult"] | null>
-  >(`useListingInitial-${listingKey}`, ref(initialListing ?? null));
-  provide(`useListingInitial-${listingKey}`, _storeInitialListing);
-  // const _storeInitialListing = sharedRef<Schemas["ProductListingResult"]>(
-  //   `${cacheKey}-initialListing-${listingKey}`
-  // );
-  // const _storeAppliedListing = sharedRef<Partial<Schemas["ProductListingResult"]>>(
-  //   `${cacheKey}-appliedListing-${listingKey}`
-  // );
-  const _storeAppliedListing = inject<
-    Ref<Schemas["ProductListingResult"] | null>
-  >(`useListingApplied-${listingKey}`, ref(null));
-  provide(`useListingApplied-${listingKey}`, _storeAppliedListing);
-
-  const getInitialListing = computed(() => _storeInitialListing.value);
-  const setInitialListing = async (
-    initialListing: Schemas["ProductListingResult"],
-  ) => {
-    _storeInitialListing.value = initialListing;
-    _storeAppliedListing.value = null;
-  };
-
-  const initSearch = async (
-    criteria: operations["searchPage post /search"]["body"],
-  ): Promise<Schemas["ProductListingResult"]> => {
-    loading.value = true;
-    try {
-      const searchCriteria = merge(
-        {} as operations["searchPage post /search"]["body"],
-        searchDefaults,
-        criteria,
-      );
-      const result = await searchMethod(searchCriteria);
-      return result;
-    } finally {
-      loading.value = false;
-    }
-  };
-
-  async function search(
-    criteria: operations["searchPage post /search"]["body"],
-  ) {
-    loading.value = true;
-    try {
-      const searchCriteria = merge(
-        {} as operations["searchPage post /search"]["body"],
-        searchDefaults,
-        criteria,
-      );
-      const result = await searchMethod(searchCriteria);
-
-      _storeAppliedListing.value = result;
-    } finally {
-      loading.value = false;
-    }
-  }
-
-  const loadMore = async (
-    criteria?: operations["searchPage post /search"]["body"],
-  ): Promise<void> => {
-    loadingMore.value = true;
-    try {
-      const q = criteria
-        ? criteria
-        : {
-            // ...router.currentRoute.query,
-            p: getCurrentPage.value + 1,
-          };
-
-      const searchCriteria = merge(
-        {} as operations["searchPage post /search"]["body"],
-        searchDefaults,
-        q,
-      ) as operations["searchPage post /search"]["body"];
-      const result = await searchMethod(searchCriteria);
-      _storeAppliedListing.value = {
-        ...(getCurrentListing.value || {}),
-        page: result.page,
-        elements: [
-          ...(getCurrentListing.value?.elements || []),
-          ...(result.elements ?? []),
-        ],
-      } as Schemas["ProductListingResult"];
-    } finally {
-      loadingMore.value = false;
-    }
-  };
-
-  const getCurrentListing = computed(() => {
-    return _storeAppliedListing.value || getInitialListing.value;
-  });
-
-  const getElements = computed(() => {
-    return getCurrentListing.value?.elements || [];
-  });
-  const getTotal = computed(() => {
-    return getCurrentListing.value?.total || 0;
-  });
-  const getLimit = computed(() => {
-    return getCurrentListing.value?.limit || searchDefaults?.limit || 10;
-  });
-
-  const getTotalPagesCount = computed(() =>
-    Math.ceil(getTotal.value / getLimit.value),
-  );
-
-  const getSortingOrders = computed(() => {
-    return getCurrentListing.value?.availableSortings;
+  const core = useListingCore({
+    listingKey,
+    searchMethod,
+    searchDefaults,
+    initialListing,
   });
 
-  const getCurrentSortingOrder = computed(
-    () => getCurrentListing.value?.sorting,
-  );
-  async function changeCurrentSortingOrder(
-    order: string,
-    query?: operations["searchPage post /search"]["body"],
-  ) {
-    await search(
-      Object.assign(
-        {
-          order,
-        },
-        query,
-      ),
-    );
-  }
-
-  const getCurrentPage = computed(() => getCurrentListing.value?.page || 1);
-
-  const changeCurrentPage = async (
-    page: number,
-    query?: operations["searchPage post /search"]["body"],
-  ) => {
-    await search(
-      Object.assign(
-        {
-          page,
-        },
-        query,
-      ),
-    );
-  };
-
-  const getInitialFilters = computed(() => {
-    return getListingFilters(getInitialListing.value?.aggregations);
+  const pagination = useProductListingPagination({
+    getCurrentListing: core.getCurrentListing,
+    getLimit: core.getLimit,
+    getTotal: core.getTotal,
+    search: core.search,
   });
 
-  const getAvailableFilters = computed(() => {
-    return getListingFilters(
-      _storeAppliedListing.value?.aggregations ||
-        getCurrentListing.value?.aggregations,
-    );
+  const sorting = useProductListingSorting({
+    getCurrentListing: core.getCurrentListing,
+    search: core.search,
   });
 
-  const getCurrentFilters = computed(() => {
-    // const currentFiltersResult: Schemas["ProductListingResult"]["currentFilters"] =
-    //   {};
-    // const currentFilters = {
-    //   ...getCurrentListing.value?.currentFilters,
-    //   // ...router.currentRoute.query,
-    // };
-    // Object.keys(currentFilters).forEach(
-    //   (objectKey: keyof Schemas["ProductListingResult"]["currentFilters"]) => {
-    //     if (!currentFilters[objectKey]) return;
-    //     if (objectKey === "navigationId") return;
-    //     if (objectKey === "price") {
-    //       if (currentFilters.price?.min)
-    //         currentFiltersResult.price.min = currentFilters[objectKey].min;
-    //       if (currentFilters[objectKey].max)
-    //         currentFiltersResult["max-price"] = currentFilters[objectKey].max;
-    //       return;
-    //     }
-    //     if (objectKey === "p") return;
-    //     currentFiltersResult[objectKey] = currentFilters[objectKey];
-    //   },
-    // );
-    return getCurrentListing.value
-      ?.currentFilters as Schemas["ProductListingResult"]["currentFilters"];
+  const filters = useProductListingFilters({
+    getInitialListing: core.getInitialListing,
+    getCurrentListing: core.getCurrentListing,
+    _storeAppliedListing: core._storeAppliedListing,
+    search: core.search,
+    searchDefaults,
   });
 
-  // this function sets the current filters as shortcut filters @see https://shopware.stoplight.io/docs/store-api/b56ebe18277c6-searching-for-products#product-listing-criteria
-  // the downside is that this does not filter the aggregations, so the aggregations are not reduced by the filter (!)
-  const setCurrentFilters = (filters: ShortcutFilterParam[]) => {
-    const newFilters = {};
-    for (const filter of filters) {
-      Object.assign(newFilters, { [filter.code]: filter.value });
-    }
-
-    const appliedFilters = Object.assign(
-      {},
-      getCurrentFilters.value,
-      {
-        query: getCurrentFilters.value?.search,
-        manufacturer: getCurrentFilters.value?.manufacturer?.join("|"),
-        properties: getCurrentFilters.value?.properties?.join("|"),
-      },
-      { ...newFilters },
-    );
-
-    if (_storeAppliedListing.value) {
-      _storeAppliedListing.value.currentFilters = {
-        ...appliedFilters,
-        manufacturer: appliedFilters.manufacturer?.split("|"),
-        properties: appliedFilters.properties?.split("|"),
-      };
-    }
-
-    return search(
-      appliedFilters as operations["searchPage post /search"]["body"],
-    );
-  };
-
-  const resetFilters = () => {
-    const defaultFilters = Object.assign(
-      {
-        manufacturer: [],
-        properties: [],
-        price: { min: 0, max: 0 },
-        search: getCurrentFilters.value?.search,
-      },
-      searchDefaults,
-    );
-
-    if (_storeAppliedListing.value) {
-      _storeAppliedListing.value.currentFilters =
-        defaultFilters as unknown as Schemas["ProductListingResult"]["currentFilters"];
-    }
-    return search({ search: getCurrentFilters.value?.search || "" });
-  };
-
-  const filtersToQuery = (filters: Schemas["ProductListingCriteria"]) => {
-    const queryObject: Record<string, unknown> = {};
-
-    for (const filter in filters) {
-      const currentFilter =
-        filters[filter as keyof Schemas["ProductListingCriteria"]];
-      if (currentFilter) {
-        if (Array.isArray(currentFilter) && currentFilter.length) {
-          queryObject[filter] = currentFilter.join("|");
-        } else if (!Array.isArray(currentFilter)) {
-          queryObject[filter] = currentFilter;
-        }
-      }
-    }
-
-    return queryObject;
-  };
-
   return {
-    changeCurrentPage,
-    changeCurrentSortingOrder,
-    filtersToQuery,
-    getAvailableFilters,
-    getCurrentFilters,
-    getCurrentListing,
-    getCurrentPage,
-    getCurrentSortingOrder,
-    getElements,
-    getInitialFilters,
-    getInitialListing,
-    getLimit,
-    getSortingOrders,
-    getTotal,
-    getTotalPagesCount,
-    initSearch,
-    loadMore,
-    loading: computed(() => loading.value),
-    loadingMore: computed(() => loadingMore.value),
-    resetFilters,
-    search,
-    setCurrentFilters,
-    setInitialListing,
+    // Core
+    getInitialListing: core.getInitialListing,
+    setInitialListing: core.setInitialListing,
+    initSearch: core.initSearch,
+    search: core.search,
+    loadMore: core.loadMore,
+    getCurrentListing: core.getCurrentListing,
+    getElements: core.getElements,
+    getTotal: core.getTotal,
+    getLimit: core.getLimit,
+    loading: computed(() => core.loading.value),
+    loadingMore: computed(() => core.loadingMore.value),
+    // Pagination
+    getCurrentPage: pagination.getCurrentPage,
+    changeCurrentPage: pagination.changeCurrentPage,
+    getTotalPagesCount: pagination.getTotalPagesCount,
+    // Sorting
+    getSortingOrders: sorting.getSortingOrders,
+    getCurrentSortingOrder: sorting.getCurrentSortingOrder,
+    changeCurrentSortingOrder: sorting.changeCurrentSortingOrder,
+    // Filters
+    getInitialFilters: filters.getInitialFilters,
+    getAvailableFilters: filters.getAvailableFilters,
+    getCurrentFilters: filters.getCurrentFilters,
+    setCurrentFilters: filters.setCurrentFilters,
+    resetFilters: filters.resetFilters,
+    filtersToQuery: filters.filtersToQuery,
   };
 }
diff --git a/packages/composables/src/useListing/useListingCore.test.ts b/packages/composables/src/useListing/useListingCore.test.ts
new file mode 100644
index 000000000..49f64b39d
--- /dev/null
+++ b/packages/composables/src/useListing/useListingCore.test.ts
@@ -0,0 +1,156 @@
+import { mount } from "@vue/test-utils";
+import { describe, expect, it, vi } from "vitest";
+import { defineComponent, h } from "vue";
+import type { Schemas } from "#shopware";
+import { useSetup } from "../_test";
+import { useListingCore, useListingCoreContext } from "./useListingCore";
+
+const mockSearchMethod = vi.fn();
+
+function setupListingCore(
+  initialListing?: Schemas["ProductListingResult"] | null,
+) {
+  return useSetup(() =>
+    useListingCore({
+      listingKey: "testListing",
+      searchMethod: mockSearchMethod,
+      searchDefaults: {},
+      initialListing,
+    }),
+  );
+}
+
+describe("useListingCore", () => {
+  it("should initialize with null listing when no initialListing provided", () => {
+    const { vm } = setupListingCore();
+
+    expect(vm.getInitialListing).toBeNull();
+    expect(vm.getCurrentListing).toBeNull();
+    expect(vm.getElements).toEqual([]);
+    expect(vm.getTotal).toBe(0);
+    expect(vm.getLimit).toBe(10);
+  });
+
+  it("should initialize with provided initialListing", () => {
+    const mockListing = {
+      elements: [{ id: "p1" }],
+      total: 5,
+      limit: 20,
+      page: 1,
+    } as Schemas["ProductListingResult"];
+
+    const { vm } = setupListingCore(mockListing);
+
+    expect(vm.getInitialListing).toEqual(mockListing);
+    expect(vm.getCurrentListing).toEqual(mockListing);
+    expect(vm.getElements).toEqual([{ id: "p1" }]);
+    expect(vm.getTotal).toBe(5);
+    expect(vm.getLimit).toBe(20);
+  });
+
+  it("should set initial listing", async () => {
+    const { vm } = setupListingCore();
+    const newListing = {
+      elements: [{ id: "p2" }],
+      total: 3,
+    } as Schemas["ProductListingResult"];
+
+    await vm.setInitialListing(newListing);
+
+    expect(vm.getInitialListing).toEqual(newListing);
+  });
+
+  it("should search and update applied listing", async () => {
+    const result = {
+      elements: [{ id: "p3" }],
+      total: 1,
+      page: 1,
+    } as Schemas["ProductListingResult"];
+    mockSearchMethod.mockResolvedValue(result);
+
+    const { vm } = setupListingCore();
+    await vm.search({ search: "test" });
+
+    expect(vm.getCurrentListing).toEqual(result);
+    expect(vm.loading).toBe(false);
+  });
+
+  it("should loadMore and append elements", async () => {
+    const initialListing = {
+      elements: [{ id: "p1" }],
+      total: 3,
+      page: 1,
+    } as Schemas["ProductListingResult"];
+
+    const moreResult = {
+      elements: [{ id: "p2" }],
+      page: 2,
+    } as Schemas["ProductListingResult"];
+    mockSearchMethod.mockResolvedValue(moreResult);
+
+    const { vm } = setupListingCore(initialListing);
+    await vm.loadMore();
+
+    expect(vm.getCurrentListing?.elements).toHaveLength(2);
+    expect(vm.getCurrentListing?.page).toBe(2);
+    expect(vm.loadingMore).toBe(false);
+  });
+
+  it("initSearch should return result without updating applied listing", async () => {
+    const result = {
+      elements: [{ id: "p5" }],
+      total: 1,
+    } as Schemas["ProductListingResult"];
+    mockSearchMethod.mockResolvedValue(result);
+
+    const { vm } = setupListingCore();
+    const returned = await vm.initSearch({ search: "test" });
+
+    expect(returned).toEqual(result);
+    expect(vm.getCurrentListing).toBeNull();
+  });
+});
+
+describe("useListingCoreContext", () => {
+  it("should throw when no context is provided", () => {
+    expect(() => useSetup(() => useListingCoreContext())).toThrowError(
+      /Listing context not found/,
+    );
+  });
+
+  it("should return context when provided by parent component", () => {
+    let childResult: ReturnType<typeof useListingCoreContext> | undefined;
+
+    const Child = defineComponent({
+      setup() {
+        childResult = useListingCoreContext();
+        return {};
+      },
+      render: () => h("span"),
+    });
+
+    const Parent = defineComponent({
+      setup() {
+        useListingCore({
+          listingKey: "testListing",
+          searchMethod: mockSearchMethod,
+          searchDefaults: {},
+        });
+      },
+      render: () => h(Child),
+    });
+
+    mount(Parent, {
+      global: {
+        provide: {
+          shopware: {},
+          apiClient: { invoke: vi.fn() },
+        },
+      },
+    });
+
+    expect(childResult).toBeDefined();
+    expect(childResult?.getCurrentListing.value).toBeNull();
+    expect(childResult?.getElements.value).toEqual([]);
+  });
+});
diff --git a/packages/composables/src/useListing/useListingCore.ts b/packages/composables/src/useListing/useListingCore.ts
new file mode 100644
index 000000000..192a34b61
--- /dev/null
+++ b/packages/composables/src/useListing/useListingCore.ts
@@ -0,0 +1,158 @@
+import { computed, inject, provide, ref } from "vue";
+import type { Ref } from "vue";
+import type { Schemas, operations } from "#shopware";
+import { merge } from "./utils";
+
+export const LISTING_CONTEXT_KEY = "listingCoreContext";
+
+export type ListingCoreContext = ReturnType<typeof useListingCore>;
+
+export function useListingCore({
+  listingKey,
+  searchMethod,
+  searchDefaults,
+  initialListing,
+}: {
+  listingKey: string;
+  searchMethod(
+    searchParams:
+      | operations["readProductListing post /product-listing/{categoryId}"]["body"]
+      | operations["searchPage post /search"]["body"],
+  ): Promise<Schemas["ProductListingResult"]>;
+  searchDefaults: operations["searchPage post /search"]["body"];
+  initialListing?: Schemas["ProductListingResult"] | null;
+}) {
+  const loading = ref(false);
+  const loadingMore = ref(false);
+
+  const _storeInitialListing = inject<
+    Ref<Schemas["ProductListingResult"] | null>
+  >(`useListingInitial-${listingKey}`, ref(initialListing ?? null));
+  provide(`useListingInitial-${listingKey}`, _storeInitialListing);
+
+  const _storeAppliedListing = inject<
+    Ref<Schemas["ProductListingResult"] | null>
+  >(`useListingApplied-${listingKey}`, ref(null));
+  provide(`useListingApplied-${listingKey}`, _storeAppliedListing);
+
+  const getInitialListing = computed(() => _storeInitialListing.value);
+
+  const setInitialListing = async (
+    initialListing: Schemas["ProductListingResult"],
+  ) => {
+    _storeInitialListing.value = initialListing;
+    _storeAppliedListing.value = null;
+  };
+
+  const getCurrentListing = computed(() => {
+    return _storeAppliedListing.value || getInitialListing.value;
+  });
+
+  const getElements = computed(() => {
+    return getCurrentListing.value?.elements || [];
+  });
+
+  const getTotal = computed(() => {
+    return getCurrentListing.value?.total || 0;
+  });
+
+  const getLimit = computed(() => {
+    return getCurrentListing.value?.limit || searchDefaults?.limit || 10;
+  });
+
+  const initSearch = async (
+    criteria: operations["searchPage post /search"]["body"],
+  ): Promise<Schemas["ProductListingResult"]> => {
+    loading.value = true;
+    try {
+      const searchCriteria = merge(
+        {} as operations["searchPage post /search"]["body"],
+        searchDefaults,
+        criteria,
+      );
+      const result = await searchMethod(searchCriteria);
+      return result;
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  async function search(
+    criteria: operations["searchPage post /search"]["body"],
+  ) {
+    loading.value = true;
+    try {
+      const searchCriteria = merge(
+        {} as operations["searchPage post /search"]["body"],
+        searchDefaults,
+        criteria,
+      );
+      const result = await searchMethod(searchCriteria);
+
+      _storeAppliedListing.value = result;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  const loadMore = async (
+    criteria?: operations["searchPage post /search"]["body"],
+  ): Promise<void> => {
+    loadingMore.value = true;
+    try {
+      const q = criteria
+        ? criteria
+        : {
+            p: (getCurrentListing.value?.page || 1) + 1,
+          };
+
+      const searchCriteria = merge(
+        {} as operations["searchPage post /search"]["body"],
+        searchDefaults,
+        q,
+      ) as operations["searchPage post /search"]["body"];
+      const result = await searchMethod(searchCriteria);
+      _storeAppliedListing.value = {
+        ...(getCurrentListing.value || {}),
+        page: result.page,
+        elements: [
+          ...(getCurrentListing.value?.elements || []),
+          ...(result.elements ?? []),
+        ],
+      } as Schemas["ProductListingResult"];
+    } finally {
+      loadingMore.value = false;
+    }
+  };
+
+  const context = {
+    _storeInitialListing,
+    _storeAppliedListing,
+    loading,
+    loadingMore,
+    searchDefaults,
+    getInitialListing,
+    setInitialListing,
+    getCurrentListing,
+    getElements,
+    getTotal,
+    getLimit,
+    initSearch,
+    search,
+    loadMore,
+  };
+
+  provide(LISTING_CONTEXT_KEY, context);
+
+  return context;
+}
+
+export function useListingCoreContext(): ListingCoreContext {
+  const context = inject<ListingCoreContext>(LISTING_CONTEXT_KEY);
+  if (!context) {
+    throw new Error(
+      "[useListingCoreContext] Listing context not found. Make sure `createCategoryListingContext` was called in a parent component.",
+    );
+  }
+  return context;
+}
diff --git a/packages/composables/src/useListing/useProductListingFilters.test.ts b/packages/composables/src/useListing/useProductListingFilters.test.ts
new file mode 100644
index 000000000..0fd154939
--- /dev/null
+++ b/packages/composables/src/useListing/useProductListingFilters.test.ts
@@ -0,0 +1,128 @@
+import { mount } from "@vue/test-utils";
+import { describe, expect, it, vi } from "vitest";
+import { defineComponent, h } from "vue";
+import type { Schemas } from "#shopware";
+import { useSetup } from "../_test";
+import { useListingCore } from "./useListingCore";
+import { useProductListingFilters } from "./useProductListingFilters";
+
+const mockSearchMethod = vi.fn();
+
+function setupWithContext(
+  initialListing?: Schemas["ProductListingResult"] | null,
+) {
+  let childResult: ReturnType<typeof useProductListingFilters> | undefined;
+
+  const Child = defineComponent({
+    setup() {
+      childResult = useProductListingFilters();
+      return childResult;
+    },
+    render: () => h("span"),
+  });
+
+  const Parent = defineComponent({
+    setup() {
+      useListingCore({
+        listingKey: "testListing",
+        searchMethod: mockSearchMethod,
+        searchDefaults: {},
+        initialListing,
+      });
+    },
+    render: () => h(Child),
+  });
+
+  const wrapper = mount(Parent, {
+    global: {
+      provide: {
+        shopware: {},
+        apiClient: { invoke: vi.fn() },
+      },
+    },
+  });
+
+  if (!childResult) throw new Error("Child component did not initialize");
+  return { vm: childResult, wrapper };
+}
+
+describe("useProductListingFilters (standalone via context)", () => {
+  it("should return empty filters when no listing is set", () => {
+    const { vm } = setupWithContext();
+
+    expect(vm.getInitialFilters.value).toEqual([]);
+    expect(vm.getAvailableFilters.value).toEqual([]);
+    expect(vm.getCurrentFilters.value).toBeUndefined();
+  });
+
+  it("should return current filters from listing", () => {
+    const listing = {
+      currentFilters: {
+        manufacturer: ["m1"],
+        properties: ["p1"],
+        search: "test",
+      },
+    } as unknown as Schemas["ProductListingResult"];
+
+    const { vm } = setupWithContext(listing);
+
+    expect(vm.getCurrentFilters.value).toEqual({
+      manufacturer: ["m1"],
+      properties: ["p1"],
+      search: "test",
+    });
+  });
+
+  it("should call search when setting filters", async () => {
+    mockSearchMethod.mockResolvedValue({ elements: [] });
+
+    const listing = {
+      currentFilters: {},
+    } as unknown as Schemas["ProductListingResult"];
+
+    const { vm } = setupWithContext(listing);
+    await vm.setCurrentFilters([{ code: "shipping-free", value: true }]);
+
+    expect(mockSearchMethod).toHaveBeenCalledWith(
+      expect.objectContaining({ "shipping-free": true }),
+    );
+  });
+
+  it("should reset filters", async () => {
+    mockSearchMethod.mockResolvedValue({ elements: [] });
+
+    const listing = {
+      currentFilters: {
+        manufacturer: ["m1"],
+        search: "test",
+      },
+    } as unknown as Schemas["ProductListingResult"];
+
+    const { vm } = setupWithContext(listing);
+    await vm.resetFilters();
+
+    expect(mockSearchMethod).toHaveBeenCalledWith(
+      expect.objectContaining({ search: "test" }),
+    );
+  });
+
+  it("filtersToQuery should convert filters to query object", () => {
+    const { vm } = setupWithContext();
+
+    expect(
+      vm.filtersToQuery({
+        limit: 10,
+        manufacturer: "m1|m2",
+      } as Schemas["ProductListingCriteria"]),
+    ).toEqual({
+      limit: 10,
+      manufacturer: "m1|m2",
+    });
+  });
+
+  it("should throw when no context is available", () => {
+    expect(() => useSetup(() => useProductListingFilters())).toThrowError(
+      /Listing context not found/,
+    );
+  });
+});
diff --git a/packages/composables/src/useListing/useProductListingFilters.ts b/packages/composables/src/useListing/useProductListingFilters.ts
new file mode 100644
index 000000000..5b198523f
--- /dev/null
+++ b/packages/composables/src/useListing/useProductListingFilters.ts
@@ -0,0 +1,118 @@
+import { getListingFilters } from "@shopware/helpers";
+import { computed, ref } from "vue";
+import type { ComputedRef, Ref } from "vue";
+import type { Schemas, operations } from "#shopware";
+import { useListingCoreContext } from "./useListingCore";
+import type { ListingCoreContext } from "./useListingCore";
+import type { ShortcutFilterParam } from "./utils";
+
+type UseProductListingFiltersParams = {
+  getInitialListing: ComputedRef<Schemas["ProductListingResult"] | null>;
+  getCurrentListing: ComputedRef<Schemas["ProductListingResult"] | null>;
+  _storeAppliedListing?: Ref<Schemas["ProductListingResult"] | null>;
+  search(
+    criteria: operations["searchPage post /search"]["body"],
+  ): Promise<void>;
+  searchDefaults?: operations["searchPage post /search"]["body"];
+};
+
+export function useProductListingFilters(
+  params?: UseProductListingFiltersParams,
+) {
+  const resolved = params || (useListingCoreContext() as ListingCoreContext);
+  const { getInitialListing, getCurrentListing, search } = resolved;
+  const _storeAppliedListing = resolved._storeAppliedListing ?? ref(null);
+  const searchDefaults =
+    resolved.searchDefaults ??
+    ({} as operations["searchPage post /search"]["body"]);
+  const getInitialFilters = computed(() => {
+    return getListingFilters(getInitialListing.value?.aggregations);
+  });
+
+  const getAvailableFilters = computed(() => {
+    return getListingFilters(
+      _storeAppliedListing.value?.aggregations ||
+        getCurrentListing.value?.aggregations,
+    );
+  });
+
+  const getCurrentFilters = computed(() => {
+    return getCurrentListing.value
+      ?.currentFilters as Schemas["ProductListingResult"]["currentFilters"];
+  });
+
+  const setCurrentFilters = (filters: ShortcutFilterParam[]) => {
+    const newFilters = {};
+    for (const filter of filters) {
+      Object.assign(newFilters, { [filter.code]: filter.value });
+    }
+
+    const appliedFilters = Object.assign(
+      {},
+      getCurrentFilters.value,
+      {
+        query: getCurrentFilters.value?.search,
+        manufacturer: getCurrentFilters.value?.manufacturer?.join("|"),
+        properties: getCurrentFilters.value?.properties?.join("|"),
+      },
+      { ...newFilters },
+    );
+
+    if (_storeAppliedListing.value) {
+      _storeAppliedListing.value.currentFilters = {
+        ...appliedFilters,
+        manufacturer: appliedFilters.manufacturer?.split("|"),
+        properties: appliedFilters.properties?.split("|"),
+      };
+    }
+
+    return search(
+      appliedFilters as operations["searchPage post /search"]["body"],
+    );
+  };
+
+  const resetFilters = () => {
+    const defaultFilters = Object.assign(
+      {
+        manufacturer: [],
+        properties: [],
+        price: { min: 0, max: 0 },
+        search: getCurrentFilters.value?.search,
+      },
+      searchDefaults,
+    );
+
+    if (_storeAppliedListing.value) {
+      _storeAppliedListing.value.currentFilters =
+        defaultFilters as unknown as Schemas["ProductListingResult"]["currentFilters"];
+    }
+    return search({ search: getCurrentFilters.value?.search || "" });
+  };
+
+  const filtersToQuery = (filters: Schemas["ProductListingCriteria"]) => {
+    const queryObject: Record<string, unknown> = {};
+
+    for (const filter in filters) {
+      const currentFilter =
+        filters[filter as keyof Schemas["ProductListingCriteria"]];
+      if (currentFilter) {
+        if (Array.isArray(currentFilter) && currentFilter.length) {
+          queryObject[filter] = currentFilter.join("|");
+        } else if (!Array.isArray(currentFilter)) {
+          queryObject[filter] = currentFilter;
+        }
+      }
+    }
+
+    return queryObject;
+  };
+
+  return {
+    getInitialFilters,
+    getAvailableFilters,
+    getCurrentFilters,
+    setCurrentFilters,
+    resetFilters,
+    filtersToQuery,
+  };
+}
diff --git a/packages/composables/src/useListing/useProductListingPagination.test.ts b/packages/composables/src/useListing/useProductListingPagination.test.ts
new file mode 100644
index 000000000..c9477ea5c
--- /dev/null
+++ b/packages/composables/src/useListing/useProductListingPagination.test.ts
@@ -0,0 +1,97 @@
+import { mount } from "@vue/test-utils";
+import { describe, expect, it, vi } from "vitest";
+import { defineComponent, h } from "vue";
+import type { Schemas } from "#shopware";
+import { useSetup } from "../_test";
+import { useListingCore } from "./useListingCore";
+import { useProductListingPagination } from "./useProductListingPagination";
+
+const mockSearchMethod = vi.fn();
+
+function setupWithContext(
+  initialListing?: Schemas["ProductListingResult"] | null,
+) {
+  let childResult: ReturnType<typeof useProductListingPagination> | undefined;
+
+  const Child = defineComponent({
+    setup() {
+      childResult = useProductListingPagination();
+      return childResult;
+    },
+    render: () => h("span"),
+  });
+
+  const Parent = defineComponent({
+    setup() {
+      useListingCore({
+        listingKey: "testListing",
+        searchMethod: mockSearchMethod,
+        searchDefaults: {},
+        initialListing,
+      });
+    },
+    render: () => h(Child),
+  });
+
+  const wrapper = mount(Parent, {
+    global: {
+      provide: {
+        shopware: {},
+        apiClient: { invoke: vi.fn() },
+      },
+    },
+  });
+
+  if (!childResult) throw new Error("Child component did not initialize");
+  return { vm: childResult, wrapper };
+}
+
+describe("useProductListingPagination (standalone via context)", () => {
+  it("should return page 1 and 0 total pages when no listing", () => {
+    const { vm } = setupWithContext();
+
+    expect(vm.getCurrentPage.value).toBe(1);
+    expect(vm.getTotalPagesCount.value).toBe(0);
+  });
+
+  it("should compute page info from listing", () => {
+    const listing = {
+      page: 3,
+      total: 50,
+      limit: 10,
+    } as Schemas["ProductListingResult"];
+
+    const { vm } = setupWithContext(listing);
+
+    expect(vm.getCurrentPage.value).toBe(3);
+    expect(vm.getTotalPagesCount.value).toBe(5);
+  });
+
+  it("should call search with page number on changeCurrentPage", async () => {
+    mockSearchMethod.mockResolvedValue({ elements: [], page: 2 });
+
+    const { vm } = setupWithContext();
+    await vm.changeCurrentPage(2);
+
+    expect(mockSearchMethod).toHaveBeenCalledWith(
+      expect.objectContaining({ page: 2 }),
+    );
+  });
+
+  it("should merge additional query params in changeCurrentPage", async () => {
+    mockSearchMethod.mockResolvedValue({ elements: [], page: 3 });
+
+    const { vm } = setupWithContext();
+    await vm.changeCurrentPage(3, { search: "test" });
+
+    expect(mockSearchMethod).toHaveBeenCalledWith(
+      expect.objectContaining({ page: 3, search: "test" }),
+    );
+  });
+
+  it("should throw when no context is available", () => {
+    expect(() => useSetup(() => useProductListingPagination())).toThrowError(
+      /Listing context not found/,
+    );
+  });
+});
diff --git a/packages/composables/src/useListing/useProductListingPagination.ts b/packages/composables/src/useListing/useProductListingPagination.ts
new file mode 100644
index 000000000..47d6f564a
--- /dev/null
+++ b/packages/composables/src/useListing/useProductListingPagination.ts
@@ -0,0 +1,46 @@
+import { computed } from "vue";
+import type { ComputedRef } from "vue";
+import type { Schemas, operations } from "#shopware";
+import { useListingCoreContext } from "./useListingCore";
+import type { ListingCoreContext } from "./useListingCore";
+
+type UseProductListingPaginationParams = {
+  getCurrentListing: ComputedRef<Schemas["ProductListingResult"] | null>;
+  getLimit: ComputedRef<number>;
+  getTotal: ComputedRef<number>;
+  search(
+    criteria: operations["searchPage post /search"]["body"],
+  ): Promise<void>;
+};
+
+export function useProductListingPagination(
+  params?: UseProductListingPaginationParams,
+) {
+  const { getCurrentListing, getLimit, getTotal, search } =
+    params || (useListingCoreContext() as ListingCoreContext);
+  const getCurrentPage = computed(() => getCurrentListing.value?.page || 1);
+
+  const getTotalPagesCount = computed(() =>
+    Math.ceil(getTotal.value / getLimit.value),
+  );
+
+  const changeCurrentPage = async (
+    page: number,
+    query?: operations["searchPage post /search"]["body"],
+  ) => {
+    await search(
+      Object.assign(
+        {
+          page,
+        },
+        query,
+      ),
+    );
+  };
+
+  return {
+    getCurrentPage,
+    getTotalPagesCount,
+    changeCurrentPage,
+  };
+}
diff --git a/packages/composables/src/useListing/useProductListingSorting.test.ts b/packages/composables/src/useListing/useProductListingSorting.test.ts
new file mode 100644
index 000000000..1af6d2d1a
--- /dev/null
+++ b/packages/composables/src/useListing/useProductListingSorting.test.ts
@@ -0,0 +1,99 @@
+import { mount } from "@vue/test-utils";
+import { describe, expect, it, vi } from "vitest";
+import { defineComponent, h } from "vue";
+import type { Schemas } from "#shopware";
+import { useSetup } from "../_test";
+import { useListingCore } from "./useListingCore";
+import { useProductListingSorting } from "./useProductListingSorting";
+
+const mockSearchMethod = vi.fn();
+
+function setupWithContext(
+  initialListing?: Schemas["ProductListingResult"] | null,
+) {
+  let childResult: ReturnType<typeof useProductListingSorting> | undefined;
+
+  const Child = defineComponent({
+    setup() {
+      childResult = useProductListingSorting();
+      return childResult;
+    },
+    render: () => h("span"),
+  });
+
+  const Parent = defineComponent({
+    setup() {
+      useListingCore({
+        listingKey: "testListing",
+        searchMethod: mockSearchMethod,
+        searchDefaults: {},
+        initialListing,
+      });
+    },
+    render: () => h(Child),
+  });
+
+  const wrapper = mount(Parent, {
+    global: {
+      provide: {
+        shopware: {},
+        apiClient: { invoke: vi.fn() },
+      },
+    },
+  });
+
+  if (!childResult) throw new Error("Child component did not initialize");
+  return { vm: childResult, wrapper };
+}
+
+describe("useProductListingSorting (standalone via context)", () => {
+  it("should return undefined sorting when no listing", () => {
+    const { vm } = setupWithContext();
+
+    expect(vm.getSortingOrders.value).toBeUndefined();
+    expect(vm.getCurrentSortingOrder.value).toBeUndefined();
+  });
+
+  it("should return sorting from listing", () => {
+    const listing = {
+      sorting: "price-asc",
+      availableSortings: [
+        { key: "price-asc", label: "Price ascending" },
+        { key: "name-asc", label: "Name ascending" },
+      ],
+    } as unknown as Schemas["ProductListingResult"];
+
+    const { vm } = setupWithContext(listing);
+
+    expect(vm.getCurrentSortingOrder.value).toBe("price-asc");
+    expect(vm.getSortingOrders.value).toHaveLength(2);
+  });
+
+  it("should call search with order on changeCurrentSortingOrder", async () => {
+    mockSearchMethod.mockResolvedValue({ elements: [] });
+
+    const { vm } = setupWithContext();
+    await vm.changeCurrentSortingOrder("name-desc");
+
+    expect(mockSearchMethod).toHaveBeenCalledWith(
+      expect.objectContaining({ order: "name-desc" }),
+    );
+  });
+
+  it("should merge additional query params in changeCurrentSortingOrder", async () => {
+    mockSearchMethod.mockResolvedValue({ elements: [] });
+
+    const { vm } = setupWithContext();
+    await vm.changeCurrentSortingOrder("price-asc", { search: "test" });
+
+    expect(mockSearchMethod).toHaveBeenCalledWith(
+      expect.objectContaining({ order: "price-asc", search: "test" }),
+    );
+  });
+
+  it("should throw when no context is available", () => {
+    expect(() => useSetup(() => useProductListingSorting())).toThrowError(
+      /Listing context not found/,
+    );
+  });
+});
diff --git a/packages/composables/src/useListing/useProductListingSorting.ts b/packages/composables/src/useListing/useProductListingSorting.ts
new file mode 100644
index 000000000..2adc4caae
--- /dev/null
+++ b/packages/composables/src/useListing/useProductListingSorting.ts
@@ -0,0 +1,46 @@
+import { computed } from "vue";
+import type { ComputedRef } from "vue";
+import type { Schemas, operations } from "#shopware";
+import { useListingCoreContext } from "./useListingCore";
+import type { ListingCoreContext } from "./useListingCore";
+
+type UseProductListingSortingParams = {
+  getCurrentListing: ComputedRef<Schemas["ProductListingResult"] | null>;
+  search(
+    criteria: operations["searchPage post /search"]["body"],
+  ): Promise<void>;
+};
+
+export function useProductListingSorting(
+  params?: UseProductListingSortingParams,
+) {
+  const { getCurrentListing, search } =
+    params || (useListingCoreContext() as ListingCoreContext);
+  const getSortingOrders = computed(() => {
+    return getCurrentListing.value?.availableSortings;
+  });
+
+  const getCurrentSortingOrder = computed(
+    () => getCurrentListing.value?.sorting,
+  );
+
+  async function changeCurrentSortingOrder(
+    order: string,
+    query?: operations["searchPage post /search"]["body"],
+  ) {
+    await search(
+      Object.assign(
+        {
+          order,
+        },
+        query,
+      ),
+    );
+  }
+
+  return {
+    getSortingOrders,
+    getCurrentSortingOrder,
+    changeCurrentSortingOrder,
+  };
+}
diff --git a/packages/composables/src/useListing/utils.ts b/packages/composables/src/useListing/utils.ts
new file mode 100644
index 000000000..2c14edce3
--- /dev/null
+++ b/packages/composables/src/useListing/utils.ts
@@ -0,0 +1,176 @@
+import type { getListingFilters } from "@shopware/helpers";
+import type { ComputedRef } from "vue";
+import type { Schemas, operations } from "#shopware";
+
+export function isObject<T>(item: T): boolean {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+
+export function merge<T extends { [key in keyof T]: unknown }>(
+  target: T,
+  ...sources: T[]
+): T {
+  if (!sources.length) return target;
+  const source = sources.shift();
+
+  if (source === undefined) {
+    return target;
+  }
+
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        merge(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+
+  return merge(target, ...sources);
+}
+
+export type ListingType = "productSearchListing" | "categoryListing";
+
+export type ShortcutFilterParam<
+  T extends
+    keyof Schemas["ProductListingCriteria"] = keyof Schemas["ProductListingCriteria"],
+> = {
+  code: T;
+  value: Schemas["ProductListingCriteria"][T];
+};
+
+/**
+ * @deprecated Use the modular composable return types from `useListingCore`, `useProductListingFilters`, `useProductListingPagination`, and `useProductListingSorting` instead.
+ */
+export type UseListingReturn = {
+  /**
+   * Listing that is currently set
+   * {@link ListingResult} object
+   */
+  getInitialListing: ComputedRef<Schemas["ProductListingResult"] | null>;
+  /**
+   * Sets the initial listing - available synchronously
+   * @param {@link initialListing} - initial listing to set
+   * @returns
+   */
+  setInitialListing(
+    initialListing: Schemas["ProductListingResult"],
+  ): Promise<void>;
+  /**
+   * @deprecated - use `search` instead
+   * Searches for the listing based on the criteria
+   * @param criteria {@link Schemas['Criteria']}
+   * @returns
+   */
+  initSearch(
+    criteria: operations["searchPage post /search"]["body"],
+  ): Promise<Schemas["ProductListingResult"]>;
+  /**
+   * Searches for the listing based on the criteria
+   * @param criteria
+   * @returns
+   */
+  search(
+    criteria:
+      | operations["readProductListing post /product-listing/{categoryId}"]["body"]
+      | operations["searchPage post /search"]["body"],
+  ): Promise<void>;
+  /**
+   * Loads more (next page) elements to the listing
+   */
+  loadMore(
+    criteria?: operations["searchPage post /search"]["body"],
+  ): Promise<void>;
+  /**
+   * Listing that is currently set
+   */
+  getCurrentListing: ComputedRef<Schemas["ProductListingResult"] | null>;
+  /**
+   * Listing elements ({@link Product}) that are currently set
+   */
+  getElements: ComputedRef<Schemas["ProductListingResult"]["elements"]>;
+  /**
+   * Available sorting orders
+   */
+  getSortingOrders: ComputedRef<
+    Schemas["ProductSorting"][] | { key: string; label: string }[] | undefined
+  >;
+  /**
+   * Current sorting order
+   */
+  getCurrentSortingOrder: ComputedRef<string | undefined>;
+  /**
+   * Changes the current sorting order
+   * @param order - i.e. "name-asc"
+   * @returns
+   */
+  changeCurrentSortingOrder(
+    order: string,
+    query?: operations["searchPage post /search"]["body"],
+  ): Promise<void>;
+  /**
+   * Current page number
+   */
+  getCurrentPage: ComputedRef<number>;
+  /**
+   * Changes the current page number
+   * @param pageNumber - page number to change to
+   * @returns
+   */
+  changeCurrentPage(
+    page: number,
+    query?: operations["searchPage post /search"]["body"],
+  ): Promise<void>;
+  /**
+   * Total number of elements found for the current search criteria
+   */
+  getTotal: ComputedRef<number>;
+  /**
+   * Total number of pages found for the current search criteria
+   */
+  getTotalPagesCount: ComputedRef<number>;
+  /**
+   * Number of elements per page
+   */
+  getLimit: ComputedRef<number>;
+  /**
+   * Initial filters
+   */
+  getInitialFilters: ComputedRef<ReturnType<typeof getListingFilters>>;
+  /**
+   * All available filters
+   */
+  getAvailableFilters: ComputedRef<ReturnType<typeof getListingFilters>>;
+  /**
+   * Filters that are currently set
+   */
+  getCurrentFilters: ComputedRef<
+    Schemas["ProductListingResult"]["currentFilters"]
+  >;
+  /**
+   * Sets the filters to be applied for the listing
+   * @param filters
+   * @returns
+   */
+  setCurrentFilters(filters: ShortcutFilterParam[]): Promise<void>;
+  /**
+   * Indicates if the listing is being fetched
+   */
+  loading: ComputedRef<boolean>;
+  /**
+   * Indicates if the listing is being fetched via `loadMore` method
+   */
+  loadingMore: ComputedRef<boolean>;
+  /**
+   * Resets the filters - clears the current filters
+   */
+  resetFilters(): Promise<void>;
+  /**
+   * Change selected filters to the query object
+   */
+  filtersToQuery(
+    filters: Schemas["ProductListingCriteria"],
+  ): Record<string, unknown>;
+};
diff --git a/templates/vue-demo-store/app/components/listing-filters/ListingFilters.vue b/templates/vue-demo-store/app/components/listing-filters/ListingFilters.vue
index 07f333f16..0b0bd09e8 100644
--- a/templates/vue-demo-store/app/components/listing-filters/ListingFilters.vue
+++ b/templates/vue-demo-store/app/components/listing-filters/ListingFilters.vue
@@ -4,13 +4,11 @@ import type { ComputedRef, UnwrapNestedRefs } from "vue";
 import type { operations } from "#shopware";
 import ListingFilter from "./ListingFilter.vue";
 
-const {
-  filtersToQuery,
-  getCurrentFilters,
-  getCurrentSortingOrder,
-  getInitialFilters,
-  search,
-} = useProductSearchListing();
+const listing = useProductSearchListing();
+const { search } = listing;
+const { filtersToQuery, getCurrentFilters, getInitialFilters } =
+  useProductListingFilters(listing);
+const { getCurrentSortingOrder } = useProductListingSorting(listing);
 
 const route = useRoute();
 const router = useRouter();
diff --git a/templates/vue-demo-store/app/pages/search.vue b/templates/vue-demo-store/app/pages/search.vue
index b9f7f174b..bdfe950f4 100644
--- a/templates/vue-demo-store/app/pages/search.vue
+++ b/templates/vue-demo-store/app/pages/search.vue
@@ -9,19 +9,19 @@ defineOptions({
   name: "SearchResultPage",
 });
 
+const listing = useProductSearchListing();
 const {
-  changeCurrentPage,
   getCurrentListing,
-  getCurrentPage,
-  getCurrentSortingOrder,
   getElements: products,
-  getInitialFilters,
-  getSortingOrders,
-  getTotalPagesCount,
   loading,
   search,
   setInitialListing,
-} = useProductSearchListing();
+} = listing;
+const { changeCurrentPage, getCurrentPage, getTotalPagesCount } =
+  useProductListingPagination(listing);
+const { getCurrentSortingOrder, getSortingOrders } =
+  useProductListingSorting(listing);
+const { getInitialFilters } = useProductListingFilters(listing);
 const { t } = useI18n();
 const productListElement = useTemplateRef("productListElement");
 
diff --git a/templates/vue-starter-template/app/pages/search.vue b/templates/vue-starter-template/app/pages/search.vue
index dd25779ba..3171eacde 100644
--- a/templates/vue-starter-template/app/pages/search.vue
+++ b/templates/vue-starter-template/app/pages/search.vue
@@ -6,14 +6,10 @@ const route = useRoute();
 const router = useRouter();
 const initLoading = ref(true);
 
-const {
-  changeCurrentPage,
-  getCurrentPage,
-  getElements: products,
-  getTotalPagesCount,
-  loading,
-  search,
-} = useProductSearchListing();
+const listing = useProductSearchListing();
+const { getElements: products, loading, search } = listing;
+const { changeCurrentPage, getCurrentPage, getTotalPagesCount } =
+  useProductListingPagination(listing);
 
 const { t } = useI18n();
 const productListElement = useTemplateRef("productListElement");