> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pontisglobe.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect your AI tools to our MCP

> Point Claude, Codex, Cursor, VS Code, Windsurf, Gemini CLI or Cline at PontisGlobe and let them build and check your requests for you.

If you build with an AI assistant, you can connect it to PontisGlobe directly and integrate by
describing what you want in natural language. Aurora answers questions about what we support, looks
up what a payout to a given country needs, and checks a request you have built against the **same
validator our API runs** — before you send anything.

Free, and it connects in under a minute.

## Two servers

| Server            | URL                                | Answers                  |
| ----------------- | ---------------------------------- | ------------------------ |
| **Aurora**        | `https://mcp.pontisglobe.com/mcp`  | "Is this request valid?" |
| **Documentation** | `https://docs.pontisglobe.com/mcp` | "How does signing work?" |

Add both. The first checks what you build; the second explains how anything works.

## Add it

<CodeGroup>
  ```bash Claude Code theme={null}
  claude mcp add --transport http pontisglobe https://mcp.pontisglobe.com/mcp
  claude mcp add --transport http pontisglobe-docs https://docs.pontisglobe.com/mcp
  ```

  ```bash Codex CLI theme={null}
  codex mcp add pontisglobe --url https://mcp.pontisglobe.com/mcp
  codex mcp add pontisglobe-docs --url https://docs.pontisglobe.com/mcp
  ```

  ```json Cursor theme={null}
  // .cursor/mcp.json  (or ~/.cursor/mcp.json for every project)
  {
    "mcpServers": {
      "pontisglobe": { "url": "https://mcp.pontisglobe.com/mcp" },
      "pontisglobe-docs": { "url": "https://docs.pontisglobe.com/mcp" }
    }
  }
  ```

  ```json VS Code theme={null}
  // .vscode/mcp.json  — note the root key is "servers", not "mcpServers"
  {
    "servers": {
      "pontisglobe": { "type": "http", "url": "https://mcp.pontisglobe.com/mcp" },
      "pontisglobe-docs": { "type": "http", "url": "https://docs.pontisglobe.com/mcp" }
    }
  }
  ```

  ```json Windsurf theme={null}
  // ~/.codeium/windsurf/mcp_config.json
  {
    "mcpServers": {
      "pontisglobe": { "serverUrl": "https://mcp.pontisglobe.com/mcp" },
      "pontisglobe-docs": { "serverUrl": "https://docs.pontisglobe.com/mcp" }
    }
  }
  ```

  ```json Gemini CLI theme={null}
  // ~/.gemini/settings.json  — remote servers use "httpUrl"
  {
    "mcpServers": {
      "pontisglobe": { "httpUrl": "https://mcp.pontisglobe.com/mcp" },
      "pontisglobe-docs": { "httpUrl": "https://docs.pontisglobe.com/mcp" }
    }
  }
  ```

  ```json Cline theme={null}
  // VS Code → Cline → MCP Servers → Configure
  {
    "mcpServers": {
      "pontisglobe": { "type": "streamableHttp", "url": "https://mcp.pontisglobe.com/mcp" },
      "pontisglobe-docs": { "type": "streamableHttp", "url": "https://docs.pontisglobe.com/mcp" }
    }
  }
  ```
</CodeGroup>

**Claude Desktop** and **ChatGPT** take the URL through their own UI rather than a file — look for
Connectors or Settings → MCP, choose a custom or remote server, and paste
`https://mcp.pontisglobe.com/mcp`.

<Note>
  Config keys differ between clients and move between versions — `servers` in VS Code, `serverUrl`
  in Windsurf, `httpUrl` in Gemini CLI. If one of these does not take, your client's own MCP docs
  are the authority. Nothing on our side changes: it is the same URL every time.
</Note>

### Check it worked

Most clients list the servers they are connected to. In Claude Code or Codex CLI, run `/mcp` — you
should see **PontisGlobe Aurora**. Then just ask a question.

## Sample prompts

Ask in plain language. Start here:

> What does PontisGlobe do?
>
> Which countries can I pay out to?
>
> What does it cost?

Then, once you are building:

> What fields does a mobile money payout need?
>
> Build a payout for 250 USDT to a Nigerian bank account and check it.
>
> Why is this request being rejected?

Or hand over the whole job:

> Add PontisGlobe payouts to my Node app — signing, the request, and the callback handler.
>
> Set up a checkout that collects USDT and tells my server when the customer has paid.
>
> Port my payout integration from Python to Go.

With both servers connected your assistant has the reference and the validator at once, so it can
write the code, check its own request against the real schema, and fix it before you run anything.

<Tip>
  If your assistant answers from memory instead of checking, say so explicitly: *"Using the
  PontisGlobe MCP server, …"*. Once it has called a tool a couple of times it tends to keep doing
  it.
</Tip>

Your assistant picks the right tool on its own, gets a real answer rather than a guess, and corrects
its own mistakes before you send a single request. If you want to see everything on offer, ask it to
list the tools — we add to them as the product grows.

One question is worth asking early: the fields a recipient needs differ per payment method, and
getting them wrong is the most common reason a first payout is rejected. Ask what a method needs
before you build the request, not after it comes back rejected.

## Is it safe to connect?

Yes — everything here is public and account-free. There is no key to hand over, and nothing behind
it that belongs to you: it cannot read a balance, look up a payment, list your beneficiaries or move
money. It answers questions about the product and about the shape of a request.

Account-aware tools are coming. Those will ask you to connect your account first, and until you do,
this stays exactly as safe as it is today.

<Note>
  The validators behind these tools are the same ones our API runs, so a request that passes here
  will not be rejected for its shape. It can still be refused for a business reason — insufficient
  funds, a corridor not enabled on your account — which needs a real call. See [Errors](/errors).
</Note>