Distance & Mileage Tracking

New Expensify offers multiple methods for tracking distance-based expenses, from real-time GPS tracking to manual waypoint entry. Choose the method that works best for your travel reimbursement needs.

Distance Tracking Methods

New Expensify supports four different ways to track mileage:

GPS Tracking

Real-time tracking that automatically records your route as you drive

Manual Entry

Type in start and end locations with optional waypoints

Map Selection

Select waypoints on an interactive map

Odometer

Enter odometer readings with a photo

GPS Distance Tracking

Real-time GPS tracking provides the most accurate mileage tracking.

Starting GPS Tracking

Open New Expensify and tap the green + button
Select Submit expense or Track expense
Choose the Distance tab
Select GPS tracking
Grant location permissions when prompted
Tap Start trip to begin recording
Drive your route normally
Tap Stop trip when you arrive
Review and submit the expense

function IOURequestStepDistanceGPS({
    route: {
        params: {action, iouType, reportID, transactionID, backTo},
    },
    transaction,
}: IOURequestStepDistanceGPSProps) {
    const [isTracking, setIsTracking] = useState(false);
    const [distanceInMeters, setDistanceInMeters] = useState(0);
    const [waypoints, setWaypoints] = useState<GpsWaypoint[]>([]);

    const startTracking = useCallback(() => {
        setIsTracking(true);
        // Start watching position
        getCurrentPosition(
            (position) => {
                const newWaypoint = {
                    latitude: position.coords.latitude,
                    longitude: position.coords.longitude,
                    timestamp: Date.now(),
                };
                setWaypoints((prev) => [...prev, newWaypoint]);
            },
            (error) => {
                Log.error('GPS Error', error);
            },
            {enableHighAccuracy: true, distanceFilter: 10}
        );
    }, []);

    const stopTracking = useCallback(() => {
        setIsTracking(false);
        // Calculate total distance from waypoints
        const distance = calculateGPSDistance(waypoints);
        setDistanceInMeters(distance);
    }, [waypoints]);

    return (
        <DistanceCounter
            distance={distanceInMeters}
            isTracking={isTracking}
        />
    );
}

GPS Features

Real-time tracking:

Live distance counter
Current trip duration
Waypoint collection
Background location tracking (with permission)

Trip management:

Pause and resume tracking
Add manual waypoints
Edit route after completion
Save for later submission

GPS tracking requires location permissions. You’ll be prompted to grant access when starting your first trip.

Background Location Tracking

For uninterrupted tracking while using other apps:

function BackgroundLocationPermissionsFlow({
    onPermissionGranted,
    onPermissionDenied,
}: BackgroundLocationPermissionsFlowProps) {
    const requestBackgroundPermission = useCallback(async () => {
        const result = await request(PERMISSIONS.IOS.LOCATION_ALWAYS);
        
        if (result === RESULTS.GRANTED) {
            onPermissionGranted();
        } else {
            onPermissionDenied();
        }
    }, [onPermissionGranted, onPermissionDenied]);

    return (
        <LocationPermissionModal
            startPermissionFlow
            onGrant={requestBackgroundPermission}
            onDeny={onPermissionDenied}
        />
    );
}

Background permissions enable:

Tracking continues when app is minimized
Automatic waypoint collection
No need to keep app open
More accurate distance measurement

Background location tracking uses more battery. Some devices may restrict this feature.

GPS Accuracy

Factors affecting GPS accuracy:

Signal strength

Better GPS signal in open areas. Urban canyons and tunnels may reduce accuracy.

Device quality

Newer devices typically have better GPS receivers.

Weather conditions

Heavy clouds or storms can affect GPS signals.

Movement speed

Faster movement may reduce precision of waypoint collection.

Manual Distance Entry

Enter start and end locations manually for flexibility.

Adding Waypoints

Select Distance when creating an expense
Choose Manual entry
Enter your starting location
- Type an address or business name
- Select from recent locations
- Use current location
Enter your destination
Add intermediate stops (optional)
Review the calculated distance
Adjust if needed
Submit the expense

function IOURequestStepDistance({
    report,
    route: {
        params: {action, iouType, reportID, transactionID},
    },
    transaction,
}: IOURequestStepDistanceProps) {
    const [waypoints, setWaypoints] = useState<WaypointCollection>(
        transaction?.comment?.waypoints ?? {
            waypoint0: {keyForList: 'start_waypoint'},
            waypoint1: {keyForList: 'stop_waypoint'},
        }
    );

    const updateWaypoint = useCallback((index: number, waypoint: Waypoint) => {
        const key = `waypoint${index}`;
        setWaypoints((prev) => ({
            ...prev,
            [key]: waypoint,
        }));
        
        // Update transaction with new waypoints
        updateWaypointsUtil(transactionID, waypoints);
    }, [transactionID, waypoints]);

    const addWaypoint = useCallback(() => {
        const newIndex = Object.keys(waypoints).length;
        const newKey = `waypoint${newIndex}`;
        setWaypoints((prev) => ({
            ...prev,
            [newKey]: {keyForList: `waypoint_${newIndex}`},
        }));
    }, [waypoints]);

    return (
        <DraggableList
            data={Object.entries(waypoints)}
            renderItem={({item, index, drag}) => (
                <DistanceRequestRenderItem
                    waypoint={item[1]}
                    onPress={() => navigateToWaypointPage(index)}
                    onLongPress={drag}
                    onDeleteWaypoint={() => removeWaypoint(transactionID, index)}
                />
            )}
        />
    );
}

Waypoint Features

Location search:

Address autocomplete
Business name lookup
Recent locations list
Saved favorite locations

Waypoint management:

Reorder via drag and drop
Add unlimited stops
Delete unnecessary waypoints
Edit any waypoint

Distance calculation:

Automatic route calculation
Updates as waypoints change
Uses optimal routing
Shows total distance

Save frequently used locations (like your office or home) for quick access in future expenses.

Map-Based Distance Entry

Visually select waypoints on an interactive map.

Using the Map Interface

Select Distance expense type
Choose Map view
Tap on the map to add waypoints
Reorder waypoints by dragging markers
The route draws automatically between points
View distance in the bottom panel
Confirm and submit

Map features:

Zoom in/out for precision
Pan to different areas
Satellite or street view
Current location marker
Route visualization

The map uses your workspace’s preferred mapping service for accurate routing.

Odometer Distance Entry

Record odometer readings with photo verification.

Submitting Odometer Expenses

Select Distance expense type
Choose Odometer
Enter starting odometer reading
Take a photo of the odometer (optional but recommended)
Enter ending odometer reading
Take another photo of the ending odometer
Review the calculated distance
Submit the expense

function IOURequestStepDistanceOdometer({
    route: {params: {transactionID}},
    transaction,
}: IOURequestStepDistanceOdometerProps) {
    const [odometerStart, setOdometerStart] = useState(
        transaction?.comment?.odometerStart ?? 0
    );
    const [odometerEnd, setOdometerEnd] = useState(
        transaction?.comment?.odometerEnd ?? 0
    );
    const [odometerImages, setOdometerImages] = useState<{
        start?: string;
        end?: string;
    }>({});

    const distance = useMemo(
        () => Math.abs(odometerEnd - odometerStart),
        [odometerEnd, odometerStart]
    );

    const captureOdometerImage = useCallback((position: 'start' | 'end') => {
        // Open camera to capture odometer
        Navigation.navigate(
            ROUTES.MONEY_REQUEST_STEP_ODOMETER_IMAGE.getRoute(
                CONST.IOU.ACTION.CREATE,
                iouType,
                transactionID,
                reportID,
                position
            )
        );
    }, [transactionID, reportID, iouType]);

    return (
        <View>
            <TextInput
                label="Starting odometer"
                value={odometerStart.toString()}
                onChangeText={(value) => setOdometerStart(Number(value))}
                keyboardType="numeric"
            />
            <Button
                text="Capture start photo"
                onPress={() => captureOdometerImage('start')}
            />
            
            <TextInput
                label="Ending odometer"
                value={odometerEnd.toString()}
                onChangeText={(value) => setOdometerEnd(Number(value))}
                keyboardType="numeric"
            />
            <Button
                text="Capture end photo"
                onPress={() => captureOdometerImage('end')}
            />
            
            <Text>Distance: {distance} miles</Text>
        </View>
    );
}

Odometer benefits:

Verification for audit purposes
Exact mileage tracking
Photo proof of readings
Simple for company vehicles

Some policies require odometer photos for all distance expenses. Check your workspace requirements.

Distance Rates

Mileage rates vary by workspace and vehicle type.

Standard Mileage Rates

Typical rate structures:

IRS standard rate: Current US federal mileage rate
Custom rates: Organization-specific rates
International rates: Country-specific reimbursement
Vehicle type rates: Different rates for cars, motorcycles, etc.

function getDefaultMileageRate(policy: Policy | undefined): MileageRate | undefined {
    if (!policy?.customUnits) {
        return undefined;
    }

    const distanceUnit = Object.values(policy.customUnits).find(
        (unit) => unit.name === CONST.CUSTOM_UNITS.NAME_DISTANCE
    );

    if (!distanceUnit?.rates) {
        return undefined;
    }

    const rates = Object.values(distanceUnit.rates);
    return rates.find((rate) => rate.name === 'Default Rate') ?? rates[0];
}

Selecting a Rate

If multiple rates are available:

After entering distance, select Rate
Choose from available rates:
- Personal vehicle
- Company vehicle
- Motorcycle
- Custom rates
The amount updates automatically
Review and submit

The most recently used rate is selected by default for faster expense creation.

Rate Calculation

The expense amount is calculated as:

Amount = Distance × Rate

Example:

Distance: 50 miles
Rate: $0.67 per mile
Amount: $33.50

function getDistanceRequestAmount(
    distance: number,
    unit: Unit,
    rate: number
): number {
    // Convert distance to miles if needed
    const distanceInMiles = unit === CONST.CUSTOM_UNITS.DISTANCE_UNIT_MILES
        ? distance
        : convertKilometersToMiles(distance);

    // Calculate amount (rate is in cents)
    const amountInCents = Math.round(distanceInMiles * rate);
    
    return amountInCents;
}

Distance Units

Support for both imperial and metric:

Unit Conversion

Miles: Default for US
Kilometers: Default for most other countries
Automatic conversion based on policy settings
Display shows your preferred unit

Changing Units

Your workspace admin configures:

Default unit (miles or kilometers)
Rate per unit
Precision (decimal places)

Editing Distance Expenses

Modify Waypoints

Open the distance expense
Click any waypoint to edit
Change the location
Distance recalculates automatically
Save changes

Reorder Stops

Rearrange waypoints:

Long-press a waypoint
Drag to new position
Drop in place
Route and distance update

Add or Remove Waypoints

Add waypoints:

Click Add stop button
Enter the location
Waypoint inserts in route

Remove waypoints:

Swipe left on waypoint (mobile)
Click the delete icon (desktop)
Confirm removal

Keep at least two waypoints (start and end) for a valid distance expense.

Route Calculation

How New Expensify calculates distances:

Automatic Routing

const {shouldFetchRoute, validatedWaypoints} = useFetchRoute(
    transaction,
    waypoints,
    action,
    transactionState
);

useEffect(() => {
    if (!shouldFetchRoute || !validatedWaypoints) {
        return;
    }

    // Fetch route from mapping service
    const fetchRoute = async () => {
        try {
            const route = await mapboxAPI.getRoute(validatedWaypoints);
            const distanceInMeters = route.distance;
            
            // Update transaction with route data
            setMoneyRequestDistance(transactionID, distanceInMeters);
        } catch (error) {
            Log.error('Route fetch failed', error);
        }
    };

    fetchRoute();
}, [shouldFetchRoute, validatedWaypoints]);

Routing features:

Optimal path between waypoints
Real road network routing
Avoids impossible routes
Updates on waypoint changes
Handles one-way streets

Manual Distance Override

For special cases, manually adjust:

Click the distance value
Enter the correct distance
Add a note explaining the change
Save the expense

Manually entered distances may require additional approval or explanation depending on policy.

Distance Violations

Common distance expense issues:

Duplicate Route Detection

src/libs/Violations/ViolationsUtils.ts

function checkForDuplicateRoutes(
    transaction: Transaction,
    allTransactions: Transaction[]
): boolean {
    const routeString = getRouteString(transaction);
    
    return allTransactions.some((t) => {
        if (t.transactionID === transaction.transactionID) {
            return false;
        }
        return getRouteString(t) === routeString &&
               isSameDay(t.created, transaction.created);
    });
}

Duplicate violations occur when:

Same route on same day
Similar start/end locations
Identical distances

Resolution:

Verify the expense is legitimate
Add distinguishing details
Contact approver if needed

Missing Waypoints

Expenses need at least two waypoints:

Start location
End location

One-waypoint expenses cannot calculate distance and won’t be submittable.

Invalid Locations

Location errors may occur:

Not found: Location doesn’t exist
Ambiguous: Multiple matches found
Invalid: Null Island (0,0 coordinates)

Fix these by:

Using more specific addresses
Adding city and state
Selecting from autocomplete suggestions

Distance Reports

View and analyze your mileage:

Mileage Summary

See totals for:

Current month
Last month
Year-to-date
Custom date ranges

Export Distance Data

Download mileage logs:

CSV format
All distance expenses
Filtered by date range
Include route details

Best Practices

Choose the right method

Use GPS for accuracy, manual entry for quick logging, and odometer for company vehicles.

Track immediately

Don’t wait—record distance as soon as the trip completes.

Be specific with locations

Use full addresses instead of general areas for better route accuracy.

Review before submitting

Check that the calculated distance matches your actual travel.

Add trip purpose

Include notes about why you made the trip in the description field.

Troubleshooting

GPS Not Working

Check these items:

Location permissions enabled
GPS signal available
Device location services on
App has background permission (if needed)

Route Won’t Calculate

Possible causes:

Invalid waypoint location
No route between points
Network connectivity issue
Mapping service error

Try:

Verify waypoint addresses
Check internet connection
Use more specific locations
Try manual distance entry

Incorrect Distance

Common reasons:

Route includes highways when local roads taken
GPS drift or signal loss
Waypoints in wrong order
Map using airline distance

Solutions:

Manually adjust the distance
Add more waypoints for accuracy
Use odometer method for verification
Add explanation in notes

Next Steps

Create an Expense

Learn how to create and submit expenses

Per Diem Expenses

Manage daily allowance expenses

SmartScan

Automatically extract details from receipts

Split Expenses

Share costs with others

Expenses

Reports

Chat & Collaboration

Workspaces

Subscription

Search

​Distance Tracking Methods

GPS Tracking

Manual Entry

Map Selection

Odometer

​GPS Distance Tracking

​Starting GPS Tracking

​GPS Features

​Background Location Tracking

​GPS Accuracy

​Manual Distance Entry

​Adding Waypoints

​Waypoint Features

​Map-Based Distance Entry

​Using the Map Interface

​Odometer Distance Entry

​Submitting Odometer Expenses

​Distance Rates

​Standard Mileage Rates

​Selecting a Rate

​Rate Calculation

​Distance Units

​Unit Conversion

​Changing Units

​Editing Distance Expenses

​Modify Waypoints

​Reorder Stops

​Add or Remove Waypoints

​Route Calculation

​Automatic Routing

​Manual Distance Override

​Distance Violations

​Duplicate Route Detection

​Missing Waypoints

​Invalid Locations

​Distance Reports

​Mileage Summary

​Export Distance Data

​Best Practices

​Troubleshooting

​GPS Not Working

​Route Won’t Calculate

​Incorrect Distance

​Next Steps

Create an Expense

Per Diem Expenses

SmartScan

Split Expenses

Build docs developers (and LLMs) love

Distance Tracking Methods

GPS Distance Tracking

Starting GPS Tracking

GPS Features

Background Location Tracking

GPS Accuracy

Manual Distance Entry

Adding Waypoints

Waypoint Features

Map-Based Distance Entry

Using the Map Interface

Odometer Distance Entry

Submitting Odometer Expenses

Distance Rates

Standard Mileage Rates

Selecting a Rate

Rate Calculation

Distance Units

Unit Conversion

Changing Units

Editing Distance Expenses

Modify Waypoints

Reorder Stops

Add or Remove Waypoints

Route Calculation

Automatic Routing

Manual Distance Override

Distance Violations

Duplicate Route Detection

Missing Waypoints

Invalid Locations

Distance Reports

Mileage Summary

Export Distance Data

Best Practices

Troubleshooting

GPS Not Working

Route Won’t Calculate

Incorrect Distance

Next Steps