# Connect Ondes PRO to Cursor

> Add the Ondes PRO MCP server to Cursor through .cursor/mcp.json, with OAuth or an API key: the agent codes against your workspace’s real docs and test mode.

Updated on 2026-10-21 · The Ondes PRO team · https://ondes.pro/en/integrations/mcp/clients/cursor

Cursor can reach a **remote MCP server** declared in a plain JSON file. Point it at your Ondes PRO workspace and Cursor’s agent writes your integration — storefront, stock sync, dashboard — by reading the real documentation of your resources, then trying its calls in test mode instead of on live orders.

## Add the Ondes PRO MCP server to Cursor

About two minutes. The default connection uses OAuth: no key to copy, nothing to hide in the repository.

1. **Pick the file’s scope** — For a single project, create `.cursor/mcp.json` at the repository root. For every project on your machine, use `~/.cursor/mcp.json` in your home folder. Both files share the same format.
2. **Declare the server** — Paste the configuration below with your subdomain (or type it in the field at the top of the page and the snippets update). The `ondes` name is up to you: it is what Cursor will display.

```json
{
  "mcpServers": {
    "ondes": { "url": "https://your-workspace.ondes.pro/mcp/" }
  }
}
```
3. **Open the MCP section of the settings** — In Cursor’s settings, the section dedicated to tools and MCP lists the `ondes` server. Until it is authorised, Cursor offers to sign you in.
4. **Authorise the connection** — A window from your Ondes PRO workspace opens in the browser. Sign in, read the consent screen, authorise. Back in Cursor, the server’s tools appear, and the connection is listed in your workspace under the machine’s name.
5. **Work in agent mode** — In Cursor’s chat, in agent mode, ask something like “Which fields do I need to create an order?”. The agent calls the right tools itself; depending on your settings, it asks before each call.

## Copy-ready Cursor configuration

The first form covers most cases. The second, with an API key, is for when you want a narrower connection — read-only on the store, for example.

Where to set it up : The project’s `.cursor/mcp.json`, or `~/.cursor/mcp.json` for the whole machine.

**OAuth connection (recommended)** (.cursor/mcp.json)

```json
{
  "mcpServers": {
    "ondes": {
      "url": "https://your-workspace.ondes.pro/mcp/"
    }
  }
}
```

**API key connection** (.cursor/mcp.json)

```json
{
  "mcpServers": {
    "ondes": {
      "url": "https://your-workspace.ondes.pro/mcp/",
      "headers": {
        "Authorization": "ApiKey opk_…"
      }
    }
  }
}
```

_Standard MCP compatible. Vendor documentation : https://cursor.com/docs/context/mcp_

## Project .cursor/mcp.json or global ~/.cursor/mcp.json?

The **project file** shines in a team: in its OAuth form it holds no secret, only the server address. You can commit it, and every developer who opens the repository is offered Ondes PRO; each one then authorises with their own account, and therefore their own permissions. Agencies working for several clients benefit too: each repository points at the right client’s workspace, so two stores never get mixed up.

The **global file** suits you if you have a single Ondes PRO workspace and want it available from any folder — including for a quick question unrelated to a repository. If the same server name appears in both files, give them distinct names (`ondes-client-a`, `ondes-client-b`) so you always know which workspace the agent is talking to.

> **Never commit an API key** — If you use the key form, do not commit `.cursor/mcp.json` as is. Cursor can read an environment variable inside that file (`"Authorization": "ApiKey ${env:ONDES_KEY}"`), so the key stays on your machine. If it leaks, revoke it under **API & Developers → API keys**; it stops working immediately.

## Example: wiring up Atelier Lumen’s checkout

_Example conversation · demo data (Atelier Lumen)_

> **You** : Hook the “Pay” button in `checkout.tsx` up to Ondes PRO. The cart holds one Suspension Laiton and two Lampe Trépied.
>
> 🔧 `ondes_chercher` Term “order”: the `shop/commandes` resource and the guide section on payments.
>
> 🔧 `ondes_ressource` `shop/commandes` sheet: required fields, amount recomputed server-side, `paiement.client_secret` when live, a simulated payment page (`paiement.checkout_url`) in test.
>
> 🔧 `ondes_appeler` `POST shop/commandes` — **test** mode stated in the response: trial order created, no real charge.
>
> **Assistant** : I wrote the call in `checkout.tsx` and checked the response shape against a test order. The browser never sends the amount: the server recomputes it from the products. In test I redirect to `paiement.checkout_url`, the simulated payment page; in production the same code mounts Stripe.js with `paiement.client_secret`. The trial order shows up in the “Test” tab of Store & Orders.

## Why an MCP server instead of a docs file in the repo?

The old approach was to download a documentation file and drop it into the repository for the assistant to read. It weighed around **44,000 tokens** — a big slice of the context window — and when it did not fit, the tool truncated it, often right in the section that says what the API does not do.

With the MCP server, Cursor keeps only about **2,700 tokens** in permanent context: a short preamble and the description of the eight tools. Everything else is read on demand, section by section, generated from your workspace’s real routes. No stale copy rotting in the repository: if a field changes, the agent sees it on the next call. And the `ondes_impossible` tool lets it confirm an endpoint does not exist before making one up. More in [MCP vs REST API](https://ondes.pro/en/integrations/mcp/mcp-vs-rest-api).

## What Cursor’s agent can do with your workspace

- Read a resource sheet before writing the code that calls it: typed fields, filters, ordering, required permission.
- Validate a request body with a dry run, without writing anything to your workspace.
- Create orders, video meetings or email sends in test mode, on resources that have a test twin.
- Reuse a complete recipe already verified against the API (create, read without N+1 calls, subscribe to events).
- Answer a question about your live data while you code: “how many products have no image?”.

## Going further

- [Connect your website](https://ondes.pro/en/integrations/mcp/guides/connect-your-website) — Show the catalogue and take Stripe payments from a site that is already live, without rebuilding it.
- [REST API v1](https://ondes.pro/en/integrations/rest-api) — Around 135 REST resources, scoped keys, an OpenAPI schema and signed webhooks.
- [Online store](https://ondes.pro/en/integrations/mcp/modules/online-store) — Orders, catalogue, promo codes and shipments handled by your assistant, in test mode by default.
- [MCP server security](https://ondes.pro/en/integrations/mcp/security) — OAuth 2.1, short-lived tokens, instant revocation and write safeguards: what your IT team needs to know.

## Frequently asked questions

### How do I add a remote MCP server to Cursor?

Declare it in `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (whole machine) under the `mcpServers` key, with its address in `url`. For Ondes PRO: `https://<your-workspace>.ondes.pro/mcp/`. Cursor then offers an OAuth sign-in.

### Can I commit .cursor/mcp.json to Git?

Yes with the OAuth form, which only contains the server address. Each developer authorises with their own account. With an API key, do not commit the key: read it from an environment variable.

### Can Cursor’s agent place real orders?

Not by default: on `shop/commandes`, writes go to test mode and the response always states which mode was used. A real write has to be requested explicitly. Cursor also asks for your approval before each tool call unless you turned on auto-run.

### Does Cursor see every module in my workspace?

It sees the ones your role opens, nothing more. Tools, the table of contents and search are filtered by your scope: the agent is never shown a resource that would answer “access denied”.

### Has the Ondes PRO team tested Cursor?

No. Cursor implements the standard MCP protocol our server follows, so the connection should work. Only Claude has been tested end to end by our team; if Cursor’s interface changes, check its documentation.