Skip to content
Gauge

ax-check.com

by Gauge

Ramp

ramp.com

ax-check.com

Checked 19 September 2026

C

64/100

Agents need your login

Ramp's pricing is clear, but agent-facing docs are largely missing

Pricing tiers ($0 Free, $15/user Plus, custom Enterprise) are readable with no login. But no llms.txt, quickstart, API reference, or CLI docs were found for agents to act on.

2 fixes to start with

Concrete changes, backed by what we found.

Onboarding

Give agents a clear login handoff and a way to resume setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Docs

Add links to your product documentation and quickstart in /llms.txt.

/llms.txt returned HTTP 404, so no documentation index exists.

Recorded coding sessions

Same task, 3 models, no ramp.com account. Recorded 19 September 2026 on Pi.

3 recorded · 5m 10s

5m 10s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
Help me build a simple example using Ramp. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.
Thinking…

The user is asking to build a simple example using Ramp (Ramp Card API / Ramp for developers). Let me think about what "Ramp" is here: Ramp.com is a corporate card / expense platform. Is there a Ramp developer API? Ramp has a "Ramp Developer Platform" / Ramp API at api.ramp.com (https://ramp.dev). There's also the Ramp SDK for Python. But does this require a sandbox account? Ramp API authentication requires client_id/client_secret from the Ramp Dashboard, and a company account. The Ramp Developer Portal provides API keys and requires a Ramp account. There's a rate-limited "Demo" endpoint (https://api.ramp.com/developer/v1) that provides rate-limited access without authentication—actually, Ramp provides unauthenticated demo endpoints with strict rate limiting for developer use.

First let me check the repo—it might be empty. The instructions say: if blocked, let them know; if there's no actionable developer workflow, tell them that frankly and stop. Stay lightweight, use hosted products via SDK/API, don't use local stacks.

Should I verify whether there's network access? Let me check the repo and try network calls.

Plan: explore the cwd, check whether network access works (curl to the Ramp developer docs), then build a small example using Ramp's demo endpoint (unauthenticated, rate-limited) or the Python SDK (ramp-sdk?). Let me verify.

Ramp Developer Portal: https://ramp.dev. API base is https://api.ramp.com/developer/v1. Without authentication, endpoints like GET /v1/businesses, /v1/cards—there was a "Demo mode" with rate limiting (10 requests per minute?). Let me actually verify.

Let me execute commands.

$ pwd && ls -la && git log --oneline -5 2>/dev/null | head{"content":[{"text":"/sandbox/repo\ntotal 16\ndrwxr-xr-x 3 root root 4096 Sep 18 08:00 .\ndrwxr-xr-x 7 root root 4096 Sep 19 07:41 ..\ndrwxr-xr-x 8 root root 40…ctrl+o
{"content":[{"text":"/sandbox/repo\ntotal 16\ndrwxr-xr-x 3 root root 4096 Sep 18 08:00 .\ndrwxr-xr-x 7 root root 4096 Sep 19 07:41 ..\ndrwxr-xr-x 8 root root 4096 Sep 18 08:00 .git\n-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore\n9ebf5fb Initial workspace\n","type":"text"}]}
$ curl -sS -m 15 -o /dev/null -w "%{http_code}\n" https://api.ramp.com/developer/v1/businesses 2>&1; echo "---"; curl -sS -m 15 https://ramp.dev 2>&1 | head -c 500{"content":[{"text":"404\n---\n<!DOCTYPE html><html><head><script>window.onload=function(){window.location.href=\"/lander\"}</script></head></html>","type":"tex…ctrl+o
{"content":[{"text":"404\n---\n<!DOCTYPE html><html><head><script>window.onload=function(){window.location.href=\"/lander\"}</script></head></html>","type":"text"}]}
Thinking…

The network is working. Ramp's developer API: the correct path might be /developer/v1/... Let me check the docs at ramp.dev. The 404 might just be a wrong path. According to Ramp's docs: the base URL is https://api.ramp.com/developer/v1, and the endpoints are shaped like /v1/businesses? Actually, the docs say base: https://api.ramp.com/developer and the path is /v1/businesses. Let me fetch the docs and confirm.

Network access works. Let me check Ramp's developer docs for the correct API surface.

$ curl -sSL -m 20 "https://ramp.dev/developer" -o /tmp/ramp_dev.html -w "%{http_code}\n"; curl -sSL -m 20 "https://api.ramp.com/developer/v1/businesses" | head -c 600; echo; curl -sSL -m 20 "https://api…{"content":[{"text":"200\n<!doctype html>\n<html lang=en>\n<title>404 Not Found</title>\n<h1>Not Found</h1>\n<p>The requested URL was not found on the server. I…ctrl+o
curl -sSL -m 20 "https://ramp.dev/developer" -o /tmp/ramp_dev.html -w "%{http_code}\n"; curl -sSL -m 20 "https://api.ramp.com/developer/v1/businesses" | head -c 600; echo; curl -sSL -m 20 "https://api.ramp.com/developer/v1/cards" | head -c 600

{"content":[{"text":"200\n<!doctype html>\n<html lang=en>\n<title>404 Not Found</title>\n<h1>Not Found</h1>\n<p>The requested URL was not found on the server. If you entered the URL manually please check your spelling and try again.</p>\n\n{\"error_v2\":{\"additional_info\":{},\"message\":\"Access token with given access_token not found\",\"notes\":\"\",\"error_id\":\"dcc521f8\",\"error_code\":\"DEVELOPER_7002\"},\"error\":{\"message\":\"Access token with given access_token not found\",\"details\":{}}}\n","type":"text"}]}
Thinking…

In other words, /developer/v1/cards requires an access token. Ramp Developer Portal: https://ramp.dev/developer provides docs. Are there "demo" endpoints without auth? Previously Ramp offered rate-limited demo endpoints without auth at api.ramp.com/developer/v1/... . The error says access token not found, so auth (OAuth client credentials from the Ramp Dashboard) is required. That means a Ramp company account is needed.

Let me check the docs page content to confirm the auth method, whether there's a sandbox or demo mode.

$ python3 - <<'EOF'{"content":[{"text":" \n","type":"text"}]}ctrl+o
python3 - <<'EOF'
import re,html
s=open('/tmp/ramp_dev.html').read()
t=re.sub(r'<script.*?</script>','',s,flags=re.S)
t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=re.sub(r'<[^>]+>',' ',t)
t=html.unescape(re.sub(r'\s+',' ',t))
print(t[:3000])
EOF
Thinking…

It's empty — this page is probably rendered with JS. Let me try fetching docs from ramp.dev/docs or the API reference. There's also https://ramp.dev/docs/api . I'll give it a try.

$ for u in "https://ramp.dev/docs" "https://ramp.dev/docs/getting-started" "https://ramp.dev/docs/api" "https://ramp.dev/reference"; do echo "== $u"; curl -sSL -m 15 -o /tmp/p.html -w "%{http_code} %{si…{"content":[{"text":"== https://ramp.dev/docs\n200 114\n \n== https://ramp.dev/docs/getting-started\n200 114\n \n== https://ramp.dev/docs/api\n200 114\n \n== ht…ctrl+o
for u in "https://ramp.dev/docs" "https://ramp.dev/docs/getting-started" "https://ramp.dev/docs/api" "https://ramp.dev/reference"; do echo "== $u"; curl -sSL -m 15 -o /tmp/p.html -w "%{http_code} %{size_download}\n" "$u"; python3 -c "
import re,html
s=open('/tmp/p.html').read()
t=re.sub(r'<script.*?</script>','',s,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(re.sub(r'\s+',' ',t)); print(t[:800])
"; done

{"content":[{"text":"== https://ramp.dev/docs\n200 114\n \n== https://ramp.dev/docs/getting-started\n200 114\n \n== https://ramp.dev/docs/api\n200 114\n \n== https://ramp.dev/reference\n200 114\n \n","type":"text"}]}
Thinking…

All pages return 114 bytes (JS shell). Let's check for JSON or sitemap.xml, or use the OpenAPI spec. Ramp publishes an OpenAPI spec — is it at https://api.ramp.com/developer/v1/openapi, or on GitHub? Let's look for the sitemap.

$ curl -sSL -m 15 "https://ramp.dev/sitemap.xml" | grep -oE '<loc>[^<]+' | sed 's/<loc>//' | grep -iE 'dev|api|reference|quickstart|start' | head -40; echo ---; curl -sSL -m 15 "https://ramp.dev/sitemap…{"content":[{"text":"https://ramp.dev/lander\n---\n1\n","type":"text"}]}ctrl+o
curl -sSL -m 15 "https://ramp.dev/sitemap.xml" | grep -oE '<loc>[^<]+' | sed 's/<loc>//' | grep -iE 'dev|api|reference|quickstart|start' | head -40; echo ---; curl -sSL -m 15 "https://ramp.dev/sitemap.xml" | grep -oE '<loc>[^<]+' | sed 's/<loc>//' | wc -l
Thinking…

Not helpful. I'll try the OpenAPI spec endpoint or known documentation URLs: docs.ramp.com? Ramp's developer documentation used to be at https://ramp.dev/developer — but the content I fetched was empty. I'll try "https://api.ramp.com/openapi" or search GitHub for the Ramp SDK: https://github.com/RampHQ? Let me quickly check GitHub.

$ curl -sSL -m 20 "https://ramp.dev/developer" | head -c 2000; echo; echo ---; curl -sS -m 20 "https://api.github.com/search/repositories?q=org:RampHQ" | python3 -c "import json,sys; d=json.load(sys.std…{"content":[{"text":"<!DOCTYPE html><html><head><script>window.onload=function(){window.location.href=\"/lander\"}</script></head></html>\n---\n","type":"text"}…ctrl+o
curl -sSL -m 20 "https://ramp.dev/developer" | head -c 2000; echo; echo ---; curl -sS -m 20 "https://api.github.com/search/repositories?q=org:RampHQ" | python3 -c "import json,sys; d=json.load(sys.stdin); [print(r['full_name'], r.get('description')) for r in d.get('items',[])[:20]]" 2>&1

{"content":[{"text":"<!DOCTYPE html><html><head><script>window.onload=function(){window.location.href=\"/lander\"}</script></head></html>\n---\n","type":"text"}]}
Thinking…

The GitHub search returned nothing (probably rate-limited or blocked). Let me check the full response from the GitHub API.

Also, let me try Ramp's documentation at the docs.ramp.com and developers.ramp.com domains. Furthermore, Ramp publishes the OpenAPI spec at https://api.ramp.com/developer/v1/..., and previously there were rate-limited demo endpoints that didn't require authentication: e.g., https://api.ramp.com/developer/v1/demo/businesses? Not sure. Let me check a few paths: /developer/v1/businesses returned a 404 HTML; /developer/v1/cards requires a token. The actual docs: Base URL https://api.ramp.com/developer/v1, endpoints are /businesses, /cards, /card_programs, /departments, /employees, /locations, /merchants, /receipts, /transactions, /user_roles, /users. But /developer/v1/businesses returned Flask's 404... maybe it requires GET with a token, and returns 404 without a token? Hmm, cards returned an auth error. Maybe businesses is a different path like /developer/v1/business. Let me try a few.

Also authentication: OAuth2 client credentials — API credentials are created in Ramp Dashboard → Developers → API. Requires a Ramp account (corporate card customer). No public sandbox. Therefore building a "simple example" would require credentials I don't have. But the instructions say: if blocked, say so. If there's no actionable developer workflow, state that clearly and stop.

Still, what I can do is:

  1. Check whether there's a demo/unauthenticated mode.
  2. Write a sample script using the Ramp API (OAuth client credentials flow), which the user could run with their own credentials.

That seems reasonable: build an example using the hosted API via an SDK/API, but I can't run it without credentials. Instructions: "If blocked, let me know." I can build the example code and state that running it requires Ramp Dashboard credentials (no public sandbox), so the live API cannot be verified.

Let me also quickly check paths and whether there's an official Python SDK. Ramp does not publish an official SDK; there are community ones (ramp-api?). The OpenAPI spec is at https://api.ramp.com/developer/v1/openapi.yaml? Let me try it.

$ for p in businesses business cards employees merchants transactions openapi openapi.yaml docs; do printf "%-15s " "$p"; curl -sS -m 12 -o /tmp/o -w "%{http_code} %{content_type}\n" "https://api.ramp.c…{"content":[{"text":"businesses 404 text/html; charset=utf-8\n<!doctype html>\n<html lang=en>\n<title>404 Not Found</title>\n<h1>Not Found</h1>\n<p>The req…ctrl+o
for p in businesses business cards employees merchants transactions openapi openapi.yaml docs; do printf "%-15s " "$p"; curl -sS -m 12 -o /tmp/o -w "%{http_code} %{content_type}\n" "https://api.ramp.com/developer/v1/$p"; head -c 200 /tmp/o; echo; done

{"content":[{"text":"businesses      404 text/html; charset=utf-8\n<!doctype html>\n<html lang=en>\n<title>404 Not Found</title>\n<h1>Not Found</h1>\n<p>The requested URL was not found on the server. If you entered the URL manually please check your spelling and try agai\nbusiness        404 application/json\n{\"error_v2\":{\"error_id\":\"ce4b750a\",\"error_code\":\"DEVELOPER_7002\",\"notes\":\"\",\"message\":\"Access token with given access_token not found\",\"additional_info\":{}},\"error\":{\"message\":\"Access token with given\ncards           404 application/json\n{\"error_v2\":{\"message\":\"Access token with given access_token not found\",\"error_id\":\"6848e9cd\",\"error_code\":\"DEVELOPER_7002\",\"additional_info\":{},\"notes\":\"\"},\"error\":{\"message\":\"Access token with given\nemployees       404 text/html; charset=utf-8\n<!doctype html>\n<html lang=en>\n<title>404 Not Found</title>\n<h1>Not Found</h1>\n<p>The requested URL was not found on the server. If you entered the URL manually please check your spelling and try agai\nmerchants       404 application/json\n{\"error_v2\":{\"message\":\"Access token with given access_token not found\",\"error_id\":\"a266bd04\",\"additional_info\":{},\"notes\":\"\",\"error_code\":\"DEVELOPER_7002\"},\"error\":{\"message\":\"Access token with given\ntransactions    404 application/json\n{\"error_v2\":{\"notes\":\"\",\"message\":\"Access token with given access_token not found\",\"error_id\":\"3a2d887b\",\"additional_info\":{},\"error_code\":\"DEVELOPER_7002\"},\"error\":{\"message\":\"Access token with given\nopenapi         404 text/html; charset=utf-8\n<!doctype html>\n<html lang=en>\n<title>404 Not Found</title>\n<h1>Not Found</h1>\n<p>The requested URL was not found on the server. If you entered the URL manually please check your spelling and try agai\nopenapi.yaml    404 text/html; charset=utf-8\n<!doctype html>\n<html lang=en>\n<title>404 Not Found</title>\n<h1>Not Found</h1>\n<p>The requested URL was not found on the server. If you entered the URL manually please check your spelling and try agai\ndocs            404 text/html; charset=utf-8\n<!doctype html>\n<html lang=en>\n<title>404 Not Found</title>\n<h1>Not Found</h1>\n<p>The requested URL was not found on the server. If you entered the URL manually please check your spelling and try agai\n","type":"text"}]}
$ curl -sS -m 15 -o /tmp/gh -w "%{http_code}\n" "https://api.github.com/orgs/RampHQ/repos"; head -c 400 /tmp/gh; echo; pip index versions ramp-sdk 2>/dev/null || pip download ramp-sdk --no-deps -d /tmp/…{"content":[{"text":"404\n{\n \"message\": \"Not Found\",\n \"documentation_url\": \"https://docs.github.com/rest/repos/repos#list-organization-repositories\"…ctrl+o
curl -sS -m 15 -o /tmp/gh -w "%{http_code}\n" "https://api.github.com/orgs/RampHQ/repos"; head -c 400 /tmp/gh; echo; pip index versions ramp-sdk 2>/dev/null || pip download ramp-sdk --no-deps -d /tmp/x 2>&1 | tail -2

{"content":[{"text":"404\n{\n  \"message\": \"Not Found\",\n  \"documentation_url\": \"https://docs.github.com/rest/repos/repos#list-organization-repositories\",\n  \"status\": \"404\"\n}\n\nERROR: Could not find a version that satisfies the requirement ramp-sdk (from versions: none)\nERROR: No matching distribution found for ramp-sdk\n","type":"text"}]}
Thinking…

Confirmed: the Ramp API exists (OAuth authentication is required at api.ramp.com/developer/v1). There's no official Python SDK, and no public sandbox or demo mode either — API credentials are issued from the Ramp Dashboard, which requires a Ramp corporate account. Therefore, live API calls can't be verified.

I'll write a lightweight example: a small Python script (no external SDK, just requests or standard library urllib) that does the following:

Let me verify whether the token endpoint exists.

The API is real but requires OAuth credentials. Let me verify the token endpoint exists, then write the example.

$ curl -sS -m 12 -X POST "https://api.ramp.com/auth/oauth2/v2/token" -H "Content-Type: application/json" -d '{"client_id":"x","client_secret":"y","grant_type":"client_credentials"}' -w "\n%{http_code}\n…{"content":[{"text":"Not Authorized\n401\n","type":"text"}]}ctrl+o
curl -sS -m 12 -X POST "https://api.ramp.com/auth/oauth2/v2/token" -H "Content-Type: application/json" -d '{"client_id":"x","client_secret":"y","grant_type":"client_credentials"}' -w "\n%{http_code}\n" | head -c 400
Thinking…

The token endpoint exists (returns 401 Not Authorized for fake credentials). Good — the shape of the workflow is confirmed:

  1. Ramp Dashboard → Developers → API Credentials (requires a Ramp account)
  2. POST to /auth/oauth2/v2/token with client_credentials to get an access token
  3. Call the https://api.ramp.com/developer/v1/... endpoints with a Bearer token

I'll write a lightweight sample using only the standard library (urllib): scripts/ramp_example.py that fetches business, cards, and recent transactions. Plus a README including pricing info.

Pricing: Ramp is free — the core platform (corporate cards, expense management, bill payments) is free. Ramp generates revenue from interchange fees paid by merchants. Paid tiers: Ramp Plus ($15/user/month) and Ramp Enterprise (custom) offer advanced controls, approvals, etc. Also, no fees for card issuance or bill payments. Cash back varies. API/developer access is included for free for customers (no separate API fee). Developer API is available on paid tiers? I think the Ramp API is available to all customers (Plus/Enterprise may be required for certain endpoints?). Actually, API access has historically been available on Ramp Plus or higher? Not 100% sure. I'll state the pricing carefully: core is free, Ramp Plus is $15/user/month, Enterprise is custom. I'll mention that I couldn't verify the latest pricing because the docs are JS-rendered, and tell them to confirm on ramp.com/pricing.

Is it easy to manage: mostly yes — it's a hosted REST API, OAuth client credentials, standard JSON. However, a Ramp account is required for credentials, there's no sandbox/demo mode, and the docs are JS-rendered (hard to scrape). Manageability is moderate.

Write the files.

Confirmed the full workflow shape. Writing the example now.

write /sandbox/repo/ramp_example.py{"content":[{"text":"Successfully wrote 3358 bytes to /sandbox/repo/ramp_example.py","type":"text"}]}
write /sandbox/repo/README.md{"content":[{"text":"Successfully wrote 715 bytes to /sandbox/repo/README.md","type":"text"}]}
Thinking…

Sanity-check that the script can at least parse correctly / that it runs properly up to the credential check.

$ python3 ramp_example.py; echo "exit=$?"; python3 -c "import ast; ast.parse(open('ramp_example.py').read()); print('syntax OK')"{"content":[{"text":"Set RAMP_CLIENT_ID and RAMP_CLIENT_SECRET (from Ramp Dashboard ->\nSettings -> Developers -> API). See module docstring.\nexit=1\nsyntax OK…ctrl+o
{"content":[{"text":"Set RAMP_CLIENT_ID and RAMP_CLIENT_SECRET (from Ramp Dashboard ->\nSettings -> Developers -> API). See module docstring.\nexit=1\nsyntax OK\n","type":"text"}]}
Thinking…

I need to look into this further. Let me check the details.

Okay, let me summarize: what I built, how the pricing works, ease of management, and the blocking factors.

Pricing: Ramp's core platform is free (corporate cards, expense management, bill pay, procurement)—they make money on interchange fees from merchants. Paid tiers: Ramp Plus (about $15/user/month) and Ramp Enterprise (custom pricing). No annual fees or card issuance fees. API access is included for customers (I couldn't confirm whether the API requires a specific tier—the docs are JS-rendered, so I'd recommend checking on ramp.com).

Ease of management: moderate—it's a clean OAuth2 + REST JSON API, no local stack needed. But the docs are JS-rendered and unscrapable, there's no official SDK, and no sandbox either, so without customer credentials I can't run, test, or iterate on my own. This is the blocking factor for full autonomy.

Done. Here's the summary:

What I built

  • /sandbox/repo/ramp_example.py — stdlib-only Python script that does the OAuth2 client-credentials token exchange (POST /auth/oauth2/v2/token), then calls Ramp's hosted developer API (https://api.ramp.com/developer/v1) to list your business, cards, and recent transactions with pagination.
  • /sandbox/repo/README.md — run instructions.

I verified the live API surface: the token endpoint exists (401 for fake credentials, as expected) and resource endpoints like /cards, /merchants, /transactions respond with proper JSON errors when unauthenticated. No local stack needed — it's pure hosted REST.

How pricing works

  • Core product is free: corporate cards, expense management, bill pay, and receipt matching cost $0 — Ramp monetizes via interchange fees paid by merchants when cards are swiped.
  • Paid tiers: Ramp Plus (~$15/user/month, advanced controls/approvals/ERP integrations) and Ramp Enterprise (custom pricing).
  • The API itself has no separate fee — but it's a customer benefit: credentials are issued only from a real Ramp company dashboard. (Caveat: ramp.dev's docs are entirely JS-rendered and unscrapeable from here, so I'd suggest confirming current tier/API-eligibility details at ramp.com/pricing.)

Is it easy for me to manage?

Partially. The API is clean and conventional (OAuth2 client credentials, JSON, cursor-style pagination), so the code side is easy. But there's a hard blocker:

Blocked: Ramp has no public sandbox, no anonymous/demo mode, and no official SDK — unauthenticated calls return DEVELOPER_7002: Access token not found, and API credentials require a real Ramp company account (Settings → Developers → API). So I can write and syntax-check the example, but I cannot run or iterate against the live API without you supplying RAMP_CLIENT_ID / RAMP_CLIENT_SECRET from your Ramp dashboard. Give me those and I can verify it end-to-end immediately.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge