Ramp MCP Server

Official Ramp MCP server. Query corporate spend, transactions, bills, reimbursements, and vendor data through the Ramp Developer API using natural language.

Payments by Ramp OAuth2 active

GitHub Docs

Overview

ramp-mcp is the official Model Context Protocol server published by Ramp (ramp-public org on GitHub) for retrieving and analyzing data from the Ramp Developer API. To work around LLM token and context limits when dealing with large financial datasets, the server implements a simple ETL pipeline backed by an ephemeral in-memory SQLite database. The agent loads Ramp data into the database, then issues SQL queries against it to answer questions about spending, vendors, reimbursements, and more.

The server exposes two classes of tools: data loaders (one per resource type, gated by OAuth scopes) and database operations (process_data, execute_query, clear_table) that let the model construct schemas and run analytical queries. It also offers a couple of direct fetch helpers for static reference data like categories and currencies. Authentication uses Ramp's OAuth2 client credentials flow, with the server defaulting to the Ramp demo environment unless RAMP_ENV=prd is set.

The project is officially maintained by Ramp under the MIT license. It is distributed as a Python package run via uv and is intended to be self-hosted locally alongside a desktop MCP client such as Claude Desktop.

Tools

Tool	Description
`process_data`	Set up the ephemeral in-memory SQLite database and ETL Ramp data into it for analysis.
`execute_query`	Run a SQL query against the in-memory database loaded with Ramp data.
`clear_table`	Remove data from a table in the in-memory database.
`get_ramp_categories`	Fetch the list of Ramp expense categories directly from the API.
`get_currencies`	Fetch supported currencies directly from the API.
`load_transactions`	Load card transactions into the database. Requires transactions:read scope.
`load_reimbursements`	Load reimbursements into the database. Requires reimbursements:read scope.
`load_bills`	Load bills into the database. Requires bills:read scope.
`load_locations`	Load locations into the database. Requires locations:read scope.
`load_departments`	Load departments into the database. Requires departments:read scope.
`load_bank_accounts`	Load Ramp bank accounts into the database. Requires bank_accounts:read scope.
`load_vendors`	Load vendors into the database. Requires vendors:read scope.
`load_vendor_bank_accounts`	Load vendor bank accounts. Requires vendor_bank_accounts:read scope.
`load_entities`	Load business entities. Requires entities:read scope.
`load_spend_limits`	Load spend limits. Requires spend_limits:read scope.
`load_spend_programs`	Load spend programs. Requires spend_programs:read scope.
`load_users`	Load Ramp users. Requires users:read scope.

Setup Guide

Prerequisites

A Ramp account with access to the Developer portal
A Ramp developer application with client credentials (RAMP_CLIENT_ID, RAMP_CLIENT_SECRET) and the desired OAuth scopes granted (for example transactions:read, bills:read, reimbursements:read)
The uv Python package manager installed locally
The repo cloned to disk: git clone https://github.com/ramp-public/ramp-mcp.git

Run the server

RAMP_CLIENT_ID=... RAMP_CLIENT_SECRET=... RAMP_ENV=<demo|qa|prd> \
  uv run ramp-mcp -s <SCOPES>

RAMP_ENV defaults to demo. Pass a comma-separated list of OAuth scopes to -s, matching the scopes granted to your developer client. Only tools whose scopes are enabled will be registered.

Claude Desktop config

Add to claude_desktop_config.json (on macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "ramp-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/<PATH>/ramp-mcp",
        "run",
        "ramp-mcp",
        "-s",
        "transactions:read,reimbursements:read"
      ],
      "env": {
        "RAMP_CLIENT_ID": "<CLIENT_ID>",
        "RAMP_CLIENT_SECRET": "<CLIENT_SECRET>",
        "RAMP_ENV": "demo"
      }
    }
  }
}

Replace /<PATH>/ramp-mcp with the absolute path to your local clone. Adjust the -s argument to include all scopes you want available to the agent.

Caveats from the README

Large datasets may not be processable due to API and MCP client limitations. The repo recommends loading data via the ETL tools and querying SQL rather than asking the model to enumerate raw records.

Use Cases

Run ad hoc finance analytics over corporate card transactions, for example summing spend by department, vendor, or category over a date range
Pull reimbursement and bill data into an in-memory database and ask Claude to flag outliers, duplicates, or policy violations
Investigate vendor spend concentration by joining vendors, transactions, and bills tables loaded by the server
Audit user, entity, and spend program configuration before a finance review or close
Build natural language dashboards over Ramp data from a desktop MCP client like Claude Desktop or Cursor

Example Prompts

"Load the last 90 days of transactions and show me top 10 vendors by total spend."
"Process bills and reimbursements, then list any reimbursements over $1,000 submitted in the last 30 days."
"What are our largest spend categories this quarter? Use the Ramp categories list."
"Load departments and transactions, then break down marketing spend by department for the year to date."
"Show all active spend limits and which users are assigned to each."

Pros

Officially published and maintained by Ramp under the ramp-public GitHub org
Clever ETL plus in-memory SQLite design avoids context window blowups when analyzing tens of thousands of rows
Broad coverage of Ramp resources: transactions, bills, reimbursements, vendors, users, departments, entities, spend limits, and spend programs
Defaults to the Ramp demo environment, which makes experimenting safe before pointing at production data

Limitations

Read-only data analysis surface; no tools for taking write actions like issuing cards or approving bills
Requires a local clone, uv, and manual OAuth client setup, so there is no hosted/remote endpoint to drop in
Per the README, large datasets may still hit API or MCP client limits and need to be paginated carefully

Alternatives

Mercury and Brex do not ship official MCP servers, but community implementations exist on GitHub
Plaid MCP for banking and transaction data across institutions
Stripe's official stripe-mcp for SaaS billing and payments analytics