Unified Expense Management API

What Is a Unified Expense Management API?

A unified expense management API is a single, standardized programming interface that lets your product submit and manage employee expenses across multiple expense platforms without building a separate integration for each one.

Expense platforms each expose their own APIs with different submission fields, category taxonomies, and approval workflows. Knit normalizes these differences so your engineering team integrates once, and Knit handles the translation layer for every expense platform your customers use.

Knit normalizes three things across all providers:

How It Works

1. Your customer connects their expense platform
Knit's pre-built embedded auth UI handles OAuth and token management per provider. Your team writes zero auth code.

2. Knit normalizes the data
Expense submissions and categories are mapped to Knit's unified schema, regardless of how each platform stores or names them internally.

3. Your product calls one API
Use a single set of endpoints across your entire product. Add a new expense platform later? No code changes on your side.

4. Stay in sync with real-time webhooks
Native and virtual webhooks fire on expense and report status changes with a consistent event schema across all providers.

Expense Data Objects

The following objects are available through the unified schema. All fields are normalized across providers.

Expenses

Individual expense submissions with merchant, amount, category, and reimbursement detail.

creationDate, currency, merchant, amount, category, email,
isReimbursable, comment, isBillable, tag, userId, metaData

creationDate is YYYY-MM-DD. currency is a 3-letter ISO code. category must match a value from the Expense Categories list. userId is looked up via the Users endpoint.

→ Expense data model · Create an expense

Report & Expense Status

Approval-state management at two levels: the individual expense line item, and the report it rolls up into.

Report status:  reportId, reportStatus, metadata

The verified Update Report Status endpoint currently supports REIMBURSED as its reportStatus value. The docs index also lists a separate Update Expense Status endpoint for individual expense line items (approved, rejected, or submitted); confirm its exact field names with engineering before publishing use-case copy that depends on it; it wasn't independently returned by the live OpenAPI spec at the time this page was written.

→ Update report status · Update expense status

Expense Categories

The category taxonomy configured in the connected expense platform, used to classify each submission.

id, name, isEnabled

→ Get expense categories

Users

The people inside a connected expense platform, referenced by userId when submitting an expense on their behalf.

id, firstName, lastName, email

→ List users

API Reference

All expense management endpoints are organized by category. Each endpoint works identically regardless of the underlying platform. Pass your API key and the customer's X-Integration-Id, and the response schema is consistent across all providers.

Expense APIs

Status APIs

Category & User APIs

Supported Platforms

Knit connects to four expense management platforms today.

This list is narrower than some standalone expense API providers and does not currently include Ramp or SAP Concur, both of which have meaningful independent search demand. If your customers run one of those platforms, use the Connector Builder / Integration Agent to add it, or check with Knit on roadmap timing.

Key Capabilities

Real-Time Sync & Webhooks

Knit supports both native webhooks (forwarded directly from platforms that emit them) and virtual webhooks (Knit polls the source, detects changes, and emits events). Both use the same subscription interface and event schema, so your integration code is identical either way.

Supported event types include: record.new, record.modified, record.deleted, and more.

Zero Data Storage

Knit never stores your customers' expense data at rest. Every API request passes through to the source expense platform in real time. This reduces your GDPR, CCPA, and SOC 2 compliance scope, since there are no replicated expense records sitting in a third-party system.

Reimbursable & Billable Flags

The Expense object carries both isReimbursable and isBillable flags, normalized the same way across providers, so your product can distinguish employee reimbursements from client-billable spend without per-provider mapping logic.

AI Connector Builder / Integration Agent

When a customer's expense platform isn't in Knit's library, the AI Connector Builder lets your team define a new connector in hours. Specify the platform's API structure and data mapping; Knit's AI generates the connector.

Passthrough API

Need a field outside the unified APIs, like a Brex-specific card control or a Rydoo policy rule? Passthrough lets you make direct calls to the underlying expense platform using Knit's authentication layer.

MCP Compatibility

Knit is MCP-compatible, giving AI agents authenticated read/write access to expenses and categories across every connected platform through the same unified layer, with no per-provider auth or endpoint logic in your agent code.

Quick Start

Authentication

All requests require two headers:

Authorization: Bearer YOUR_API_KEY
X-Integration-Id: YOUR_CUSTOMER_INTEGRATION_ID

The X-Integration-Id is the unique identifier for a specific customer's connected expense platform, issued after they complete the Knit auth flow.

Get expense categories

curl --request GET \
     --url https://api.getknit.dev/v1.0/expense.categories \
     --header 'accept: application/json' \
     --header 'Authorization: Bearer YOUR_API_KEY' \
     --header 'X-Knit-Integration-Id: YOUR_CUSTOMER_INTEGRATION_ID'

Response: same schema whether the customer uses Expensify, Rydoo, Lucca Expense, or Brex:

{
  "success": true,
  "data": {
    "expenseCategories": [
      { "id": "e1ef30a7-7789-4d8e-3115-08ddd31cb2ce", "name": "Maintenance", "isEnabled": true },
      { "id": "e5819a5a-b2be-488b-3116-08ddd31cb2ce", "name": "Meals", "isEnabled": true },
      { "id": "cdd5d8fd-f933-41ce-3117-08ddd31cb2ce", "name": "Benefits", "isEnabled": true }
    ]
  }
}

Create an expense

curl --request POST \
     --url https://api.getknit.dev/v1.0/expense.create \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --header 'Authorization: Bearer YOUR_API_KEY' \
     --header 'X-Knit-Integration-Id: YOUR_CUSTOMER_INTEGRATION_ID' \
     --data '
{
  "creationDate": "2026-08-17",
  "currency": "USD",
  "merchant": "Uber",
  "amount": 42.50,
  "category": "Travel",
  "email": "[email protected]",
  "isReimbursable": true,
  "isBillable": false
}'

Response:

{
  "success": true,
  "data": {
    "id": "unique id of expense"
  }
}

Update report status

curl --request POST \
     --url https://api.getknit.dev/v1.0/expense.status.update \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --header 'Authorization: Bearer YOUR_API_KEY' \
     --header 'X-Knit-Integration-Id: YOUR_CUSTOMER_INTEGRATION_ID' \
     --data '
{
  "reportId": "your-report-id",
  "reportStatus": "REIMBURSED"
}'

Use Cases

Embedded Expense Capture

Let users submit expenses directly from your product, whichever expense platform their company runs on, without redirecting them to a separate app.

Typical flow: capture receipt and amount in your UI → look up category via categories endpoint → submit expense on the user's behalf via userId

Corporate Card & Spend Platforms

For fintech and spend-management products, sync expense submissions and reimbursement status between your platform and a customer's existing expense tool, avoiding duplicate data entry across two systems.

Typical flow: create expense on submission → poll or webhook on report status → update reimbursement state in your own ledger once REIMBURSED

Expense-to-Accounting Reconciliation

Combine the Unified Expense Management API with Knit's Unified Accounting API to reconcile submitted expenses against the chart of accounts and journal entries in a customer's accounting system.

Typical flow: fetch expenses by date range → match against accounting expense records via merchant and amount → flag discrepancies for review

Policy Compliance Tooling

Read expense categories and submission data to power a compliance layer that flags out-of-policy spend before it reaches an approver.

Typical flow: fetch expense categories → validate new submissions against configured category and amount rules → flag violations before report submission

AI Expense Assistants

Feed normalized expense data into LLM pipelines and MCP-compatible agents to build assistants that auto-categorize receipts or answer questions about spend history.

Typical flow: sync expenses and categories → embed into vector store → ground LLM categorization suggestions in the connected platform's real category list → submit via MCP write tools

FAQ

What is a unified expense management API?
A unified expense management API is a single, standardized interface that lets your product submit and manage employee expenses across multiple expense platforms without building a separate integration for each one. You integrate with Knit once; Knit normalizes the data models, authentication, and API differences between providers.

Which expense platforms does Knit support?
Expensify, Rydoo, Lucca Expense, and Brex today. This does not currently include Ramp or SAP Concur. If your customers run one of those platforms, check with Knit on roadmap or use the Connector Builder.

Can I approve or reimburse expenses through the API?
Yes, at the report level via the Update Report Status endpoint. Knit's docs index also references a separate endpoint for individual expense-line status; confirm its exact behavior with the Knit team before relying on it in production.

How long does it take to integrate?
Most teams go live in 1–3 days with Knit. Building a production-ready 1:1 native integration against a single platform like Brex typically takes several weeks. When you build with Knit, one integration gives you access to every connected expense platform, and Knit maintains all connectors as providers update their APIs.

Does Knit store expense data?
No. Knit is a pass-through layer: requests hit the source expense platform in real time and no data is stored at rest. This reduces your GDPR, CCPA, and SOC 2 compliance scope.

What if a customer's expense platform isn't on the list?
Using the Connector Builder, we can add a new connector in hours.

Is Knit compatible with AI agents and MCP?
Yes. Knit is MCP-compatible, so agents in MCP-compatible frameworks can perform authenticated expense read/write actions via Knit with no per-provider logic.

What's the passthrough API?
The passthrough API lets you make direct calls to the underlying expense platform using Knit's authentication layer. Use it for fields outside the unified schema.

Next Steps