There's a split inside the Navan corporate card program that catches a lot of engineering and finance teams off guard. Navan actually feeds the ERP three distinct record types: corporate card charges (split between native Navan cards and externally issued Navan Connect cards), manual transactions for out-of-pocket reimbursements, and reimbursement payments. Native Navan cards and Navan Connect cards both land in Navan Expense, but they don't carry the same fields, the same enrichment, or the same timing. Your sync logic has to know which record type it's handling before it starts posting anything to the ERP.
TLDR:
- Navan sends three record types to the ERP: card charges, manual reimbursements, and reimbursement payments, each needing its own posting logic
- Native cards arrive fully enriched, Navan Connect cards often don't
- Navan's expense API requires provisioning by Navan's team, and the initial sync covers only the last two months
- Card programs can be prefunded or credit-based, and Hotglue configures the right posting path customer by customer
- Expenses with a service period can post to a prepaid account and amortize across that period
- Hotglue's Navan connector syncs one way, Navan into the ERP, then writes a SYNCED status back to each Navan record once it posts
What the Navan Corporate Card Actually Is (and How It Fits Into Your Expense Stack)
Navan is a corporate travel and expense management product that combines travel booking, corporate cards, and expense automation in one place. It launched in 2015, rebranded from TripActions in 2023, and went public on the Nasdaq in 2025.
The card side of Navan splits into two distinct programs, and that split matters once you start thinking about ERP sync.
The first is Navan's natively issued corporate card, where travel booked through Navan is automatically matched and posted within the same system. The second is Navan Connect, a "bring your own card" program that links existing Visa, Mastercard, and Amex cards to Navan's expense workflows without requiring a full card migration.
For finance teams, both paths land transactions inside Navan Expense. For engineers building an ERP sync, they behave differently at the data layer.
Card Charges, Manual Reimbursements, and Reimbursement Payments
An ERP sync actually has to deal with three distinct record types coming out of Navan, not one generic "expense" blob. Treating them as interchangeable is a common source of broken reconciliation.
Card charges are a company liability from the moment the card is swiped. They clear once the card statement is paid, with no employee payable involved. Manual transactions, by contrast, cover out-of-pocket spend an employee submits for reimbursement, which creates a payable owed to that employee rather than a statement balance. Reimbursement payments are the payouts that settle those approved reimbursements and clear the payable off the books.
- Card charges: company liability, cleared when the card statement is paid
- Manual transactions/reimbursements: out-of-pocket spend creating a payable owed to the employee
- Reimbursement payments: payouts that settle approved reimbursements and clear the payable
Navan's own ERP integration docs back this up: Navan's QuickBooks integration settings treat card transactions, reimbursements, and repayments as separate sync types, each with its own record-type configuration. Each type posts to the GL differently, so one generic payload structure breaks reconciliation the moment real volume hits your pipeline.
Navan Native Cards vs. Navan Connect: Why the Distinction Matters for ERP Sync
When a Navan-issued card is swiped, the transaction flows directly into Navan Expense with full enrichment: merchant category, travel booking context, policy flags, and receipt matching all happen automatically within the same system. The card and the expense tool are the same product, so data completeness is high by default.
Navan Connect works differently. Instead of issuing a new card, it pulls transaction data from the underlying card network feed for existing Visa, Mastercard, or Amex cards.
The practical gap shows up at the field level. Network-sourced transactions typically carry fewer enriched attributes than natively issued ones. Fields like custom GL codes, project tags, or traveler policy metadata may be absent or populated later via manual employee input.
For ERP sync, this matters. If your pipeline assumes every transaction arrives with a complete set of coded attributes, Navan Connect records will break that assumption. You need logic that handles partially enriched records, holds transactions pending approval and coding, and avoids posting incomplete data into your GL. Getting that distinction wrong leads to duplicate entries or missing charges at month-end.
How Navan's Public Expense API Works
Navan's expense API uses machine-to-machine OAuth 2.0 via the client credentials grant. There's no browser login involved: you create a Client ID and Secret Key inside Navan, exchange them for an access token, and that token drives all subsequent requests. Tokens are time-limited, so your sync pipeline needs to handle refresh automatically.
One thing worth knowing before you start building: API access isn't on by default. Any customer who wants to use the Expense API must first request that the Navan team provision it for their account. Factor that into your implementation timeline, because finding out on go-live day is not a good time.
Once provisioned, the API exposes:
- Card and manual transactions
- Receipts and affidavits
- Custom field definitions and values
- GL coding attributes and sync status
- User and department data
One constraint matters for historical data: initial sync covers only two months. If your ERP implementation started mid-year, anything older than that window requires a manual export. Plan your data gap strategy before go-live, not after.
What Data Lives on a Navan Transaction Record
A Navan transaction record is not a flat row with just a merchant name and an amount. Depending on how the card was issued, you get a fairly rich set of fields to work with:
- Merchant name and category code
- Transaction amount and currency
- Cardholder identity and department
- Receipt attachment or missing-receipt affidavit
- Expense category, GL code, subsidiary, and cost center
- Custom fields (project tags, cost codes, etc.)
- Sync status indicating whether the record has been posted to an ERP
The caveat is field completeness. On a native Navan card, most of these fields arrive pre-populated because the card and the expense tool share the same data model. On a Navan Connect record sourced from a network feed, the core payment fields are reliable, but enriched attributes like project tags or cost codes often depend on the employee completing their expense report after the fact.
For ERP targets like NetSuite, Sage Intacct, or QuickBooks, that gap has real consequences. Journal entries and bill records typically require a GL account, a department, and sometimes a subsidiary before they can post. If those fields are blank, your sync either fails validation or posts to a default account that someone has to correct later. "Fix it in the GL" is nobody's favorite item on a Friday afternoon.
The Month-End Problem: Why Manual Navan-to-ERP Syncs Break Down
One survey found account reconciliation to be the top bottleneck slowing month-end close for finance teams, and corporate card charges compound that problem when no automated sync exists between Navan and the ERP.
The manual fallback most teams default to: export a CSV from Navan, clean up the columns, import into NetSuite or Intacct, match and fix mismatches by hand. It works until it doesn't. Late transaction feeds mean charges from the last few days of the month may not have cleared Navan's approval workflow before the books need to close. Employees who haven't submitted expense reports leave card charges sitting uncoded, with no GL account attached.
The deeper issue is that the export-import loop treats each month as a fresh manual process. There's no state. If a charge was partially coded but not fully approved, the next export might pull it again, creating a duplicate. If someone corrected a GL code after the last export, that correction doesn't propagate. Each cycle resets the same failure modes.
GL Coding and Attribute Mapping: The Core Sync Design Problem
Navan's expense attributes don't map cleanly to any ERP out of the box. The same conceptual field, like a cost center or business unit, gets modeled differently depending on which accounting system sits on the other end.
Take "department" as an example. In Navan, it's a flat attribute attached to the cardholder. In QuickBooks Online, the equivalent is a Class or Location. In Sage Intacct, it's a dimension with potential parent-child relationships. In NetSuite, you might deal with a Department, a Subsidiary, or both, depending on how the chart of accounts is structured. A naive one-to-one field map will either drop data silently or post to the wrong account.
Custom fields add more complexity. Navan supports company-defined fields like project codes that have no standard counterpart in most ERPs. You need transformation logic that reads those field definitions via the API, then routes values to the right ERP object: a custom segment in Intacct, a journal entry line field in NetSuite, or a tag in QuickBooks.
As a concrete example: a project_code custom field in Navan has no native target in Sage Intacct. Your transformation layer needs to first fetch the field definition from Navan's custom field endpoint to confirm the field key and value type, then map the value to a user-defined dimension in Intacct (typically a custom dimension like PROJECT that you've already configured on the GL entry object). The same charge arriving at NetSuite would instead write that value to a custom segment on the journal entry line, while in QuickBooks Online it would map to a tag or a custom field on the transaction. Each ERP stores the same underlying data in a structurally different location, so your routing logic needs an explicit per-target mapping table instead of a single generic passthrough.
The shape of the target record matters too. NetSuite and Sage Intacct want charges posted as journal entries with explicit debit and credit lines. QuickBooks Online accepts bank transactions with a simpler structure. Your transformation layer has to know which ERP it's writing to before constructing the payload.
Prefunded vs. Credit Card Programs: Picking the Right Posting Path
Navan customers run one of two card funding models, and your posting logic needs to know which one it's looking at. A prefunded program draws charges against a balance the company loaded ahead of time, so each charge reduces a prefunded or clearing asset account, not a liability. A credit program works the other way: charges accrue to a credit card liability account, and that balance gets cleared out once the statement is paid.
Post a prefunded charge like a credit transaction (or the reverse) and the account balances quietly drift away from what Navan actually shows, the kind of mismatch nobody notices until the books refuse to close.
- Prefunded: charge reduces a prefunded or clearing asset account
- Credit: charge accrues to a credit card liability, cleared on statement payment
Hotglue configures the posting path per customer, so each end customer's Navan program maps to the right accounts in their own ERP without a separate code path for every variation.
Closing the Loop: Writing SYNCED Status Back to Navan
Hotglue's Navan sync runs one way: data moves from Navan into your ERP. Hotglue does not push your chart of accounts, departments, or subsidiaries into Navan. Employees still code transactions against whatever values Navan already has, so your chart of accounts setup inside Navan itself is what determines what they see at submission time.
What does come back is a status update. Once a transaction posts to the ERP, Hotglue writes that outcome to the Navan record so the two systems stay in agreement about what has already been processed.
That write-back covers:
- Sync status set to SYNCED
- The ID of the ERP record that was created
- A link back to that ERP record
- Whether the record posted as a charge or a reimbursement
The payoff is simple. The transaction drops out of Navan's ready-to-export state, so nobody pulls it again by mistake. Finance can trace any expense straight to its ERP entry without hunting through two systems. And because the next sync run sees the SYNCED flag, it skips the record instead of posting it a second time, which is what keeps duplicates out of the GL in the first place.
Handling Externally Issued Cards: Edge Cases That Break Standard Sync Logic
Navan Connect introduces a different class of sync problem. The card isn't Navan's, the feed isn't real-time, and the enrichment isn't guaranteed.
Network-fed transactions from external Visa, Mastercard, or Amex cards typically arrive with a lag. The card network batches and settles on its own schedule, so a charge made on the 29th may not appear in Navan until the 31st or later. For teams running a sync on the last business day of the month, that lag is a real exposure.
The enrichment gap is the harder problem. A natively issued Navan card carries category codes, policy flags, and booking context from the moment the charge hits. A Connect transaction from a bank-issued card carries whatever the network sends: merchant name, amount, date, and not much else.
That creates a holding pattern. Your sync logic needs to know whether a Connect transaction is in a "pending coding" state or genuinely ready to post. Pushing an uncoded record into NetSuite or Sage Intacct doesn't fail loudly; it just posts to a default GL account that someone has to fix in a journal entry later.
The last edge case is the mixed environment. Many mid-market companies run Navan's native card for road warriors while keeping an existing Amex or Visa program for other departments. Both card types land in Navan Expense, but they don't behave the same way in your pipeline.
Native cards can post more aggressively once approved; Connect cards should wait for coding confirmation before anything hits the GL. If your sync doesn't distinguish between card source types, you apply the wrong rules to the wrong records.
ERP Targets: How Sync Architecture Differs Across Systems
Each ERP expects expense data in a different shape, and that difference starts at the record type level before you even get to field mapping.
| ERP | Preferred Record Type | Key Considerations |
|---|---|---|
| QuickBooks Online | Bank transaction or credit card charge | Simpler structure; Class/Location for department mapping |
| QuickBooks Desktop | Journal entry via Web Connector | Requires Windows agent; debit/credit lines explicit |
| NetSuite | Journal entry or expense report | Subsidiary required; multi-book environments add complexity |
| Sage Intacct | AP bill or journal entry | Dimension-based GL; parent-child department hierarchies |
| Microsoft Dynamics 365 | General journal or expense journal | Business unit and legal entity must match |
| Acumatica | AP document or GL journal | Flexible but requires branch and subaccount mapping |
QuickBooks Online is the most forgiving target, accepting bank transactions with a flat structure where department coding maps to Class or Location. QuickBooks Desktop adds friction because writes go through the Web Connector, which runs on a Windows machine and polls on a schedule instead of accepting a live API push.
NetSuite and Sage Intacct are stricter. Both require complete dimension sets before a record can post. Missing a subsidiary in NetSuite or a department dimension in Intacct fails validation outright, a familiar headache covered in our NetSuite subsidiary integration guide. Sage Intacct's parent-child dimension model also means a cost center that looks flat in Navan may need to resolve to a child dimension before the entry is valid, a common contributor to period-close data gaps.
Dynamics 365 and Acumatica introduce legal entity and branch requirements respectively. A charge tied to one legal entity cannot post against another, so your mapping layer needs cardholder-to-entity resolution logic before constructing the payload.
Service Periods and Amortization
Some Navan expenses cover a stretch of time rather than a single moment. An annual software subscription bought on a card, or a conference registration paid months ahead, are both charges that happened once but deliver value over a longer window. Posting the full amount in the month of purchase skews the P&L for that month and understates every month after it.
When an expense line carries a service period, Hotglue can post it to a prepaid account and recognize the cost across that service period instead, so the GL reflects when the value was actually consumed, and not merely when the card was charged.
The prepaid account and the service period logic are both set up per customer, so the mapping matches how each finance team already structures its chart of accounts.
Sync Frequency and Scheduling Considerations
Sync cadence is an accounting decision with real consequences at close, not purely an infrastructure question.
Daily batches work well for most of the month. A nightly pull captures approved, coded transactions and posts them to the ERP while volume is manageable. The problem appears at the edges: the last two or three days of the month, when pending charges haven't cleared and employees are racing to submit expense reports before the books close.
A few specific timing problems worth designing for:
- Pending charges that appear in Navan but haven't settled will show a different final amount after clearing. Posting the authorization amount creates a mismatch when the settled charge arrives.
- Refunds often arrive days after the original transaction. If the original posted in a prior sync run, the refund needs to match against it and not create a new record.
- Month-boundary transactions booked on the 31st but settled on the 1st can land in the wrong accounting period if your sync doesn't carry explicit transaction dates through to the ERP.
On-demand syncs help for ad-hoc close support, but they're not a substitute for a consistent scheduled cadence. Hotglue supports flexible cron-based scheduling configurable per connector, so you can run Navan hourly during close week and nightly the rest of the month without touching your pipeline architecture.
hotglue's Navan Connector: How Finance and Product Teams Use It in Practice
Hotglue ships a Navan connector that handles the full sync cycle from Navan into your ERP: card charges (both native and Connect), manual reimbursements, and reimbursement payments, along with receipts. It maps expense categories to GL accounts, supports prefunded or credit posting paths configured per customer, handles service period amortization, then writes a SYNCED status, ERP record ID, and link back to each Navan transaction once it posts. It's the kind of thing that makes your Head of Finance unreasonably happy at month-end.
For a CPO or Head of Partnerships at a B2B SaaS company, the ownership question is straightforward: your engineering team configures the pipeline once, your customers authenticate their own Navan accounts inside your product, and hotglue handles the OAuth token lifecycle, API rate limits, and field transformation between Navan and the target ERP. No dedicated integrations team required.
The infrastructure runs at scale. We process approximately 10 billion records weekly across active tenants, so month-end volume spikes run on infrastructure built for them.
Hotglue's connectors are also open-source. You can read the implementation, fork it, or extend it if your Navan setup has fields or edge cases the standard connector doesn't cover. No black box to debug when something goes wrong at close.