Major

Ramp AI agents: API guide and governed finance automations

Understand Ramp AI agents, verify the API and custom Major connection, and design finance review workflows with durable state, scoped access, and controller approval.

Ritvij GautamUpdated
Major x Ramp logo lockup

Ramp AI agents handle finance tasks inside Ramp, including expense review, invoice coding, and policy checks. Major adds governed cross-system work: agents judge exceptions, while deterministic apps hold review queues, mappings, and the record of what happened.

This guide covers Ramp's native AI, its API, the custom connection to Major, and practical automations for controllers and finance operations leads.

What Ramp is and who relies on it

Ramp brings corporate cards, expense management, bill pay, procurement, and accounting automation into a finance operating environment. Its developer guides distinguish transactions, bills, reimbursements, vendors, and accounting metadata because each has a different lifecycle.

Controllers use those records to prepare accounting exports and investigate coding exceptions. Accounts payable teams manage invoices, approvals, and payment status. Employees submit expenses and receipts, while managers review spending against policy. Procurement owners need purchase requests and purchase orders to remain connected to downstream bills.

The difficult work often starts at a boundary: a transaction has a plausible category in Ramp, but the correct subsidiary, department, or project depends on information elsewhere. Major is the enterprise platform where agents build the software they run on. An agent can build a deterministic reconciliation app that validates identifiers and stores review state, then reserve its own judgment for ambiguous expense context.

That gives finance a durable control surface rather than another conversation to reconstruct during close. Ramp remains the source for its spend records; the Major app records the additional investigation and approval history.

Ramp AI agents and the native Intelligence layer

Ramp Intelligence is the vendor's AI layer across its products, not a single standalone assistant. Ramp describes agents that review expenses against company policy, escalate risky or ambiguous transactions, identify suspicious spending, and help employees answer policy questions.

Its accounting features extract and categorize invoice and expense information, apply coding learned from past invoices, and collect receipts or draft memos. Ramp also describes automated three-way matching between invoices, purchase orders, and item receipts. These capabilities are useful precisely because they operate close to the spend data and controls already in Ramp.

Start by identifying what Ramp already handles. Building a second invoice extraction process adds little if the native result meets your needs. Availability and behavior should be checked against your own Ramp configuration rather than assumed from a marketing page.

Major adds value when the decision needs evidence beyond Ramp: a contract in Google Drive, a finance-approved NetSuite mapping, or an unresolved discussion in Slack. The agent evaluates that combined context. The app stores its proposal, evidence, and reviewer outcome, and the workflow waits for approval before an accounting change. Native Ramp AI and a Major agent can therefore serve different stages of the same process without competing for ownership.

How Ramp connects to Major

Ramp has no native or Pipedream connector in the catalog: it connects as a custom API connector, with base URL and authentication configured once by IT. The catalog cross-check matters because an API being available does not mean Major lists a packaged connector.

Use the production base URL https://api.ramp.com, or https://demo-api.ramp.com for testing, as documented in Ramp's quickstart. IT registers the Ramp developer application, grants only the required permissions, and configures the custom connection. Credentials stay centrally in Major's connector vault, never in code or prompts.

Separate a read-only discovery connection from a narrowly scoped write capability where practical. A controller dashboard needs transaction and accounting reads; it does not need authority to pay vendors. The workflow should expose only the approved action to the execution step, not unrestricted API access to the agent.

Major orchestrates Ramp; it never replaces it. Ramp continues to manage spend and its configured financial controls. Major provides the deterministic app layer for cross-system state, agent judgment for exceptions, and workflow orchestration for retries and human approvals. SSO, RBAC, and audit logs cover every app, agent, and workflow.

Ramp API guide for builders

Authentication and permissions

Ramp uses OAuth 2.0. Its authorization guide documents client credentials for internal server-to-server integrations and authorization code grants for third-party access. Client credentials produce business-wide access limited by granted scopes, not an individual employee session. That flow has no refresh token; request another access token when it expires.

The endpoints below require transactions:read, accounting:read, accounting:write, or bills:read as indicated in the official OpenAPI specification. Begin with reads and add accounting writes only after review controls exist. Read the token response's expiry value rather than issuing a token for every request.

Pagination, quotas, events, and testing

Ramp uses keyset pagination. Follow the complete URL in page.next unchanged until it is null. Standard page_size defaults to 20 and has a maximum of 100 where supported; start is an opaque cursor. Verify each endpoint's pagination contract before applying that default.

The current rate-limit guide publishes 200 requests per 10 seconds per source IP, plus a production token-issuance limit of 100 requests per 10 seconds per source IP. A breach can block requests for 60 seconds. Honor Retry-After when present and coordinate workers sharing an outbound IP.

Webhooks include transaction-cleared, transaction-ready-for-review, bill-approved, and bill-paid events. Verify HMAC-SHA256 against the raw request bytes using X-Ramp-Signature and the subscription secret. Setup uses a separate verification challenge. Acknowledge durable receipt within 10 seconds; 429, server errors, and timeouts receive up to 10 total delivery attempts with exponential backoff and jitter. Other 3xx or 4xx responses do not trigger retries.

The sandbox has separate credentials and no real money movement. Its demo actions can create transactions and simulate paid bills or reimbursements. Test duplicate delivery and approval invalidation there before production.

POST /developer/v1/token

Exchanges application credentials or an authorized grant for a scoped access token.

  • App: Display connection health without exposing secrets.
  • Agent: Receive authorized business context through the connector, never the token itself.
  • Workflow: Reuse a valid token and renew it according to the configured grant.

GET /developer/v1/transactions

Lists card transactions with documented filters and ordering, requiring transactions:read.

  • App: Populate the close-review queue with stable Ramp transaction IDs.
  • Agent: Identify records needing deeper coding investigation.
  • Workflow: Paginate the initial import and reconcile later changes.

GET /developer/v1/transactions/{transaction_id}

Fetches one transaction, requiring transactions:read, so downstream work uses current source data.

  • App: Show the selected transaction beside its review history.
  • Agent: Reassess an exception using current transaction context.
  • Workflow: Fetch the object after an event and again before an approved write.

GET /developer/v1/accounting/accounts

Lists general ledger accounts, requiring accounting:read, including active-state and accounting-connection information.

  • App: Maintain a validated account-selection list.
  • Agent: Choose among real eligible accounts rather than inventing a category.
  • Workflow: Refresh metadata and reject proposals referencing inactive accounts.

GET /developer/v1/accounting/fields

Lists custom accounting fields, requiring accounting:read, to identify the dimensions configured in Ramp.

  • App: Store field identifiers separately from display labels.
  • Agent: Recognize which department or project dimension needs clarification.
  • Workflow: Detect schema drift before applying an existing mapping.

POST /developer/v1/accounting/codings

Writes accounting coding selections with accounting:write; the current schema supports card transactions, not every spend object.

  • App: Retain the exact approved field and option identifiers.
  • Agent: Propose selections with an evidence-based explanation.
  • Workflow: Write only the approved transaction version and record the outcome.

GET /developer/v1/bills

Lists bills with bills:read for an accounts payable queue or export investigation.

  • App: Track bill exceptions and reviewer ownership.
  • Agent: Prioritize records that need missing-context investigation.
  • Workflow: Reconcile the queue without interpreting creation-date filters as update filters.

GET /developer/v1/bills/{bill_id}

Retrieves an individual bill with bills:read for a current-state review.

  • App: Display the source bill alongside supporting evidence.
  • Agent: Explain a discrepancy between the bill and external documentation.
  • Workflow: Recheck approval and payment context before releasing a downstream task.

Ramp automation use cases on Major

Expense coding review across Ramp and NetSuite

This is grounded in the published finance use case, with a controller owning the accounting outcome.

  • App: Store Ramp transaction IDs, NetSuite mappings, evidence, and approval versions.
  • Agent: Propose the GL account and class when merchant context alone is ambiguous.
  • Workflow: Read transactions, accounts, and fields; request review; apply approved coding through the coding-write endpoint above.

Choose one accounting export owner. If Ramp's existing integration exports the transaction, Major should not also create a duplicate journal entry. A custom export is a separate implementation decision, not an automatic extension of a coding recommendation.

Bill discrepancy investigation with Google Drive and Slack

  • App: Maintain a bill-exception register linked to the relevant contract evidence.
  • Agent: Compare the bill context with an authorized contract and explain the discrepancy.
  • Workflow: Use the bill-list and bill-detail reads above, route an evidence packet to the owner, and record the response.

This design drafts an investigation, not a payment instruction. Missing documents remain visible blockers rather than reasons for the agent to guess terms.

Close-readiness briefs across Ramp, NetSuite, and Slack

  • App: Hold the outstanding transaction queue and last reconciled status for each record.
  • Agent: Explain which exceptions threaten close and distinguish a coding problem from an ownership problem.
  • Workflow: Use transaction-list and transaction-detail reads, combine approved ERP status, and deliver a scheduled brief.

Start with a read-only brief. Measure whether reviewers can act on its evidence before granting any write authority. These are distinct automation patterns, not claims that a packaged integration performs them without configuration.

Build the architecture on Major

Ramp and NetSuite connector data flows through a Major workflow and agent into a controller review app

Ramp evidence enters a workflow; the agent judges coding and the app holds review state.

Build a narrow process first, such as transaction coding exceptions for one legal entity. The agent can build the deterministic app once, then use it for repeatable imports, identifier validation, queue filtering, and audit retrieval. Those operations do not need fresh reasoning on every run.

  1. Connect: IT configures Ramp's custom API connection and the permitted NetSuite context.
  2. Persist: The app stores source IDs, entity, proposal version, evidence references, and reviewer status in managed database tables.
  3. Orchestrate: A workflow starts on a verified event or schedule, fetches current data, and validates required fields.
  4. Judge: The agent resolves ambiguous coding and explains uncertainty instead of manufacturing certainty.
  5. Review: The controller sees the proposal and evidence in the app. Approval applies to that version only.
  6. Execute: The workflow rechecks source state, performs the permitted action, and records the response.

Keep deterministic validation outside the judgment step. A valid account identifier does not prove the expense belongs there; that remains a finance judgment supported by the agent and reviewer.

A worked example with numbers

For example, consider an illustrative controller team reviewing 600 ambiguous card transactions each month. Assume each currently takes six minutes to gather context, choose a coding, and record the decision. That is 600 x 6 = 3,600 minutes, or 60 hours.

Suppose the Major review app presents the Ramp record, current account mappings, and an agent's explanation together. Assume 450 transactions now take two minutes each to review, while 150 difficult cases still take six minutes. Review time becomes 900 + 900 = 1,800 minutes, or 30 hours.

Add five hours for monitoring, correcting mappings, and reviewing failures. The illustrative total becomes 35 hours, compared with the original 60, a difference of 25 hours. This is planning arithmetic, not a customer result or a forecast of guaranteed savings.

The sequence matters more than the estimate: import the queue, validate the entity and accounts, ask the agent only where interpretation is needed, obtain approval, and hand off to the single export owner. Measure reviewer time, reversal rate, duplicate prevention, and unresolved backlog in a pilot before increasing volume or permissions.

Governance and failure handling

Ramp read-only refresh proceeds automatically while coding changes require controller approval in Major

Reads refresh the app automatically; consequential writes wait for an approved current proposal.

The agent must never independently release payments, change bank details, expand its permissions, or treat low confidence as approval. In this design, accounting changes and export actions require an authorized reviewer. Read-only imports and dashboard refreshes can proceed automatically within their granted scope.

Store reviewer identity, evidence references, proposal version, source version, execution time, and the external result. Invalidate approval if the transaction or proposed coding changes. SSO and RBAC should separate the people who investigate from those permitted to authorize financial changes.

Follow Ramp's delivery guidance: deduplicate by event ID, persist before acknowledgment, and expect out-of-order events. Fetch current state instead of assuming the last event received describes the newest state. Add scheduled reconciliation because webhook retries are finite.

For API throttling, honor Retry-After and back off with jitter under the documented quotas. After a timed-out write, inspect the source outcome before retrying. Escalate an uncertain result to a visible exception queue rather than risking duplicate accounting work. Limit retained sensitive data and log credential-free diagnostics.

Ramp AI Apps, Agents and Workflow Automations

This is the current core implementation guide for Ramp. Its focus is the expense-coding handoff, not the whole accounts payable lifecycle. Use it when the principal question is how to get a reviewable accounting recommendation from transaction context without losing the controller's approval record.

The hub covers the broader boundaries that guide that implementation: permission scope, event handling, source freshness, and ownership of the export. Read the detailed guide for that specific process rather than assuming a bill investigation follows the same steps or has the same write permissions.

For broader planning, the finance use-case collection helps identify adjacent processes and their owners. Keep the first pilot narrow: one exception class, one review queue, and one agreed export path. Expand only after the team can explain every recommendation, recover failed runs, and prove that an approval maps to the exact action executed.

Frequently asked questions

What are Ramp AI agents?

Ramp AI agents are native finance capabilities within Ramp's Intelligence layer. Ramp describes expense-policy review, invoice coding, receipt collection, and suspicious-spend detection. Agents on Major can add cross-system judgment while deterministic apps hold state and workflows coordinate approvals.

Does Major have a native Ramp connector?

No. The current catalog lists neither a native nor a Pipedream connector for Ramp. IT configures a custom API connector using Ramp's API base URL and scoped authentication, with credentials stored centrally in Major's vault.

Can an AI agent code Ramp expenses for NetSuite?

An agent can propose coding using transaction context and valid accounting metadata. In the design here, a controller approves the exact proposal before the workflow writes it. Choose one export owner so Ramp's existing integration and a custom integration do not post the same expense twice.

Which Ramp API scopes should a read-only review use?

The endpoints in this guide use transactions:read for card transactions, accounting:read for accounts and fields, and bills:read for bills. Accounting coding writes require accounting:write. Grant only the scopes the chosen process needs, as described in Ramp's authorization documentation.

Can Ramp automations be tested without moving real money?

Yes. Ramp documents a separate sandbox with its own API host and credentials. Demo actions can create transactions and simulate bill or reimbursement payment states without real money movement. Test approval gates and recovery paths there before enabling production writes.

How should duplicate or failed Ramp webhooks be handled?

Verify the signature, durably store the event under its unique ID, and acknowledge promptly. Treat duplicate IDs as already received, then process asynchronously. Fetch current source data for out-of-order events and reconcile periodically because Ramp's delivery retries are finite.

Sources

Start building on Major

Build a Ramp coding-review app with a durable queue, evidence-based agent recommendations, and controller approval before writes. Keep IT in control of credentials and permissions as the process grows.

About the author

Ritvij Gautam is Head of Growth at Major.

Last reviewed November 20, 2026 by Ritvij Gautam.

Frequently asked questions

What are Ramp AI agents?
Ramp AI agents are native finance capabilities within Ramp's Intelligence layer. Ramp describes expense-policy review, invoice coding, receipt collection, and suspicious-spend detection. Agents on Major can add cross-system judgment while deterministic apps hold state and workflows coordinate approvals.
Does Major have a native Ramp connector?
No. The current catalog lists neither a native nor a Pipedream connector for Ramp. IT configures a custom API connector using Ramp's API base URL and scoped authentication, with credentials stored centrally in Major's vault.
Can an AI agent code Ramp expenses for NetSuite?
An agent can propose coding using transaction context and valid accounting metadata. In the design here, a controller approves the exact proposal before the workflow writes it. Choose one export owner so Ramp's existing integration and a custom integration do not post the same expense twice.
Which Ramp API scopes should a read-only review use?
The endpoints in this guide use transactions:read for card transactions, accounting:read for accounts and fields, and bills:read for bills. Accounting coding writes require accounting:write. Grant only the scopes the chosen process needs, as described in Ramp's [authorization documentation](https://docs.ramp.com/llms-guides/authorization.txt).
Can Ramp automations be tested without moving real money?
Yes. Ramp documents a separate sandbox with its own API host and credentials. Demo actions can create transactions and simulate bill or reimbursement payment states without real money movement. Test approval gates and recovery paths there before enabling production writes.
How should duplicate or failed Ramp webhooks be handled?
Verify the signature, durably store the event under its unique ID, and acknowledge promptly. Treat duplicate IDs as already received, then process asynchronously. Fetch current source data for out-of-order events and reconcile periodically because Ramp's delivery retries are finite.