diff --git a/src/app/api/datasets/route.ts b/src/app/api/datasets/route.ts
index ddf170ba..04a77e21 100644
--- a/src/app/api/datasets/route.ts
+++ b/src/app/api/datasets/route.ts
@@ -17,7 +17,7 @@ export async function POST(request: Request) {
     const response = await datasetList(options, session);
 
     const result = {
-      datasets: response.data.results,
+      results: response.data.results,
       count: response.data.count,
     };
 
diff --git a/src/app/datasets/FilterList/ClearFilterButton.tsx b/src/app/datasets/FilterList/ClearFilterButton.tsx
index e16c886f..ce82e883 100644
--- a/src/app/datasets/FilterList/ClearFilterButton.tsx
+++ b/src/app/datasets/FilterList/ClearFilterButton.tsx
@@ -5,49 +5,18 @@
 "use client";
 
 import Button from "@/components/Button";
-import { useSearchParams } from "next/navigation";
-import { useEffect } from "react";
+import { useFilters } from "@/providers/FilterProvider";
 
-type ClearFilterButtonProps = {
-  facetGroups: string[];
-};
-
-export default function ClearFilterButton({
-  facetGroups,
-}: ClearFilterButtonProps) {
-  const queryParams = useSearchParams();
-
-  useEffect(() => {}, [queryParams]);
-
-  function isAnyGroupFilterApplied() {
-    if (!queryParams) return false;
-
-    return Array.from(queryParams.keys()).some(
-      (key) =>
-        key !== "page" &&
-        key !== "q" &&
-        facetGroups.some((group) => key.includes(group))
-    );
-  }
-  function getQueryStringWithoutGroupFilter() {
-    if (!queryParams) return "";
-    return Array.from(queryParams.keys())
-      .filter(
-        (x) => facetGroups.every((group) => !x.includes(group)) && x !== "page"
-      )
-      .map((x) => `&${x}=${queryParams.get(x)}`)
-      .join("");
-  }
+export default function ClearFilterButton() {
+  const { clearActiveFilters } = useFilters();
 
   return (
     <div className="flex justify-end">
-      {isAnyGroupFilterApplied() && (
-        <Button
-          href={`/datasets?page=1${getQueryStringWithoutGroupFilter()}`}
-          text="Clear Filters"
-          type="warning"
-        />
-      )}
+      <Button
+        text="Clear Filters"
+        type="warning"
+        onClick={clearActiveFilters}
+      />
     </div>
   );
 }
diff --git a/src/app/datasets/FilterList/DropdownFilterItem.tsx b/src/app/datasets/FilterList/DropdownFilterItem.tsx
index e993c5c1..7343bed9 100644
--- a/src/app/datasets/FilterList/DropdownFilterItem.tsx
+++ b/src/app/datasets/FilterList/DropdownFilterItem.tsx
@@ -3,51 +3,63 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { Disclosure } from "@headlessui/react";
-import { useRouter, useSearchParams } from "next/navigation";
-import { useEffect, useState } from "react";
 import { FilterItemProps } from "./FilterItem";
+import { useFilters } from "@/providers/FilterProvider";
 
 type DropdownFilterContentProps = FilterItemProps;
 
 export default function DropdownFilterContent({
   filter,
 }: DropdownFilterContentProps) {
-  const router = useRouter();
-  const searchParams = useSearchParams();
-  const [options, setOptions] = useState<string[]>([]);
+  const { activeFilters, addActiveFilter, removeActiveFilter } = useFilters();
 
-  useEffect(() => {
-    const paramValue =
-      searchParams?.get(`${filter.source}-${filter.key}`) || "";
-    if (paramValue) {
-      setOptions(paramValue.split(","));
-    } else {
-      setOptions([]);
-    }
-  }, [searchParams, filter.key, filter.source]);
+  const correspondingActiveFilter = activeFilters.find(
+    (f) => f.key === filter.key
+  );
 
-  const handleCheckboxChange = (value: string, checked: boolean) => {
-    const newOptions = checked
-      ? [...options, value]
-      : options.filter((v) => v !== value);
+  const handleCheckboxChange = (
+    value: string,
+    label: string,
+    checked: boolean
+  ) => {
+    const isFilterAlreadyActive = correspondingActiveFilter !== undefined;
 
-    setOptions(newOptions);
-    updateUrl(newOptions);
-  };
+    if (isFilterAlreadyActive) {
+      const currentValues = correspondingActiveFilter.values as {
+        value: string;
+      }[];
+      const newValues = checked
+        ? [...currentValues, { value }]
+        : currentValues.filter((v) => v.value !== value);
 
-  const updateUrl = (newOptions: string[]) => {
-    const params = new URLSearchParams(searchParams?.toString() || "");
+      if (!newValues.length) {
+        removeActiveFilter(filter.key, filter.source);
+        return;
+      }
 
-    if (newOptions.length > 0) {
-      params.set(`${filter.source}-${filter.key}`, newOptions.join(","));
+      const newActiveFilter = {
+        ...correspondingActiveFilter,
+        values: newValues,
+      };
+      addActiveFilter(newActiveFilter);
     } else {
-      params.delete(`${filter.source}-${filter.key}`);
+      const newActiveFilter = {
+        source: filter.source,
+        type: filter.type,
+        key: filter.key,
+        label: filter.label,
+        values: [{ value, label }],
+      };
+      addActiveFilter(newActiveFilter);
     }
+  };
 
-    params.set("page", "1");
-
-    const newUrl = `${window.location.pathname}?${params.toString()}`;
-    router.push(newUrl);
+  const isChecked = (item: { value: string }) => {
+    return correspondingActiveFilter
+      ? correspondingActiveFilter
+          ?.values!.map((v) => v.value)
+          .includes(item.value)
+      : false;
   };
 
   return (
@@ -63,9 +75,9 @@ export default function DropdownFilterContent({
               className="h-4 w-4 border rounded-md checked:accent-warning flex-none"
               id={`${filter.source}-${item.value}`}
               value={item.value}
-              checked={options.includes(item.value)}
+              checked={isChecked(item)}
               onChange={(e) =>
-                handleCheckboxChange(item.value, e.target.checked)
+                handleCheckboxChange(item.value, item.label, e.target.checked)
               }
             />
             <label
diff --git a/src/app/datasets/FilterList/FilterItem.tsx b/src/app/datasets/FilterList/FilterItem.tsx
index 8c60c780..d00f2bcf 100644
--- a/src/app/datasets/FilterList/FilterItem.tsx
+++ b/src/app/datasets/FilterList/FilterItem.tsx
@@ -9,12 +9,22 @@ import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
 import { Disclosure } from "@headlessui/react";
 import { default as DropdownFilterContent } from "./DropdownFilterItem";
 import FreeTextFilterContent from "./FreeTextFilterItem";
+import { useFilters } from "@/providers/FilterProvider";
 
 export type FilterItemProps = {
   filter: Filter;
 };
 
 function FilterItem({ filter }: FilterItemProps) {
+  const { activeFilters } = useFilters();
+
+  const correspondingActiveFilter = activeFilters.find(
+    (activeFilter) =>
+      activeFilter.key === filter.key && activeFilter.source === filter.source
+  );
+  const isFilterActive = correspondingActiveFilter !== undefined;
+  const nbActiveValues = correspondingActiveFilter?.values?.length || 0;
+
   const getFilterContent = (type: FilterType) => {
     switch (type) {
       case FilterType.DROPDOWN:
@@ -35,7 +45,13 @@ function FilterItem({ filter }: FilterItemProps) {
           {({ open }) => (
             <>
               <Disclosure.Button className="flex w-full justify-between px-4 py-2 text-left">
-                <span className="text-base px-1.5">{filter.label}</span>
+                <div>
+                  <span className="text-base px-1.5">{filter.label}</span>
+                  <span className="text-base text-info">
+                    {isFilterActive &&
+                      `(${nbActiveValues} ${nbActiveValues > 1 ? "filters" : "filter"} active)`}
+                  </span>
+                </div>
                 <FontAwesomeIcon
                   icon={faChevronDown}
                   className={`h-5 w-5 transition-transform ${open ? "rotate-180" : ""}`}
diff --git a/src/app/datasets/FilterList/FreeTextFilterItem.tsx b/src/app/datasets/FilterList/FreeTextFilterItem.tsx
index 49b24bd2..4ccb5067 100644
--- a/src/app/datasets/FilterList/FreeTextFilterItem.tsx
+++ b/src/app/datasets/FilterList/FreeTextFilterItem.tsx
@@ -3,28 +3,20 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import Button from "@/components/Button";
-import { FilterType } from "@/services/discovery/types/filter.type";
+import { ActiveFilter, Operator } from "@/services/discovery/types/filter.type";
 import { faCheck, faPlusCircle } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
 import { Disclosure } from "@headlessui/react";
 import { useState } from "react";
 import { FilterItemProps } from "./FilterItem";
+import { useFilters } from "@/providers/FilterProvider";
 
 type FreeTextFilterContentProps = FilterItemProps;
 
-type FreeTextFilterValue = {
-  value: string;
-  operator: FilterType;
-};
-
-type FreeTextFilterOutput = {
-  filterKey: string;
-  values: FreeTextFilterValue[];
-};
-
 export default function FreeTextFilterContent({
   filter,
 }: FreeTextFilterContentProps) {
+  const { addActiveFilter } = useFilters();
   const [nbFilters, setNbFilters] = useState(1);
   const [openedDropdown, setOpenedDropdown] = useState<number | null>(null);
 
@@ -56,28 +48,30 @@ export default function FreeTextFilterContent({
 
   const handleSubmitValue = (event: React.FormEvent<HTMLFormElement>) => {
     event.preventDefault();
+
     const formData = new FormData(event.target as HTMLFormElement);
-    const filterValues: FreeTextFilterValue[] = Array.from({
-      length: nbFilters,
-    }).reduce((acc: FreeTextFilterValue[], _, index) => {
+    const values = [] as { value: string; operator: Operator }[];
+
+    for (let index = 0; index < nbFilters; index++) {
       const value = formData.get(`${filter.key}-${index}-value`) as string;
       const operator = formData.get(
         `${filter.key}-${index}-operator`
-      ) as FilterType;
+      ) as Operator;
 
       if (value && operator) {
-        acc.push({ value, operator });
+        values.push({ value, operator });
       }
+    }
 
-      return acc;
-    }, []);
-
-    const filterOutput: FreeTextFilterOutput = {
-      filterKey: filter.key,
-      values: filterValues,
-    };
+    const newActiveFilter = {
+      source: filter.source,
+      type: filter.type,
+      key: filter.key,
+      label: filter.label,
+      values,
+    } as ActiveFilter;
 
-    return filterOutput;
+    addActiveFilter(newActiveFilter);
   };
 
   return (
diff --git a/src/app/datasets/FilterList/index.tsx b/src/app/datasets/FilterList/index.tsx
index 5b0d870c..7b8f4c8f 100644
--- a/src/app/datasets/FilterList/index.tsx
+++ b/src/app/datasets/FilterList/index.tsx
@@ -2,14 +2,13 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-import { Filter } from "@/services/discovery/types/filter.type";
-import FilterItem from "./FilterItem";
+"use client";
 
-type FilterListProps = {
-  filters: Filter[];
-};
+import FilterItem from "./FilterItem";
+import { useFilters } from "@/providers/FilterProvider";
 
-export default async function FilterList({ filters }: FilterListProps) {
+export default function FilterList() {
+  const { filters } = useFilters();
   const filtersSortedBySource = filters.sort((f1, f2) =>
     f2.source.localeCompare(f1.source)
   );
diff --git a/src/app/datasets/page.tsx b/src/app/datasets/page.tsx
index ef51a8e9..28e0f94e 100644
--- a/src/app/datasets/page.tsx
+++ b/src/app/datasets/page.tsx
@@ -1,34 +1,32 @@
 // SPDX-FileCopyrightText: 2024 PNED G.I.E.
 //
 // SPDX-License-Identifier: Apache-2.0
+"use client";
 
 import Error from "@/app/error";
 import PageContainer from "@/components/PageContainer";
 import SearchBar from "@/components/Searchbar";
 import DatasetsProvider from "@/providers/datasets/DatasetsProvider";
-import { Filter } from "@/services/discovery/types/filter.type";
-import { redirect } from "next/navigation";
-import { GET } from "../api/filters/route";
+import { redirect, useSearchParams } from "next/navigation";
 import DatasetCount from "./DatasetCount";
 import DatasetListContainer from "./DatasetListContainer";
 import FilterList from "./FilterList";
 import NoDatasetMessage from "./NoDatasetMessage";
+import { useFilters } from "@/providers/FilterProvider";
+import ActiveFilters from "@/components/ActiveFilters";
 
-export default async function DatasetsPage({
-  searchParams,
-}: {
-  searchParams?: { [key: string]: string | string[] | undefined };
-}) {
-  if (!searchParams?.page) {
+export default function DatasetsPage() {
+  const searchParams = useSearchParams() as URLSearchParams;
+
+  if (!searchParams.get("page")) {
     redirect("/datasets?page=1");
   }
 
-  const getFiltersResponse = await GET();
-  if (getFiltersResponse.status !== 200) {
-    return <Error statusCode={getFiltersResponse.status} />;
-  }
+  const { error } = useFilters();
 
-  const filters = (await getFiltersResponse.json()) as Filter[];
+  if (error) {
+    return <Error statusCode={error.statusCode} />;
+  }
 
   return (
     <PageContainer>
@@ -40,16 +38,16 @@ export default async function DatasetsPage({
           <DatasetCount />
           <div className="col-start-0 col-span-12 flex flex-col gap-4 sm:block xl:hidden">
             <div className="my-4 h-fit">
-              <FilterList filters={filters} />
+              <FilterList />
             </div>
           </div>
           <div className="col-start-0 col-span-4 flex flex-col gap-y-6">
             <div className="col-start-0 col-span-4 mr-6 hidden h-fit xl:block px-6">
-              <FilterList filters={filters} />
+              <FilterList />
             </div>
           </div>
           <div className="col-span-12 xl:col-span-8">
-            {/* <AppliedFilters searchFacets={filters} /> */}
+            <ActiveFilters />
             <NoDatasetMessage />
             <DatasetListContainer />
           </div>
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
index 24edb061..a7041b66 100644
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -13,6 +13,7 @@ import SessionProviderWrapper from "./SessionProviderWrapper";
 import "./globals.css";
 config.autoAddCss = false;
 import contentConfig from "@/config/contentConfig";
+import { FilterProvider } from "@/providers/FilterProvider";
 
 export default function RootLayout({
   children,
@@ -37,7 +38,9 @@ export default function RootLayout({
                 <div>
                   <Header />
                 </div>
-                <div>{children}</div>
+                <FilterProvider>
+                  <div>{children}</div>
+                </FilterProvider>
                 <Footer />
               </SessionProviderWrapper>
             </div>
diff --git a/src/app/page.tsx b/src/app/page.tsx
index 7d4bff40..247edc8f 100644
--- a/src/app/page.tsx
+++ b/src/app/page.tsx
@@ -24,10 +24,10 @@ const HomePage = () => {
     async function fetchData() {
       try {
         const response = await datasetList({
-          limit: 4,
+          rows: 4,
           sort: "issued desc",
         });
-        setDatasets(response.data.datasets);
+        setDatasets(response.data.results);
       } catch (error) {
         if (error instanceof AxiosError) {
           setAlert({
diff --git a/src/components/ActiveFilters.tsx b/src/components/ActiveFilters.tsx
new file mode 100644
index 00000000..957ed1a2
--- /dev/null
+++ b/src/components/ActiveFilters.tsx
@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: 2024 PNED G.I.E.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+"use client";
+
+import React from "react";
+import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+import { faTimes } from "@fortawesome/free-solid-svg-icons";
+import ClearFilterButton from "@/app/datasets/FilterList/ClearFilterButton";
+import { useFilters } from "@/providers/FilterProvider";
+import { ActiveFilter } from "@/services/discovery/types/filter.type";
+
+export default function ActiveFilters() {
+  const { activeFilters, addActiveFilter, removeActiveFilter } = useFilters();
+
+  if (!activeFilters.length) {
+    return null;
+  }
+
+  const removeActiveValue = (
+    activeFilter: ActiveFilter,
+    valueToRemove: string,
+    operator?: string
+  ): void => {
+    const newActiveFilter = {
+      ...activeFilter,
+      values: activeFilter.values!.filter(
+        (v) => v.value !== valueToRemove || v.operator !== operator
+      ),
+    };
+
+    if (!newActiveFilter.values.length) {
+      removeActiveFilter(activeFilter.key, activeFilter.source);
+    } else {
+      addActiveFilter(newActiveFilter);
+    }
+  };
+
+  return (
+    <div className="mb-4">
+      <div className="flex justify-between items-center mb-4">
+        <h3 className="text-lg font-subheading">Active Filters</h3>
+        <ClearFilterButton />
+      </div>
+      <div className="flex flex-wrap gap-2">
+        {activeFilters.map((f) =>
+          f.values!.map((v) => (
+            <div
+              key={`${f.source}-${f.key}-${v.value}-${v.operator}`}
+              className="flex items-center gap-2 bg-surface rounded-lg px-3 py-1"
+            >
+              <span className="font-body text-md">
+                {`${f.label} ${v.operator || ":"} ${v.label ?? v.value}`}
+              </span>
+              <button
+                onClick={() => removeActiveValue(f, v.value, v.operator)}
+                className="text-info hover:text-secondary"
+              >
+                <FontAwesomeIcon icon={faTimes} className="h-4 w-4" />
+              </button>
+            </div>
+          ))
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/AppliedFilters.tsx b/src/components/AppliedFilters.tsx
deleted file mode 100644
index 09ba22d1..00000000
--- a/src/components/AppliedFilters.tsx
+++ /dev/null
@@ -1,103 +0,0 @@
-/* SPDX-FileCopyrightText: 2024 PNED G.I.E. */
-
-/* SPDX-License-Identifier: Apache-2.0 */
-// "use client";
-
-// import React from "react";
-// import { useSearchParams, useRouter } from "next/navigation";
-// import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
-// import { faTimes } from "@fortawesome/free-solid-svg-icons";
-// import ClearFilterButton from "@/app/datasets/FilterList/ClearFilterButton";
-
-// const AppliedFilters = ({ searchFacets }: { searchFacets: Facet[] }) => {
-//   const searchParams = useSearchParams();
-//   const router = useRouter();
-
-//   const filterItemProps: FilterItemProps[] = React.useMemo(() => {
-//     return convertDataToFilterItemProps(searchFacets);
-//   }, [searchFacets]);
-
-//   const appliedFilters = React.useMemo(() => {
-//     if (!searchParams) return [];
-
-//     return Array.from(searchParams.entries())
-//       .filter(([key]) => key !== "page" && key.includes("-"))
-//       .map(([key, value]) => {
-//         const [groupKey, field] = key.split("-");
-//         const filterItem = filterItemProps.find(
-//           (item) => item.groupKey === groupKey && item.field === field
-//         );
-//         return {
-//           groupKey,
-//           field,
-//           values: value.split(",").map((val) => ({
-//             value: val,
-//             label:
-//               filterItem?.data.find((option) => option.value === val)?.label ||
-//               val,
-//           })),
-//           label: filterItem?.label || field,
-//         };
-//       });
-//   }, [searchParams, filterItemProps]);
-
-//   const facetGroups = React.useMemo(() => {
-//     return Array.from(new Set(appliedFilters.map((filter) => filter.groupKey)));
-//   }, [appliedFilters]);
-
-//   const handleRemoveFilter = (
-//     groupKey: string,
-//     field: string,
-//     value: string
-//   ) => {
-//     if (!searchParams) return;
-
-//     const params = new URLSearchParams(searchParams.toString());
-//     const currentValues = params.get(`${groupKey}-${field}`)?.split(",") || [];
-//     const newValues = currentValues.filter((v) => v !== value);
-
-//     if (newValues.length > 0) {
-//       params.set(`${groupKey}-${field}`, newValues.join(","));
-//     } else {
-//       params.delete(`${groupKey}-${field}`);
-//     }
-
-//     params.set("page", "1");
-//     router.push(`${window.location.pathname}?${params.toString()}`);
-//   };
-
-//   if (appliedFilters.length === 0) {
-//     return null;
-//   }
-
-//   return (
-//     <div className="mb-4">
-//       <div className="flex justify-between items-center mb-4">
-//         <h3 className="text-lg font-subheading">Applied Filters</h3>
-//         <ClearFilterButton facetGroups={facetGroups} />
-//       </div>
-//       <div className="flex flex-wrap gap-2">
-//         {appliedFilters.flatMap(({ groupKey, field, values, label }) =>
-//           values.map(({ value, label: valueLabel }) => (
-//             <div
-//               key={`${groupKey}-${field}-${value}`}
-//               className="flex items-center gap-2 bg-surface rounded-lg px-3 py-1"
-//             >
-//               <span className="font-body text-md">
-//                 {label}: {valueLabel}
-//               </span>
-//               <button
-//                 onClick={() => handleRemoveFilter(groupKey, field, value)}
-//                 className="text-info hover:text-secondary"
-//               >
-//                 <FontAwesomeIcon icon={faTimes} className="h-4 w-4" />
-//               </button>
-//             </div>
-//           ))
-//         )}
-//       </div>
-//     </div>
-//   );
-// };
-
-// export default AppliedFilters;
diff --git a/src/providers/FilterProvider.tsx b/src/providers/FilterProvider.tsx
new file mode 100644
index 00000000..133babeb
--- /dev/null
+++ b/src/providers/FilterProvider.tsx
@@ -0,0 +1,182 @@
+// SPDX-FileCopyrightText: 2024 PNED G.I.E.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+"use client";
+
+import { ActiveFilter, Filter } from "@/services/discovery/types/filter.type";
+import React, { createContext, useContext, useEffect, useReducer } from "react";
+
+type FilterContextState = {
+  filters: Filter[];
+  activeFilters: ActiveFilter[];
+  isLoading: boolean;
+  error: { message: string; statusCode: number } | null;
+};
+
+type FilterContextReturnType = FilterContextState & {
+  addActiveFilter: (filter: ActiveFilter) => void;
+  removeActiveFilter: (key: string, source: string) => void;
+  clearActiveFilters: () => void;
+};
+
+enum FilterActionType {
+  FILTERS_RETRIEVED,
+  ACTIVE_FILTER_ADDED,
+  ACTIVE_FILTER_REMOVED,
+  ACTIVE_FILTERS_CLEARED,
+  ACTIVE_VALUE_REMOVED,
+  LOADING,
+  REJECTED,
+}
+
+type FilterAction = {
+  type: FilterActionType;
+  payload?: unknown;
+};
+
+function reducer(
+  state: FilterContextState,
+  action: FilterAction
+): FilterContextState {
+  switch (action.type) {
+    case FilterActionType.FILTERS_RETRIEVED: {
+      return {
+        ...state,
+        filters: action.payload as Filter[],
+        isLoading: false,
+        error: null,
+      };
+    }
+    case FilterActionType.ACTIVE_FILTER_ADDED: {
+      const newActiveFilter = action.payload as ActiveFilter;
+      const existingIndex = state.activeFilters.findIndex(
+        (f) =>
+          f.key === newActiveFilter.key && f.source === newActiveFilter.source
+      );
+
+      return {
+        ...state,
+        activeFilters:
+          existingIndex >= 0
+            ? state.activeFilters.map((f, i) =>
+                i === existingIndex ? newActiveFilter : f
+              )
+            : [...state.activeFilters, newActiveFilter],
+        error: null,
+      };
+    }
+    case FilterActionType.ACTIVE_FILTER_REMOVED: {
+      const { key, source } = action.payload as { key: string; source: string };
+      return {
+        ...state,
+        activeFilters: state.activeFilters.filter(
+          (f) => f.key !== key || f.source !== source
+        ),
+        isLoading: false,
+        error: null,
+      };
+    }
+    case FilterActionType.ACTIVE_FILTERS_CLEARED: {
+      return {
+        ...state,
+        activeFilters: [],
+        isLoading: false,
+        error: null,
+      };
+    }
+    case FilterActionType.LOADING: {
+      return {
+        ...state,
+        isLoading: true,
+      };
+    }
+    case FilterActionType.REJECTED: {
+      return {
+        ...state,
+        isLoading: false,
+        error: action.payload as { message: string; statusCode: number },
+      };
+    }
+    default:
+      return state;
+  }
+}
+
+function FilterProvider({ children }: { children: React.ReactNode }) {
+  const initialState = {
+    filters: [],
+    activeFilters: [],
+    isLoading: false,
+    error: null,
+  } as FilterContextState;
+
+  const [{ filters, activeFilters, isLoading, error }, dispatch] = useReducer(
+    reducer,
+    initialState
+  );
+
+  useEffect(() => {
+    retrieveFilters();
+  }, []);
+
+  const retrieveFilters = async () => {
+    dispatch({ type: FilterActionType.LOADING });
+    const response = await fetch("api/filters");
+
+    if (!response.ok) {
+      dispatch({
+        type: FilterActionType.REJECTED,
+        payload: { message: response.statusText, statusCode: response.status },
+      });
+    }
+
+    const filters = await response.json();
+    dispatch({ type: FilterActionType.FILTERS_RETRIEVED, payload: filters });
+  };
+
+  const addActiveFilter = (filter: ActiveFilter) => {
+    dispatch({ type: FilterActionType.ACTIVE_FILTER_ADDED, payload: filter });
+  };
+
+  const removeActiveFilter = (key: string, source: string) => {
+    dispatch({
+      type: FilterActionType.ACTIVE_FILTER_REMOVED,
+      payload: { key, source },
+    });
+  };
+
+  const clearActiveFilters = () => {
+    dispatch({ type: FilterActionType.ACTIVE_FILTERS_CLEARED });
+  };
+
+  return (
+    <FilterContext.Provider
+      value={{
+        filters,
+        activeFilters,
+        isLoading,
+        error,
+        addActiveFilter,
+        removeActiveFilter,
+        clearActiveFilters,
+      }}
+    >
+      {children}
+    </FilterContext.Provider>
+  );
+}
+
+const FilterContext = createContext<FilterContextReturnType | undefined>(
+  undefined
+);
+
+function useFilters() {
+  const context = useContext(FilterContext);
+  if (context === undefined) {
+    throw new Error("useFilters must be used within a FilterProvider");
+  }
+  return context;
+}
+
+export { FilterProvider, useFilters };
diff --git a/src/providers/datasets/DatasetsProvider.tsx b/src/providers/datasets/DatasetsProvider.tsx
index 7ff606e2..bf5a3f73 100644
--- a/src/providers/datasets/DatasetsProvider.tsx
+++ b/src/providers/datasets/DatasetsProvider.tsx
@@ -7,7 +7,7 @@
 import { datasetList } from "@/services/discovery/index.public";
 import {
   DatasetSearchOptions,
-  DatasetSearchQueryFacet,
+  Facet,
 } from "@/services/discovery/types/datasetSearch.types";
 import { AxiosError } from "axios";
 import { useSearchParams } from "next/navigation";
@@ -23,27 +23,38 @@ import {
   DatasetsActionType,
   DatasetsState,
 } from "./DatasetProvider.types";
+import {
+  ActiveFilter,
+  FilterType,
+  Operator,
+} from "@/services/discovery/types/filter.type";
+import { useFilters } from "@/providers/FilterProvider";
+
+function convertActiveFiltersToFacets(activeFilters: ActiveFilter[]): Facet[] {
+  return activeFilters
+    .map((filter) => {
+      const baseFacet = {
+        source: filter.source,
+        type: filter.type,
+        key: filter.key,
+      };
 
-function parseFacets(queryParams: URLSearchParams): DatasetSearchQueryFacet[] {
-  const facetsQuery: DatasetSearchQueryFacet[] = [];
-
-  queryParams.forEach((value, key) => {
-    if (!["page", "q", "sort"].includes(key)) {
-      const source = key.split("-")[0];
-      const facetKey = key.split("-")[1];
-      const values = value.split(",");
-
-      values.map((v) =>
-        facetsQuery.push({
-          source,
-          type: "DROPDOWN",
-          key: facetKey,
-          value: v,
+      if (filter.type === FilterType.ENTRIES) {
+        return {
+          ...baseFacet,
+          entries: filter.entries,
+        };
+      }
+
+      return filter!.values!.map(
+        (value: { value: string; label?: string; operator?: Operator }) => ({
+          ...baseFacet,
+          value: value.value,
+          operator: value.operator,
         })
       );
-    }
-  });
-  return facetsQuery;
+    })
+    .flat();
 }
 
 const DatasetsContext = createContext<DatasetsState | undefined>(undefined);
@@ -82,6 +93,7 @@ export default function DatasetsProvider({
   children: React.ReactNode;
 }) {
   const queryParams = useSearchParams();
+  const { activeFilters } = useFilters();
   const [{ datasets, datasetCount, isLoading, errorCode }, dispatch] =
     useReducer(reducer, initialState);
 
@@ -90,14 +102,13 @@ export default function DatasetsProvider({
 
     const query = queryParams || new URLSearchParams();
     const options: DatasetSearchOptions = {
-      facets: parseFacets(query),
-      offset: query.get("page")
-        ? (Number(query.get("page")) - 1) * DATASET_PER_PAGE
-        : 0,
-      limit: DATASET_PER_PAGE,
       query: query.get("q") as string | undefined,
+      facets: convertActiveFiltersToFacets(activeFilters),
       sort: query.get("sort") as string | "relevance",
-      include_private: false,
+      start: query.get("page")
+        ? (Number(query.get("page")) - 1) * DATASET_PER_PAGE
+        : 0,
+      rows: DATASET_PER_PAGE,
     };
 
     try {
@@ -105,7 +116,7 @@ export default function DatasetsProvider({
       dispatch({
         type: DatasetsActionType.DATASETS_LOADED,
         payload: {
-          datasets: response.data?.datasets,
+          datasets: response.data?.results,
           datasetCount: response.data?.count,
         },
       });
@@ -118,11 +129,11 @@ export default function DatasetsProvider({
       });
       console.error(error);
     }
-  }, [queryParams]);
+  }, [queryParams, activeFilters]);
 
   useEffect(() => {
     fetchDatasets();
-  }, [queryParams, fetchDatasets]);
+  }, [queryParams, fetchDatasets, activeFilters]);
 
   return (
     <DatasetsContext.Provider
diff --git a/src/services/discovery/__tests__/datasetList.test.ts b/src/services/discovery/__tests__/datasetList.test.ts
index e06380a7..78a49d6f 100644
--- a/src/services/discovery/__tests__/datasetList.test.ts
+++ b/src/services/discovery/__tests__/datasetList.test.ts
@@ -6,6 +6,7 @@ import { jest } from "@jest/globals";
 import axios from "axios";
 import { makeDatasetList } from "../datasetList";
 import { searchedDatasetFixture } from "../fixtures/datasetFixtures";
+import { DatasetSearchOptions } from "@/services/discovery/types/datasetSearch.types";
 
 jest.mock("axios");
 const mockedAxios = axios as jest.Mocked<typeof axios>;
@@ -63,14 +64,15 @@ describe("datasetList", () => {
       },
     ];
     const searchOptions = {
-      facets: facets,
-      limit: 1,
-    };
+      facets,
+      rows: 1,
+    } as DatasetSearchOptions;
+
     const expectedBody = {
-      start: 0,
       rows: 1,
       facets: facets,
     };
+
     await datasetList(searchOptions, null);
 
     expect(mockedAxios.post).toHaveBeenCalled();
@@ -99,10 +101,9 @@ describe("datasetList", () => {
           value: "org-2",
         },
       ],
-      limit: 1,
-    };
+      rows: 1,
+    } as DatasetSearchOptions;
     const expectedBody = {
-      start: 0,
       rows: 1,
       facets: [
         {
@@ -173,10 +174,9 @@ describe("datasetList", () => {
 
     const searchOptions = {
       facets: facets,
-      limit: 2,
+      rows: 2,
     };
     const expectedBody = {
-      start: 0,
       rows: 2,
       facets: facets,
     };
diff --git a/src/services/discovery/datasetList.ts b/src/services/discovery/datasetList.ts
index 2c4d3794..d77e9171 100644
--- a/src/services/discovery/datasetList.ts
+++ b/src/services/discovery/datasetList.ts
@@ -6,7 +6,6 @@ import { ExtendedSession } from "@/app/api/auth/auth.types";
 import axios, { AxiosResponse } from "axios";
 import {
   DatasetSearchOptions,
-  DatasetSearchQuery,
   DatasetsSearchResponse,
 } from "./types/datasetSearch.types";
 import { createHeaders } from "./utils";
@@ -16,18 +15,9 @@ export const makeDatasetList = (discoveryUrl: string) => {
     options: DatasetSearchOptions,
     session: ExtendedSession | null
   ): Promise<AxiosResponse<DatasetsSearchResponse>> => {
-    const datasetSearchQuery = {
-      start: options?.offset ?? 0,
-      rows: options?.limit ?? 10,
-      query: options?.query,
-      sort: options?.sort,
-      facets: options.facets,
-      operator: options.operator,
-    } as DatasetSearchQuery;
-
     return await axios.post<DatasetsSearchResponse>(
       `${discoveryUrl}/api/v1/datasets/search`,
-      datasetSearchQuery,
+      options,
       {
         headers: await createHeaders(session),
       }
diff --git a/src/services/discovery/public/datasetList.ts b/src/services/discovery/public/datasetList.ts
index 09c98b7f..d711b630 100644
--- a/src/services/discovery/public/datasetList.ts
+++ b/src/services/discovery/public/datasetList.ts
@@ -5,12 +5,12 @@
 import axios, { AxiosResponse } from "axios";
 import {
   DatasetSearchOptions,
-  DatasetsSearchResult,
+  DatasetsSearchResponse,
 } from "../types/datasetSearch.types";
 
 export const datasetList = async (
   options: DatasetSearchOptions
-): Promise<AxiosResponse<DatasetsSearchResult>> => {
+): Promise<AxiosResponse<DatasetsSearchResponse>> => {
   return await axios.post(
     "/api/datasets",
     { options },
diff --git a/src/services/discovery/types/dataset.types.ts b/src/services/discovery/types/dataset.types.ts
index c7a385a0..6075dc98 100644
--- a/src/services/discovery/types/dataset.types.ts
+++ b/src/services/discovery/types/dataset.types.ts
@@ -42,7 +42,7 @@ export type SearchedDataset = {
 };
 
 export type DatasetEntitlement = {
-  dataset?: SearchedDataset;
+  dataset: SearchedDataset;
   start: string;
   end: string;
 };
diff --git a/src/services/discovery/types/datasetSearch.types.ts b/src/services/discovery/types/datasetSearch.types.ts
index 23a43457..29f61a32 100644
--- a/src/services/discovery/types/datasetSearch.types.ts
+++ b/src/services/discovery/types/datasetSearch.types.ts
@@ -3,69 +3,34 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { SearchedDataset } from "./dataset.types";
-import { Operator } from "./filter.type";
+import { Operator } from "@/services/discovery/types/filter.type";
 
 export interface DatasetSearchOptions {
-  facets?: DatasetSearchQueryFacet[];
-  offset?: number;
-  limit?: number;
   query?: string;
+  facets?: Facet[];
   sort?: string;
-  include_private?: boolean;
+  rows?: number;
+  start?: number;
   operator?: QueryOperator;
 }
 
-export interface DatasetsSearchResult {
-  datasets: SearchedDataset[];
-  count: number;
-}
-
-export enum FacetType {
-  Organization = "organization",
-  Theme = "theme",
-  Tags = "tags",
-  PublisherName = "publisher_name",
-  ResponseFormat = "res_format",
-  AccessRights = "access_rights",
-  SpatialUrl = "spatial_uri",
-}
-
-export const facetToLabelMapping: Record<string, string> = {
-  organization: "Organizations",
-  theme: "Themes",
-  access_rights: "Access Rights",
-  publisher_name: "Publishers",
-  res_format: "File Formats",
-  spatial_uri: "Spatial Coverage",
-  tags: "Keywords",
-};
-
-export type DatasetSearchQueryFacet = {
+export type Facet = {
   source: string;
   type: string;
   key: string;
   value?: string;
   operator?: Operator;
-  entries?: QueryEntry[];
+  entries?: FacetEntry[];
 };
 
-export type QueryEntry = {
+export type FacetEntry = {
   key: string;
   value: string;
 };
 
-export type DatasetSearchQuery = {
-  query?: string;
-  facets?: DatasetSearchQueryFacet[];
-  sort?: string;
-  rows?: number;
-  start?: number;
-  operator?: QueryOperator;
-};
-
 export type ValueLabel = {
-  value: string;
   label: string;
+  value: string;
 };
 
 export type DatasetsSearchResponse = {
@@ -73,23 +38,6 @@ export type DatasetsSearchResponse = {
   results: SearchedDataset[];
 };
 
-export type FacetGroup = {
-  label: string;
-  key: string;
-  facets: Facet[];
-};
-
-export type Facet = {
-  key: string;
-  label: string;
-  values: ValueLabel[];
-};
-
-export enum DatasetSource {
-  Ckan = "ckan",
-  Beacon = "beacon",
-}
-
 export enum QueryOperator {
   And = "AND",
   Or = "OR",
diff --git a/src/services/discovery/types/filter.type.ts b/src/services/discovery/types/filter.type.ts
index a37ff7c3..5176b1bc 100644
--- a/src/services/discovery/types/filter.type.ts
+++ b/src/services/discovery/types/filter.type.ts
@@ -33,3 +33,17 @@ export type FilterEntry = {
   key: string;
   label: string;
 };
+
+export type ActiveFilter = {
+  source: string;
+  type: string;
+  key: string;
+  label: string;
+  values?: { value: string; label?: string; operator?: Operator }[];
+  entries?: ActiveFilterEntry[];
+};
+
+export type ActiveFilterEntry = {
+  key: string;
+  value: string;
+};
diff --git a/src/services/discovery/utils.ts b/src/services/discovery/utils.ts
index 4fa13e84..0582f7c8 100644
--- a/src/services/discovery/utils.ts
+++ b/src/services/discovery/utils.ts
@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { ExtendedSession } from "@/app/api/auth/auth.types";
 import { decrypt } from "@/utils/encryption";
-import { DatasetSearchQuery } from "./types/datasetSearch.types";
+import { DatasetSearchOptions } from "./types/datasetSearch.types";
 
 export const createHeaders = async (
   session: ExtendedSession | null
@@ -19,6 +19,6 @@ export const createHeaders = async (
   return headers;
 };
 
-export const DEFAULT_DATASET_SEARCH_QUERY: DatasetSearchQuery = {
+export const DEFAULT_DATASET_SEARCH_QUERY: DatasetSearchOptions = {
   rows: 0,
 };
diff --git a/src/utils/__tests__/datasetEntitlements.test.ts b/src/utils/__tests__/datasetEntitlements.test.ts
new file mode 100644
index 00000000..fcd63b80
--- /dev/null
+++ b/src/utils/__tests__/datasetEntitlements.test.ts
@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: 2024 PNED G.I.E.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+  createDatasetEntitlements,
+  mapToDatasetEntitlement,
+} from "@/utils/datasetEntitlements";
+import {
+  DatasetEntitlement,
+  SearchedDataset,
+} from "@/services/discovery/types/dataset.types";
+import { Entitlement } from "@/types/entitlements.types";
+import { datasetList } from "@/services/discovery/index.public";
+import { AxiosResponse } from "axios";
+import { DatasetsSearchResponse } from "@/services/discovery/types/datasetSearch.types";
+
+jest.mock("@/services/discovery/index.public");
+
+describe("datasetEntitlements", () => {
+  const mockedDatasetList = datasetList as jest.MockedFunction<
+    typeof datasetList
+  >;
+
+  it("should correctly map to dataset entitlements", () => {
+    const datasets: SearchedDataset[] = [
+      { identifier: "1", title: "Dataset 1" } as SearchedDataset,
+      { identifier: "2", title: "Dataset 2" } as SearchedDataset,
+    ];
+
+    const entitlements: Entitlement[] = [
+      { datasetId: "1", start: "2021-01-01", end: "2021-12-31" },
+      { datasetId: "2", start: "2022-01-01", end: "2022-12-31" },
+    ];
+
+    const expected = [
+      {
+        dataset: { identifier: "1", title: "Dataset 1" },
+        start: "2021-01-01",
+        end: "2021-12-31",
+      },
+      {
+        dataset: { identifier: "2", title: "Dataset 2" },
+        start: "2022-01-01",
+        end: "2022-12-31",
+      },
+    ];
+
+    const result = mapToDatasetEntitlement(datasets, entitlements);
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should return an empty array if no match between datasets and entitlements", () => {
+    const datasets: SearchedDataset[] = [
+      { identifier: "1", title: "Dataset 1" } as SearchedDataset,
+    ];
+
+    const entitlements: Entitlement[] = [
+      { datasetId: "2", start: "2021-01-01", end: "2021-12-31" },
+    ];
+
+    const expected: DatasetEntitlement[] = [];
+
+    const result = mapToDatasetEntitlement(datasets, entitlements);
+
+    expect(result).toEqual(expected);
+  });
+
+  it("should create dataset entitlements", async () => {
+    const mockApiResponse = {
+      data: {
+        results: [
+          { identifier: "1", title: "Dataset 1" } as SearchedDataset,
+          { identifier: "2", title: "Dataset 2" } as SearchedDataset,
+        ],
+        count: 2,
+      },
+    } as AxiosResponse<DatasetsSearchResponse>;
+
+    mockedDatasetList.mockResolvedValue(mockApiResponse);
+
+    const datasetEntitlements = await createDatasetEntitlements([
+      { datasetId: "2", start: "2022-01-01", end: "2022-12-31" },
+    ]);
+
+    expect(datasetEntitlements).toEqual([
+      {
+        dataset: { identifier: "2", title: "Dataset 2" },
+        start: "2022-01-01",
+        end: "2022-12-31",
+      },
+    ]);
+  });
+});
diff --git a/src/utils/datasetEntitlements.ts b/src/utils/datasetEntitlements.ts
index 8aa8e370..c2d486f7 100644
--- a/src/utils/datasetEntitlements.ts
+++ b/src/utils/datasetEntitlements.ts
@@ -17,18 +17,24 @@ export const mapToDatasetEntitlement = (
   datasets: SearchedDataset[],
   entitlements: Entitlement[]
 ): DatasetEntitlement[] => {
-  return entitlements.map((e) => ({
-    dataset: datasets.find((x) => x.identifier === e.datasetId),
-    start: e.start,
-    end: e.end,
-  }));
+  return entitlements
+    .filter(
+      (e) => datasets.find((x) => x.identifier === e.datasetId) !== undefined
+    )
+    .map((e) => ({
+      dataset: datasets.find(
+        (x) => x.identifier === e.datasetId
+      ) as SearchedDataset,
+      start: e.start,
+      end: e.end,
+    }));
 };
 
 export const createDatasetEntitlements = async (
   entitlements: Entitlement[]
 ): Promise<DatasetEntitlement[]> => {
   const options: DatasetSearchOptions = {
-    limit: 1000,
+    rows: 1000,
     facets: entitlements.map((e) => ({
       source: "ckan",
       type: "DROPDOWN",
@@ -40,5 +46,5 @@ export const createDatasetEntitlements = async (
 
   const datasetsResponse = await datasetList(options);
 
-  return mapToDatasetEntitlement(datasetsResponse.data.datasets, entitlements);
+  return mapToDatasetEntitlement(datasetsResponse.data.results, entitlements);
 };