diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index 8b634e8387dec..b40b6792c4216 100755
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -248,6 +248,7 @@ const CONST = {
     POPOVER_MENU_MAX_HEIGHT: 496,
     POPOVER_MENU_MAX_HEIGHT_MOBILE: 432,
     POPOVER_DATE_WIDTH: 338,
+    POPOVER_DATE_RANGE_WIDTH: 672,
     POPOVER_DATE_MAX_HEIGHT: 366,
     POPOVER_DATE_MIN_HEIGHT: 322,
     TOOLTIP_ANIMATION_DURATION: 500,
@@ -7408,6 +7409,7 @@ const CONST = {
             EQUAL_TO: 'eq',
             CONTAINS: 'contains',
             NOT_EQUAL_TO: 'neq',
+            RANGE: 'range',
             GREATER_THAN: 'gt',
             GREATER_THAN_OR_EQUAL_TO: 'gte',
             LOWER_THAN: 'lt',
@@ -7482,6 +7484,7 @@ const CONST = {
             ON_PREFIX: 'reportFieldOn-',
             AFTER_PREFIX: 'reportFieldAfter-',
             BEFORE_PREFIX: 'reportFieldBefore-',
+            RANGE_PREFIX: 'reportFieldRange-',
         },
         TAG_EMPTY_VALUE: 'none',
         CATEGORY_EMPTY_VALUE: 'none',
@@ -7610,6 +7613,7 @@ const CONST = {
             ON: 'On',
             AFTER: 'After',
             BEFORE: 'Before',
+            RANGE: 'Range',
         },
         AMOUNT_MODIFIERS: {
             LESS_THAN: 'LessThan',
diff --git a/src/components/DatePicker/CalendarPicker/Day.tsx b/src/components/DatePicker/CalendarPicker/Day.tsx
index 3db884bb7fdc0..ed57ddb5bf025 100644
--- a/src/components/DatePicker/CalendarPicker/Day.tsx
+++ b/src/components/DatePicker/CalendarPicker/Day.tsx
@@ -27,13 +27,9 @@ function Day({disabled, selected, pressed, hovered, children}: DayProps) {
     const StyleUtils = useStyleUtils();
     return (
         <View
-            style={[
-                themeStyles.calendarDayContainer,
-                selected ? themeStyles.buttonDefaultBG : {},
-                !disabled ? StyleUtils.getButtonBackgroundColorStyle(getButtonState(hovered, pressed)) : {},
-            ]}
+            style={[themeStyles.calendarDayContainer, selected ? themeStyles.buttonSuccess : {}, !disabled ? StyleUtils.getButtonBackgroundColorStyle(getButtonState(hovered, pressed)) : {}]}
         >
-            <Text style={disabled ? themeStyles.buttonOpacityDisabled : {}}>{children}</Text>
+            <Text style={[disabled ? themeStyles.buttonOpacityDisabled : {}, selected ? themeStyles.buttonSuccessText : {}]}>{children}</Text>
         </View>
     );
 }
diff --git a/src/components/DatePicker/CalendarPicker/index.tsx b/src/components/DatePicker/CalendarPicker/index.tsx
index b520650c8c74c..0364dc61c5ec9 100644
--- a/src/components/DatePicker/CalendarPicker/index.tsx
+++ b/src/components/DatePicker/CalendarPicker/index.tsx
@@ -1,6 +1,7 @@
 import {addMonths, endOfDay, endOfMonth, format, getYear, isSameDay, parseISO, setDate, setYear, startOfDay, startOfMonth, subMonths} from 'date-fns';
 import {Str} from 'expensify-common';
 import React, {useCallback, useEffect, useRef, useState} from 'react';
+import type {StyleProp, ViewStyle} from 'react-native';
 import {View} from 'react-native';
 import Animated, {useAnimatedStyle, useSharedValue, withTiming} from 'react-native-reanimated';
 import PressableWithFeedback from '@components/Pressable/PressableWithFeedback';
@@ -35,6 +36,9 @@ type CalendarPickerProps = {
 
     /** A function called when the date is selected */
     onSelected?: (selectedDate: string) => void;
+
+    /** Optional style override for the header container */
+    headerContainerStyle?: StyleProp<ViewStyle>;
 };
 
 function getInitialCurrentDateView(value: Date | string, minDate: Date, maxDate: Date) {
@@ -56,6 +60,7 @@ function CalendarPicker({
     onSelected,
     DayComponent = Day,
     selectableDates,
+    headerContainerStyle,
 }: CalendarPickerProps) {
     // eslint-disable-next-line rulesdir/prefer-shouldUseNarrowLayout-instead-of-isSmallScreenWidth
     const {isSmallScreenWidth} = useResponsiveLayout();
@@ -175,13 +180,14 @@ function CalendarPicker({
 
     const webOnlyMarginStyle = isSmallScreenWidth ? {} : styles.mh1;
     const calendarContainerStyle = isSmallScreenWidth ? [webOnlyMarginStyle, themeStyles.calendarBodyContainer] : [webOnlyMarginStyle, animatedStyle];
+    const headerPaddingStyle = headerContainerStyle ?? themeStyles.ph5;
 
     const getAccessibilityState = useCallback((isSelected: boolean) => ({selected: isSelected}), []);
 
     return (
         <View style={[themeStyles.pb4]}>
             <View
-                style={[themeStyles.calendarHeader, themeStyles.flexRow, themeStyles.justifyContentBetween, themeStyles.alignItemsCenter, themeStyles.ph5]}
+                style={[themeStyles.calendarHeader, themeStyles.flexRow, themeStyles.justifyContentBetween, themeStyles.alignItemsCenter, headerPaddingStyle]}
                 dataSet={{[CONST.SELECTION_SCRAPER_HIDDEN_ELEMENT]: true}}
             >
                 <PressableWithFeedback
diff --git a/src/components/Search/FilterComponents/DateFilterBase.tsx b/src/components/Search/FilterComponents/DateFilterBase.tsx
index e4ba0d19baec6..2c6951eb3d8bf 100644
--- a/src/components/Search/FilterComponents/DateFilterBase.tsx
+++ b/src/components/Search/FilterComponents/DateFilterBase.tsx
@@ -1,12 +1,15 @@
 import React, {useCallback, useMemo, useRef, useState} from 'react';
+import {View} from 'react-native';
 import Button from '@components/Button';
 import FormAlertWithSubmitButton from '@components/FormAlertWithSubmitButton';
 import HeaderWithBackButton from '@components/HeaderWithBackButton';
 import ScrollView from '@components/ScrollView';
 import type {ReportFieldDateKey, SearchDateFilterKeys} from '@components/Search/types';
+import Text from '@components/Text';
 import useLocalize from '@hooks/useLocalize';
 import useOnyx from '@hooks/useOnyx';
 import useThemeStyles from '@hooks/useThemeStyles';
+import {getDateRangeDisplayValueFromFormValue} from '@libs/SearchQueryUtils';
 import {getDatePresets} from '@libs/SearchUIUtils';
 import type {SearchDateModifier, SearchDateModifierLower} from '@libs/SearchUIUtils';
 import CONST from '@src/CONST';
@@ -30,6 +33,7 @@ function DateFilterBase({title, dateKey, back, onSubmit}: DateFilterBaseProps) {
     const [searchAdvancedFiltersForm, searchAdvancedFiltersFormMetadata] = useOnyx(ONYXKEYS.FORMS.SEARCH_ADVANCED_FILTERS_FORM);
     const isSearchAdvancedFiltersFormLoading = isLoadingOnyxValue(searchAdvancedFiltersFormMetadata);
     const [selectedDateModifier, setSelectedDateModifier] = useState<SearchDateModifier | null>(null);
+    const [shouldShowRangeError, setShouldShowRangeError] = useState(false);
 
     const dateOnKey = dateKey.startsWith(CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX)
         ? (dateKey.replace(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX, CONST.SEARCH.REPORT_FIELD.ON_PREFIX) as ReportFieldDateKey)
@@ -43,19 +47,36 @@ function DateFilterBase({title, dateKey, back, onSubmit}: DateFilterBaseProps) {
         ? (dateKey.replace(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX, CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX) as ReportFieldDateKey)
         : (`${dateKey}${CONST.SEARCH.DATE_MODIFIERS.AFTER}` as const);
 
+    const dateRangeKey = dateKey.startsWith(CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX)
+        ? (`${CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX}${dateKey.replace(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX, '')}` as ReportFieldDateKey)
+        : (`${dateKey}${CONST.SEARCH.DATE_MODIFIERS.RANGE}` as const);
+
     const dateOnValue = searchAdvancedFiltersForm?.[dateOnKey];
     const dateBeforeValue = searchAdvancedFiltersForm?.[dateBeforeKey];
     const dateAfterValue = searchAdvancedFiltersForm?.[dateAfterKey];
+    const dateRangeValue = searchAdvancedFiltersForm?.[dateRangeKey];
 
     const defaultDateValues = useMemo(
         () => ({
             [CONST.SEARCH.DATE_MODIFIERS.ON]: dateOnValue,
             [CONST.SEARCH.DATE_MODIFIERS.BEFORE]: dateBeforeValue,
             [CONST.SEARCH.DATE_MODIFIERS.AFTER]: dateAfterValue,
+            [CONST.SEARCH.DATE_MODIFIERS.RANGE]: dateRangeValue,
         }),
-        [dateAfterValue, dateBeforeValue, dateOnValue],
+        [dateAfterValue, dateBeforeValue, dateOnValue, dateRangeValue],
+    );
+    const [rangeDisplayText, setRangeDisplayText] = useState(() =>
+        getDateRangeDisplayValueFromFormValue(
+            defaultDateValues[CONST.SEARCH.DATE_MODIFIERS.RANGE],
+            defaultDateValues[CONST.SEARCH.DATE_MODIFIERS.AFTER],
+            defaultDateValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE],
+        ),
     );
 
+    const handleDateValuesChange = useCallback(() => {
+        setRangeDisplayText(searchDatePresetFilterBaseRef.current?.getRangeDisplayText() ?? '');
+    }, []);
+
     const presets = useMemo(() => {
         const hasFeed = !!searchAdvancedFiltersForm?.feed?.length;
         return getDatePresets(dateKey, hasFeed);
@@ -76,11 +97,14 @@ function DateFilterBase({title, dateKey, back, onSubmit}: DateFilterBaseProps) {
 
         if (selectedDateModifier) {
             searchDatePresetFilterBaseRef.current.clearDateValueOfSelectedDateModifier();
+            setRangeDisplayText(searchDatePresetFilterBaseRef.current.getRangeDisplayText());
             setSelectedDateModifier(null);
+            setShouldShowRangeError(false);
             return;
         }
 
         searchDatePresetFilterBaseRef.current.clearDateValues();
+        setRangeDisplayText('');
     }, [selectedDateModifier]);
 
     const save = useCallback(() => {
@@ -89,36 +113,49 @@ function DateFilterBase({title, dateKey, back, onSubmit}: DateFilterBaseProps) {
         }
 
         if (selectedDateModifier) {
+            if (!searchDatePresetFilterBaseRef.current.validate()) {
+                return;
+            }
+
             searchDatePresetFilterBaseRef.current.setDateValueOfSelectedDateModifier();
+            setRangeDisplayText(searchDatePresetFilterBaseRef.current.getRangeDisplayText());
             setSelectedDateModifier(null);
+            setShouldShowRangeError(false);
             return;
         }
 
         const dateValues = searchDatePresetFilterBaseRef.current.getDateValues();
-
         onSubmit({
             [dateOnKey]: dateValues[CONST.SEARCH.DATE_MODIFIERS.ON] ?? null,
             [dateBeforeKey]: dateValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE] ?? null,
             [dateAfterKey]: dateValues[CONST.SEARCH.DATE_MODIFIERS.AFTER] ?? null,
+            [dateRangeKey]: dateValues[CONST.SEARCH.DATE_MODIFIERS.RANGE] ?? null,
         });
-    }, [selectedDateModifier, dateOnKey, dateBeforeKey, dateAfterKey, onSubmit]);
+    }, [selectedDateModifier, dateOnKey, dateBeforeKey, dateAfterKey, dateRangeKey, onSubmit]);
 
     const goBack = () => {
         if (selectedDateModifier) {
+            if (searchDatePresetFilterBaseRef.current && selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE) {
+                searchDatePresetFilterBaseRef.current.resetDateValuesToDefault();
+                setRangeDisplayText(searchDatePresetFilterBaseRef.current.getRangeDisplayText());
+            }
             setSelectedDateModifier(null);
+            setShouldShowRangeError(false);
             return;
         }
 
         back();
     };
 
+    const hasRangeInput = !!rangeDisplayText;
+
     return (
-        <>
+        <View style={styles.flex1}>
             <HeaderWithBackButton
                 title={computedTitle}
                 onBackButtonPress={goBack}
             />
-            <ScrollView contentContainerStyle={[styles.flexGrow1]}>
+            <ScrollView contentContainerStyle={[styles.flexGrow1, styles.pb5]}>
                 <DatePresetFilterBase
                     ref={searchDatePresetFilterBaseRef}
                     defaultDateValues={defaultDateValues}
@@ -126,21 +163,32 @@ function DateFilterBase({title, dateKey, back, onSubmit}: DateFilterBaseProps) {
                     onSelectDateModifier={setSelectedDateModifier}
                     presets={presets}
                     isSearchAdvancedFiltersFormLoading={isSearchAdvancedFiltersFormLoading}
+                    shouldShowRangeError={shouldShowRangeError}
+                    onDateValuesChange={handleDateValuesChange}
+                    onRangeValidationErrorChange={setShouldShowRangeError}
+                    forceVerticalCalendars
+                />
+                {selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE && hasRangeInput && (
+                    <Text style={[styles.textLabelSupporting, styles.mh5, styles.mt2]}>
+                        {`${translate('common.range')}: `}
+                        <Text style={[styles.textLabel]}>{rangeDisplayText}</Text>
+                    </Text>
+                )}
+                <View style={styles.flexGrow1} />
+                <Button
+                    text={translate('common.reset')}
+                    onPress={reset}
+                    style={[styles.mh4, styles.mt4]}
+                    large
+                />
+                <FormAlertWithSubmitButton
+                    buttonText={translate('common.save')}
+                    containerStyles={[styles.m4, styles.mt3]}
+                    onSubmit={save}
+                    enabledWhenOffline
                 />
             </ScrollView>
-            <Button
-                text={translate('common.reset')}
-                onPress={reset}
-                style={[styles.mh4, styles.mt4]}
-                large
-            />
-            <FormAlertWithSubmitButton
-                buttonText={translate('common.save')}
-                containerStyles={[styles.m4, styles.mt3, styles.mb5]}
-                onSubmit={save}
-                enabledWhenOffline
-            />
-        </>
+        </View>
     );
 }
 
diff --git a/src/components/Search/FilterComponents/DatePresetFilterBase.tsx b/src/components/Search/FilterComponents/DatePresetFilterBase.tsx
index bb0465ea20195..0c4618190ded0 100644
--- a/src/components/Search/FilterComponents/DatePresetFilterBase.tsx
+++ b/src/components/Search/FilterComponents/DatePresetFilterBase.tsx
@@ -1,4 +1,4 @@
-import React, {useCallback, useEffect, useImperativeHandle, useMemo, useState} from 'react';
+import React, {useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState} from 'react';
 import type {Ref} from 'react';
 import CalendarPicker from '@components/DatePicker/CalendarPicker';
 import MenuItem from '@components/MenuItem';
@@ -9,9 +9,11 @@ import useLocalize from '@hooks/useLocalize';
 import useStyleUtils from '@hooks/useStyleUtils';
 import useTheme from '@hooks/useTheme';
 import useThemeStyles from '@hooks/useThemeStyles';
-import {isSearchDatePreset} from '@libs/SearchQueryUtils';
+import {getDateRangeDisplayValueFromFormValue, getRangeBoundariesFromFormValue, getRangeQueryValue, isSearchDatePreset} from '@libs/SearchQueryUtils';
 import type {SearchDateModifier} from '@libs/SearchUIUtils';
 import CONST from '@src/CONST';
+import RangeDatePicker from './RangeDatePicker';
+import SearchDatePickerDay from './SearchDatePickerDay';
 
 type SearchDateValues = Record<SearchDateModifier, string | undefined>;
 
@@ -19,6 +21,9 @@ type DatePresetFilterBaseHandle = {
     /** Gets date values */
     getDateValues: () => SearchDateValues;
 
+    /** Gets the formatted range display text for current date values */
+    getRangeDisplayText: () => string;
+
     /** Clears date values */
     clearDateValues: () => void;
 
@@ -27,6 +32,12 @@ type DatePresetFilterBaseHandle = {
 
     /** Clears the date value of the selected date modifier */
     clearDateValueOfSelectedDateModifier: () => void;
+
+    /** Resets date values to the provided defaults */
+    resetDateValuesToDefault: () => void;
+
+    /** Validates the selected date modifier input */
+    validate: () => boolean;
 };
 
 type DatePresetFilterBaseProps = {
@@ -45,6 +56,21 @@ type DatePresetFilterBaseProps = {
     /** Whether the search advanced filters form Onyx data is loading or not */
     isSearchAdvancedFiltersFormLoading?: boolean;
 
+    /** Whether to show the range validation error */
+    shouldShowRangeError?: boolean;
+
+    /** Whether the range error should be rendered inside the picker */
+    shouldShowRangeErrorInPicker?: boolean;
+
+    /** Callback when date values change (useful for parent to track range display text) */
+    onDateValuesChange?: (dateValues: SearchDateValues) => void;
+
+    /** Callback when range validation error changes */
+    onRangeValidationErrorChange?: (shouldShowRangeError: boolean) => void;
+
+    /** Force vertical stacking of calendars in range picker */
+    forceVerticalCalendars?: boolean;
+
     /** The ref handle */
     ref: Ref<DatePresetFilterBaseHandle>;
 };
@@ -59,7 +85,19 @@ type DatePresetFilterBaseProps = {
  * - On save: if a date modifier is selected (i.e. user clicked save at the calendar picker) you should `setDateValueOfSelectedDateModifier` otherwise `getDateValues`
  * - On reset: if a date modifier is selected (i.e. user clicked reset at the calendar picker) you should `clearDateValueOfSelectedDateModifier` otherwise `clearDateValues`
  */
-function DatePresetFilterBase({defaultDateValues, selectedDateModifier, onSelectDateModifier, presets, isSearchAdvancedFiltersFormLoading, ref}: DatePresetFilterBaseProps) {
+function DatePresetFilterBase({
+    defaultDateValues,
+    selectedDateModifier,
+    onSelectDateModifier,
+    presets,
+    isSearchAdvancedFiltersFormLoading,
+    shouldShowRangeError = false,
+    shouldShowRangeErrorInPicker = true,
+    onDateValuesChange,
+    onRangeValidationErrorChange,
+    forceVerticalCalendars = false,
+    ref,
+}: DatePresetFilterBaseProps) {
     const theme = useTheme();
     const styles = useThemeStyles();
     const StyleUtils = useStyleUtils();
@@ -67,48 +105,67 @@ function DatePresetFilterBase({defaultDateValues, selectedDateModifier, onSelect
 
     const shouldShowHorizontalRule = !!presets?.length;
 
+    const getRangeDisplayTextFromDateValues = useCallback((dateValues: SearchDateValues) => {
+        const rangeValue = dateValues[CONST.SEARCH.DATE_MODIFIERS.RANGE];
+        if (!rangeValue) {
+            return '';
+        }
+        return getDateRangeDisplayValueFromFormValue(rangeValue, dateValues[CONST.SEARCH.DATE_MODIFIERS.AFTER], dateValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE]);
+    }, []);
+
+    const onDateValuesChangeRef = useRef(onDateValuesChange);
+    useEffect(() => {
+        onDateValuesChangeRef.current = onDateValuesChange;
+    }, [onDateValuesChange]);
+
     const [dateValues, setDateValues] = useState<SearchDateValues>(defaultDateValues);
+    const dateValuesRef = useRef<SearchDateValues>(defaultDateValues);
+    const updateDateValues = useCallback((updater: SearchDateValues | ((prevDateValues: SearchDateValues) => SearchDateValues)) => {
+        const nextDateValues = typeof updater === 'function' ? updater(dateValuesRef.current) : updater;
+        dateValuesRef.current = nextDateValues;
+        setDateValues(nextDateValues);
+        onDateValuesChangeRef.current?.(nextDateValues);
+    }, []);
 
     useEffect(() => {
         if (isSearchAdvancedFiltersFormLoading) {
             return;
         }
-        setDateValues(defaultDateValues);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isSearchAdvancedFiltersFormLoading]);
-
-    const setDateValue = useCallback((dateModifier: SearchDateModifier, value: string | undefined) => {
-        setDateValues((prevDateValues) => {
-            if (dateModifier === CONST.SEARCH.DATE_MODIFIERS.ON && isSearchDatePreset(value)) {
-                return {
-                    [CONST.SEARCH.DATE_MODIFIERS.ON]: value,
-                    [CONST.SEARCH.DATE_MODIFIERS.BEFORE]: undefined,
-                    [CONST.SEARCH.DATE_MODIFIERS.AFTER]: undefined,
-                };
-            }
+        const currentDateValues = dateValuesRef.current;
+        const hasDefaultValuesChanged =
+            currentDateValues[CONST.SEARCH.DATE_MODIFIERS.ON] !== defaultDateValues[CONST.SEARCH.DATE_MODIFIERS.ON] ||
+            currentDateValues[CONST.SEARCH.DATE_MODIFIERS.AFTER] !== defaultDateValues[CONST.SEARCH.DATE_MODIFIERS.AFTER] ||
+            currentDateValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE] !== defaultDateValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE] ||
+            currentDateValues[CONST.SEARCH.DATE_MODIFIERS.RANGE] !== defaultDateValues[CONST.SEARCH.DATE_MODIFIERS.RANGE];
 
-            if (dateModifier !== CONST.SEARCH.DATE_MODIFIERS.ON && isSearchDatePreset(prevDateValues[CONST.SEARCH.DATE_MODIFIERS.ON])) {
-                return {
-                    ...prevDateValues,
-                    [dateModifier]: value,
-                    [CONST.SEARCH.DATE_MODIFIERS.ON]: undefined,
-                };
-            }
+        if (!hasDefaultValuesChanged) {
+            return;
+        }
+        dateValuesRef.current = defaultDateValues;
+        // eslint-disable-next-line react-hooks/set-state-in-effect
+        setDateValues(defaultDateValues);
+        onDateValuesChangeRef.current?.(defaultDateValues);
+    }, [isSearchAdvancedFiltersFormLoading, defaultDateValues]);
 
-            return {...prevDateValues, [dateModifier]: value};
-        });
-    }, []);
+    const setDateValue = useCallback(
+        (dateModifier: SearchDateModifier, value: string | undefined) => {
+            updateDateValues((prevDateValues) => {
+                return {...prevDateValues, [dateModifier]: value};
+            });
+        },
+        [updateDateValues],
+    );
 
     const dateDisplayValues = useMemo<SearchDateValues>(() => {
         const dateOn = dateValues[CONST.SEARCH.DATE_MODIFIERS.ON];
         const dateAfter = dateValues[CONST.SEARCH.DATE_MODIFIERS.AFTER];
         const dateBefore = dateValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE];
-
         return {
             // dateOn could be a preset e.g. Last month which should not be displayed as the On field
             [CONST.SEARCH.DATE_MODIFIERS.ON]: isSearchDatePreset(dateOn) ? undefined : dateOn,
             [CONST.SEARCH.DATE_MODIFIERS.AFTER]: dateAfter,
             [CONST.SEARCH.DATE_MODIFIERS.BEFORE]: dateBefore,
+            [CONST.SEARCH.DATE_MODIFIERS.RANGE]: dateValues[CONST.SEARCH.DATE_MODIFIERS.RANGE] ? 'range' : undefined,
         };
     }, [dateValues]);
 
@@ -119,23 +176,80 @@ function DatePresetFilterBase({defaultDateValues, selectedDateModifier, onSelect
         [getInitialEphemeralDateValue],
     );
 
+    // Separate ephemeral state for Range mode calendar selections
+    const [rangeEphemeralValues, setRangeEphemeralValues] = useState<{from?: string; to?: string}>(() => {
+        const rangeBoundaries = getRangeBoundariesFromFormValue(defaultDateValues[CONST.SEARCH.DATE_MODIFIERS.RANGE]);
+        return {
+            from: rangeBoundaries.from,
+            to: rangeBoundaries.to,
+        };
+    });
+
     const selectDateModifier = useCallback(
         (dateModifier: SearchDateModifier | null) => {
             resetEphemeralDateValue(dateModifier);
+            onRangeValidationErrorChange?.(false);
+
+            if (dateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE) {
+                const currentDateValues = dateValuesRef.current;
+                const rangeBoundaries = getRangeBoundariesFromFormValue(
+                    currentDateValues[CONST.SEARCH.DATE_MODIFIERS.RANGE],
+                    currentDateValues[CONST.SEARCH.DATE_MODIFIERS.AFTER],
+                    currentDateValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE],
+                );
+                setRangeEphemeralValues({
+                    from: rangeBoundaries.from,
+                    to: rangeBoundaries.to,
+                });
+            }
+
             onSelectDateModifier(dateModifier);
         },
-        [resetEphemeralDateValue, onSelectDateModifier],
+        [resetEphemeralDateValue, onSelectDateModifier, onRangeValidationErrorChange],
     );
 
+    const validate = useCallback(() => {
+        if (selectedDateModifier !== CONST.SEARCH.DATE_MODIFIERS.RANGE) {
+            onRangeValidationErrorChange?.(false);
+            return true;
+        }
+
+        const isValid = !!(rangeEphemeralValues.from && rangeEphemeralValues.to);
+        onRangeValidationErrorChange?.(!isValid);
+        return isValid;
+    }, [onRangeValidationErrorChange, rangeEphemeralValues.from, rangeEphemeralValues.to, selectedDateModifier]);
+
     useImperativeHandle(
         ref,
         () => ({
             getDateValues() {
-                return dateValues;
+                return dateValuesRef.current;
+            },
+
+            getRangeDisplayText() {
+                return getRangeDisplayTextFromDateValues(dateValuesRef.current);
+            },
+
+            resetDateValuesToDefault() {
+                dateValuesRef.current = defaultDateValues;
+                updateDateValues(defaultDateValues);
+                onRangeValidationErrorChange?.(false);
+            },
+
+            validate() {
+                return validate();
             },
 
             clearDateValues() {
-                setDateValues({[CONST.SEARCH.DATE_MODIFIERS.ON]: undefined, [CONST.SEARCH.DATE_MODIFIERS.BEFORE]: undefined, [CONST.SEARCH.DATE_MODIFIERS.AFTER]: undefined});
+                const clearedValues = {
+                    [CONST.SEARCH.DATE_MODIFIERS.ON]: undefined,
+                    [CONST.SEARCH.DATE_MODIFIERS.BEFORE]: undefined,
+                    [CONST.SEARCH.DATE_MODIFIERS.AFTER]: undefined,
+                    [CONST.SEARCH.DATE_MODIFIERS.RANGE]: undefined,
+                };
+                dateValuesRef.current = clearedValues;
+                updateDateValues(clearedValues);
+                onRangeValidationErrorChange?.(false);
             },
 
             setDateValueOfSelectedDateModifier() {
@@ -143,6 +257,18 @@ function DatePresetFilterBase({defaultDateValues, selectedDateModifier, onSelect
                     return;
                 }
 
+                const currentDateValues = dateValuesRef.current;
+                // For Range, mark as Range mode without altering ON/AFTER/BEFORE values.
+                if (selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE) {
+                    const rangeValue = getRangeQueryValue(rangeEphemeralValues.from, rangeEphemeralValues.to) || undefined;
+                    const updatedValues = {...currentDateValues, [CONST.SEARCH.DATE_MODIFIERS.RANGE]: rangeValue};
+                    dateValuesRef.current = updatedValues;
+                    setDateValue(CONST.SEARCH.DATE_MODIFIERS.RANGE, rangeValue);
+                    return;
+                }
+
+                const updatedValues = {...currentDateValues, [selectedDateModifier]: ephemeralDateValue};
+                dateValuesRef.current = updatedValues;
                 setDateValue(selectedDateModifier, ephemeralDateValue);
             },
 
@@ -151,60 +277,125 @@ function DatePresetFilterBase({defaultDateValues, selectedDateModifier, onSelect
                     return;
                 }
 
+                const currentDateValues = dateValuesRef.current;
+                // Range flag is independent metadata and should not clear ON/AFTER/BEFORE values.
+                if (selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE) {
+                    const updatedValues = {...currentDateValues, [CONST.SEARCH.DATE_MODIFIERS.RANGE]: undefined};
+                    dateValuesRef.current = updatedValues;
+                    setRangeEphemeralValues({});
+                    setDateValue(CONST.SEARCH.DATE_MODIFIERS.RANGE, undefined);
+                    onRangeValidationErrorChange?.(false);
+                    return;
+                }
+
+                const updatedValues = {...currentDateValues, [selectedDateModifier]: undefined};
+                dateValuesRef.current = updatedValues;
                 setDateValue(selectedDateModifier, undefined);
+                onRangeValidationErrorChange?.(false);
             },
         }),
-        [selectedDateModifier, dateValues, ephemeralDateValue, setDateValue],
+        [
+            selectedDateModifier,
+            defaultDateValues,
+            ephemeralDateValue,
+            rangeEphemeralValues.from,
+            rangeEphemeralValues.to,
+            getRangeDisplayTextFromDateValues,
+            setDateValue,
+            updateDateValues,
+            validate,
+            onRangeValidationErrorChange,
+        ],
     );
 
-    return !selectedDateModifier ? (
-        <>
-            {presets?.map((preset) => (
-                <SingleSelectListItem
-                    key={preset}
-                    showTooltip
-                    item={{
-                        text: translate(`search.filters.date.presets.${preset}`),
-                        isSelected: dateValues[CONST.SEARCH.DATE_MODIFIERS.ON] === preset,
-                    }}
-                    onSelectRow={() => setDateValue(CONST.SEARCH.DATE_MODIFIERS.ON, preset)}
-                    wrapperStyle={styles.flexReset}
+    const rangeDescription = getRangeDisplayTextFromDateValues(dateValues) || undefined;
+
+    if (!selectedDateModifier) {
+        return (
+            <>
+                {presets?.map((preset) => (
+                    <SingleSelectListItem
+                        key={preset}
+                        showTooltip
+                        item={{
+                            text: translate(`search.filters.date.presets.${preset}`),
+                            isSelected: dateValues[CONST.SEARCH.DATE_MODIFIERS.ON] === preset,
+                        }}
+                        onSelectRow={() => setDateValue(CONST.SEARCH.DATE_MODIFIERS.ON, preset)}
+                        wrapperStyle={styles.flexReset}
+                    />
+                ))}
+                {shouldShowHorizontalRule && (
+                    <SpacerView
+                        shouldShow
+                        style={[StyleUtils.getBorderColorStyle(theme.border), styles.mh3]}
+                    />
+                )}
+                <MenuItem
+                    shouldShowRightIcon
+                    viewMode={CONST.OPTION_MODE.COMPACT}
+                    title={translate('common.on')}
+                    description={dateDisplayValues[CONST.SEARCH.DATE_MODIFIERS.ON]}
+                    onPress={() => selectDateModifier(CONST.SEARCH.DATE_MODIFIERS.ON)}
                 />
-            ))}
-            {shouldShowHorizontalRule && (
-                <SpacerView
-                    shouldShow
-                    style={[StyleUtils.getBorderColorStyle(theme.border), styles.mh3]}
+                <MenuItem
+                    shouldShowRightIcon
+                    viewMode={CONST.OPTION_MODE.COMPACT}
+                    title={translate('common.after')}
+                    description={dateDisplayValues[CONST.SEARCH.DATE_MODIFIERS.AFTER]}
+                    onPress={() => selectDateModifier(CONST.SEARCH.DATE_MODIFIERS.AFTER)}
                 />
-            )}
-            <MenuItem
-                shouldShowRightIcon
-                viewMode={CONST.OPTION_MODE.COMPACT}
-                title={translate('common.on')}
-                description={dateDisplayValues[CONST.SEARCH.DATE_MODIFIERS.ON]}
-                onPress={() => selectDateModifier(CONST.SEARCH.DATE_MODIFIERS.ON)}
-            />
-            <MenuItem
-                shouldShowRightIcon
-                viewMode={CONST.OPTION_MODE.COMPACT}
-                title={translate('common.after')}
-                description={dateDisplayValues[CONST.SEARCH.DATE_MODIFIERS.AFTER]}
-                onPress={() => selectDateModifier(CONST.SEARCH.DATE_MODIFIERS.AFTER)}
-            />
-            <MenuItem
-                shouldShowRightIcon
-                viewMode={CONST.OPTION_MODE.COMPACT}
-                title={translate('common.before')}
-                description={dateDisplayValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE]}
-                onPress={() => selectDateModifier(CONST.SEARCH.DATE_MODIFIERS.BEFORE)}
+                <MenuItem
+                    shouldShowRightIcon
+                    viewMode={CONST.OPTION_MODE.COMPACT}
+                    title={translate('common.before')}
+                    description={dateDisplayValues[CONST.SEARCH.DATE_MODIFIERS.BEFORE]}
+                    onPress={() => selectDateModifier(CONST.SEARCH.DATE_MODIFIERS.BEFORE)}
+                />
+                <MenuItem
+                    shouldShowRightIcon
+                    viewMode={CONST.OPTION_MODE.COMPACT}
+                    title={translate('common.range')}
+                    description={rangeDescription}
+                    onPress={() => selectDateModifier(CONST.SEARCH.DATE_MODIFIERS.RANGE)}
+                />
+            </>
+        );
+    }
+
+    if (selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE) {
+        // Use ephemeral state for Range mode to keep it separate from individual filters
+        return (
+            <RangeDatePicker
+                fromValue={rangeEphemeralValues.from}
+                toValue={rangeEphemeralValues.to}
+                onFromSelected={(date) => {
+                    setRangeEphemeralValues((prev) => {
+                        const nextValues = {...prev, from: date};
+                        setDateValue(CONST.SEARCH.DATE_MODIFIERS.RANGE, getRangeQueryValue(nextValues.from, nextValues.to) || undefined);
+                        return nextValues;
+                    });
+                }}
+                onToSelected={(date) => {
+                    setRangeEphemeralValues((prev) => {
+                        const nextValues = {...prev, to: date};
+                        setDateValue(CONST.SEARCH.DATE_MODIFIERS.RANGE, getRangeQueryValue(nextValues.from, nextValues.to) || undefined);
+                        return nextValues;
+                    });
+                }}
+                shouldShowError={shouldShowRangeErrorInPicker ? shouldShowRangeError : false}
+                forceVertical={forceVerticalCalendars}
             />
-        </>
-    ) : (
+        );
+    }
+
+    return (
         <CalendarPicker
             value={ephemeralDateValue}
             onSelected={setEphemeralDateValue}
             minDate={CONST.CALENDAR_PICKER.MIN_DATE}
             maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
+            DayComponent={SearchDatePickerDay}
         />
     );
 }
diff --git a/src/components/Search/FilterComponents/RangeDatePicker.tsx b/src/components/Search/FilterComponents/RangeDatePicker.tsx
new file mode 100644
index 0000000000000..4891e40185bcb
--- /dev/null
+++ b/src/components/Search/FilterComponents/RangeDatePicker.tsx
@@ -0,0 +1,84 @@
+import React from 'react';
+import {View} from 'react-native';
+import CalendarPicker from '@components/DatePicker/CalendarPicker';
+import FormHelpMessage from '@components/FormHelpMessage';
+import Text from '@components/Text';
+import useLocalize from '@hooks/useLocalize';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useThemeStyles from '@hooks/useThemeStyles';
+import CONST from '@src/CONST';
+import SearchDatePickerDay from './SearchDatePickerDay';
+
+type RangeDatePickerProps = {
+    /** The "From" date value */
+    fromValue?: string;
+
+    /** The "To" date value */
+    toValue?: string;
+
+    /** Callback when "From" date is selected */
+    onFromSelected: (date: string) => void;
+
+    /** Callback when "To" date is selected */
+    onToSelected: (date: string) => void;
+
+    /** Whether to show validation error */
+    shouldShowError?: boolean;
+
+    /** Force vertical stacking of calendars */
+    forceVertical?: boolean;
+};
+
+function RangeDatePicker({fromValue, toValue, onFromSelected, onToSelected, shouldShowError = false, forceVertical = false}: RangeDatePickerProps) {
+    const styles = useThemeStyles();
+    const {translate} = useLocalize();
+    // eslint-disable-next-line rulesdir/prefer-shouldUseNarrowLayout-instead-of-isSmallScreenWidth
+    const {isSmallScreenWidth} = useResponsiveLayout();
+    const shouldStack = forceVertical || isSmallScreenWidth;
+    const fromMaxDate = toValue ? new Date(toValue) : CONST.CALENDAR_PICKER.MAX_DATE;
+    const toMinDate = fromValue ? new Date(fromValue) : CONST.CALENDAR_PICKER.MIN_DATE;
+
+    return (
+        <>
+            <View style={[!shouldStack && styles.flexRow, !shouldStack && styles.alignItemsStretch, styles.mh5, isSmallScreenWidth && styles.mt3]}>
+                <View style={[!shouldStack && styles.flex1, !shouldStack && styles.mr2]}>
+                    <View style={[styles.borderedContentCard, !shouldStack && styles.flex1]}>
+                        <Text style={[styles.textLabelSupporting, styles.mb2, styles.ph4, styles.pt4]}>{translate('common.from')}</Text>
+                        <CalendarPicker
+                            value={fromValue}
+                            onSelected={onFromSelected}
+                            minDate={CONST.CALENDAR_PICKER.MIN_DATE}
+                            maxDate={fromMaxDate}
+                            DayComponent={SearchDatePickerDay}
+                            headerContainerStyle={styles.ph4}
+                        />
+                    </View>
+                </View>
+
+                <View style={[!shouldStack && styles.flex1, !shouldStack && styles.ml2, shouldStack && styles.mt4]}>
+                    <View style={[styles.borderedContentCard, !shouldStack && styles.flex1]}>
+                        <Text style={[styles.textLabelSupporting, styles.mb2, styles.ph4, styles.pt4]}>{translate('common.to')}</Text>
+                        <CalendarPicker
+                            value={toValue}
+                            onSelected={onToSelected}
+                            minDate={toMinDate}
+                            maxDate={CONST.CALENDAR_PICKER.MAX_DATE}
+                            DayComponent={SearchDatePickerDay}
+                            headerContainerStyle={styles.ph4}
+                        />
+                    </View>
+                </View>
+            </View>
+
+            {shouldShowError && (
+                <FormHelpMessage
+                    isError
+                    message={translate('search.errors.pleaseSelectDatesForBothFromAndTo')}
+                    style={[styles.mh5, styles.mt2]}
+                />
+            )}
+        </>
+    );
+}
+
+export default RangeDatePicker;
diff --git a/src/components/Search/FilterComponents/SearchDatePickerDay.tsx b/src/components/Search/FilterComponents/SearchDatePickerDay.tsx
new file mode 100644
index 0000000000000..c6b63d7f8670d
--- /dev/null
+++ b/src/components/Search/FilterComponents/SearchDatePickerDay.tsx
@@ -0,0 +1,17 @@
+import React from 'react';
+import {View} from 'react-native';
+import type {DayProps} from '@components/DatePicker/CalendarPicker/Day';
+import Text from '@components/Text';
+import useThemeStyles from '@hooks/useThemeStyles';
+
+function SearchDatePickerDay({disabled, selected, children}: DayProps) {
+    const styles = useThemeStyles();
+
+    return (
+        <View style={[styles.calendarDayContainer, selected ? styles.buttonSuccess : {}]}>
+            <Text style={[disabled ? styles.buttonOpacityDisabled : {}, selected ? styles.buttonSuccessText : {}]}>{children}</Text>
+        </View>
+    );
+}
+
+export default SearchDatePickerDay;
diff --git a/src/components/Search/FilterDropdowns/DateSelectPopup.tsx b/src/components/Search/FilterDropdowns/DateSelectPopup.tsx
index 626c381eba5af..d6792fede0d8f 100644
--- a/src/components/Search/FilterDropdowns/DateSelectPopup.tsx
+++ b/src/components/Search/FilterDropdowns/DateSelectPopup.tsx
@@ -1,14 +1,21 @@
-import React, {useCallback, useRef, useState} from 'react';
+import React, {useCallback, useEffect, useRef, useState} from 'react';
 import {View} from 'react-native';
 import Button from '@components/Button';
 import HeaderWithBackButton from '@components/HeaderWithBackButton';
+import Icon from '@components/Icon';
+import PressableWithoutFeedback from '@components/Pressable/PressableWithoutFeedback';
+import ScrollView from '@components/ScrollView';
 import DatePresetFilterBase from '@components/Search/FilterComponents/DatePresetFilterBase';
 import type {SearchDatePresetFilterBaseHandle, SearchDateValues} from '@components/Search/FilterComponents/DatePresetFilterBase';
 import type {SearchDatePreset} from '@components/Search/types';
 import Text from '@components/Text';
+import {useMemoizedLazyExpensifyIcons} from '@hooks/useLazyAsset';
 import useLocalize from '@hooks/useLocalize';
 import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useTheme from '@hooks/useTheme';
 import useThemeStyles from '@hooks/useThemeStyles';
+import useWindowDimensions from '@hooks/useWindowDimensions';
+import {getDateRangeDisplayValueFromFormValue} from '@libs/SearchQueryUtils';
 import type {SearchDateModifier, SearchDateModifierLower} from '@libs/SearchUIUtils';
 import CONST from '@src/CONST';
 
@@ -27,16 +34,53 @@ type DateSelectPopupProps = {
 
     /** Function to call to close the overlay when changes are applied */
     closeOverlay: () => void;
+
+    /** Function to set the popover width dynamically */
+    setPopoverWidth?: (width: number | undefined) => void;
 };
 
-function DateSelectPopup({label, value, presets, closeOverlay, onChange}: DateSelectPopupProps) {
+function DateSelectPopup({label, value, presets, closeOverlay, onChange, setPopoverWidth}: DateSelectPopupProps) {
     // eslint-disable-next-line rulesdir/prefer-shouldUseNarrowLayout-instead-of-isSmallScreenWidth
     const {isSmallScreenWidth} = useResponsiveLayout();
 
     const {translate} = useLocalize();
     const styles = useThemeStyles();
+    const {windowHeight} = useWindowDimensions();
+    const theme = useTheme();
+    const backArrowIcon = useMemoizedLazyExpensifyIcons(['BackArrow']);
     const searchDatePresetFilterBaseRef = useRef<SearchDatePresetFilterBaseHandle>(null);
+    const scrollViewRef = useRef<React.ComponentRef<typeof ScrollView>>(null);
     const [selectedDateModifier, setSelectedDateModifier] = useState<SearchDateModifier | null>(null);
+    const [shouldShowRangeError, setShouldShowRangeError] = useState(false);
+    const [rangeText, setRangeText] = useState(() =>
+        getDateRangeDisplayValueFromFormValue(value[CONST.SEARCH.DATE_MODIFIERS.RANGE], value[CONST.SEARCH.DATE_MODIFIERS.AFTER], value[CONST.SEARCH.DATE_MODIFIERS.BEFORE]),
+    );
+
+    const updateRangeText = useCallback(() => {
+        setRangeText(searchDatePresetFilterBaseRef.current?.getRangeDisplayText() ?? '');
+    }, []);
+
+    // Widen the popover when Range is selected, reset when not
+    useEffect(() => {
+        if (selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE) {
+            setPopoverWidth?.(CONST.POPOVER_DATE_RANGE_WIDTH);
+        } else {
+            setPopoverWidth?.(undefined);
+        }
+    }, [selectedDateModifier, setPopoverWidth]);
+
+    const clearSelection = useCallback(() => {
+        setSelectedDateModifier(null);
+        setShouldShowRangeError(false);
+    }, []);
+
+    const handleBackPress = useCallback(() => {
+        if (searchDatePresetFilterBaseRef.current && selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE) {
+            searchDatePresetFilterBaseRef.current.resetDateValuesToDefault();
+            updateRangeText();
+        }
+        clearSelection();
+    }, [clearSelection, selectedDateModifier, updateRangeText]);
 
     const applyChanges = useCallback(() => {
         if (!searchDatePresetFilterBaseRef.current) {
@@ -44,15 +88,23 @@ function DateSelectPopup({label, value, presets, closeOverlay, onChange}: DateSe
         }
 
         if (selectedDateModifier) {
+            if (!searchDatePresetFilterBaseRef.current.validate()) {
+                setTimeout(() => {
+                    scrollViewRef.current?.scrollToEnd({animated: true});
+                }, 100);
+                return;
+            }
+
             searchDatePresetFilterBaseRef.current.setDateValueOfSelectedDateModifier();
-            setSelectedDateModifier(null);
+            updateRangeText();
+            clearSelection();
             return;
         }
 
         const dateValues = searchDatePresetFilterBaseRef.current.getDateValues();
         onChange(dateValues);
         closeOverlay();
-    }, [closeOverlay, onChange, selectedDateModifier]);
+    }, [clearSelection, closeOverlay, onChange, selectedDateModifier, updateRangeText]);
 
     const resetChanges = useCallback(() => {
         if (!searchDatePresetFilterBaseRef.current) {
@@ -61,40 +113,137 @@ function DateSelectPopup({label, value, presets, closeOverlay, onChange}: DateSe
 
         if (selectedDateModifier) {
             searchDatePresetFilterBaseRef.current.clearDateValueOfSelectedDateModifier();
-            setSelectedDateModifier(null);
+            updateRangeText();
+            clearSelection();
             return;
         }
 
-        searchDatePresetFilterBaseRef.current.clearDateValues();
-        onChange({
+        const emptyDateValues: SearchDateValues = {
             [CONST.SEARCH.DATE_MODIFIERS.ON]: undefined,
             [CONST.SEARCH.DATE_MODIFIERS.BEFORE]: undefined,
             [CONST.SEARCH.DATE_MODIFIERS.AFTER]: undefined,
-        });
+            [CONST.SEARCH.DATE_MODIFIERS.RANGE]: undefined,
+        };
+        searchDatePresetFilterBaseRef.current.clearDateValues();
+        setRangeText('');
+        setShouldShowRangeError(false);
+        onChange(emptyDateValues);
         closeOverlay();
-    }, [closeOverlay, onChange, selectedDateModifier]);
+    }, [clearSelection, closeOverlay, onChange, selectedDateModifier, updateRangeText]);
 
-    return (
-        <View style={[!isSmallScreenWidth && styles.pv4, styles.gap2]}>
-            {isSmallScreenWidth && !selectedDateModifier && <Text style={[styles.textLabel, styles.textSupporting, styles.ph5, styles.pv1]}>{label}</Text>}
-            <View>
-                {!!selectedDateModifier && (
-                    <HeaderWithBackButton
-                        shouldDisplayHelpButton={false}
-                        style={[styles.h10, styles.pb3]}
-                        subtitle={translate(`common.${selectedDateModifier.toLowerCase() as SearchDateModifierLower}`)}
-                        onBackButtonPress={() => setSelectedDateModifier(null)}
-                    />
-                )}
-                <DatePresetFilterBase
-                    ref={searchDatePresetFilterBaseRef}
-                    defaultDateValues={value}
-                    selectedDateModifier={selectedDateModifier}
-                    onSelectDateModifier={setSelectedDateModifier}
-                    presets={presets}
-                />
+    const isInRangeMode = selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE;
+
+    const maxPopupHeight = Math.round(windowHeight * 0.875);
+
+    // For non-Range modes, use original simple styles. For Range, use custom layout
+    const useRangeLayout = isInRangeMode;
+    const datePresetFilterBase = (
+        <DatePresetFilterBase
+            ref={searchDatePresetFilterBaseRef}
+            defaultDateValues={value}
+            selectedDateModifier={selectedDateModifier}
+            onSelectDateModifier={setSelectedDateModifier}
+            presets={presets}
+            shouldShowRangeError={shouldShowRangeError}
+            onDateValuesChange={updateRangeText}
+            onRangeValidationErrorChange={setShouldShowRangeError}
+        />
+    );
+
+    if (!isSmallScreenWidth) {
+        return (
+            <View style={[styles.pv4, styles.gap2]}>
+                <View>
+                    {!!selectedDateModifier && (
+                        <HeaderWithBackButton
+                            shouldDisplayHelpButton={false}
+                            style={[styles.h10, styles.pb3]}
+                            subtitle={translate(`common.${selectedDateModifier.toLowerCase() as SearchDateModifierLower}`)}
+                            onBackButtonPress={handleBackPress}
+                        />
+                    )}
+                    {datePresetFilterBase}
+                </View>
+                <View style={[styles.flexRow, styles.gap2, useRangeLayout ? styles.mh5 : styles.ph5, useRangeLayout && styles.alignItemsCenter, useRangeLayout && styles.pt1]}>
+                    {useRangeLayout && (
+                        <View style={[styles.flex1, styles.mr2]}>
+                            {!!rangeText && (
+                                <Text style={[styles.textLabelSupporting]}>
+                                    {`${translate('common.range')}: `}
+                                    <Text style={[styles.textLabel]}>{rangeText}</Text>
+                                </Text>
+                            )}
+                        </View>
+                    )}
+                    <View style={[styles.flex1, useRangeLayout && styles.ml2]}>
+                        <View style={[styles.flexRow, styles.gap2]}>
+                            <Button
+                                medium
+                                style={[styles.flex1]}
+                                text={translate('common.reset')}
+                                onPress={resetChanges}
+                            />
+                            <Button
+                                success
+                                medium
+                                style={[styles.flex1]}
+                                text={translate('common.apply')}
+                                onPress={applyChanges}
+                            />
+                        </View>
+                    </View>
+                </View>
             </View>
-            <View style={[styles.flexRow, styles.gap2, styles.ph5]}>
+        );
+    }
+
+    const topPaddingStyle = selectedDateModifier ? styles.pt3 : undefined;
+    const buttonRowSpacing = selectedDateModifier ? styles.mt4 : styles.mt2;
+    const mobileContainerStyle = useRangeLayout ? [topPaddingStyle, styles.flexGrow1, {maxHeight: maxPopupHeight}] : styles.gap2;
+    const mobileLabelStyle = useRangeLayout ? [styles.textLabel, styles.ph5, styles.pb3] : [styles.textLabel, styles.textSupporting, styles.ph5, styles.pv1];
+    const mobileButtonRowStyle = useRangeLayout ? [styles.flexRow, styles.ph5, buttonRowSpacing, styles.alignItemsCenter, styles.gap2] : [styles.flexRow, styles.gap2, styles.ph5];
+
+    return (
+        <View style={mobileContainerStyle}>
+            {!selectedDateModifier && <Text style={mobileLabelStyle}>{label}</Text>}
+            <ScrollView
+                ref={scrollViewRef}
+                style={useRangeLayout ? [styles.flexGrow1] : undefined}
+                contentContainerStyle={useRangeLayout ? [!selectedDateModifier && styles.pt4, selectedDateModifier && styles.pt0] : undefined}
+            >
+                {!!selectedDateModifier &&
+                    (useRangeLayout ? (
+                        <View style={[styles.flexRow, styles.alignItemsCenter, styles.ph5, styles.pb2, styles.gap2]}>
+                            <PressableWithoutFeedback
+                                onPress={handleBackPress}
+                                role={CONST.ROLE.BUTTON}
+                                accessibilityLabel={translate('common.back')}
+                                sentryLabel="DateSelectPopup-Back"
+                            >
+                                <Icon
+                                    src={backArrowIcon.BackArrow}
+                                    fill={theme.icon}
+                                />
+                            </PressableWithoutFeedback>
+                            <Text style={[styles.textLabelSupporting]}>{translate(`common.${selectedDateModifier.toLowerCase() as SearchDateModifierLower}`)}</Text>
+                        </View>
+                    ) : (
+                        <HeaderWithBackButton
+                            shouldDisplayHelpButton={false}
+                            style={[styles.h10, styles.pb3]}
+                            subtitle={translate(`common.${selectedDateModifier.toLowerCase() as SearchDateModifierLower}`)}
+                            onBackButtonPress={handleBackPress}
+                        />
+                    ))}
+                {datePresetFilterBase}
+            </ScrollView>
+            {!!rangeText && selectedDateModifier === CONST.SEARCH.DATE_MODIFIERS.RANGE && (
+                <Text style={[styles.textLabelSupporting, styles.ph5, styles.mt2, styles.textAlignLeft]}>
+                    {`${translate('common.range')}: `}
+                    <Text style={[styles.textLabel]}>{rangeText}</Text>
+                </Text>
+            )}
+            <View style={mobileButtonRowStyle}>
                 <Button
                     medium
                     style={[styles.flex1]}
diff --git a/src/components/Search/FilterDropdowns/DropdownButton.tsx b/src/components/Search/FilterDropdowns/DropdownButton.tsx
index f0012ea465e7d..ff4805c64c3f7 100644
--- a/src/components/Search/FilterDropdowns/DropdownButton.tsx
+++ b/src/components/Search/FilterDropdowns/DropdownButton.tsx
@@ -21,6 +21,7 @@ import type WithSentryLabel from '@src/types/utils/SentryLabel';
 
 type PopoverComponentProps = {
     closeOverlay: () => void;
+    setPopoverWidth?: (width: number | undefined) => void;
 };
 
 type DropdownButtonProps = WithSentryLabel & {
@@ -70,6 +71,7 @@ function DropdownButton({label, value, viewportOffsetTop, PopoverComponent, medi
     const triggerRef = useRef<View | null>(null);
     const anchorRef = useRef<View | null>(null);
     const [isOverlayVisible, setIsOverlayVisible] = useState(false);
+    const [customPopoverWidth, setCustomPopoverWidth] = useState<number | undefined>(undefined);
     const {calculatePopoverPosition} = usePopoverPosition();
 
     const [popoverTriggerPosition, setPopoverTriggerPosition] = useState({
@@ -114,15 +116,17 @@ function DropdownButton({label, value, viewportOffsetTop, PopoverComponent, medi
         return `${label}: ${selectedItems}`;
     }, [label, value]);
 
+    const actualPopoverWidth = customPopoverWidth ?? CONST.POPOVER_DROPDOWN_WIDTH;
+
     const containerStyles = useMemo(() => {
         if (isSmallScreenWidth) {
             return styles.w100;
         }
-        return {width: CONST.POPOVER_DROPDOWN_WIDTH};
-    }, [isSmallScreenWidth, styles]);
+        return {width: actualPopoverWidth};
+    }, [isSmallScreenWidth, styles, actualPopoverWidth]);
 
     const popoverContent = useMemo(() => {
-        return PopoverComponent({closeOverlay: toggleOverlay});
+        return PopoverComponent({closeOverlay: toggleOverlay, setPopoverWidth: setCustomPopoverWidth});
     }, [PopoverComponent, toggleOverlay]);
 
     return (
@@ -171,7 +175,7 @@ function DropdownButton({label, value, viewportOffsetTop, PopoverComponent, medi
                 shouldCloseWhenBrowserNavigationChanged={false}
                 innerContainerStyle={containerStyles}
                 popoverDimensions={{
-                    width: CONST.POPOVER_DROPDOWN_WIDTH,
+                    width: actualPopoverWidth,
                     height: CONST.POPOVER_DROPDOWN_MIN_HEIGHT,
                 }}
                 shouldSkipRemeasurement
diff --git a/src/components/Search/SearchPageHeader/SearchFiltersBar.tsx b/src/components/Search/SearchPageHeader/SearchFiltersBar.tsx
index db9abfcd719ce..11fbc49c1158c 100644
--- a/src/components/Search/SearchPageHeader/SearchFiltersBar.tsx
+++ b/src/components/Search/SearchPageHeader/SearchFiltersBar.tsx
@@ -32,7 +32,7 @@ import {updateAdvancedFilters} from '@libs/actions/Search';
 import DateUtils from '@libs/DateUtils';
 import Navigation from '@libs/Navigation/Navigation';
 import {getDisplayNameOrDefault} from '@libs/PersonalDetailsUtils';
-import {buildQueryStringFromFilterFormValues, getQueryWithUpdatedValues, isFilterSupported, isSearchDatePreset} from '@libs/SearchQueryUtils';
+import {buildQueryStringFromFilterFormValues, getDateRangeDisplayValueFromFormValue, getQueryWithUpdatedValues, isFilterSupported, isSearchDatePreset} from '@libs/SearchQueryUtils';
 import {
     filterValidHasValues,
     getDatePresets,
@@ -77,13 +77,14 @@ type DatePickerFilterPopupProps = PopoverComponentProps & {
     updateFilterForm: (values: Partial<SearchAdvancedFiltersForm>) => void;
 };
 
-function DatePickerFilterPopup({closeOverlay, filterKey, value, translationKey, updateFilterForm}: DatePickerFilterPopupProps) {
+function DatePickerFilterPopup({closeOverlay, setPopoverWidth, filterKey, value, translationKey, updateFilterForm}: DatePickerFilterPopupProps) {
     const {translate} = useLocalize();
     const onChange = (selectedDates: SearchDateValues) => {
         const dateFormValues: Record<string, string | undefined> = {};
         dateFormValues[`${filterKey}On`] = selectedDates[CONST.SEARCH.DATE_MODIFIERS.ON];
         dateFormValues[`${filterKey}After`] = selectedDates[CONST.SEARCH.DATE_MODIFIERS.AFTER];
         dateFormValues[`${filterKey}Before`] = selectedDates[CONST.SEARCH.DATE_MODIFIERS.BEFORE];
+        dateFormValues[`${filterKey}Range`] = selectedDates[CONST.SEARCH.DATE_MODIFIERS.RANGE];
         updateFilterForm(dateFormValues as Partial<SearchAdvancedFiltersForm>);
     };
     return (
@@ -92,6 +93,7 @@ function DatePickerFilterPopup({closeOverlay, filterKey, value, translationKey,
             value={value}
             onChange={onChange}
             closeOverlay={closeOverlay}
+            setPopoverWidth={setPopoverWidth}
             presets={getDatePresets(filterKey, true)}
         />
     );
@@ -201,11 +203,13 @@ function SearchFiltersBar({queryJSON, isMobileSelectionModeEnabled}: SearchFilte
     const isOptions = Object.values(CONST.SEARCH.IS_VALUES).map((value) => ({text: translate(`common.${value}`), value}));
     const is = isFilterValues ? isOptions.filter((option) => isFilterValues.includes(option.value)) : [];
 
-    const createDateDisplayValue = (filterValues: {on?: string; after?: string; before?: string}): [SearchDateValues, string[]] => {
+    const createDateDisplayValue = (filterValues: {on?: string; after?: string; before?: string; range?: string}): [SearchDateValues, string[]] => {
+        const hasRange = !!filterValues.range;
         const value: SearchDateValues = {
             [CONST.SEARCH.DATE_MODIFIERS.ON]: filterValues.on,
             [CONST.SEARCH.DATE_MODIFIERS.AFTER]: filterValues.after,
             [CONST.SEARCH.DATE_MODIFIERS.BEFORE]: filterValues.before,
+            [CONST.SEARCH.DATE_MODIFIERS.RANGE]: filterValues.range,
         };
 
         const displayText: string[] = [];
@@ -218,6 +222,12 @@ function SearchFiltersBar({queryJSON, isMobileSelectionModeEnabled}: SearchFilte
         if (value.Before) {
             displayText.push(`${translate('common.before')} ${DateUtils.formatToReadableString(value.Before)}`);
         }
+        if (hasRange) {
+            const rangeDisplay = getDateRangeDisplayValueFromFormValue(filterValues.range, filterValues.after, filterValues.before);
+            if (rangeDisplay) {
+                displayText.push(`${translate('common.range')}: ${rangeDisplay}`);
+            }
+        }
 
         return [value, displayText];
     };
@@ -226,18 +236,21 @@ function SearchFiltersBar({queryJSON, isMobileSelectionModeEnabled}: SearchFilte
         on: searchAdvancedFiltersForm.dateOn,
         after: searchAdvancedFiltersForm.dateAfter,
         before: searchAdvancedFiltersForm.dateBefore,
+        range: searchAdvancedFiltersForm.dateRange,
     });
 
     const [posted, displayPosted] = createDateDisplayValue({
         on: searchAdvancedFiltersForm.postedOn,
         after: searchAdvancedFiltersForm.postedAfter,
         before: searchAdvancedFiltersForm.postedBefore,
+        range: searchAdvancedFiltersForm.postedRange,
     });
 
     const [withdrawn, displayWithdrawn] = createDateDisplayValue({
         on: searchAdvancedFiltersForm.withdrawnOn,
         after: searchAdvancedFiltersForm.withdrawnAfter,
         before: searchAdvancedFiltersForm.withdrawnBefore,
+        range: searchAdvancedFiltersForm.withdrawnRange,
     });
 
     const withdrawalTypeOptions = getWithdrawalTypeOptions(translate);
@@ -355,6 +368,7 @@ function SearchFiltersBar({queryJSON, isMobileSelectionModeEnabled}: SearchFilte
     const datePickerComponent = (props: PopoverComponentProps) => (
         <DatePickerFilterPopup
             closeOverlay={props.closeOverlay}
+            setPopoverWidth={props.setPopoverWidth}
             filterKey={CONST.SEARCH.SYNTAX_FILTER_KEYS.DATE}
             value={date}
             translationKey="common.date"
@@ -365,6 +379,7 @@ function SearchFiltersBar({queryJSON, isMobileSelectionModeEnabled}: SearchFilte
     const postedPickerComponent = (props: PopoverComponentProps) => (
         <DatePickerFilterPopup
             closeOverlay={props.closeOverlay}
+            setPopoverWidth={props.setPopoverWidth}
             filterKey={CONST.SEARCH.SYNTAX_FILTER_KEYS.POSTED}
             value={posted}
             translationKey="search.filters.posted"
@@ -375,6 +390,7 @@ function SearchFiltersBar({queryJSON, isMobileSelectionModeEnabled}: SearchFilte
     const withdrawnPickerComponent = (props: PopoverComponentProps) => (
         <DatePickerFilterPopup
             closeOverlay={props.closeOverlay}
+            setPopoverWidth={props.setPopoverWidth}
             filterKey={CONST.SEARCH.SYNTAX_FILTER_KEYS.WITHDRAWN}
             value={withdrawn}
             translationKey="search.filters.withdrawn"
@@ -471,9 +487,11 @@ function SearchFiltersBar({queryJSON, isMobileSelectionModeEnabled}: SearchFilte
     const shouldDisplayGroupCurrencyFilter = shouldDisplayGroupByFilter && hasMultipleOutputCurrency;
     const shouldDisplayFeedFilter = feedOptions.length > 1 && !!searchAdvancedFiltersForm.feed;
     const shouldDisplayPostedFilter =
-        !!searchAdvancedFiltersForm.feed && (!!searchAdvancedFiltersForm.postedOn || !!searchAdvancedFiltersForm.postedAfter || !!searchAdvancedFiltersForm.postedBefore);
+        !!searchAdvancedFiltersForm.feed &&
+        (!!searchAdvancedFiltersForm.postedOn || !!searchAdvancedFiltersForm.postedAfter || !!searchAdvancedFiltersForm.postedBefore || !!searchAdvancedFiltersForm.postedRange);
     const shouldDisplayWithdrawalTypeFilter = !!searchAdvancedFiltersForm.withdrawalType;
-    const shouldDisplayWithdrawnFilter = !!searchAdvancedFiltersForm.withdrawnOn || !!searchAdvancedFiltersForm.withdrawnAfter || !!searchAdvancedFiltersForm.withdrawnBefore;
+    const shouldDisplayWithdrawnFilter =
+        !!searchAdvancedFiltersForm.withdrawnOn || !!searchAdvancedFiltersForm.withdrawnAfter || !!searchAdvancedFiltersForm.withdrawnBefore || !!searchAdvancedFiltersForm.withdrawnRange;
 
     const filters = [
         {
@@ -634,7 +652,12 @@ function SearchFiltersBar({queryJSON, isMobileSelectionModeEnabled}: SearchFilte
         return hiddenFilters.filter((key) => {
             const dateFilterKey = DATE_FILTER_KEYS.find((dateKey) => key === dateKey);
             if (dateFilterKey) {
-                return filterFormValues[`${dateFilterKey}On`] ?? filterFormValues[`${dateFilterKey}After`] ?? filterFormValues[`${dateFilterKey}Before`];
+                return (
+                    filterFormValues[`${dateFilterKey}On`] ??
+                    filterFormValues[`${dateFilterKey}After`] ??
+                    filterFormValues[`${dateFilterKey}Before`] ??
+                    filterFormValues[`${dateFilterKey}Range`]
+                );
             }
 
             if (key === CONST.SEARCH.SYNTAX_FILTER_KEYS.REPORT_FIELD) {
diff --git a/src/languages/de.ts b/src/languages/de.ts
index bdb59e445f342..7eef075e9aaf6 100644
--- a/src/languages/de.ts
+++ b/src/languages/de.ts
@@ -509,6 +509,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: 'Ein',
         before: 'Vor',
         after: 'Nach',
+        range: 'Bereich',
         reschedule: 'Verschieben',
         general: 'Allgemein',
         workspacesTabTitle: 'Workspaces',
@@ -7293,6 +7294,9 @@ Fordern Sie Spesendetails wie Belege und Beschreibungen an, legen Sie Limits und
             selectAllMatchingItems: 'Alle passenden Einträge auswählen',
             allMatchingItemsSelected: 'Alle passenden Elemente ausgewählt',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: 'Bitte wähle Daten für Von und Bis',
+        },
         spendOverTime: 'Ausgaben im Zeitverlauf',
     },
     genericErrorPage: {
diff --git a/src/languages/en.ts b/src/languages/en.ts
index 3c02f0097a8c3..94c254b1eabab 100644
--- a/src/languages/en.ts
+++ b/src/languages/en.ts
@@ -528,6 +528,7 @@ const translations = {
         on: 'On',
         before: 'Before',
         after: 'After',
+        range: 'Range',
         reschedule: 'Reschedule',
         general: 'General',
         workspacesTabTitle: 'Workspaces',
@@ -7255,6 +7256,9 @@ const translations = {
             selectAllMatchingItems: 'Select all matching items',
             allMatchingItemsSelected: 'All matching items selected',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: 'Please select dates for both From and To',
+        },
     },
     genericErrorPage: {
         title: 'Uh-oh, something went wrong!',
diff --git a/src/languages/es.ts b/src/languages/es.ts
index 091cfe1e11a0a..c317cc1879b20 100644
--- a/src/languages/es.ts
+++ b/src/languages/es.ts
@@ -373,6 +373,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: 'El',
         before: 'Antes',
         after: 'Después',
+        range: 'Rango',
         reschedule: 'Reprogramar',
         general: 'General',
         workspacesTabTitle: 'Espacios',
@@ -7101,6 +7102,9 @@ ${amount} para ${merchant} - ${date}`,
             selectAllMatchingItems: 'Seleccionar todos los elementos coincidentes',
             allMatchingItemsSelected: 'Todos los elementos coincidentes seleccionados',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: 'Por favor, selecciona fechas para De y A',
+        },
     },
     genericErrorPage: {
         title: '¡Oh-oh, algo salió mal!',
diff --git a/src/languages/fr.ts b/src/languages/fr.ts
index b031aa989d389..3e1729298be40 100644
--- a/src/languages/fr.ts
+++ b/src/languages/fr.ts
@@ -509,6 +509,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: 'Activé',
         before: 'Avant',
         after: 'Après',
+        range: 'Intervalle',
         reschedule: 'Reprogrammer',
         general: 'Général',
         workspacesTabTitle: 'Espaces de travail',
@@ -7315,6 +7316,9 @@ Rendez obligatoires des informations de dépense comme les reçus et les descrip
             selectAllMatchingItems: 'Sélectionnez tous les éléments correspondants',
             allMatchingItemsSelected: 'Tous les éléments correspondants sont sélectionnés',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: 'Veuillez sélectionner des dates pour De et À',
+        },
         spendOverTime: 'Dépenses dans le temps',
     },
     genericErrorPage: {
diff --git a/src/languages/it.ts b/src/languages/it.ts
index d2eaee2bad698..e2d272f0c5db5 100644
--- a/src/languages/it.ts
+++ b/src/languages/it.ts
@@ -509,6 +509,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: 'Attivo',
         before: 'Prima',
         after: 'Dopo',
+        range: 'Intervallo',
         reschedule: 'Ripianifica',
         general: 'Generale',
         workspacesTabTitle: 'Area di lavoro',
@@ -7280,6 +7281,9 @@ Richiedi dettagli sulle spese come ricevute e descrizioni, imposta limiti e valo
             selectAllMatchingItems: 'Seleziona tutti gli elementi corrispondenti',
             allMatchingItemsSelected: 'Tutti gli elementi corrispondenti selezionati',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: 'Seleziona le date per Da e A',
+        },
         spendOverTime: 'Spesa nel tempo',
     },
     genericErrorPage: {
diff --git a/src/languages/ja.ts b/src/languages/ja.ts
index 492e1d1a2cd0d..d939544fe5626 100644
--- a/src/languages/ja.ts
+++ b/src/languages/ja.ts
@@ -508,6 +508,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: 'オン',
         before: '前',
         after: '後',
+        range: '範囲',
         reschedule: '予定を変更',
         general: '一般',
         workspacesTabTitle: 'ワークスペース',
@@ -7196,6 +7197,9 @@ ${reportName}
             selectAllMatchingItems: '一致する項目をすべて選択',
             allMatchingItemsSelected: '一致する項目をすべて選択済み',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: '開始日と終了日の両方を選択してください',
+        },
         spendOverTime: '時間経過による支出',
     },
     genericErrorPage: {
diff --git a/src/languages/nl.ts b/src/languages/nl.ts
index 4ba410ef1f335..6eff1e9a8ed10 100644
--- a/src/languages/nl.ts
+++ b/src/languages/nl.ts
@@ -508,6 +508,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: 'Aan',
         before: 'Vooraf',
         after: 'Na',
+        range: 'Bereik',
         reschedule: 'Opnieuw plannen',
         general: 'Algemeen',
         workspacesTabTitle: 'Werkruimtes',
@@ -7247,6 +7248,9 @@ Vereis onkostendetails zoals bonnen en beschrijvingen, stel limieten en standaar
             selectAllMatchingItems: 'Selecteer alle overeenkomende items',
             allMatchingItemsSelected: 'Alle overeenkomende items geselecteerd',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: 'Selecteer datums voor Van en Tot',
+        },
         chartTitles: {
             [CONST.SEARCH.GROUP_BY.FROM]: 'Van',
             [CONST.SEARCH.GROUP_BY.CARD]: 'Kaarten',
diff --git a/src/languages/pl.ts b/src/languages/pl.ts
index 5d3866abbecf3..be44cd4e98371 100644
--- a/src/languages/pl.ts
+++ b/src/languages/pl.ts
@@ -508,6 +508,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: 'Włączone',
         before: 'Przed',
         after: 'PoPo',
+        range: 'Zakres',
         reschedule: 'Przełóż',
         general: 'Ogólne',
         workspacesTabTitle: 'Przestrzenie robocze',
@@ -7247,6 +7248,9 @@ Wymagaj szczegółów wydatków, takich jak paragony i opisy, ustawiaj limity i
             selectAllMatchingItems: 'Zaznacz wszystkie pasujące elementy',
             allMatchingItemsSelected: 'Zaznaczono wszystkie pasujące elementy',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: 'Wybierz daty dla Od i Do',
+        },
         spendOverTime: 'Wydatki w czasie',
     },
     genericErrorPage: {
diff --git a/src/languages/pt-BR.ts b/src/languages/pt-BR.ts
index 3b62c36315def..2c2e3734e1d29 100644
--- a/src/languages/pt-BR.ts
+++ b/src/languages/pt-BR.ts
@@ -507,6 +507,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: 'Ativado',
         before: 'Antes',
         after: 'Depois',
+        range: 'Intervalo',
         reschedule: 'Reagendar',
         general: 'Geral',
         workspacesTabTitle: 'Espaços de trabalho',
@@ -7251,6 +7252,9 @@ Exija dados de despesas como recibos e descrições, defina limites e padrões e
             emptyStateTitle: 'Este relatório não tem despesas.',
             accessPlaceHolder: 'Abrir para ver detalhes',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: 'Selecione datas para De e Até',
+        },
         spendOverTime: 'Gastos ao longo do tempo',
     },
     genericErrorPage: {
diff --git a/src/languages/zh-hans.ts b/src/languages/zh-hans.ts
index 7c303102c2dc2..b407de100a4cf 100644
--- a/src/languages/zh-hans.ts
+++ b/src/languages/zh-hans.ts
@@ -504,6 +504,7 @@ const translations: TranslationDeepObject<typeof en> = {
         on: '开打开',
         before: '之前',
         after: '之后',
+        range: '范围',
         reschedule: '重新安排',
         general: '常规',
         workspacesTabTitle: '工作区',
@@ -7087,6 +7088,9 @@ ${reportName}
             selectAllMatchingItems: '选择所有匹配的项目',
             allMatchingItemsSelected: '已选择所有匹配的项目',
         },
+        errors: {
+            pleaseSelectDatesForBothFromAndTo: '请选择起始和结束日期',
+        },
         spendOverTime: '随时间支出',
     },
     genericErrorPage: {
diff --git a/src/libs/DateUtils.ts b/src/libs/DateUtils.ts
index 3a84dfa9fcf31..2180b468b67fb 100644
--- a/src/libs/DateUtils.ts
+++ b/src/libs/DateUtils.ts
@@ -1017,13 +1017,13 @@ function isDateStringInMonth(dateString: string, year: number, month: number): b
 /**
  * Returns a formatted date range.
  */
-function getFormattedDateRangeForSearch(startDate: string, endDate: string): string {
+function getFormattedDateRangeForSearch(startDate: string, endDate: string, shouldShowFullYear = false): string {
     const start = parse(startDate, 'yyyy-MM-dd', new Date());
     const end = parse(endDate, 'yyyy-MM-dd', new Date());
-    if (isSameYear(new Date(start), new Date(end))) {
-        return `${format(start, 'MMM d')} - ${format(end, 'MMM d, yyyy')}`;
+    if (shouldShowFullYear || !isSameYear(new Date(start), new Date(end))) {
+        return `${format(start, 'MMM d, yyyy')} - ${format(end, 'MMM d, yyyy')}`;
     }
-    return `${format(start, 'MMM d, yyyy')} - ${format(end, 'MMM d, yyyy')}`;
+    return `${format(start, 'MMM d')} - ${format(end, 'MMM d, yyyy')}`;
 }
 
 function getYearDateRange(year: number): {start: string; end: string} {
diff --git a/src/libs/SearchQueryUtils.ts b/src/libs/SearchQueryUtils.ts
index f6762c0cabfa5..c3aa66c9e2ced 100644
--- a/src/libs/SearchQueryUtils.ts
+++ b/src/libs/SearchQueryUtils.ts
@@ -36,6 +36,7 @@ import arraysEqual from '@src/utils/arraysEqual';
 import {getCardFeedsForDisplay} from './CardFeedUtils';
 import {getCardDescription} from './CardUtils';
 import {convertToBackendAmount, convertToFrontendAmountAsInteger} from './CurrencyUtils';
+import DateUtils from './DateUtils';
 import Log from './Log';
 import {validateAmount} from './MoneyRequestUtils';
 import {getPreservedNavigatorState} from './Navigation/AppNavigator/createSplitNavigator/usePreserveNavigatorState';
@@ -55,6 +56,7 @@ type FilterKeys = keyof typeof CONST.SEARCH.SYNTAX_FILTER_KEYS;
 const operatorToCharMap = {
     [CONST.SEARCH.SYNTAX_OPERATORS.EQUAL_TO]: ':' as const,
     [CONST.SEARCH.SYNTAX_OPERATORS.CONTAINS]: '*:' as const,
+    [CONST.SEARCH.SYNTAX_OPERATORS.RANGE]: '~' as const,
     [CONST.SEARCH.SYNTAX_OPERATORS.LOWER_THAN]: '<' as const,
     [CONST.SEARCH.SYNTAX_OPERATORS.LOWER_THAN_OR_EQUAL_TO]: '<=' as const,
     [CONST.SEARCH.SYNTAX_OPERATORS.GREATER_THAN]: '>' as const,
@@ -128,6 +130,136 @@ function sanitizeSearchValue(str: string) {
     return str;
 }
 
+function getRangeQueryValue(from?: string, to?: string) {
+    if (from && to) {
+        return `${from},${to}`;
+    }
+    if (from) {
+        return from;
+    }
+    if (to) {
+        return `,${to}`;
+    }
+    return '';
+}
+
+function getRangeBoundariesFromFormValue(rangeValue?: string, fallbackFrom?: string, fallbackTo?: string) {
+    if (!rangeValue) {
+        return {
+            from: undefined,
+            to: undefined,
+        };
+    }
+
+    const parsedRange = parseRangeQueryValue(rangeValue);
+    if (parsedRange.from || parsedRange.to) {
+        return parsedRange;
+    }
+
+    return {
+        from: isValidDate(fallbackFrom ?? '') ? fallbackFrom : undefined,
+        to: isValidDate(fallbackTo ?? '') ? fallbackTo : undefined,
+    };
+}
+
+function getDateRangeDisplayValueFromFormValue(rangeValue?: string, fallbackFrom?: string, fallbackTo?: string) {
+    const rangeBoundaries = getRangeBoundariesFromFormValue(rangeValue, fallbackFrom, fallbackTo);
+    if (rangeBoundaries.from && rangeBoundaries.to) {
+        return DateUtils.getFormattedDateRangeForSearch(rangeBoundaries.from, rangeBoundaries.to, true);
+    }
+
+    const singleBoundary = rangeBoundaries.from ?? rangeBoundaries.to;
+    return singleBoundary ? DateUtils.formatToReadableString(singleBoundary) : '';
+}
+
+function parseRangeQueryValue(rangeValue?: string) {
+    if (!rangeValue) {
+        return {
+            from: undefined,
+            to: undefined,
+        };
+    }
+
+    const [rawFrom = '', rawTo = ''] = rangeValue.split(',', 2);
+    const from = isValidDate(rawFrom) ? rawFrom : undefined;
+    const to = isValidDate(rawTo) ? rawTo : undefined;
+    const singleBoundary = !rangeValue.includes(',') && isValidDate(rangeValue) ? rangeValue : undefined;
+
+    return {
+        from: from ?? singleBoundary,
+        to,
+    };
+}
+
+function normalizeRangeFilterKey(rawKey: string): string {
+    const normalizedKey = rawKey.toLowerCase();
+
+    if (DATE_FILTER_KEYS.includes(normalizedKey as SearchDateFilterKeys)) {
+        return normalizedKey;
+    }
+
+    if (normalizedKey.startsWith('report-field-')) {
+        return `${CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX}${rawKey.slice('report-field-'.length)}`;
+    }
+
+    // cspell:ignore reportfield
+    const reportFieldNoDashPrefix = 'reportfield-';
+    if (normalizedKey.startsWith(reportFieldNoDashPrefix)) {
+        return `${CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX}${rawKey.slice(reportFieldNoDashPrefix.length)}`;
+    }
+
+    return rawKey;
+}
+
+function normalizeRangeFiltersForParsing(query: SearchQueryString): {
+    parserQuery: SearchQueryString;
+    explicitRangeFilters: Map<string, {from?: string; to?: string}>;
+} {
+    const tokens = query.match(/"[^"]*"|[^ \t\r\n\xA0]+/g) ?? [];
+    const normalizedTokens: string[] = [];
+    const explicitRangeFilters = new Map<string, {from?: string; to?: string}>();
+    const rangeTokenPattern = /^(-?)([^~\s]+)~([^~\s]+)$/;
+
+    for (const token of tokens) {
+        if (token.startsWith('"') || !token.includes('~')) {
+            normalizedTokens.push(token);
+            continue;
+        }
+
+        const match = token.match(rangeTokenPattern);
+        if (!match) {
+            normalizedTokens.push(token);
+            continue;
+        }
+
+        const [, negation, rawKey, rangeValue] = match;
+        if (negation) {
+            normalizedTokens.push(token);
+            continue;
+        }
+
+        const boundaries = parseRangeQueryValue(rangeValue);
+        if (!boundaries.from && !boundaries.to) {
+            normalizedTokens.push(token);
+            continue;
+        }
+
+        explicitRangeFilters.set(normalizeRangeFilterKey(rawKey), boundaries);
+
+        if (boundaries.from) {
+            normalizedTokens.push(`${rawKey}>${boundaries.from}`);
+        }
+        if (boundaries.to) {
+            normalizedTokens.push(`${rawKey}<${boundaries.to}`);
+        }
+    }
+
+    return {
+        parserQuery: normalizedTokens.join(' '),
+        explicitRangeFilters,
+    };
+}
+
 /**
  * @private
  * Returns date filter value for QueryString.
@@ -137,16 +269,25 @@ function buildDateFilterQuery(filterValues: Partial<SearchAdvancedFiltersForm>,
     const dateOn = filterValues[`${filterKey}${CONST.SEARCH.DATE_MODIFIERS.ON}`];
     const dateAfter = filterValues[`${filterKey}${CONST.SEARCH.DATE_MODIFIERS.AFTER}`];
     const dateBefore = filterValues[`${filterKey}${CONST.SEARCH.DATE_MODIFIERS.BEFORE}`];
+    const dateRange = filterValues[`${filterKey}${CONST.SEARCH.DATE_MODIFIERS.RANGE}`];
+    const rangeBoundaries = getRangeBoundariesFromFormValue(dateRange, dateAfter, dateBefore);
+    const hasRange = !!dateRange && !!(rangeBoundaries.from ?? rangeBoundaries.to);
 
     const dateFilters = [];
 
     if (dateOn) {
         dateFilters.push(`${filterKey}:${dateOn}`);
     }
-    if (dateAfter) {
+    if (hasRange) {
+        const rangeValue = getRangeQueryValue(rangeBoundaries.from, rangeBoundaries.to);
+        if (rangeValue) {
+            dateFilters.push(`${filterKey}${operatorToCharMap[CONST.SEARCH.SYNTAX_OPERATORS.RANGE]}${rangeValue}`);
+        }
+    }
+    if (dateAfter && (!hasRange || dateAfter !== rangeBoundaries.from)) {
         dateFilters.push(`${filterKey}>${dateAfter}`);
     }
-    if (dateBefore) {
+    if (dateBefore && (!hasRange || dateBefore !== rangeBoundaries.to)) {
         dateFilters.push(`${filterKey}<${dateBefore}`);
     }
     if (negatedDate) {
@@ -444,6 +585,14 @@ function getChartViewDefaults(queryJSON: SearchQueryJSON): Partial<SearchQueryJS
     return defaults;
 }
 
+function getRangeBoundariesFromFilterValues(values: QueryFilter[]) {
+    const normalizedValues = values.map((value) => value.value.toString()).filter((value) => isValidDate(value));
+    return {
+        from: normalizedValues.at(0),
+        to: normalizedValues.at(1),
+    };
+}
+
 /**
  * Parses a given search query string into a structured `SearchQueryJSON` format.
  * This format of query is most commonly shared between components and also sent to backend to retrieve search results.
@@ -452,7 +601,8 @@ function getChartViewDefaults(queryJSON: SearchQueryJSON): Partial<SearchQueryJS
  */
 function getRawFilterListFromQuery(rawQuery: SearchQueryString) {
     try {
-        const rawResult = parseSearchQuery(rawQuery) as SearchQueryJSON;
+        const {parserQuery} = normalizeRangeFiltersForParsing(rawQuery);
+        const rawResult = parseSearchQuery(parserQuery) as SearchQueryJSON;
         const sanitizedFilters = getSanitizedRawFilters(rawResult);
         return sanitizedFilters;
     } catch (error) {
@@ -477,7 +627,8 @@ function buildSearchQueryJSON(query: SearchQueryString, rawQuery?: SearchQuerySt
     }
 
     try {
-        const result = parseSearchQuery(query) as SearchQueryJSON;
+        const {parserQuery} = normalizeRangeFiltersForParsing(query);
+        const result = parseSearchQuery(parserQuery) as SearchQueryJSON;
         const flatFilters = getFilters(result);
 
         // Add the full input and hash to the results
@@ -643,6 +794,20 @@ function buildQueryStringFromFilterFormValues(filterValues: Partial<SearchAdvanc
     // only available for the previous type. Remove all filters that are not allowed for the new type
     const providedFilterKeys = Object.keys(supportedFilterValues) as SearchAdvancedFiltersKey[];
     for (const filter of providedFilterKeys) {
+        const isDateRangeModifier = filter.endsWith(CONST.SEARCH.DATE_MODIFIERS.RANGE);
+        if (isDateRangeModifier) {
+            const dateKey = filter.slice(0, -CONST.SEARCH.DATE_MODIFIERS.RANGE.length);
+            const afterKey = `${dateKey}${CONST.SEARCH.DATE_MODIFIERS.AFTER}` as SearchAdvancedFiltersKey;
+            const beforeKey = `${dateKey}${CONST.SEARCH.DATE_MODIFIERS.BEFORE}` as SearchAdvancedFiltersKey;
+
+            if (
+                isFilterSupported(afterKey, supportedFilterValues.type ?? CONST.SEARCH.DATA_TYPES.EXPENSE) ||
+                isFilterSupported(beforeKey, supportedFilterValues.type ?? CONST.SEARCH.DATA_TYPES.EXPENSE)
+            ) {
+                continue;
+            }
+        }
+
         if (isFilterSupported(filter, supportedFilterValues.type ?? CONST.SEARCH.DATA_TYPES.EXPENSE)) {
             continue;
         }
@@ -738,6 +903,7 @@ function buildQueryStringFromFilterFormValues(filterValues: Partial<SearchAdvanc
                 const isFieldNegated = filterKey.startsWith(CONST.SEARCH.REPORT_FIELD.NOT_PREFIX);
                 const isTextBasedReportField = filterKey.startsWith(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX) || isNegated;
                 const fieldPrefix = isFieldNegated ? '-' : '';
+                const isRangeDateField = filterKey.startsWith(CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX);
 
                 if (isTextBasedReportField) {
                     return `${fieldPrefix}${filterKey}:${value}`;
@@ -752,12 +918,59 @@ function buildQueryStringFromFilterFormValues(filterValues: Partial<SearchAdvanc
                     return `${key}:${value}`;
                 }
 
+                if (isRangeDateField) {
+                    const suffix = filterKey.replace(CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX, '');
+                    const key = `${CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX}${suffix}`;
+                    const afterKey = `${CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX}${suffix}` as SearchAdvancedFiltersKey;
+                    const beforeKey = `${CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX}${suffix}` as SearchAdvancedFiltersKey;
+                    const rangeBoundaries = getRangeBoundariesFromFormValue(
+                        filterValue as string | undefined,
+                        supportedFilterValues[afterKey] as string | undefined,
+                        supportedFilterValues[beforeKey] as string | undefined,
+                    );
+                    const rangeValue = getRangeQueryValue(rangeBoundaries.from, rangeBoundaries.to);
+
+                    if (!rangeValue) {
+                        return undefined;
+                    }
+
+                    return `${key}${operatorToCharMap[CONST.SEARCH.SYNTAX_OPERATORS.RANGE]}${rangeValue}`;
+                }
+
                 if (isAfterDateField) {
+                    const suffix = filterKey.replace(CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX, '');
+                    const rangeKey = `${CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX}${suffix}` as SearchAdvancedFiltersKey;
+                    const afterKey = `${CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX}${suffix}` as SearchAdvancedFiltersKey;
+                    const beforeKey = `${CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX}${suffix}` as SearchAdvancedFiltersKey;
+                    const rangeValue = supportedFilterValues[rangeKey] as string | undefined;
+                    const rangeBoundaries = getRangeBoundariesFromFormValue(
+                        rangeValue,
+                        supportedFilterValues[afterKey] as string | undefined,
+                        supportedFilterValues[beforeKey] as string | undefined,
+                    );
+                    if (rangeValue && rangeBoundaries.from === (filterValue as string)) {
+                        return undefined;
+                    }
+
                     const key = filterKey.replace(CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX, CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX);
                     return `${key}>${value}`;
                 }
 
                 if (isBeforeDateField) {
+                    const suffix = filterKey.replace(CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX, '');
+                    const rangeKey = `${CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX}${suffix}` as SearchAdvancedFiltersKey;
+                    const afterKey = `${CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX}${suffix}` as SearchAdvancedFiltersKey;
+                    const beforeKey = `${CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX}${suffix}` as SearchAdvancedFiltersKey;
+                    const rangeValue = supportedFilterValues[rangeKey] as string | undefined;
+                    const rangeBoundaries = getRangeBoundariesFromFormValue(
+                        rangeValue,
+                        supportedFilterValues[afterKey] as string | undefined,
+                        supportedFilterValues[beforeKey] as string | undefined,
+                    );
+                    if (rangeValue && rangeBoundaries.to === (filterValue as string)) {
+                        return undefined;
+                    }
+
                     const key = filterKey.replace(CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX, CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX);
                     return `${key}<${value}`;
                 }
@@ -850,6 +1063,7 @@ function buildFilterFormValuesFromQuery(
     const filters = queryJSON.flatFilters;
     const filtersForm = {} as Partial<SearchAdvancedFiltersForm>;
     const policyID = queryJSON.policyID;
+    const {explicitRangeFilters} = normalizeRangeFiltersForParsing(queryJSON.inputQuery);
 
     for (const queryFilter of filters) {
         const filterList = queryFilter.filters;
@@ -971,9 +1185,11 @@ function buildFilterFormValuesFromQuery(
             const beforeKey = `${filterKey}${CONST.SEARCH.DATE_MODIFIERS.BEFORE}` as `${SearchDateFilterKeys}${typeof CONST.SEARCH.DATE_MODIFIERS.BEFORE}`;
             const afterKey = `${filterKey}${CONST.SEARCH.DATE_MODIFIERS.AFTER}` as `${SearchDateFilterKeys}${typeof CONST.SEARCH.DATE_MODIFIERS.AFTER}`;
             const onKey = `${filterKey}${CONST.SEARCH.DATE_MODIFIERS.ON}` as `${SearchDateFilterKeys}${typeof CONST.SEARCH.DATE_MODIFIERS.ON}`;
+            const rangeKey = `${filterKey}${CONST.SEARCH.DATE_MODIFIERS.RANGE}` as `${SearchDateFilterKeys}${typeof CONST.SEARCH.DATE_MODIFIERS.RANGE}`;
 
             const beforeFilter = filterList.find((filter) => filter.operator === CONST.SEARCH.SYNTAX_OPERATORS.LOWER_THAN && isValidDate(filter.value.toString()));
             const afterFilter = filterList.find((filter) => filter.operator === CONST.SEARCH.SYNTAX_OPERATORS.GREATER_THAN && isValidDate(filter.value.toString()));
+            const dateRangeFilters = filterList.filter((filter) => filter.operator === CONST.SEARCH.SYNTAX_OPERATORS.RANGE);
 
             // The `On` and `Not on` filter could be either a date or a date preset (e.g. Last month)
             const negatedFilter = filterList.find((filter) => {
@@ -982,11 +1198,24 @@ function buildFilterFormValuesFromQuery(
             const onFilter = filterList.find((filter) => {
                 return filter.operator === CONST.SEARCH.SYNTAX_OPERATORS.EQUAL_TO && (isValidDate(filter.value.toString()) || isSearchDatePreset(filter.value.toString()));
             });
-
-            filtersForm[beforeKey] = beforeFilter?.value.toString() ?? filtersForm[beforeKey];
-            filtersForm[afterKey] = afterFilter?.value.toString() ?? filtersForm[afterKey];
+            const explicitRange = explicitRangeFilters.get(filterKey);
+            const rangeBoundariesFromOperator = getRangeBoundariesFromFilterValues(dateRangeFilters);
+            const rangeValue = getRangeQueryValue(rangeBoundariesFromOperator.from ?? explicitRange?.from, rangeBoundariesFromOperator.to ?? explicitRange?.to);
+            const afterFilterValue = afterFilter?.value.toString();
+            const beforeFilterValue = beforeFilter?.value.toString();
+            const shouldIgnoreAfterAsRangeBoundary = !!explicitRange?.from && afterFilterValue === explicitRange.from;
+            const shouldIgnoreBeforeAsRangeBoundary = !!explicitRange?.to && beforeFilterValue === explicitRange.to;
+
+            filtersForm[beforeKey] = shouldIgnoreBeforeAsRangeBoundary ? filtersForm[beforeKey] : (beforeFilterValue ?? filtersForm[beforeKey]);
+            filtersForm[afterKey] = shouldIgnoreAfterAsRangeBoundary ? filtersForm[afterKey] : (afterFilterValue ?? filtersForm[afterKey]);
             filtersForm[onKey] = onFilter?.value.toString() ?? filtersForm[onKey];
             filtersForm[negatedKey] = negatedFilter?.value.toString() ?? filtersForm[negatedKey];
+
+            if (rangeValue) {
+                filtersForm[rangeKey] = rangeValue;
+                continue;
+            }
+            filtersForm[rangeKey] = undefined;
         }
 
         if (AMOUNT_FILTER_KEYS.includes(filterKey as SearchAmountFilterKeys)) {
@@ -1020,17 +1249,19 @@ function buildFilterFormValuesFromQuery(
         }
 
         if (filterKey.startsWith(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX)) {
-            const suffix = filterKey.replace(CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX, '');
+            const suffix = filterKey.replace(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX, '');
 
             const textKey = filterKey as ReportFieldTextKey;
-            const negatedKey = `${CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX}${CONST.SEARCH.NOT_MODIFIER}${suffix}` as ReportFieldNegatedKey;
-            const dateOnKey = `${CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX}${CONST.SEARCH.DATE_MODIFIERS.ON}${suffix}` as ReportFieldDateKey;
-            const dateBeforeKey = `${CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX}${CONST.SEARCH.DATE_MODIFIERS.BEFORE}${suffix}` as ReportFieldDateKey;
-            const dateAfterKey = `${CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX}${CONST.SEARCH.DATE_MODIFIERS.AFTER}${suffix}` as ReportFieldDateKey;
+            const negatedKey: ReportFieldNegatedKey = `${CONST.SEARCH.REPORT_FIELD.NOT_PREFIX}${suffix}`;
+            const dateOnKey: ReportFieldDateKey = `${CONST.SEARCH.REPORT_FIELD.ON_PREFIX}${suffix}`;
+            const dateBeforeKey: ReportFieldDateKey = `${CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX}${suffix}`;
+            const dateAfterKey: ReportFieldDateKey = `${CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX}${suffix}`;
+            const dateRangeKey: ReportFieldDateKey = `${CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX}${suffix}`;
 
             let dateBeforeFilter;
             let dateAfterFilter;
             let dateOnFilter;
+            const dateRangeFilters: QueryFilter[] = [];
             let negatedFilter;
             let textFilter;
 
@@ -1039,6 +1270,8 @@ function buildFilterFormValuesFromQuery(
                     dateBeforeFilter = filter;
                 } else if (filter.operator === CONST.SEARCH.SYNTAX_OPERATORS.GREATER_THAN && isValidDate(filter.value.toString())) {
                     dateAfterFilter = filter;
+                } else if (filter.operator === CONST.SEARCH.SYNTAX_OPERATORS.RANGE) {
+                    dateRangeFilters.push(filter);
                 } else if (filter.operator === CONST.SEARCH.SYNTAX_OPERATORS.EQUAL_TO && (isValidDate(filter.value.toString()) || isSearchDatePreset(filter.value.toString()))) {
                     dateOnFilter = filter;
                 } else if (filter.operator === CONST.SEARCH.SYNTAX_OPERATORS.NOT_EQUAL_TO) {
@@ -1048,11 +1281,25 @@ function buildFilterFormValuesFromQuery(
                 }
             }
 
+            const explicitRange = explicitRangeFilters.get(filterKey);
+            const rangeBoundariesFromOperator = getRangeBoundariesFromFilterValues(dateRangeFilters);
+            const rangeValue = getRangeQueryValue(rangeBoundariesFromOperator.from ?? explicitRange?.from, rangeBoundariesFromOperator.to ?? explicitRange?.to);
+            const dateAfterFilterValue = dateAfterFilter?.value.toString();
+            const dateBeforeFilterValue = dateBeforeFilter?.value.toString();
+            const shouldIgnoreAfterAsRangeBoundary = !!explicitRange?.from && dateAfterFilterValue === explicitRange.from;
+            const shouldIgnoreBeforeAsRangeBoundary = !!explicitRange?.to && dateBeforeFilterValue === explicitRange.to;
+
             filtersForm[textKey] = textFilter?.value.toString() ?? filtersForm[textKey];
             filtersForm[negatedKey] = negatedFilter?.value.toString() ?? filtersForm[negatedKey];
             filtersForm[dateOnKey] = dateOnFilter?.value.toString() ?? filtersForm[dateOnKey];
-            filtersForm[dateBeforeKey] = dateBeforeFilter?.value.toString() ?? filtersForm[dateBeforeKey];
-            filtersForm[dateAfterKey] = dateAfterFilter?.value.toString() ?? filtersForm[dateAfterKey];
+            filtersForm[dateBeforeKey] = shouldIgnoreBeforeAsRangeBoundary ? filtersForm[dateBeforeKey] : (dateBeforeFilterValue ?? filtersForm[dateBeforeKey]);
+            filtersForm[dateAfterKey] = shouldIgnoreAfterAsRangeBoundary ? filtersForm[dateAfterKey] : (dateAfterFilterValue ?? filtersForm[dateAfterKey]);
+
+            if (rangeValue) {
+                filtersForm[dateRangeKey] = rangeValue;
+                continue;
+            }
+            filtersForm[dateRangeKey] = undefined;
         }
     }
 
@@ -1646,6 +1893,10 @@ function shouldSkipSuggestedSearchNavigation(queryJSON?: SearchQueryJSON) {
 }
 
 export {
+    getDateRangeDisplayValueFromFormValue,
+    getRangeBoundariesFromFormValue,
+    getRangeQueryValue,
+    parseRangeQueryValue,
     isSearchDatePreset,
     isFilterSupported,
     buildSearchQueryJSON,
diff --git a/src/pages/ScheduleCall/AvailableBookingDay.tsx b/src/pages/ScheduleCall/AvailableBookingDay.tsx
index abe89a351df1b..5244c09197fc9 100644
--- a/src/pages/ScheduleCall/AvailableBookingDay.tsx
+++ b/src/pages/ScheduleCall/AvailableBookingDay.tsx
@@ -17,7 +17,7 @@ function AvailableBookingDay({disabled, selected, pressed, hovered, children}: D
                 selected ? themeStyles.buttonSuccess : {},
             ]}
         >
-            <Text>{children}</Text>
+            <Text style={selected ? themeStyles.buttonSuccessText : {}}>{children}</Text>
         </View>
     );
 }
diff --git a/src/pages/Search/AdvancedSearchFilters.tsx b/src/pages/Search/AdvancedSearchFilters.tsx
index ea817a1c8fd9b..6dcc138a5dd20 100644
--- a/src/pages/Search/AdvancedSearchFilters.tsx
+++ b/src/pages/Search/AdvancedSearchFilters.tsx
@@ -9,7 +9,7 @@ import type {LocaleContextProps} from '@components/LocaleContextProvider';
 import MenuItemWithTopDescription from '@components/MenuItemWithTopDescription';
 import {usePersonalDetails} from '@components/OnyxListItemProvider';
 import ScrollView from '@components/ScrollView';
-import type {SearchAmountFilterKeys, SearchDateFilterKeys, SearchDatePreset, SearchFilterKey} from '@components/Search/types';
+import type {SearchAmountFilterKeys, SearchDateFilterKeys, SearchFilterKey} from '@components/Search/types';
 import SpacerView from '@components/SpacerView';
 import Text from '@components/Text';
 import useAdvancedSearchFilters from '@hooks/useAdvancedSearchFilters';
@@ -32,6 +32,7 @@ import {
     buildQueryStringFromFilterFormValues,
     buildSearchQueryJSON,
     getCurrentSearchQueryJSON,
+    getDateRangeDisplayValueFromFormValue,
     isCannedSearchQuery,
     isSearchDatePreset,
     sortOptionsWithEmptyValue,
@@ -338,9 +339,11 @@ function getFilterDisplayTitle(
         const keyOn = `${filterKey}${CONST.SEARCH.DATE_MODIFIERS.ON}` as `${SearchDateFilterKeys}${typeof CONST.SEARCH.DATE_MODIFIERS.ON}`;
         const keyAfter = `${filterKey}${CONST.SEARCH.DATE_MODIFIERS.AFTER}` as `${SearchDateFilterKeys}${typeof CONST.SEARCH.DATE_MODIFIERS.AFTER}`;
         const keyBefore = `${filterKey}${CONST.SEARCH.DATE_MODIFIERS.BEFORE}` as `${SearchDateFilterKeys}${typeof CONST.SEARCH.DATE_MODIFIERS.BEFORE}`;
+        const keyRange = `${filterKey}${CONST.SEARCH.DATE_MODIFIERS.RANGE}` as `${SearchDateFilterKeys}${typeof CONST.SEARCH.DATE_MODIFIERS.RANGE}`;
         const dateOn = filters[keyOn];
         const dateAfter = filters[keyAfter];
         const dateBefore = filters[keyBefore];
+        const dateRange = filters[keyRange];
         const dateValue = [];
 
         if (dateOn) {
@@ -355,6 +358,13 @@ function getFilterDisplayTitle(
             dateValue.push(translate('search.filters.date.before', dateBefore));
         }
 
+        if (dateRange) {
+            const rangeDisplay = getDateRangeDisplayValueFromFormValue(dateRange, dateAfter, dateBefore);
+            if (rangeDisplay) {
+                dateValue.push(`${translate('common.range')}: ${rangeDisplay}`);
+            }
+        }
+
         return dateValue.join(', ');
     }
 
@@ -389,42 +399,73 @@ function getFilterDisplayTitle(
 
     if (key.startsWith(CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX)) {
         const values: string[] = [];
+        const reportFieldValues: Record<string, {text?: string; on?: string; after?: string; before?: string; range?: string}> = {};
 
         for (const [fieldKey, fieldValue] of Object.entries(filters)) {
-            if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.NOT_PREFIX) || !fieldValue || !fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX)) {
+            if (!fieldValue || fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.NOT_PREFIX) || !fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX)) {
                 continue;
             }
 
-            const fieldName = fieldKey
+            const suffix = fieldKey
+                .replace(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX, '')
                 .replace(CONST.SEARCH.REPORT_FIELD.ON_PREFIX, '')
                 .replace(CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX, '')
                 .replace(CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX, '')
-                .replace(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX, '')
+                .replace(CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX, '');
+
+            if (!suffix) {
+                continue;
+            }
+
+            if (!reportFieldValues[suffix]) {
+                reportFieldValues[suffix] = {};
+            }
+
+            if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX)) {
+                reportFieldValues[suffix].text = fieldValue as string;
+            } else if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.ON_PREFIX)) {
+                reportFieldValues[suffix].on = fieldValue as string;
+            } else if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX)) {
+                reportFieldValues[suffix].after = fieldValue as string;
+            } else if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX)) {
+                reportFieldValues[suffix].before = fieldValue as string;
+            } else if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX)) {
+                reportFieldValues[suffix].range = fieldValue as string;
+            }
+        }
+
+        for (const [suffix, fieldDateValues] of Object.entries(reportFieldValues)) {
+            const fieldName = suffix
                 .split('-')
                 .map((word, index) => (index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word))
                 .join(' ');
 
-            if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.ON_PREFIX)) {
-                const dateString = isSearchDatePreset(fieldValue as string)
-                    ? translate(`search.filters.date.presets.${fieldValue as SearchDatePreset}`)
-                    : translate('search.filters.date.on', fieldValue as string);
+            if (fieldDateValues.text) {
+                values.push(translate('search.filters.reportField', fieldName, fieldDateValues.text));
+            }
 
-                values.push(translate('search.filters.reportField', fieldName, dateString.toLowerCase()));
+            if (fieldDateValues.on) {
+                const onString = isSearchDatePreset(fieldDateValues.on)
+                    ? translate(`search.filters.date.presets.${fieldDateValues.on}`)
+                    : translate('search.filters.date.on', fieldDateValues.on);
+                values.push(translate('search.filters.reportField', fieldName, onString.toLowerCase()));
             }
 
-            if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX)) {
-                const dateString = translate('search.filters.date.after', fieldValue as string).toLowerCase();
-                values.push(translate('search.filters.reportField', fieldName, dateString.toLowerCase()));
+            if (fieldDateValues.after) {
+                const afterString = translate('search.filters.date.after', fieldDateValues.after).toLowerCase();
+                values.push(translate('search.filters.reportField', fieldName, afterString));
             }
 
-            if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX)) {
-                const dateString = translate('search.filters.date.before', fieldValue as string).toLowerCase();
-                values.push(translate('search.filters.reportField', fieldName, dateString.toLowerCase()));
+            if (fieldDateValues.before) {
+                const beforeString = translate('search.filters.date.before', fieldDateValues.before).toLowerCase();
+                values.push(translate('search.filters.reportField', fieldName, beforeString));
             }
 
-            if (fieldKey.startsWith(CONST.SEARCH.REPORT_FIELD.DEFAULT_PREFIX)) {
-                const valueString = translate('search.filters.reportField', fieldName, fieldValue as string);
-                values.push(valueString);
+            if (fieldDateValues.range) {
+                const rangeDisplay = getDateRangeDisplayValueFromFormValue(fieldDateValues.range, fieldDateValues.after, fieldDateValues.before);
+                if (rangeDisplay) {
+                    values.push(translate('search.filters.reportField', fieldName, `${translate('common.range')}: ${rangeDisplay}`.toLowerCase()));
+                }
             }
         }
 
diff --git a/src/pages/Search/SearchAdvancedFiltersPage/SearchFiltersReportFieldPage/index.tsx b/src/pages/Search/SearchAdvancedFiltersPage/SearchFiltersReportFieldPage/index.tsx
index 82744203adaa6..5897571ac3b34 100644
--- a/src/pages/Search/SearchAdvancedFiltersPage/SearchFiltersReportFieldPage/index.tsx
+++ b/src/pages/Search/SearchAdvancedFiltersPage/SearchFiltersReportFieldPage/index.tsx
@@ -13,7 +13,7 @@ import useOnyx from '@hooks/useOnyx';
 import useThemeStyles from '@hooks/useThemeStyles';
 import {updateAdvancedFilters} from '@libs/actions/Search';
 import Navigation from '@libs/Navigation/Navigation';
-import {isSearchDatePreset} from '@libs/SearchQueryUtils';
+import {getDateRangeDisplayValueFromFormValue, isSearchDatePreset} from '@libs/SearchQueryUtils';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import ROUTES from '@src/ROUTES';
@@ -43,6 +43,7 @@ function SearchFiltersReportFieldPage() {
                 const onValue = advancedFiltersForm?.[`${CONST.SEARCH.REPORT_FIELD.ON_PREFIX}${suffix}`];
                 const afterValue = advancedFiltersForm?.[`${CONST.SEARCH.REPORT_FIELD.AFTER_PREFIX}${suffix}`];
                 const beforeValue = advancedFiltersForm?.[`${CONST.SEARCH.REPORT_FIELD.BEFORE_PREFIX}${suffix}`];
+                const rangeValue = advancedFiltersForm?.[`${CONST.SEARCH.REPORT_FIELD.RANGE_PREFIX}${suffix}`];
 
                 if (onValue) {
                     dateValues.push(isSearchDatePreset(onValue) ? translate(`search.filters.date.presets.${onValue}`) : translate('search.filters.date.on', onValue));
@@ -56,6 +57,13 @@ function SearchFiltersReportFieldPage() {
                     dateValues.push(translate('search.filters.date.before', beforeValue));
                 }
 
+                if (rangeValue) {
+                    const rangeDisplay = getDateRangeDisplayValueFromFormValue(rangeValue, afterValue, beforeValue);
+                    if (rangeDisplay) {
+                        dateValues.push(`${translate('common.range')}: ${rangeDisplay}`);
+                    }
+                }
+
                 return {key: field.fieldID, name: field.name, value: dateValues.join(', '), field};
             }
 
diff --git a/src/types/form/SearchAdvancedFiltersForm.ts b/src/types/form/SearchAdvancedFiltersForm.ts
index 4e799a2b01652..1b834502c6aa8 100644
--- a/src/types/form/SearchAdvancedFiltersForm.ts
+++ b/src/types/form/SearchAdvancedFiltersForm.ts
@@ -38,31 +38,37 @@ const FILTER_KEYS = {
     DATE_ON: 'dateOn',
     DATE_AFTER: 'dateAfter',
     DATE_BEFORE: 'dateBefore',
+    DATE_RANGE: 'dateRange',
 
     SUBMITTED_NOT: 'submittedNot',
     SUBMITTED_ON: 'submittedOn',
     SUBMITTED_AFTER: 'submittedAfter',
     SUBMITTED_BEFORE: 'submittedBefore',
+    SUBMITTED_RANGE: 'submittedRange',
 
     APPROVED_NOT: 'approvedNot',
     APPROVED_ON: 'approvedOn',
     APPROVED_AFTER: 'approvedAfter',
     APPROVED_BEFORE: 'approvedBefore',
+    APPROVED_RANGE: 'approvedRange',
 
     PAID_NOT: 'paidNot',
     PAID_ON: 'paidOn',
     PAID_AFTER: 'paidAfter',
     PAID_BEFORE: 'paidBefore',
+    PAID_RANGE: 'paidRange',
 
     EXPORTED_NOT: 'exportedNot',
     EXPORTED_ON: 'exportedOn',
     EXPORTED_AFTER: 'exportedAfter',
     EXPORTED_BEFORE: 'exportedBefore',
+    EXPORTED_RANGE: 'exportedRange',
 
     POSTED_NOT: 'postedNot',
     POSTED_ON: 'postedOn',
     POSTED_AFTER: 'postedAfter',
     POSTED_BEFORE: 'postedBefore',
+    POSTED_RANGE: 'postedRange',
 
     WITHDRAWAL_TYPE_NOT: 'withdrawalTypeNot',
     WITHDRAWAL_TYPE: 'withdrawalType',
@@ -71,6 +77,7 @@ const FILTER_KEYS = {
     WITHDRAWN_ON: 'withdrawnOn',
     WITHDRAWN_AFTER: 'withdrawnAfter',
     WITHDRAWN_BEFORE: 'withdrawnBefore',
+    WITHDRAWN_RANGE: 'withdrawnRange',
 
     CURRENCY_NOT: 'currencyNot',
     CURRENCY: 'currency',
@@ -556,31 +563,39 @@ type SearchAdvancedFiltersForm = Form<
 
         [FILTER_KEYS.DATE_ON]: string;
         [FILTER_KEYS.DATE_NOT]: string;
+        [FILTER_KEYS.DATE_AFTER]: string;
+        [FILTER_KEYS.DATE_BEFORE]: string;
+        [FILTER_KEYS.DATE_RANGE]: string;
 
         [FILTER_KEYS.SUBMITTED_ON]: string;
         [FILTER_KEYS.SUBMITTED_NOT]: string;
         [FILTER_KEYS.SUBMITTED_AFTER]: string;
         [FILTER_KEYS.SUBMITTED_BEFORE]: string;
+        [FILTER_KEYS.SUBMITTED_RANGE]: string;
 
         [FILTER_KEYS.APPROVED_ON]: string;
         [FILTER_KEYS.APPROVED_NOT]: string;
         [FILTER_KEYS.APPROVED_AFTER]: string;
         [FILTER_KEYS.APPROVED_BEFORE]: string;
+        [FILTER_KEYS.APPROVED_RANGE]: string;
 
         [FILTER_KEYS.PAID_ON]: string;
         [FILTER_KEYS.PAID_NOT]: string;
         [FILTER_KEYS.PAID_AFTER]: string;
         [FILTER_KEYS.PAID_BEFORE]: string;
+        [FILTER_KEYS.PAID_RANGE]: string;
 
         [FILTER_KEYS.EXPORTED_ON]: string;
         [FILTER_KEYS.EXPORTED_NOT]: string;
         [FILTER_KEYS.EXPORTED_AFTER]: string;
         [FILTER_KEYS.EXPORTED_BEFORE]: string;
+        [FILTER_KEYS.EXPORTED_RANGE]: string;
 
         [FILTER_KEYS.POSTED_ON]: string;
         [FILTER_KEYS.POSTED_NOT]: string;
         [FILTER_KEYS.POSTED_AFTER]: string;
         [FILTER_KEYS.POSTED_BEFORE]: string;
+        [FILTER_KEYS.POSTED_RANGE]: string;
 
         [FILTER_KEYS.WITHDRAWAL_TYPE]: SearchWithdrawalType;
         [FILTER_KEYS.WITHDRAWAL_TYPE_NOT]: SearchWithdrawalType;
@@ -589,6 +604,7 @@ type SearchAdvancedFiltersForm = Form<
         [FILTER_KEYS.WITHDRAWN_NOT]: string;
         [FILTER_KEYS.WITHDRAWN_AFTER]: string;
         [FILTER_KEYS.WITHDRAWN_BEFORE]: string;
+        [FILTER_KEYS.WITHDRAWN_RANGE]: string;
 
         [FILTER_KEYS.CURRENCY]: string[];
         [FILTER_KEYS.CURRENCY_NOT]: string[];
diff --git a/tests/unit/Search/SearchQueryUtilsTest.ts b/tests/unit/Search/SearchQueryUtilsTest.ts
index 7aac5ba596191..23b45aef0036c 100644
--- a/tests/unit/Search/SearchQueryUtilsTest.ts
+++ b/tests/unit/Search/SearchQueryUtilsTest.ts
@@ -5,12 +5,14 @@ import {generatePolicyID} from '@libs/actions/Policy/Policy';
 // eslint-disable-next-line no-restricted-syntax
 import type * as PersonalDetailsUtils from '@libs/PersonalDetailsUtils';
 import CONST from '@src/CONST';
+import DateUtils from '@src/libs/DateUtils';
 import {
     buildFilterFormValuesFromQuery,
     buildQueryStringFromFilterFormValues,
     buildSearchQueryJSON,
     buildSearchQueryString,
     buildUserReadableQueryString,
+    getDateRangeDisplayValueFromFormValue,
     getFilterDisplayValue,
     getQueryWithUpdatedValues,
     shouldHighlight,
@@ -54,6 +56,32 @@ jest.mock('@libs/PersonalDetailsUtils', () => {
 const defaultQuery = `type:expense sortBy:date sortOrder:desc`;
 
 describe('SearchQueryUtils', () => {
+    describe('getDateRangeDisplayValueFromFormValue', () => {
+        test('returns full range display when both boundaries exist', () => {
+            const result = getDateRangeDisplayValueFromFormValue('2025-03-01,2025-03-10');
+
+            expect(result).toBe(DateUtils.getFormattedDateRangeForSearch('2025-03-01', '2025-03-10', true));
+        });
+
+        test('returns single boundary display when only one boundary exists', () => {
+            const result = getDateRangeDisplayValueFromFormValue('2025-03-01');
+
+            expect(result).toBe(DateUtils.formatToReadableString('2025-03-01'));
+        });
+
+        test('falls back to after and before values when range value is invalid', () => {
+            const result = getDateRangeDisplayValueFromFormValue('invalid', '2025-03-01', '2025-03-10');
+
+            expect(result).toBe(DateUtils.getFormattedDateRangeForSearch('2025-03-01', '2025-03-10', true));
+        });
+
+        test('returns empty string when no valid range boundaries exist', () => {
+            const result = getDateRangeDisplayValueFromFormValue('invalid');
+
+            expect(result).toBe('');
+        });
+    });
+
     describe('getQueryWithUpdatedValues', () => {
         test('returns default query for empty value', () => {
             const userQuery = '';
@@ -246,6 +274,51 @@ describe('SearchQueryUtils', () => {
             expect(result).not.toMatch(CONST.VALIDATE_FOR_HTML_TAG_REGEX);
         });
 
+        test('serializes explicit date range with dedicated range operator', () => {
+            const filterValues: Partial<SearchAdvancedFiltersForm> = {
+                type: 'expense',
+                dateRange: '2025-03-01,2025-03-10',
+            };
+
+            const result = buildQueryStringFromFilterFormValues(filterValues);
+            expect(result).toContain('date~2025-03-01,2025-03-10');
+            expect(result).not.toContain('date>2025-03-01');
+            expect(result).not.toContain('date<2025-03-10');
+
+            const queryJSON = buildSearchQueryJSON(result);
+            const dateOperators = queryJSON?.flatFilters
+                .filter((filter) => filter.key === CONST.SEARCH.SYNTAX_FILTER_KEYS.DATE)
+                .flatMap((filter) => filter.filters.map((dateFilter) => dateFilter.operator));
+            expect(dateOperators).toEqual(expect.arrayContaining([CONST.SEARCH.SYNTAX_OPERATORS.GREATER_THAN, CONST.SEARCH.SYNTAX_OPERATORS.LOWER_THAN]));
+        });
+
+        test('serializes explicit report field range with dedicated range operator', () => {
+            const filterValues: Partial<SearchAdvancedFiltersForm> = {
+                type: 'expense',
+                'reportFieldRange-start-date': '2025-03-01,2025-03-10',
+            };
+
+            const result = buildQueryStringFromFilterFormValues(filterValues);
+            expect(result).toContain('reportField-start-date~2025-03-01,2025-03-10');
+            expect(result).not.toContain('reportField-start-date>2025-03-01');
+            expect(result).not.toContain('reportField-start-date<2025-03-10');
+        });
+
+        test('serializes explicit range with only before boundary using leading comma', () => {
+            const filterValues: Partial<SearchAdvancedFiltersForm> = {
+                type: 'expense',
+                dateRange: ',2025-03-10',
+            };
+
+            const result = buildQueryStringFromFilterFormValues(filterValues);
+            expect(result).toContain('date~,2025-03-10');
+
+            const queryJSON = buildSearchQueryJSON(result);
+            expect(queryJSON?.flatFilters.find((filter) => filter.key === CONST.SEARCH.SYNTAX_FILTER_KEYS.DATE)?.filters).toEqual([
+                {operator: CONST.SEARCH.SYNTAX_OPERATORS.LOWER_THAN, value: '2025-03-10'},
+            ]);
+        });
+
         test('total filter values', () => {
             const filterValues: Partial<SearchAdvancedFiltersForm> = {
                 type: 'expense',
@@ -773,6 +846,90 @@ describe('SearchQueryUtils', () => {
             });
         });
 
+        test('hydrates explicit date range flag from range query operator', () => {
+            const policyCategories = {};
+            const policyTags = {};
+            const currencyList = {};
+            const personalDetails = {};
+            const cardList = {};
+            const reports = {};
+            const taxRates = {};
+            const queryString = 'sortBy:date sortOrder:desc type:expense date~2025-03-01,2025-03-10';
+            const queryJSON = buildSearchQueryJSON(queryString);
+
+            if (!queryJSON) {
+                throw new Error('Failed to parse query string');
+            }
+
+            const result = buildFilterFormValuesFromQuery(queryJSON, policyCategories, policyTags, currencyList, personalDetails, cardList, reports, taxRates);
+
+            expect(result.dateAfter).toBeUndefined();
+            expect(result.dateBefore).toBeUndefined();
+            expect(result.dateRange).toBe('2025-03-01,2025-03-10');
+        });
+
+        test('does not set explicit date range flag when only date boundaries are provided', () => {
+            const policyCategories = {};
+            const policyTags = {};
+            const currencyList = {};
+            const personalDetails = {};
+            const cardList = {};
+            const reports = {};
+            const taxRates = {};
+            const queryString = 'sortBy:date sortOrder:desc type:expense date>2025-03-01 date<2025-03-10';
+            const queryJSON = buildSearchQueryJSON(queryString);
+
+            if (!queryJSON) {
+                throw new Error('Failed to parse query string');
+            }
+
+            const result = buildFilterFormValuesFromQuery(queryJSON, policyCategories, policyTags, currencyList, personalDetails, cardList, reports, taxRates);
+
+            expect(result.dateRange).toBeUndefined();
+        });
+
+        test('hydrates explicit report field range flag from range query operator', () => {
+            const policyCategories = {};
+            const policyTags = {};
+            const currencyList = {};
+            const personalDetails = {};
+            const cardList = {};
+            const reports = {};
+            const taxRates = {};
+            const queryString = 'sortBy:date sortOrder:desc type:expense reportField-start-date~2025-03-01,2025-03-10';
+            const queryJSON = buildSearchQueryJSON(queryString);
+
+            if (!queryJSON) {
+                throw new Error('Failed to parse query string');
+            }
+
+            const result = buildFilterFormValuesFromQuery(queryJSON, policyCategories, policyTags, currencyList, personalDetails, cardList, reports, taxRates);
+
+            expect(result['reportFieldAfter-start-date']).toBeUndefined();
+            expect(result['reportFieldBefore-start-date']).toBeUndefined();
+            expect(result['reportFieldRange-start-date']).toBe('2025-03-01,2025-03-10');
+        });
+
+        test('does not set explicit report field range flag when only date boundaries are provided', () => {
+            const policyCategories = {};
+            const policyTags = {};
+            const currencyList = {};
+            const personalDetails = {};
+            const cardList = {};
+            const reports = {};
+            const taxRates = {};
+            const queryString = 'sortBy:date sortOrder:desc type:expense reportField-start-date>2025-03-01 reportField-start-date<2025-03-10';
+            const queryJSON = buildSearchQueryJSON(queryString);
+
+            if (!queryJSON) {
+                throw new Error('Failed to parse query string');
+            }
+
+            const result = buildFilterFormValuesFromQuery(queryJSON, policyCategories, policyTags, currencyList, personalDetails, cardList, reports, taxRates);
+
+            expect(result['reportFieldRange-start-date']).toBeUndefined();
+        });
+
         describe('view parameter', () => {
             const emptyParams = {
                 policyCategories: {},