SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Ramp MCP with Claude Agent SDK

Connect Claude Agent SDK to Ramp MCP. Download last month's statement as pdf, list all transactions over $500 this week, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Ramp logoRamp
Oauth2

Ramp is a finance automation platform for tracking business expenses and income. It helps you manage spending and gain actionable insights into your company's finances.

186 Tools

Introduction

This guide walks you through connecting Ramp to the Claude Agent SDK using the Composio tool router. By the end, you'll have a working Ramp agent that can review card transactions, issue virtual and physical cards, create and update bills, track reimbursements, and adjust spending limits through natural language commands.

This guide will help you understand how to give your Claude Agent SDK agent real control over a Ramp account through Composio's Ramp MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Ramp with

Claude CodeClaude CoworkOpenAI Agents SDKCodexOpenClawHermesAtomic AgentGoogle ADKLangChainVercel AI SDKMastra AILlamaIndexCrewAIPydantic AIAutoGen

TL;DR

Here's what you'll learn:
  • Get and set up your Claude/Anthropic and Composio API keys
  • Install the necessary dependencies
  • Initialize Composio and create a Tool Router session for Ramp
  • Configure an AI agent that can use Ramp as a tool
  • Run a live chat session where you can ask the agent to perform Ramp operations

What is Claude Agent SDK?

The Claude Agent SDK is Anthropic's official framework for building AI agents powered by Claude. It provides a streamlined interface for creating agents with MCP tool support and conversation management.

Key features include:

  • Native MCP Support: Built-in support for Model Context Protocol servers
  • Permission Modes: Control tool execution permissions
  • Streaming Responses: Real-time response streaming for interactive applications
  • Context Manager: Clean async context management for sessions

What is the Ramp MCP server, and what's possible with it?

The Ramp MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Ramp account. It provides structured and secure access to your company's financial data, so your agent can fetch transactions, analyze card activity, generate statements, manage departments, and retrieve detailed expense information on your behalf.

  • Comprehensive transaction tracking: Instantly pull lists of all your business transactions or your own card activity, making it easy to monitor expenses and spot anomalies.
  • Card management and insights: Retrieve details about specific Ramp cards or see all cards assigned to you, including limits, status, and cardholder info for better financial oversight.
  • Automated statement generation: Ask your agent to generate and download account statements in multiple formats (PDF, CSV, JSON) for reporting or bookkeeping.
  • Department and organizational management: Create new departments or fetch detailed department profiles to help structure your expense tracking and categorize spending.
  • Detailed transaction analysis: Dive into specific transactions to get merchant information, receipts, dispute details, and accounting codes for audit and compliance purposes.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Composio API Key and Claude/Anthropic API Key
  • Primary know-how of Claude Agents SDK
  • A Ramp account
  • Some knowledge of Python
2

Getting API Keys for Claude/Anthropic and Composio

Claude/Anthropic API Key
  • Go to the Anthropic Console and create an API key. You'll need credits to use the models.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install dependencies

npm install @anthropic-ai/claude-agent-sdk @composio/core dotenv

Install the Composio SDK and the Claude Agents SDK.

What's happening:

  • @composio/core provides Composio integration for Anthropic
  • @anthropic-ai/claude-agent-sdk is the core agent framework
  • dotenv/config loads environment variables
4

Set up environment variables

bash
COMPOSIO_API_KEY=your_composio_api_key_here
USER_ID=your_user_id_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here

Create a .env file in your project root.

What's happening:

  • COMPOSIO_API_KEY authenticates with Composio
  • USER_ID identifies the user for session management
  • ANTHROPIC_API_KEY authenticates with Anthropic/Claude
5

Import dependencies

import 'dotenv/config';
import readline from 'node:readline';
import { Composio } from '@composio/core';
import { query, type Options } from "@anthropic-ai/claude-agent-sdk";

dotenv.config();
What's happening:
  • We're importing all necessary libraries including the Claude Agent SDK and Composio
  • The dotenv.config() function loads environment variables from your .env file
  • This setup prepares the foundation for connecting Claude with Ramp functionality
6

Create a Composio instance and Tool Router session

async function chat() {
  const { COMPOSIO_API_KEY, USER_ID } = process.env;
  if (!COMPOSIO_API_KEY || !USER_ID) {
    throw new Error('COMPOSIO_API_KEY and USER_ID required in .env');
  }

  const composio = new Composio({ apiKey: COMPOSIO_API_KEY });

  // Create Tool Router session for Ramp
  const session = await composio.create(USER_ID, {
    toolkits: ['ramp'],
  });
  const mcpUrl = session?.mcp.url;
What's happening:
  • The function checks for the required COMPOSIO_API_KEY environment variable
  • We're creating a Composio instance using our API key
  • The create method creates a Tool Router session for Ramp
  • The returned url is the MCP server URL that your agent will use
7

Configure Claude Agent with MCP

const options: Options = {
  permissionMode: 'bypassPermissions',
  mcpServers: {
    composio: {
      type: 'http',
      url: mcpUrl,
      headers: { 'x-api-key': COMPOSIO_API_KEY }
    }
  },
  systemPrompt: 'You are a helpful assistant with access to Ramp tools via Composio.',
  maxTurns: 10,
};
What's happening:
  • We're configuring the Claude Agent options with the MCP server URL
  • permissionMode: 'bypassPermissions' allows the agent to execute operations without asking for permission each time
  • The system prompt instructs the agent that it has access to Ramp
  • maxTurns: 10 limits the conversation length to prevent excessive API usage
8

Create client and start chat loop

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
  });

  console.log('\nChat started. Type "exit" to quit.\n');

  let isProcessing = false;

  async function ask(prompt: string) {
    isProcessing = true;
    rl.pause();

    process.stdout.write('Claude is thinking...');
    const stream = query({ prompt, options });

    let firstChunk = true;
    for await (const msg of stream) {
      const content = (msg as any).message?.content || (msg as any).content;
      if (Array.isArray(content)) {
        for (const block of content) {
          if (block.type === 'text' && block.text) {
            if (firstChunk) {
              process.stdout.write('\r\x1b[K');
              process.stdout.write('Claude: ');
              firstChunk = false;
            }
            process.stdout.write(block.text);
          }
        }
      }
    }
    process.stdout.write('\n\n');

    isProcessing = false;
    rl.resume();
    rl.prompt();
  }

  rl.on('line', async (line) => {
    if (isProcessing) return;

    const input = line.trim();
    if (input === 'exit') {
      rl.close();
      process.exit(0);
    }
    if (input) await ask(input);
    else rl.prompt();
  });

  await ask('What can you help me with?');
}
What's happening:
  • The readline interface is created to handle user input and output
  • The query function is used to send the user's input to the agent
  • The chat loop continues until the user types 'exit' or 'quit'
9

Run the application

try {
  await chat();
} catch (error) {
  console.error(error);
  process.exit(1);
}
What's happening:
  • The chat function is the entry point for the application
  • The try-catch block is used to handle any errors that occur

Complete Code

Here's the complete code to get you started with Ramp and Claude Agent SDK:

import 'dotenv/config';
import readline from 'node:readline';
import { Composio } from '@composio/core';
import { query, type Options } from "@anthropic-ai/claude-agent-sdk";

async function chat() {
  const { COMPOSIO_API_KEY, USER_ID } = process.env;
  if (!COMPOSIO_API_KEY || !USER_ID) {
    throw new Error('COMPOSIO_API_KEY and USER_ID required in .env');
  }

  const composio = new Composio({ apiKey: COMPOSIO_API_KEY });
  const session = await composio.create(USER_ID, {
    toolkits: ['ramp']
  });
  const mcp_url = session?.mcp.url;

  const options: Options = {
    permissionMode: 'bypassPermissions',
    mcpServers: {
      composio: {
        type: 'http',
        url: mcp_url,
        headers: { 'x-api-key': COMPOSIO_API_KEY }
      }
    },
    systemPrompt: 'You are a helpful assistant with access to Ramp tools via Composio.',
    maxTurns: 10,
  };

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
  });

  console.log('\nChat started. Type "exit" to quit.\n');

  let isProcessing = false;

  async function ask(prompt: string) {
    isProcessing = true;
    rl.pause();

    process.stdout.write('Claude is thinking...');
    const stream = query({ prompt, options });

    let firstChunk = true;
    for await (const msg of stream) {
      const content = (msg as any).message?.content || (msg as any).content;
      if (Array.isArray(content)) {
        for (const block of content) {
          if (block.type === 'text' && block.text) {
            if (firstChunk) {
              process.stdout.write('\r\x1b[K');
              process.stdout.write('Claude: ');
              firstChunk = false;
            }
            process.stdout.write(block.text);
          }
        }
      }
    }
    process.stdout.write('\n\n');

    isProcessing = false;
    rl.resume();
    rl.prompt();
  }

  rl.on('line', async (line) => {
    if (isProcessing) return;

    const input = line.trim();
    if (input === 'exit') {
      rl.close();
      process.exit(0);
    }
    if (input) await ask(input);
    else rl.prompt();
  });

  await ask('What can you help me with?');
}

try {
  await chat();
} catch (error) {
  console.error(error);
  process.exit(1);
}

Conclusion

You've successfully built a Claude Agent SDK agent that can interact with Ramp through Composio's Tool Router.

Key features:

  • Native MCP support through Claude's agent framework
  • Streaming responses for real-time interaction
  • Permission bypass for smooth automated workflows
You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent.
TOOLS

Supported Tools

Every Ramp action and event your agent gets out of the box.

Add Purchase Order Line Items

Add line items to an existing Ramp Plus purchase order.

Add Receipt Integration Opt Out Email

Add an email to a business's receipt integrations opt-out list.

Archive Bill

Archive a bill, cancelling inflight payments or terminating its one-time card where possible.

Archive Purchase Order

Archive a Ramp Plus purchase order.

Archive Vendor Bank Account

Archive a vendor bank account by vendor ID and bank account ID.

Create Accounting Field Option Filter Rules

Create accounting field option filter rules in bulk.

Create Bill

Create a Ramp bill.

Create Card Embed Token

Create an embed initialization token for an activated, currently active card.

Create Card Vault

Create a spend limit and virtual card synchronously, returning sensitive card details.

Create Department

Tool for creating a new department in your Ramp organization.

Create Draft Bill (Beta)

Beta: create a Ramp draft bill for a vendor without submitting it.

Create Draft Spend Request Via OCR

Create a draft spend request by extracting information from an uploaded document.

Create Inventory Item Accounting Field

Tool to create a new inventory item accounting field for tracking inventory categories.

Create Item Receipt

Create an item receipt for purchase order lines.

Create Location

Create a named location in the Ramp organization, optionally under a business entity.

Create Transaction Memo

Tool for uploading a new memo for a transaction in Ramp.

Create Mileage Reimbursement

Tool to create a mileage reimbursement in Ramp.

Create Mock Webhook Event

Create a mock webhook event for active subscriptions matching its event type.

Create New Custom Accounting Field

Tool for creating a new custom accounting field.

Create Procurement Request

Create a procurement request for a purchase-order or approval-only spend program.

Create Purchase Order

Create a purchase order.

Create Spend Program

Create a Ramp spend program with spending limits and optional issuance rules.

Create Tax Code Accounting Field

Tool to create a new tax code accounting field in Ramp.

Create User Invite

Tool to create a user invite for onboarding new employees to Ramp.

Create Vendor

Create an approved Ramp vendor, bypassing existing vendor approval policies.

Create Vendor Contact

Create a contact for an existing Ramp vendor.

Create Webhook Subscription

Tool to create a new webhook subscription for receiving event notifications from Ramp.

Deactivate User

Tool to deactivate a user in your Ramp organization.

Delete Accounting GL Account

Tool to delete a general ledger account from Ramp.

Delete Accounting Connection

Tool to disconnect the current active API-based accounting connection.

Delete Accounting Field Option Filter Rules

Bulk delete specific accounting field option filter rules (Ramp Plus required).

Delete Custom Accounting Field

Tool to delete a custom accounting field from Ramp.

Delete Accounting Inventory Item Option

Tool to delete an accounting inventory item option from Ramp.

Delete Tax Code Accounting Field

Tool to delete the tax code accounting field from Ramp.

Delete Accounting Tax Code Option

Tool to delete a tax code option from Ramp.

Delete Accounting Tax Rate

Tool to delete an accounting tax rate from Ramp.

Delete Accounting Vendor

Tool to delete an accounting vendor from Ramp.

Delete Custom Field Option

Tool to delete a custom accounting field option from Ramp.

Delete Inventory Item Field

Tool to delete the inventory item accounting field from Ramp.

Delete Item Receipt

Delete an item receipt by its ID.

Delete Procurement Request

Delete a procurement request by its unified request ID.

Delete Purchase Order Line Item

Delete one line item from an approved Ramp Plus purchase order.

Remove Users from Shared Limit

Tool to remove users from a shared spend limit in Ramp.

Delete Vendor

Delete a Ramp vendor by ID.

Delete Webhook Subscription

Delete a Ramp webhook subscription by ID.

Download Bill Remittance Receipt

Download the remittance receipt PDF for a Ramp bill.

Fetch General Ledger Account

Tool to fetch a specific general ledger account by ID from Ramp.

Fetch Accounting Vendor

Tool to fetch a specific accounting vendor by ID from Ramp.

Fetch Custom Accounting Field

Tool for fetching a custom accounting field.

List General Ledger Accounts

Tool to list general ledger accounts from Ramp.

Fetch All Accounting Connections

Tool to fetch all accounting connections for the current Ramp business.

Get Accounting Connection

Tool to fetch the current active accounting connection for a Ramp account.

Fetch Accounting Connection By ID

Tool to fetch a specific accounting connection by ID from Ramp.

List Custom Accounting Fields

Tool to list custom accounting fields for coding transactions.

Get Accounting Tax Code

Fetch the tax code accounting field for the current Ramp accounting connection.

List Accounting Vendors

Tool to list accounting vendors from Ramp.

Get All Transactions

List a page of Ramp transactions, with optional filters and sorting.

Get Bank Account

Get one connected Ramp bank account by UUID.

Get Banking Balance History

Get daily available balance history for one Ramp banking account.

Get Bill

Fetch one Ramp bill by ID, including its coding, line items, and payment.

Get Business

Fetch the connected Ramp company's information, including names, billing address and approved credit limit.

Get Business Balance

Fetch the current Ramp business's balances, available card and flex limits, overall spending limit, and billing dates.

Get Card

Tool for retrieving detailed information about a specific card.

Get Card Vault Resource

Tool to fetch a card's sensitive details from the vault.

Get Cashback

Fetch one Ramp cashback payment by ID, including its amount and sync status.

Get Custom Field Option

Tool to fetch a custom accounting field option by its ID.

Get Custom Form Collection Response

Fetch one custom form collection response by its response ID, including question labels, typed answers, comments, mappings and conditional workflows.

Get Department

Retrieve a specific Ramp department by ID, returning its ID and name.

Get Draft Bill (Beta)

Beta: retrieve one Ramp draft bill by its unique identifier.

Get Entity

Get one Ramp business entity by UUID, including accounts and locations.

Get Inventory Item Field

Tool to fetch inventory item accounting field for the current accounting connection.

Get Item Receipt

Fetch an item receipt by UUID, including its purchase order, line items and document URLs.

Get Location

Fetch one Ramp location by its UUID, returning its name and business entity ID.

Get Memo

Tool to fetch a transaction memo.

Get Procurement Request

Retrieve one unified procurement or spend request by its unified request ID, including ownership, amounts, status, approval history and memos.

Get Purchase Order

Fetch a Ramp Plus purchase order and its detailed line items.

Get Receipt

Fetch a Ramp receipt by UUID, returning a temporary image URL and optional structured OCR data.

Get Reimbursement Details

Retrieve details of a specific reimbursement, including amount, status, user information, accounting details, and receipts, for approval workflows or analysis.

Get Spend Limit

Tool to fetch detailed information about a specific spend limit.

Get Spend Program

Retrieve one Ramp spend program by ID, including restrictions and request forms.

Get Statement

Retrieve a statement in JSON or request PDF or CSV format.

Get Transaction Details

Tool for retrieving complete details of a specific transaction.

Get Transfer

Fetch one Ramp transfer payment by its transfer identifier.

Get Trip

Fetch an existing Ramp trip by UUID, including locations, spend events and totals.

Get User

Tool to retrieve detailed information about a specific Ramp user by their ID.

Get Users Deferred Status

Tool for fetching the status of a deferred user task.

Get Vendor Details

Tool for retrieving detailed information about a specific vendor.

Get Vendor Bank Account

Fetch one vendor bank account by its vendor ID and bank account ID.

Get Vendor Contact

Fetch one vendor contact by vendor ID and contact ID.

Get Webhook

Tool to retrieve detailed information about a specific webhook subscription by ID.

Hold Bill

Beta: place a Ramp bill on hold, blocking all payment rails and descheduling payments.

Hold Vendor

Block payments to a vendor by placing a vendor-scoped hold.

Issue Virtual Card

Request asynchronous issuance of a virtual card for a user, with optional spending limits and restrictions.

List Accounting Field Option Filter Rules

List rules determining which target accounting field options are available based on selected trigger field options.

List Accounting Inventory Item Options

Tool to list accounting inventory item options from Ramp.

List Accounting Tax Code Options

List one page of accounting tax code options, including external tax rate IDs and entity availability.

List Accounting Tax Rates

Tool to list tax rates from Ramp's accounting integration.

List Audit Log Events

List one page of Ramp audit log events (requires Ramp Plus).

List Bank Accounts

List connected Ramp bank accounts, one page at a time.

List Banking Accounts

List the business's Ramp checking, brokerage, and investment accounts.

List Bills

List Ramp bills using payment, status, accounting, date, and amount filters.

List All Cards

Tool for listing all cards across the organization with optional filters.

List Cashbacks

List one page of cashback payments, optionally filtered by entity, statement, dates, or accounting sync status.

List Child Vendors

List child vendors of a parent Ramp vendor.

List Departments

List Ramp departments with pagination, returning department IDs and names.

List Draft Bills (Beta)

Beta: list Ramp draft bills with filters and cursor pagination.

List Entities

List Ramp business entities, one page at a time.

List Item Receipts

List one page of item receipts, optionally filtered by entity or purchase order.

List Locations

List one page of Ramp locations, optionally filtered by business entity.

List Memos

Tool for listing memos associated with transactions in your Ramp organization.

List Merchants

List one page of Ramp merchants, optionally filtered by URL, name, or transaction dates.

List Procurement Request Attachments

List all non-deleted attachments on a unified procurement request, oldest first, including supporting documents and purchase order PDF attachments.

List Procurement Requests

List unified procurement and spend requests visible to the connected user, with filters and cursor pagination.

List Purchase Orders

List and filter Ramp Plus purchase orders using cursor pagination.

List Receipt Integration Opt Out Emails

List emails opted out of receipt integrations.

List Receipts

List one page of receipts filtered by creation dates, transaction dates or linked IDs.

List Reimbursements

List reimbursements with filtering options.

List Repayments

List one page of repayments, newest creation date first.

List Roles

List the business's custom roles and their product capabilities.

List Spend Programs

List Ramp spend programs and their spending restrictions, one page at a time.

List Spend Program Workflow Nodes

List External Approval Request nodes for one Ramp spend program.

List Statements

Tool for listing all statements with filtering options.

List Syncable Banking Transactions

List banking transactions available to sync to an accounting provider.

List Transfers

List one page of transfer payments filtered by status, entity, statement, dates, or accounting sync status.

List Trips

List one page of business trips filtered by travelers, status, dates, amount or name.

List Users

Tool for listing users in your Ramp organization with flexible filtering.

List Vendors

Tool for listing vendors with their spending information.

List Vendor Bank Accounts

Tool for listing bank accounts associated with a specific vendor.

List Vendor Contacts

Tool for listing contacts associated with a specific vendor.

List Vendor Credits

Tool to list all vendor credits for all vendors of a business.

List Webhooks

List webhook subscriptions for the organization, including endpoint URLs, event types, and status.

Mark Accounting Connection Ready to Migrate

Mark an inactive API accounting connection ready for the customer's ERP migration flow.

Mark Accounting Objects Ready to Sync

Mark Ramp transactions or reimbursements reviewed and ready for accounting sync.

Options for Custom Accounting Field

Tool for listing options for a given accounting field.

Update Accounting Connection

Tool to update an accounting connection's settings.

Update Card

Tool to update a card's properties including owner, display name, and spending restrictions.

Update Custom Field Option

Tool to update a custom accounting field option.

Update General Ledger Account

Tool to update a general ledger account in Ramp.

Update Inventory Item Field

Tool to update the inventory item accounting field for a Ramp connection.

Upload Accounting GL Accounts

Tool to batch upload general ledger accounts to Ramp.

Post Accounting Codings

Post accounting coding selections to an existing Ramp card transaction.

Create Accounting Connection

Tool to register a new API-based accounting connection between Ramp and an accounting provider.

Post Accounting Syncs

Report successful and failed ERP sync results for Ramp objects.

Upload Accounting Vendors

Tool to batch upload vendors to Ramp for coding transactions, bills, and purchase orders.

Upload Inventory Item Options

Tool to upload inventory item options for an active inventory item accounting field.

Create Physical Card

Tool to create a physical card asynchronously.

Reactivate Accounting Connection

Tool to reactivate a previously unlinked accounting connection by changing its status back to linked.

Reactivate User

Tool to reactivate a suspended user in your Ramp organization.

Release Bill Hold

Beta: release a Ramp bill hold so payments can be scheduled again.

Release Vendor

Release the active vendor-scoped hold to allow new payments to be scheduled.

Remove Receipt Integration Opt Out Email

Remove an email from the receipt integration opt-out list by its entry ID.

Resolve External Approval

Approve or reject a blank canvas external approval workflow step.

Submit Draft Bill (Beta)

Beta: submit a Ramp draft bill and return the resulting standard bill.

Submit Procurement Request

Submit a procurement draft for approval and return its request detail.

Submit Reimbursement Receipt

Tool to upload a receipt for a reimbursement.

Suspend Card

Tool to suspend a card by creating an async task that locks the card from use.

Terminate Card

Tool to permanently terminate a Ramp card.

Update Custom Accounting Field

Tool to update a custom accounting field.

Update Accounting Inventory Item Option

Update the name of an existing inventory item option in Ramp's accounting system.

Update Accounting Tax Code

Update the tax code accounting field's name and optionally its display name in Ramp's accounting system.

Update Accounting Tax Code Option

Tool to update a tax code option in Ramp.

Update Accounting Tax Rate

Tool to update an accounting tax rate in Ramp.

Update Accounting Vendor

Tool to update an accounting vendor in Ramp.

Update Bill

Update an approved Ramp bill.

Update Card Spending Limit

Retrieve a card's details, including its current spending restrictions, after querying limits for the card.

Update Custom Accounting Field Option

Update an existing custom accounting field option by ID.

Update Department

Tool for updating an existing department in your Ramp organization.

Update Draft Bill (Beta)

Beta: update only explicitly supplied fields on a Ramp draft bill.

Update External Approval Metadata

Update display metadata for a Ramp blank canvas external approval request.

Update Spending Limit

Update a Ramp spending limit, including its display name, spending restrictions, permitted spend types, or user assignment.

Update Location

Update a Ramp location's name and optionally its business entity.

Update Procurement Request

Edit an owned native draft or submitted Ramp Plus procurement request.

Update Purchase Order

Update an approved Ramp Plus purchase order; unapproved orders are rejected by Ramp.

Update Purchase Order Line Item

Update one line item on an approved Ramp Plus purchase order.

Update User

Tool to update an existing user in your Ramp organization.

Update Vendor

Update an existing Ramp vendor by UUID.

Update Vendor Bank Accounts

Add vendor payment details through Ramp's approval workflow.

Upload Bill Attachment

Upload an invoice or supporting file to an existing Ramp bill.

Upload Draft Bill Attachment

Upload an invoice or supporting file to an existing Ramp draft bill.

Upload External Approval Document

Upload a document for a blank canvas external approval workflow step.

Upload New Options for Custom Accounting Field

Tool for uploading new options for a given accounting field.

Upload Procurement Request Attachment

Upload a supporting document or purchase-order attachment to a procurement request.

Upload Receipt

Upload a receipt image or PDF for a Ramp user.

Upload Tax Code Options

Tool to upload tax code options to Ramp.

Upload Accounting Tax Rates

Tool to batch upload tax rates to Ramp.

Verify Webhook

Verify a pending webhook subscription using its delivered challenge.

FRAMEWORKS

How to build Ramp MCP Agent with another framework

Claude Code logo

Claude Code

Use Ramp MCP with Claude Code

Claude Cowork logo

Claude Cowork

Use Ramp MCP with Claude Cowork

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Ramp MCP with OpenAI Agents SDK

Codex logo

Codex

Use Ramp MCP with Codex

OpenClaw logo

OpenClaw

Use Ramp MCP with OpenClaw

Hermes logo

Hermes

Use Ramp MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Ramp MCP with Atomic Agent

Google ADK logo

Google ADK

Use Ramp MCP with Google ADK

LangChain logo

LangChain

Use Ramp MCP with LangChain

Vercel AI SDK logo

Vercel AI SDK

Use Ramp MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Ramp MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Ramp MCP with LlamaIndex

CrewAI logo

CrewAI

Use Ramp MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Ramp MCP with Pydantic AI

AutoGen logo

AutoGen

Use Ramp MCP with AutoGen

FAQ

Frequently asked questions

With a standalone Ramp MCP server, the agents and LLMs can only access a fixed set of Ramp tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Ramp and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. Claude Agent SDK fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Ramp tools.

Yes, absolutely. You can configure which Ramp scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Ramp data and credentials are handled as safely as possible.

Start with Ramp.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Ramp tool your agent needs.Free to start.

Start building