MRT logoMantine React Table

On This Page

    Column Filtering Feature Guide

    Filtering is one of the most powerful features of Mantine React Table and is enabled by default. There is a lot of flexibility and customization available here. Whether you want to customize the powerful client-side filtering already built in or implement your own server-side filtering, Mantine React Table has got you covered.

    Relevant Table Options

    #
    Prop Name
    Type
    Default Value
    More Info Links
    1'subheader' | 'popover' | 'custom''subheader'MRT Column Filtering Docs
    2Array<MRT_FilterOption | string> | nullMRT Column Filtering Docs
    3booleanfalseMRT Column Filtering Docs
    4booleantrueMRT Column Filtering Docs
    5booleanMRT Column Filtering Docs
    6booleantrueMRT Column Filtering Docs
    7booleantrueTanStack Filters Docs
    8Record<string, FilterFn>TanStack Table Filters Docs
    9booleanfalseTanStack Filtering Docs
    10() => Map<any, number>TanStack Table Filters Docs
    11() => RowModel<TData>TanStack Table Filters Docs
    12() => Map<any, number>TanStack Table Filters Docs
    13() => RowModel<TData>TanStack Table Filters Docs
    14AutocompleteProps | ({ column, table, rangeFilterIndex }) => AutocompletePropsMantine Autocomplete Docs
    15CheckboxProps | ({ column, table }) => CheckboxPropsMantine Checkbox Docs
    16DateInputProps | ({ table, column, rangeFilterIndex }) => DateInputPropsMantine DateInput Docs
    17MultiSelectProps | ({ column, table }) => MultiSelectPropsMantine MultiSelect Docs
    18SelectProps | ({ column, table }) => SelectPropsMantine Select Docs
    19TextInputProps | ({ table, column, rangeFilterIndex }) => TextInputPropsMantine TextInput Docs
    20HighlightProps | ({ cell, column, row, table }) => HighlightPropsMantine Highlight Docs
    21booleanTanStack Table Filters Docs
    22number100TanStack Table Filtering Docs
    23OnChangeFn<{ [key: string]: MRT_FilterOption }>
    24OnChangeFn<ColumnFiltersState>TanStack Table Filter Docs
    25OnChangeFn<boolean>
    26({ column, internalFilterOptions, onSelectFilterMode, table }) => ReactNode

    Relevant Column Options

    #
    Column Option
    Type
    Default Value
    More Info Links
    1Array<string>
    2booleanMRT Column Filtering Docs
    3booleanMRT Column Filtering Docs
    4({ column, header, table }) => ReactNodeMRT Column Filtering Docs
    5MRT_FilterFn'fuzzy'
    6'text' | 'autocomplete' | 'select' | 'multi-select' | 'range' | 'range-slider' | 'checkbox' | 'date' | 'date-range''text'
    7AutocompleteProps | ({ column, table, rangeFilterIndex}) => AutocompletePropsMantine Autocomplete Docs
    8CheckboxProps | ({ column, table }) => CheckboxPropsMantine Checkbox Props
    9MultiSelectProps | ({ column, table }) => MultiSelectPropsMantine MultiSelect Docs
    10SelectProps | ({ column, table }) => SelectPropsMantine Select Docs
    11TextInputProps | ({ column, rangeFilterIndex, table }) => TextInputPropsMantine TextInput Docs
    12

    Relevant State Options

    #
    State Option
    Type
    Default Value
    More Info Links
    1{ [key: string]: MRT_FilterFn }
    2Array<{id: string, value: unknown}>{}TanStack Table Filters Docs
    3booleanfalse

    Disable Filtering Features

    Various subsets of filtering features can be disabled. If you want to disable filtering completely, you can set the enableColumnFilters table option to false to remove all filters from each column. Alternatively, enableColumnFilter can be set to false for individual columns.

    enableFilters can be set to false to disable both column filters and the global search filter.

    Filter Variants

    Mantine React Table has several built-in filter variants for advanced filtering. These can be specified on a per-column basis using the filterVariant option. The following variants are available:

    • 'text' - shows the default text field

    • 'autocomplete' - shows an autocomplete text field with the options from faceted values or specified in mantineFilterAutocompleteProps.data array.

    • 'select' - shows a select dropdown with the options from faceted values or specified in mantineFilterSelectProps.data array.

    • 'multi-select' - shows a select dropdown with the options from faceted values or specified in mantineFilterMultiSelectProps.data and allows multiple selections with checkboxes

    • 'range' - shows min and max text fields for filtering a range of values

    • 'range-slider' - shows a slider for filtering a range of values

    • 'date' - shows a date picker for filtering by date values

    • 'date-range' - shows a date range picker for filtering by date ranges

    • 'checkbox' - shows a checkbox for filtering by 'true' or 'false' values

    Account Status
    Name
    Hire Date
    Age
    Salary
    City
    State
    ActiveTanner Linsley2/23/201642$100,000.00San FranciscoCalifornia
    ActiveKevin Vandy2/23/201951$80,000.00RichmondVirginia
    InactiveJohn Doe2/23/201427$120,000.00RiversideSouth Carolina
    ActiveJane Doe2/25/201532$150,000.00San FranciscoCalifornia
    InactiveJohn Smith6/11/202342$75,000.00Los AngelesCalifornia
    ActiveJane Smith2/23/201951$56,000.00BlacksburgVirginia
    InactiveSamuel Jackson2/23/201027$90,000.00New YorkNew York

    Rows per page

    1-7 of 7

    import '@mantine/core/styles.css';
    import '@mantine/dates/styles.css'; //if using mantine date picker features
    import 'mantine-react-table/styles.css'; //make sure MRT styles were imported in your app root (once)
    import { useMemo } from 'react';
    import {
      MantineReactTable,
      useMantineReactTable,
      type MRT_ColumnDef,
    } from 'mantine-react-table';
    import { citiesList, data, usStateList, type Person } from './makeData';
    
    const Example = () => {
      const columns = useMemo<MRT_ColumnDef<Person>[]>(
        () => [
          {
            accessorFn: (originalRow) => (originalRow.isActive ? 'true' : 'false'), //must be strings
            id: 'isActive',
            header: 'Account Status',
            filterVariant: 'checkbox',
            Cell: ({ cell }) =>
              cell.getValue() === 'true' ? 'Active' : 'Inactive',
            size: 220,
          },
          {
            accessorKey: 'name',
            header: 'Name',
            filterVariant: 'text', // default
          },
          {
            accessorFn: (originalRow) => new Date(originalRow.hireDate), //convert to date for sorting and filtering
            id: 'hireDate',
            header: 'Hire Date',
            filterVariant: 'date-range',
            Cell: ({ cell }) => cell.getValue<Date>().toLocaleDateString(), // convert back to string for display
          },
          {
            accessorKey: 'age',
            header: 'Age',
            filterVariant: 'range',
            filterFn: 'between',
            size: 80,
          },
          {
            accessorKey: 'salary',
            header: 'Salary',
            Cell: ({ cell }) =>
              cell.getValue<number>().toLocaleString('en-US', {
                style: 'currency',
                currency: 'USD',
              }),
            filterVariant: 'range-slider',
            filterFn: 'betweenInclusive', // default (or between)
            mantineFilterRangeSliderProps: {
              max: 200_000, //custom max (as opposed to faceted max)
              min: 30_000, //custom min (as opposed to faceted min)
              step: 10_000,
              label: (value) =>
                value.toLocaleString('en-US', {
                  style: 'currency',
                  currency: 'USD',
                }),
            },
          },
          {
            accessorKey: 'city',
            header: 'City',
            filterVariant: 'select',
            mantineFilterSelectProps: {
              data: citiesList as any,
            },
          },
          {
            accessorKey: 'state',
            header: 'State',
            filterVariant: 'multi-select',
            mantineFilterMultiSelectProps: {
              data: usStateList as any,
            },
          },
        ],
        [],
      );
    
      const table = useMantineReactTable({
        columns,
        data,
        initialState: { showColumnFilters: true },
      });
    
      return <MantineReactTable table={table} />;
    };
    
    export default Example;

    Faceted Values for Filter Variants

    Faceted values are a list of unique values for a column that gets generated under the hood from table data when the enableFacetedValues table option is set to true. These values can be used to populate the autocomplete suggestions, select dropdowns, or the min and max values for the 'range-slider' variant. This means that you no longer need to manually specify the filter select data props for these variants manually, especially if you are using client-side filtering.

    Name
    Salary
    City
    State
    Tanner Linsley$100,000.00San FranciscoCalifornia
    Kevin Vandy$80,000.00RichmondVirginia
    John Doe$120,000.00RiversideSouth Carolina
    Jane Doe$150,000.00San FranciscoCalifornia
    John Smith$75,000.00Los AngelesCalifornia
    Jane Smith$56,000.00BlacksburgVirginia
    Samuel Jackson$90,000.00New YorkNew York

    Rows per page

    1-7 of 7

    import '@mantine/core/styles.css';
    import '@mantine/dates/styles.css'; //if using mantine date picker features
    import 'mantine-react-table/styles.css'; //make sure MRT styles were imported in your app root (once)
    import { useMemo } from 'react';
    import {
      MantineReactTable,
      useMantineReactTable,
      type MRT_ColumnDef,
    } from 'mantine-react-table';
    import { data, type Person } from './makeData';
    
    const Example = () => {
      const columns = useMemo<MRT_ColumnDef<Person>[]>(
        () => [
          {
            accessorKey: 'name',
            header: 'Name',
            filterVariant: 'autocomplete',
            //no need to specify autocomplete props data if using faceted values
            size: 100,
          },
          {
            accessorKey: 'salary',
            header: 'Salary',
            Cell: ({ cell }) =>
              cell.getValue<number>().toLocaleString('en-US', {
                style: 'currency',
                currency: 'USD',
              }),
            filterVariant: 'range-slider',
            filterFn: 'betweenInclusive', // default (or between)
            mantineFilterRangeSliderProps: {
              //no need to specify min/max/step if using faceted values
              color: 'pink',
              step: 5_000,
              label: (value) =>
                value.toLocaleString('en-US', {
                  style: 'currency',
                  currency: 'USD',
                }),
            },
          },
          {
            accessorKey: 'city',
            header: 'City',
            filterVariant: 'select',
            //no need to specify select props data if using faceted values
          },
          {
            accessorKey: 'state',
            header: 'State',
            filterVariant: 'multi-select',
            //no need to specify select props data if using faceted values
          },
        ],
        [],
      );
    
      const table = useMantineReactTable({
        columns,
        data,
        enableFacetedValues: true,
        initialState: { showColumnFilters: true },
      });
    
      return <MantineReactTable table={table} />;
    };
    
    export default Example;

    Custom Faceted Values

    If you are using server-side pagination and filtering, you can still customize the faceted values output with the getFacetedUniqueValues and getFacetedMinMaxValues table options.

    const table = useMantineReactTable({
      columns,
      data,
      enableFacetedValues: true,
      //if using server-side pagination and filtering
      getFacetedMinMaxValues: (table) => {
        //fetch min and max values from server
        return [minValue, maxValue];
      },
      //if using server-side filtering
      getFacetedUniqueValues: (table) => {
        const uniqueValueMap = new Map<string, number>();
        //fetch unique values from server, ideally including the count of each unique value
        return uniqueValueMap;
      },
    });

    Column Filter Display Modes

    By default, column filters inputs show below the column header. You can switch to a more "excel-like" UI by setting the columnFilterDisplayMode table option to 'popover'. This will show a filter icon in the column header that can be clicked to open a popover with the filter input.

    const table = useMantineReactTable({
      columns,
      data,
      columnFilterDisplayMode: 'popover', //filter inputs will show in a popover (like excel)
    });

    Alternatively, if you want to render your own column filter UI in a separate sidebar, but still want to use the built-in filtering functionality, you can set the columnFilterDisplayMode table option to 'custom'.

    const table = useMantineReactTable({
      columns,
      data,
      columnFilterDisplayMode: 'custom', //render your own column filter UI (e.g. in a sidebar)
    });
    ID
    First Name
    Last Name
    Gender
    Age
    1HughMungusMale42
    2LeroyJenkinsMale51
    3CandiceNutellaFemale27
    4MicahJohnsonOther32

    Rows per page

    1-4 of 4

    import '@mantine/core/styles.css';
    import '@mantine/dates/styles.css'; //if using mantine date picker features
    import 'mantine-react-table/styles.css'; //make sure MRT styles were imported in your app root (once)
    import { useMemo } from 'react';
    import { MantineReactTable, type MRT_ColumnDef } from 'mantine-react-table';
    import { data, type Person } from './makeData';
    
    const Example = () => {
      const columns = useMemo<MRT_ColumnDef<Person>[]>(
        () => [
          {
            accessorKey: 'id',
            header: 'ID',
          },
          {
            accessorKey: 'firstName',
            header: 'First Name',
          },
          {
            accessorKey: 'lastName',
            header: 'Last Name',
          },
          {
            accessorKey: 'gender',
            header: 'Gender',
            filterFn: 'equals',
            mantineFilterSelectProps: {
              data: ['Male', 'Female', 'Other'],
            },
            filterVariant: 'select',
          },
          {
            accessorKey: 'age',
            header: 'Age',
            filterVariant: 'range',
          },
        ],
        [],
      );
    
      return (
        <MantineReactTable
          columns={columns}
          data={data}
          columnFilterDisplayMode="popover"
        />
      );
    };
    
    export default Example;

    Custom Filter Functions

    You can specify either a pre-built filterFn that comes with Mantine React Table or pass in your own custom filter functions.

    Custom Filter Functions Per Column

    By default, Mantine React Table uses a fuzzy filtering algorithm based on the popular match-sorter library from Kent C. Dodds. However, Mantine React Table also comes with numerous other filter functions that you can specify per column in the filterFn column options.

    Pre-built MRT Filter Functions

    Pre-built filter functions from Mantine React Table include between, betweenInclusive, contains, empty, endsWith, equals, fuzzy, greaterThan, greaterThanOrEqualTo, lessThan, lessThanOrEqualTo, notEmpty, notEquals, and startsWith. View these algorithms here

    Pre-built TanStack Table Filter Functions

    Pre-built filter functions from TanStack Table include includesString, includesStringSensitive, equalsString, equalsStringSensitive, arrIncludes, arrIncludesAll, arrIncludesSome, weakEquals, and inNumberRange. View more information about these algorithms in the TanStack Table Filter docs.

    You can specify either a pre-built filter function, from Mantine React Table or TanStack Table, or you can even specify your own custom filter function in the filterFn column option.

    const columns = [
      {
        accessorKey: 'firstName',
        header: 'First Name',
        // using a prebuilt filter function from Mantine React Table
        filterFn: 'startsWith',
      },
      {
        accessorKey: 'middleName',
        header: 'Middle Name',
        // using a prebuilt filter function from TanStack Table
        filterFn: 'includesStringSensitive',
      },
      {
        accessorKey: 'lastName',
        header: 'Last Name',
        // custom filter function
        filterFn: (row, id, filterValue) =>
          row.getValue(id).startsWith(filterValue),
      },
    ];

    If you provide a custom filter function, it must have the following signature:

    (row: Row<TData>, id: string, filterValue: string | number) => boolean;

    This function will be used to filter 1 row at a time and should return a boolean indicating whether or not that row passes the filter.

    Add Custom Filter Functions

    You can add custom filter functions to the filterFns table option. These will be available to all columns to use. The filterFn column option on a column will override any filter function with the same name in the filterFns table option.

    const columns = [
      {
        accessorKey: 'name',
        header: 'Name',
        filterFn: 'customFilterFn',
      },
    ];
    
    const table = useMantineReactTable({
      data,
      columns,
      filterFns: {
        customFilterFn: (row, id, filterValue) => {
          return row.customField === value;
        },
      },
    });

    Filter Modes

    Enable Column Filter Modes (Filter Switching)

    If you want to let the user switch between multiple different filter modes from a drop-down menu on the Filter Textfield, you can enable that with the enableColumnFilterModes table or column option. This will enable the filter icon in the filter text field to open a drop-down menu with the available filter modes when clicked.

    const table = useMantineReactTable({
      columns,
      data,
      enableColumnFilterModes: true,
    });

    Customize Filter Modes

    You can narrow down the available filter mode options by setting the columnFilterModeOptions table or a column specific columnFilterModeOptions option.

    const columns = [
      {
        accessorKey: 'firstName',
        header: 'First Name',
        columnFilterModeOptions: ['fuzzy', 'contains', 'startsWith'],
      },
      {
        accessorKey: 'age',
        header: 'Age',
        columnFilterModeOptions: ['between', 'lessThan', 'greaterThan'],
      },
    ];

    Render Custom Filter Mode Menu

    You can also render custom menu items in the filter mode drop-down menu by setting the renderColumnFilterModeMenuItems table or column option. This option is a function that takes in the column and returns an array of MenuItem components. This is useful if you want to add custom filter modes that are not included in Mantine React Table, or if you just want to render the menu in your own custom way

    const columns = [
      {
        accessorKey: 'firstName',
        header: 'First Name',
        renderColumnFilterModeMenuItems: ({ column, onSelectFilterMode }) => [
          <MenuItem
            key="startsWith"
            onClick={() => onSelectFilterMode('startsWith')}
          >
            Start With
          </MenuItem>,
          <MenuItem
            key="endsWith"
            onClick={() => onSelectFilterMode('yourCustomFilterFn')}
          >
            Your Custom Filter Fn
          </MenuItem>,
        ],
      },
    ];
    
    const table = useMantineReactTable({
      columns,
      data,
      enableColumnFilterModes: true,
      // renderColumnFilterModeMenuItems could go here if you want to apply to all columns
    });
    ID
    First Name
    Middle Name
    Last Name
    Age
    1HughJayMungus42
    2LeroyLeroyJenkins51
    3CandiceDeniseNutella27
    4MicahHenryJohnson32

    Rows per page

    1-4 of 4

    import '@mantine/core/styles.css';
    import '@mantine/dates/styles.css'; //if using mantine date picker features
    import 'mantine-react-table/styles.css'; //make sure MRT styles were imported in your app root (once)
    import { useMemo } from 'react';
    import { MantineReactTable, type MRT_ColumnDef } from 'mantine-react-table';
    import { Menu } from '@mantine/core';
    import { data, type Person } from './makeData';
    
    const Example = () => {
      const columns = useMemo<MRT_ColumnDef<Person>[]>(
        () => [
          {
            accessorKey: 'id',
            enableColumnFilterModes: false, //disable changing filter mode for this column
            filterFn: 'equals', //set filter mode to equals
            header: 'ID',
          },
          {
            accessorKey: 'firstName', //normal, all filter modes are enabled
            header: 'First Name',
          },
          {
            accessorKey: 'middleName',
            enableColumnFilterModes: false, //disable changing filter mode for this column
            filterFn: 'startsWith', //even though changing the mode is disabled, you can still set the default filter mode
            header: 'Middle Name',
          },
          {
            accessorKey: 'lastName',
            header: 'Last Name',
            //if you do not want to use the default filter modes, you can provide your own and render your own menu
            renderColumnFilterModeMenuItems: ({ onSelectFilterMode }) => (
              <>
                <Menu.Item onClick={() => onSelectFilterMode('contains')}>
                  <div>Contains</div>
                </Menu.Item>
                <Menu.Item
                  key="1"
                  onClick={() => onSelectFilterMode('customFilterFn')}
                >
                  <div>Custom Filter Fn</div>
                </Menu.Item>
              </>
            ),
          },
          {
            accessorKey: 'age',
            columnFilterModeOptions: ['between', 'greaterThan', 'lessThan'], //only allow these filter modes
            filterFn: 'between',
            header: 'Age',
          },
        ],
        [],
      );
    
      return (
        <MantineReactTable
          columns={columns}
          data={data}
          enableColumnFilterModes //enable changing filter mode for all columns unless explicitly disabled in a column def
          initialState={{ showColumnFilters: true }} //show filters by default
          filterFns={{
            customFilterFn: (row, id, filterValue) => {
              return row.getValue(id) === filterValue;
            },
          }}
          localization={
            {
              filterCustomFilterFn: 'Custom Filter Fn',
            } as any
          }
        />
      );
    };
    
    export default Example;

    Expanded Leaf Row Filtering Options

    If you are using the filtering features along-side either the grouping or expanding features, then there are a few behaviors and customizations you should be aware of.

    Check out the Expanded Leaf Row Filtering Behavior docs to learn more about the filterFromLeafRows and maxLeafRowFilterDepth table options.

    Manual Server-Side Column Filtering

    A very common use case when you have a lot of data is to filter the data on the server, instead of client-side. In this case, you will want to set the manualFiltering table option to true and manage the columnFilters state yourself like so (can work in conjunction with manual global filtering).

    // You can manage and have control over the columnFilters state yourself
    const [columnFilters, setColumnFilters] = useState([]);
    const [data, setData] = useState([]); //data will get updated after re-fetching
    
    useEffect(() => {
      const fetchData = async () => {
        // send api requests when columnFilters state changes
        const filteredData = await fetch();
        setData([...filteredData]);
      };
    }, [columnFilters]);
    
    const table = useMantineReactTable({
      columns,
      data, // this will already be filtered on the server
      manualFiltering: true, //turn off client-side filtering
      onColumnFiltersChange: setColumnFilters, //hoist internal columnFilters state to your state
      state: { columnFilters }, //pass in your own managed columnFilters state
    });
    
    return <MantineReactTable table={table} />;

    Specifying manualFiltering turns off all client-side filtering and assumes that the data you pass to <MantineReactTable /> is already filtered.

    See the full Remote Data example featuring server-side filtering, pagination, and sorting.

    Customize Mantine Filter Input Components

    You can customize the Mantine filter components by setting the mantineFilterTextInputProps table or column option.

    ID
    First Name
    Last Name
    Gender
    Age
    1HughMungusMale42
    2LeroyJenkinsMale51
    3CandiceNutellaFemale27
    4MicahJohnsonOther32

    Rows per page

    1-4 of 4

    import '@mantine/core/styles.css';
    import '@mantine/dates/styles.css'; //if using mantine date picker features
    import 'mantine-react-table/styles.css'; //make sure MRT styles were imported in your app root (once)
    import { useMemo } from 'react';
    import { MantineReactTable, type MRT_ColumnDef } from 'mantine-react-table';
    import { data } from './makeData';
    
    export type Person = {
      id: number;
      firstName: string;
      lastName: string;
      gender: string;
      age: number;
    };
    
    const Example = () => {
      const columns = useMemo<MRT_ColumnDef<Person>[]>(
        () => [
          {
            accessorKey: 'id',
            header: 'ID',
            mantineFilterTextInputProps: { placeholder: 'ID' },
          },
          {
            accessorKey: 'firstName',
            header: 'First Name',
          },
          {
            accessorKey: 'lastName',
            header: 'Last Name',
          },
          {
            accessorKey: 'gender',
            header: 'Gender',
            filterFn: 'equals',
            mantineFilterSelectProps: {
              data: ['Male', 'Female', 'Other'] as any,
            },
            filterVariant: 'select',
          },
          {
            accessorKey: 'age',
            header: 'Age',
            filterVariant: 'range',
          },
        ],
        [],
      );
    
      return (
        <MantineReactTable
          columns={columns}
          data={data}
          initialState={{ showColumnFilters: true }} //show filters by default
          mantineFilterTextInputProps={{
            style: { borderBottom: 'unset', marginTop: '8px' },
            variant: 'filled',
          }}
          mantineFilterSelectProps={{
            style: { borderBottom: 'unset', marginTop: '8px' },
            variant: 'filled',
          }}
        />
      );
    };
    
    export default Example;

    Custom Filter Components

    If you need custom filter components that are much more complex than text-boxes and dropdowns, you can create and pass in your own filter components using the Filter column option.

    Filter Match Highlighting

    Filter Match Highlighting is a new featured enabled by default that will highlight text in the table body cells that matches the current filter query with a shade of the theme.colors.yellow color.

    Filter Match Highlighting will only work on columns with the default text filter variant. Also, if you are using a custom Cell render override for a column, you will need to use the renderedCellValue param instead of cell.getValue() in order to preserve the filter match highlighting.

    const columns = [
      {
        accessorKey: 'name',
        header: 'Name',
        Cell: ({ renderedCellValue }) => <span>{renderedCellValue}</span>, // use renderedCellValue instead of cell.getValue()
      },
    ];

    Disable Filter Match Highlighting

    This feature can be disabled by setting the enableFilterMatchHighlighting table option to false.

    const table = useMantineReactTable({
      columns,
      data,
      enableFilterMatchHighlighting: false,
    });

    View Extra Storybook Examples