Developers & AI agents

Every RideDesk account is an API — and an MCP server.

Connect Claude, ChatGPT or any MCP client to a live booking desk, or build a complete transfer or rental website on the REST API. Prices are always computed server-side from the operator's own rate card — an AI agent or a browser can ask for a price and book it, but never invent one.

MCP connector

Your booking desk, inside Claude and ChatGPT.

RideDesk speaks the Model Context Protocol — the open standard AI assistants use to work with external tools. One endpoint per account, on the account's own domain:

https://your-company.ridedesk.app/api/mcp

Replace your-company.ridedesk.app with your workspace subdomain or verified custom domain — the account is resolved from the host, so this endpoint is your server, priced with your rate card.

There is also one platform-wide server: https://ridedesk.app/api/mcp is RideDesk's own documentation MCP — auth-free and read-only, serving this page's docs as queryable tools (list_docs, get_doc, search_docs, get_integration_brief) so a coding agent can pull the exact contract while it builds. It is also published in ChatGPT's app directory, where it installs with no account and no key.

RideDesk docs in ChatGPT

Four tools, one honest contract

  • list_options — The operator’s bookable options: vehicle classes, standard extras (meet & greet name sign, child seats, waiting time) with prices, catalog add-ons, trip types and payment preferences — including a deposit now with the rest paid to the driver, when the operator takes one.
  • get_quote — The server measures the driving route and prices every vehicle class from the live rate card — route rules, surcharges, early-booking discounts and vouchers included. Returns a quote ref, valid 45 minutes.
  • book_transfer — Books a quote ref. Price, route and voucher come from the stored quote — the agent only picks the class and supplies customer details. The booking runs the normal pipeline: verification, auto-approve, confirmation email, CRM.
  • get_booking — Status of an existing booking, verified by booking id plus the customer email it was booked with, including what has been paid, the balance and the link to pay the rest.

An agent can never set a price. Every figure comes from the server-side quote engine, and a booking is only accepted against a stored quote — the same pipeline the operator's website uses, with the same verification and auto-approve gates. MCP bookings are tagged “AI agent” in the panel.

Two ways in

  • OAuth 2.1 for chat apps — claude.ai and ChatGPT connectors can't send static headers, so the server supports the full flow: discovery at /.well-known/oauth-protected-resource, dynamic client registration (RFC 7591), PKCE, staff consent, refresh-token rotation. Paste the URL; the app registers itself and asks a signed-in staff member to approve.
  • API key for developer clients — CLIs, IDEs, your own agents. Send Authorization: Bearer <key>; the key is generated in the panel under Settings → AI agents.
  • Streamable HTTP, stateless — plain JSON-RPC over POST, no sessions to hold open. Protocol revisions from 2024-11-05 through the current spec.

Requires the AI agents add-on and the Transfers module; switched on per account in Settings → AI agents. Connected apps are listed there and can be disconnected — revoking every token — in one click.

Claude

In claude.ai: Settings → Connectors → Add custom connector, paste your /api/mcp URL. Claude opens your account's consent page; sign in as staff and approve. Works on web, desktop and mobile.

ChatGPT

In ChatGPT: Settings → Connectors (with developer mode enabled on plans that gate it) → Create, paste the same URL. ChatGPT self-registers over OAuth and walks the identical approve flow.

Claude Code / CLI clients

Anything that can send a header connects with the API key instead — no OAuth round-trip: claude mcp add --transport http bookings https://your-company.ridedesk.app/api/mcp --header "Authorization: Bearer <key>"

Booking API

Build a complete booking website on the API.

Every endpoint lives on the account's own domain and is CORS-open — a static site, a WordPress theme or a hand-built Next.js/Astro frontend all talk to it directly. This is the same engine RideDesk's own widgets use; hand this page to a developer or paste it into a coding agent and they have the whole contract.

The integration in three calls

// 1) Price it — the server measures the route and prices EVERY class
const { quote } = await fetch('https://your-company.ridedesk.app/api/quote', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    pickup_location: 'Frankfurt Airport (FRA)',
    dropoff_location: 'Hauptbahnhof, Koblenz',
    trip_type: 'one_way',            // one_way | return | hourly
    pickup_date: '2026-09-06T14:30', // enables surcharges & early-booking discounts
    voucher_code: 'WELCOME10',       // optional — validated server-side
  }),
}).then(r => r.json());
// quote.prices = { Economy: { total }, Business: { total }, … } — FINAL figures.

// 2) Book the quote — price, route & voucher come from the stored record
const res = await fetch('https://your-company.ridedesk.app/api/transfers', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    quote_ref: quote.ref,
    vehicle_type: 'Business',
    pickup_location: 'Frankfurt Airport (FRA)',
    dropoff_location: 'Hauptbahnhof, Koblenz',
    pickup_date: '2026-09-06T14:30',
    price: quote.prices.Business.total,
    client_name: 'Jane Doe',
    client_email: 'jane@example.com',
    client_phone: '+49 170 1234567',
    turnstile_token: '<from the Turnstile widget>',
  }),
}).then(r => r.json());

// 3) Obey the checkout contract — never hardcode a payment flow
//    res.checkout.mode: 'email'  → thank-you page, pay link is emailed
//                       'link'   → redirect to res.checkout.pay_url
//                       'inline' → render Stripe on your page with
//                                  res.checkout.publishable_key
//
// 4) INLINE ONLY, AND REQUIRED: after stripe.confirmPayment resolves, POST the
//    settleUrl from /api/stripe/wallet with { token, paymentIntentId }. That is
//    what records the payment. Without it the booking is only marked paid if the
//    operator's Stripe webhook is configured perfectly -- and a missing event
//    there loses the payment silently.

The operator decides what happens after a booking once, in their panel, and the response carries the answer — switch the account from an emailed pay link to on-page Apple Pay and the website follows with no redeploy.

The endpoints

POST

/api/quote

Server-priced quote for every vehicle class + a 45-minute quote ref. No captcha — rate-limited.

POST

/api/transfers

Create a transfer booking. Send quote_ref so price, route and voucher come from the stored quote.

POST

/api/quote/progress

Fire-and-forget funnel telemetry: class_selected / details. Powers the quote funnel in the panel.

POST

/api/enquiries

Contact / quote leads — tours, groups, corporate, rental enquiries. Works as a Contact Form 7 bridge too.

POST

/api/rentals

Request a vehicle rental, priced server-side from the vehicle’s rates and duration discounts.

GET

/api/vehicles

The fleet: bookable vehicle classes with capacity (transfers) or live rental rates (rentals).

GET

/api/addons

The bookable extras catalog with prices — the exact figures bookings are verified against.

POST

/api/customer/*

Optional customer portal: register, magic-code login, their bookings and paid-invoice PDFs.

Full field-by-field references — request bodies, response shapes, runnable examples with the account's real host — live in the panel at /admin/help. That page is personalised and always current; this one is the login-free overview.

Or skip the build: widgets

Embeddable booking, enquiry and rental forms at /embed/* — quote-first, themed to the brand, 12 languages, auto-resizing iframes. A WordPress plugin (shortcode + Gutenberg block) ships from the panel; all booking logic stays server-side, so it never needs updating.

Attribution that survives browsing

One hosted tag — /embed/attribution.js — captures the campaign and landing page the moment a visitor arrives and hands it to every quote and booking, so paid traffic never reports as “direct”. The same tag runs live presence and chat, and a consent-first cookie banner, when the operator switches them on. One tag per site.

Server-authoritative by design

Prices, discounts and add-ons are computed and re-verified server-side; public POSTs are bot-protected (Cloudflare Turnstile) and rate-limited; each account's data is isolated per organisation. A frontend — human-built or AI-built — holds no secrets and can't corrupt a price.

For coding agents

Paste this brief, get a booking site.

Building with Claude Code, Cursor or any coding agent? This is the contract in one block. Swap the host for the operator's real domain.

TASK: build a transfer-booking flow on RideDesk's public API.

HOST: https://your-company.ridedesk.app   (the operator's RideDesk domain — everything below is
relative to it; all endpoints are CORS-open, org resolved from the host)

FLOW
1. GET  /api/addons    → render & price extras (never hardcode a price)
2. GET  /api/vehicles  → the bookable vehicle classes + capacity
3. POST /api/quote     → { pickup_location, dropoff_location, trip_type,
                           pickup_date, voucher_code? } → per-class FINAL
                           prices + quote.ref (valid 45 min)
4. POST /api/transfers → { quote_ref, vehicle_type, price, pickup/dropoff,
                           pickup_date, client_name/email/phone,
                           turnstile_token } → 201 { id, pay_token, checkout }
5. Obey checkout.mode from the response: "email" → thank-you page;
   "link" → redirect to checkout.pay_url; "inline" → Stripe Payment +
   Express Checkout Elements with checkout.publishable_key (amount comes
   from POST /api/stripe/wallet { token: pay_token } — never client-side).
6. INLINE ONLY, REQUIRED: the moment stripe.confirmPayment resolves without
   an error, POST the settleUrl returned by /api/stripe/wallet with
   { token: pay_token, paymentIntentId }. This is what marks the booking
   paid. It is verified server-side and idempotent, so call it every time;
   skipping it means a successful charge can stay unrecorded with no error.

RULES (each one is enforced server-side; violating it = booking stays
pending for manual review)
- Always book with quote_ref. Never compute, cache or re-apply a price,
  surcharge or discount client-side — quote.prices are final figures.
- Send pickup_date on the quote or lead-time pricing can't apply.
- Render the Cloudflare Turnstile widget and send its token on POSTs.
- Add <script async src="https://your-company.ridedesk.app/embed/attribution.js"></script> in <head>
  on EVERY page and send attribution: window.rdAttribution?.() ?? {} on
  every POST — captured on arrival, not at submit.
- Optional funnel telemetry: sendBeacon POST /api/quote/progress
  { ref, stage: "class_selected" | "details" } — fire-and-forget.

OPTIONAL: add RideDesk's documentation MCP to your editor — one URL, no
auth — and query this contract as you build:
  claude mcp add --transport http ridedesk-docs https://ridedesk.app/api/mcp
Tools: list_docs, get_doc, search_docs, get_integration_brief.

Rentals and enquiries follow the same pattern via POST /api/rentals and
POST /api/enquiries. Full field references: the operator's panel at
/admin/help.
RIDEDESK

A booking desk your agents can talk to.

Start an account, switch on the AI agents add-on, and the endpoint on your own domain is live — for Claude, for ChatGPT, and for whatever you build next.

Already a customer? Your personalised docs are in the panel: /admin/help.