Splitting Expenses - New Expensify

Split expenses in New Expensify make it easy to divide costs among multiple people. Whether you’re splitting a group dinner, shared project costs, or team expenses, New Expensify handles the calculations and payment tracking.

What Are Split Expenses?

Split expenses allow you to:

Share costs with multiple people
Divide bills evenly or by custom amounts
Request payment from each participant
Track who paid and who owes
Settle up directly through the app

Split expenses work for both personal costs (dinner with friends) and work expenses (shared workspace costs).

Creating a Split Expense

Tap the green + button
Select Split expense
Choose the expense type:
- Manual: Enter amount manually
- Scan: Upload a receipt
- Distance: Split mileage costs
Enter or scan the expense details
Select participants
Choose split method (equal or custom)
Review and submit

function IOURequestStartPage({
    route: {
        params: {iouType, reportID},
    },
}: IOURequestStartPageProps) {
    const tabTitles = {
        [CONST.IOU.TYPE.SPLIT]: translate('iou.splitExpense'),
        [CONST.IOU.TYPE.SPLIT_EXPENSE]: translate('iou.splitExpense'),
    };

    const shouldUseTab = iouType !== CONST.IOU.TYPE.SEND && 
                         iouType !== CONST.IOU.TYPE.PAY && 
                         iouType !== CONST.IOU.TYPE.INVOICE;

    return (
        <ScreenWrapper>
            <HeaderWithBackButton
                title={tabTitles[iouType]}
                onBackButtonPress={navigateBack}
            />
            <OnyxTabNavigator>
                <TopTab.Screen name={CONST.TAB_REQUEST.MANUAL}>
                    {() => <IOURequestStepAmount />}
                </TopTab.Screen>
                <TopTab.Screen name={CONST.TAB_REQUEST.SCAN}>
                    {() => <IOURequestStepScan />}
                </TopTab.Screen>
                {iouType === CONST.IOU.TYPE.SPLIT && (
                    <TopTab.Screen name={CONST.TAB_REQUEST.DISTANCE}>
                        {() => <IOURequestStepDistance />}
                    </TopTab.Screen>
                )}
            </OnyxTabNavigator>
        </ScreenWrapper>
    );
}

Method 2: From a Group Chat

Open a group chat
Tap the attachment icon or + button
Select Split expense
All chat members are auto-selected as participants
Enter expense details
Submit to split among the group

Method 3: From an Existing Expense

Open any expense
Tap the three dots menu
Select Split expense
Choose participants
Adjust split amounts if needed
Submit

Converting an existing expense to split is useful when you realize you should share a cost after already creating it.

Selecting Participants

Choose who to split the expense with:

Adding Participants

function IOURequestStepParticipants({
    route: {
        params: {iouType, transactionID, reportID},
    },
    transaction,
}: IOURequestStepParticipantsProps) {
    const [participants, setParticipants] = useState<Participant[]>(
        transaction?.participants ?? []
    );

    const addParticipant = useCallback((participant: Participant) => {
        setParticipants((prev) => [...prev, participant]);
        setMoneyRequestParticipants(transactionID, [...participants, participant]);
    }, [participants, transactionID]);

    const removeParticipant = useCallback((accountID: number) => {
        const updated = participants.filter(
            (p) => p.accountID !== accountID
        );
        setParticipants(updated);
        setMoneyRequestParticipants(transactionID, updated);
    }, [participants, transactionID]);

    return (
        <MoneyRequestParticipantsSelector
            participants={participants}
            onAddParticipant={addParticipant}
            onRemoveParticipant={removeParticipant}
            iouType={iouType}
        />
    );
}

Ways to add participants:

Search by name - Type to find contacts
Recent contacts - Quick access to frequent contacts
Workspace members - Add from your workspace
Group chats - Select entire groups
Email/phone - Invite new users

Participant Requirements

Minimum: 2 participants (you + at least one other)
Maximum: No limit (but practical limit ~20-30)
Must have: Expensify account or valid email/phone

If someone doesn’t have an Expensify account, they’ll receive an invitation to join when you split the expense.

Split Methods

Choose how to divide the expense:

Equal Split (Default)

Divide the cost evenly among all participants:

Amount per person = Total amount ÷ Number of participants

Example:

Total: $100
Participants: 4 people
Each pays: $25

function splitBill({
    participants,
    currentUserAccountID,
    amount,
    comment,
    currency,
    merchant,
    created,
    splitShares = {},
}: SplitBillActionsParams) {
    // Calculate equal shares if not provided
    const shares = isEmptyObject(splitShares)
        ? calculateEqualSplitShares(participants, amount)
        : splitShares;

    const {splitData, splits, onyxData} = createSplitsAndOnyxData({
        participants,
        currentUserAccountID,
        transactionParams: {
            amount,
            comment,
            currency,
            merchant,
            created,
            splitShares: shares,
        },
    });

    API.write(WRITE_COMMANDS.SPLIT_BILL, splitData, onyxData);
}

function calculateEqualSplitShares(
    participants: Participant[],
    totalAmount: number
): SplitShares {
    const numberOfParticipants = participants.length;
    const amountPerPerson = Math.round(totalAmount / numberOfParticipants);
    
    const shares: SplitShares = {};
    participants.forEach((participant) => {
        shares[participant.accountID] = amountPerPerson;
    });
    
    // Adjust for rounding - give the difference to the first person
    const totalSplit = Object.values(shares).reduce((sum, amt) => sum + amt, 0);
    const difference = totalAmount - totalSplit;
    if (difference !== 0) {
        shares[participants[0].accountID] += difference;
    }
    
    return shares;
}

Custom Split

Manually assign amounts to each participant:

Select Custom split
Enter amount for each person
Ensure total equals expense amount
System validates the split adds up
Submit when balanced

Use cases for custom splits:

Someone had an expensive item
Unequal consumption (3 drinks vs 1 drink)
Percentage-based splits
One person doesn’t owe anything

function setSplitShares(
    transactionID: string,
    shares: SplitShares
): void {
    // Validate that shares equal the total amount
    const transaction = allTransactions[transactionID];
    const totalAmount = transaction?.amount ?? 0;
    const totalShares = Object.values(shares).reduce(
        (sum, amount) => sum + amount,
        0
    );

    if (totalShares !== totalAmount) {
        throw new Error(
            `Split shares (${totalShares}) must equal total amount (${totalAmount})`
        );
    }

    Onyx.merge(`${ONYXKEYS.COLLECTION.SPLIT_TRANSACTION_DRAFT}${transactionID}`, {
        splitShares: shares,
    });
}

Custom splits must add up exactly to the total expense amount. The system will show an error if they don’t match.

Percentage Split

Some workspaces support percentage-based splits:

Enter percentage for each person
System calculates dollar amounts
Useful for consistent split ratios
Percentages must total 100%

Split Expense Details

What You Can Split

All expense types support splitting: Manual expenses:

Meals and entertainment
Shared purchases
Group activities
Utilities or rent

Receipt-based:

Restaurant bills
Shared shopping
Event tickets
Travel bookings

Distance expenses:

Carpooling costs
Shared ride expenses
Group travel

When you split a receipt, each participant sees a copy of the receipt in their split detail.

Split Expense Fields

All split expenses include:

Amount: Total cost to split
Merchant: Where expense occurred
Date: When expense happened
Category: Expense type (if workspace expense)
Description: Purpose or notes
Currency: Transaction currency
Receipt: Attached if available

Viewing Split Expenses

Split Bill Details Page

See comprehensive split information:

function SplitBillDetailsPage({route, report, reportAction}: SplitBillDetailsPageProps) {
    const reportID = report?.reportID;
    const originalMessage = reportAction && isMoneyRequestAction(reportAction) 
        ? getOriginalMessage(reportAction) 
        : undefined;
    const IOUTransactionID = originalMessage?.IOUTransactionID;
    const participantAccountIDs = originalMessage?.participantAccountIDs ?? [];

    const [transaction] = useOnyx(
        `${ONYXKEYS.COLLECTION.TRANSACTION}${IOUTransactionID}`
    );
    const [draftTransaction] = useOnyx(
        `${ONYXKEYS.COLLECTION.SPLIT_TRANSACTION_DRAFT}${IOUTransactionID}`
    );

    const participants = participantAccountIDs.map((accountID) =>
        getParticipantsOption(
            {accountID, selected: true, reportID: ''},
            personalDetails
        )
    );

    const {
        amount: splitAmount,
        currency: splitCurrency,
        comment: splitComment,
        merchant: splitMerchant,
        created: splitCreated,
    } = getTransactionDetails(draftTransaction ?? transaction) ?? {};

    return (
        <ScreenWrapper>
            <HeaderWithBackButton title={translate('common.details')} />
            <MoneyRequestConfirmationList
                selectedParticipants={participants}
                iouAmount={splitAmount ?? 0}
                iouComment={splitComment}
                iouCurrencyCode={splitCurrency}
                iouCreated={splitCreated}
                merchant={splitMerchant}
                isSplitBill
                isReadOnly
            />
        </ScreenWrapper>
    );
}

Details shown:

Total expense amount
Amount per participant
Who created the split
All participants
Payment status for each person
Receipt or e-receipt
Expense metadata

Split Status Indicators

Track payment status:

Pending: Awaiting participant response
Viewed: Participant has seen the split
Paid: Participant has settled their share
Declined: Participant rejected the split

Editing Split Expenses

While Scanning

For receipt-based splits still being processed:

/**
 * Used for editing a split expense while it's still scanning or when SmartScan fails,
 * it completes a split expense started by startSplitBill above.
 */
function completeSplitBill(
    reportID: string,
    reportAction: ReportAction,
    draftTransaction: Transaction,
    sessionAccountID: number,
    isASAPSubmitBetaEnabled: boolean,
    quickAction: QuickAction,
    transactionViolations: TransactionViolations,
    betas: Beta[],
    sessionEmail?: string,
) {
    const currentUserEmailForIOUSplit = sessionEmail ?? CONST.EMAIL.FAKE_EMAIL_FOR_SPLIT_TRANSACTION;
    const {splitData, splits, onyxData} = createSplitsAndOnyxData({
        participants: draftTransaction.participants ?? [],
        currentUserLogin: currentUserEmailForIOUSplit,
        currentUserAccountID: sessionAccountID,
        existingSplitChatReportID: reportID,
        transactionParams: {
            amount: draftTransaction.amount,
            currency: draftTransaction.currency,
            comment: draftTransaction.comment?.comment ?? '',
            merchant: draftTransaction.merchant,
            created: draftTransaction.created,
            category: draftTransaction.category,
            tag: draftTransaction.tag,
            billable: draftTransaction.billable,
        },
    });

    API.write(WRITE_COMMANDS.COMPLETE_SPLIT_BILL, splitData, onyxData);
}

Open the split expense
Edit any field while SmartScan is processing
Changes save automatically
Complete the split when ready

After Submission

Once submitted, editing options depend on status: Before anyone pays:

Creator can edit details
Can adjust participants (add/remove)
Can change amounts
Can delete the split

After payments start:

Limited editing allowed
Can’t change amounts
Can’t remove paid participants
Contact participants directly for changes

Once someone has paid their share, you cannot modify their split amount.

Settling Split Expenses

Payment Options

Participants can pay their share via:

Expensify Wallet: Instant settlement
Bank transfer: Direct from bank account
Venmo: If connected
PayPal: If connected
Mark as paid: External payment confirmation

Requesting Payment

The split creator can:

Send reminders to unpaid participants
View payment status
Accept “paid outside app” confirmations
Cancel requests if needed

Payment Tracking

The system automatically tracks:

Who has paid
Outstanding balances
Payment methods used
Settlement dates
Running totals

Split expenses settle individually - each participant pays their share independently.

Workspace Split Expenses

Split expenses work differently in workspace contexts:

Workspace + Individuals

Split between a workspace and people:

One participant is the workspace
Other participants are individuals
Workspace portion submits as expense report
Individuals receive payment requests

// In case this is workspace split expense, we manually add the workspace 
// as the second participant of the split expense because we don't save any 
// accountID in the report action's originalMessage other than the payee's accountID
let participants: Array<Participant | OptionData>;
if (isPolicyExpenseChat(report)) {
    participants = [
        getParticipantsOption(
            {accountID: participantAccountIDs.at(0), selected: true, reportID: ''},
            personalDetails
        ),
        getPolicyExpenseReportOption(
            {...report, selected: true, reportID},
            currentUserPersonalDetails.accountID,
            personalDetails,
            report,
            chatReport,
            reportAttributesDerived
        ),
    ];
} else {
    participants = participantAccountIDs.map((accountID) =>
        getParticipantsOption(
            {accountID, selected: true, reportID: ''},
            personalDetails
        )
    );
}

Example scenario:

Team dinner costs $200
Workspace covers $100 (50%)
Two employees split remaining $100 ($ 50 each)
Workspace portion goes to expense report
Employees settle person-to-person

Team Expenses

For project or team costs:

Split among team members
All portions go to workspace
Tracked in expense reports
Approvers see full split details

Multi-Scan for Split Expenses

Capture multiple receipts for group expenses:

Enable Multi-Scan mode
Scan all receipts from the event
Review captured receipts
Select which to include in split
System sums amounts automatically
Choose participants
Submit the split

Multi-Scan is perfect for splitting multiple bills from a group outing or shared shopping trip.

Split Expense Notifications

Participants receive notifications:

For Splitters (Participants)

New split: “[Name] split $X with you”
Reminder: “You owe $X for [expense]”
Paid confirmation: “Your payment of $X was received”

For Creator

Payment received: “[Name] paid their $X share”
Declined: “[Name] declined the split”
All paid: “Everyone has paid their share”

Common Split Scenarios

Scenario 1: Restaurant Bill

Situation: Dinner with 5 friends, total $150

Take photo of receipt
SmartScan extracts $150
Select 5 friends as participants
Each owes $30 (equal split)
Submit
Friends pay via Expensify

Scenario 2: Unequal Split

Situation: 3 people, but one had expensive wine

Total bill: $180
Select custom split
Person A: $40 (had budget meal)
Person B: $50 (regular meal)
Person C: $90 (had expensive wine)
Total checks out at $180
Submit

Scenario 3: Workspace + Personal

Situation: Team lunch, company pays 60%

Total: $300
Add participants:
- Workspace ($180)
- You ($60)
- Teammate ($60)
Custom split assigns amounts
Workspace portion → expense report
Personal portions settle individually

Best Practices

Split at the time of expense

Create the split immediately while everyone is present to confirm amounts.

Use receipts when possible

Receipts provide proof and prevent disputes about amounts.

Be clear in descriptions

Add notes about what the expense was for to help participants remember.

Follow up on payments

Send friendly reminders to unpaid participants after a few days.

Keep it simple

Use equal splits when possible - custom splits can get complicated.

Troubleshooting

Split Won’t Submit

Common causes:

Participant list is empty
Custom split doesn’t balance
Missing required expense details
Network connectivity issue

Solutions:

Add at least one other participant
Verify custom amounts equal total
Fill in merchant and date
Check internet connection

Participant Can’t See Split

Possible reasons:

Invitation email went to spam
Wrong email/phone number used
They haven’t accepted invitation
Notification settings disabled

Try:

Resend the split notification
Verify contact information
Ask them to check spam folder
Have them enable notifications

Payment Not Showing

If someone paid but it’s not reflected:

Payment may still be processing
External payment wasn’t confirmed
They need to “mark as paid”
System sync delay

Resolution:

Wait a few minutes and refresh
Ask participant to confirm payment
Have them mark as paid in app
Contact support if persists

Can’t Edit Split

Editing may be locked because:

Someone already paid
Split was approved (workspace)
Time limit expired (policy setting)
You’re not the creator

Options:

Create a new split with correct details
Settle incorrect split and adjust
Contact participants directly
Ask admin to assist (workspace splits)

Advanced Features

Split Categories

For workspace splits:

Assign category to split expense
All participants inherit category
Useful for project tracking
Appears in workspace reports

Split Tags

Organize splits with tags:

Custom workspace tags
Apply to entire split
Filter and report by tags
Track shared project costs

Recurring Splits

For regular shared expenses:

Set up recurring split
Automatic creation on schedule
Same participants each time
Consistent amounts or variable

Recurring splits are useful for shared subscriptions, rent, utilities, or regular team expenses.

Split Expense Reports

View and analyze split expenses:

Personal Summary

Total amount split
Number of splits created
Outstanding balances
Payment history

Workspace Reports

Team split activity
Category breakdowns
Project cost sharing
Settlement tracking

Next Steps

Create an Expense

Learn how to create regular expenses

SmartScan

Scan receipts to split

Distance Tracking

Split mileage costs

Expense Overview

Return to expense management overview

Expenses

Reports

Chat & Collaboration

Workspaces

Subscription

Search

​What Are Split Expenses?

​Creating a Split Expense

​Method 1: From the Create Menu

​Method 2: From a Group Chat

​Method 3: From an Existing Expense

​Selecting Participants

​Adding Participants

​Participant Requirements

​Split Methods

​Equal Split (Default)

​Custom Split

​Percentage Split

​Split Expense Details

​What You Can Split

​Split Expense Fields

​Viewing Split Expenses

​Split Bill Details Page

​Split Status Indicators

​Editing Split Expenses

​While Scanning

​After Submission

​Settling Split Expenses

​Payment Options

​Requesting Payment

​Payment Tracking

​Workspace Split Expenses

​Workspace + Individuals

​Team Expenses

​Multi-Scan for Split Expenses

​Split Expense Notifications

​For Splitters (Participants)

​For Creator

​Common Split Scenarios

​Scenario 1: Restaurant Bill

​Scenario 2: Unequal Split

​Scenario 3: Workspace + Personal

​Best Practices

​Troubleshooting

​Split Won’t Submit

​Participant Can’t See Split

​Payment Not Showing

​Can’t Edit Split

​Advanced Features

​Split Categories

​Split Tags

​Recurring Splits

​Split Expense Reports

​Personal Summary

​Workspace Reports

​Next Steps

Create an Expense

SmartScan

Distance Tracking

Expense Overview

Build docs developers (and LLMs) love

What Are Split Expenses?

Creating a Split Expense

Method 1: From the Create Menu

Method 2: From a Group Chat

Method 3: From an Existing Expense

Selecting Participants

Adding Participants

Participant Requirements

Split Methods

Equal Split (Default)

Custom Split

Percentage Split

Split Expense Details

What You Can Split

Split Expense Fields

Viewing Split Expenses

Split Bill Details Page

Split Status Indicators

Editing Split Expenses

While Scanning

After Submission

Settling Split Expenses

Payment Options

Requesting Payment

Payment Tracking

Workspace Split Expenses

Workspace + Individuals

Team Expenses

Multi-Scan for Split Expenses

Split Expense Notifications

For Splitters (Participants)

For Creator

Common Split Scenarios

Scenario 1: Restaurant Bill

Scenario 2: Unequal Split

Scenario 3: Workspace + Personal

Best Practices

Troubleshooting

Split Won’t Submit

Participant Can’t See Split

Payment Not Showing

Can’t Edit Split

Advanced Features

Split Categories

Split Tags

Recurring Splits

Split Expense Reports

Personal Summary

Workspace Reports

Next Steps