Bolt.new AI and Expensify integration: Step-by-Step Guide 2025

To integrate Bolt.new with Expensify, you don’t “connect” Bolt itself — you build a small API-based integration inside a Bolt.new project. Expensify exposes a real, documented HTTPS API called the Expensify Integration Server. Your Bolt.new backend (Node/Express or similar) will call that API using a partner key and your Expensify account credentials. The flow is: store your Expensify credentials as environment variables in Bolt.new, create a backend route that signs requests in the format Expensify expects, and then call Expensify’s endpoints (such as creating expense reports or exporting transactions). Bolt.new acts only as the development environment; the actual integration happens through your own API code running inside it.

 

What Expensify Actually Provides

 

Expensify exposes an HTTPS API called the Integration Server API. It has no OAuth flow like Google; instead, it uses:

• partnerUserID – your Expensify login email
• partnerUserSecret – an API key generated inside Expensify
• requestJobDescription – a JSON payload describing the job (e.g., create report, export expenses)

The API endpoint is real and stable:

• https://integrations.expensify.com/Integration-Server/ExpensifyIntegrations

 

How you integrate this inside Bolt.new

 

You create a small backend (Node.js is simplest) in your Bolt.new workspace. Bolt.new will run this backend and let you test calls directly. The key is to store your Expensify credentials as environment variables so you never hardcode them in code.

• BOLT_ENV: PARTNER_USER\_ID = Your Expensify login email
• BOLT_ENV: PARTNER_USER\_SECRET = Your Expensify secret from Expensify settings

Then you write a backend route that takes your app’s input (e.g., a new expense), formats it in Expensify’s job format, and sends it over HTTPS.

 

Minimal working backend example (Node.js inside Bolt.new)

 

import express from "express"
import fetch from "node-fetch"

const app = express()
app.use(express.json())

app.post("/expensify/create-expense", async (req, res) => {
  try {
    const { amount, currency, merchant, created } = req.body // expecting data from your frontend

    const payload = {
      type: "create",
      credentials: {
        partnerUserID: process.env.PARTNER_USER_ID,        // stored in bolt env
        partnerUserSecret: process.env.PARTNER_USER_SECRET // stored in bolt env
      },
      inputSettings: {
        type: "expenses",
        expenses: [
          {
            amount: amount,         // Expensify uses integers in cents
            currency: currency,
            merchant: merchant,
            created: created        // ISO8601 timestamp
          }
        ]
      }
    }

    const response = await fetch(
      "https://integrations.expensify.com/Integration-Server/ExpensifyIntegrations",
      {
        method: "POST",
        headers: { "Content-Type": "application/x-www-form-urlencoded" },
        body: `requestJobDescription=${encodeURIComponent(JSON.stringify(payload))}`
      }
    )

    const result = await response.text() // Expensify returns text, not JSON
    res.send({ success: true, result })
  } catch (err) {
    res.status(500).send({ error: err.message })
  }
})

app.listen(3000, () => console.log("Bolt.new backend running on :3000"))

 

Why this works

 

Expensify requires a very specific POST format: application/x-www-form-urlencoded with a single field called requestJobDescription. Inside that field is a serialized JSON object. This is exactly how their real API works. Bolt.new will run this code unchanged.

Because Bolt.new sandboxes the project, your environment variables are safe in the dev context, and you can quickly iterate on the API calls without exposing secrets.

 

Testing the integration inside Bolt.new

 

• Launch backend panel → Start server.
• Use Bolt’s built-in HTTP client or a simple frontend button to POST to /expensify/create-expense.
• Verify Expensify responds with success (usually a job GUID and status).

 

Hardening for production (outside Bolt.new)

 

• Move environment variables to your real server (Vercel, AWS, Render, etc.).
• Enable HTTPS on your deployed API.
• Store Expensify secrets in secure environment management (Vault, AWS Secrets Manager, etc.).
• Validate inputs before passing them to Expensify.

 

Summary

 

Integrating Bolt.new with Expensify is simply building a standard REST API call inside a Bolt.new backend. Expensify only needs a partnerUserID, partnerUserSecret, and a correctly formatted requestJobDescription. Once you create a backend route that wraps this call, you can create expenses, reports, and exports directly from your full‑stack application built in Bolt.new.