● Model Context Protocol Hosted - nothing to install

Your coding agent, fluent in ROKI payments.

Connect any MCP-capable AI coding client and it stops guessing: real operations, real schemas, real error catalogue, and a validator that catches the mistakes this API accepts without an error.

https://mcp.roki.la/mcp

That URL is the server. Point your client at it over Streamable HTTP and you are done - there is nothing to clone, install or run.

ROKI Connect API v2.0.0 - 14 operations, 18 schemas, 126 guide sections

A contract test runs this corpus against the live ROKI API every day. Today's result: status.json.

agent session

> Integrate ROKI Connect payments into this checkout.

▸ roki_list_operations

14 operations across 3 modes, including void, refund and listing.

▸ roki_get_operation createPayment

required: amount, external_reference, name

▸ roki_validate_request

! service_fee is not a field - the API would ignore it

! use service_fee_enabled instead

$roki->createPayment([ 'amount' => 150.00, 'external_reference' => $order->id, 'name' => "Order #{$order->id}", 'service_fee_enabled' => true, ]);

✓ VALID - 201 Created, redirecting to checkout_url

One sentence is the whole integration

Once your client is connected, you do not read documentation and you do not look up field names. You say this, and the agent does the rest.

Say this to your agent

Integrate ROKI Connect payments into this application.

What the agent handles on its own

Looks up all 14 operations across the three modes, so it never writes a call that 404s.
Pulls the exact field names, types and limits from the verified schema.
Writes the API client with timeouts, error handling and idempotency derived from the order content.
Builds the webhook handler: HMAC over the raw body, constant-time compare, 400 on mismatch, idempotent processing.
Adds the polling fallback, because a redirect is never proof of payment.
Stores credentials so a key rotation needs no redeploy.
Validates every payload before shipping it - catching the typos this API would accept and only complain about afterwards.
Follows your project conventions: your framework, your folder layout, your style.

What it will ask you for

Your secret key, copied from the ROKI portal. It is shown once.
The webhook signing secret, after you register your endpoint URL.

Two portal steps no software can do for you. The agent tells you exactly where to click and what to paste back.

Connect your client

Six clients, one server. Pick yours and copy the configuration - each opens to show the exact file and keys, because they genuinely differ.

Easiest path

Using Claude Code? Install the plugin instead.

It bundles this server, so there is no configuration to copy - and it adds four commands for the work that actually takes time.

/plugin marketplace add ROKImcp/roki-plugins
/plugin install roki-connect@roki

/roki-integrate

Full guided integration, start to finish.

/roki-audit

Audit existing code, worst findings first.

/roki-webhook

Build the handler, or find why a signature fails.

/roki-debug

Turn an error into a cause and a fix.

Claude Code

.mcp.json

One line in the terminal

claude mcp add --transport http roki-connect https://mcp.roki.la/mcp

Or by hand in .mcp.json

{
  "mcpServers": {
    "roki-connect": {
      "type": "http",
      "url": "https://mcp.roki.la/mcp"
    }
  }
}

An entry with url but no type is read as a stdio server and skipped.

OpenAI Codex

~/.codex/config.toml

[features]
experimental_use_rmcp_client = true

[mcp_servers.roki-connect]
url = "https://mcp.roki.la/mcp"
startup_timeout_sec = 20

Older builds load stdio servers only; the [features] block enables remote HTTP.

Cursor

.cursor/mcp.json

{
  "mcpServers": {
    "roki-connect": {
      "type": "streamable-http",
      "url": "https://mcp.roki.la/mcp"
    }
  }
}

If your build rejects type, remove that line and keep url.

Google Antigravity

.agents/mcp_config.json

{
  "mcpServers": {
    "roki-connect": {
      "serverUrl": "https://mcp.roki.la/mcp"
    }
  }
}

Antigravity uses serverUrl, not url.

GitHub Copilot

.vscode/mcp.json

{
  "servers": {
    "roki-connect": {
      "type": "http",
      "url": "https://mcp.roki.la/mcp"
    }
  }
}

The top-level key is servers, not mcpServers. Then use Agent mode.

Gemini CLI

.gemini/settings.json

{
  "mcpServers": {
    "roki-connect": {
      "httpUrl": "https://mcp.roki.la/mcp",
      "timeout": 30000
    }
  }
}

The key is httpUrl. In Gemini CLI, url means an SSE endpoint and will not work.

No credentials needed. This server is read-only documentation. It stores no API keys, never calls the ROKI API, and has no access to merchant data.

What your agent gains

19 tools across the three integration modes: all read-only except a sandbox that makes real calls using no key of yours. Every answer comes from a corpus verified against the live API.

Hosted checkout

Redirect to a ROKI page. No frontend work.

Embedded components

ROKI card fields in an iframe on your own site.

Saved cards

Charge a card the customer already saved.

roki_status

Server and corpus health. Safe first call.

roki_search_docs

Ranked search across the guide, operations and schemas.

roki_list_operations

All 14 operations across the three integration modes.

roki_get_operation

Full contract: headers, field table, responses, examples.

roki_get_schema

Dereferenced JSON Schema for any object.

roki_validate_request

Validate a payload without sending it, business rules included.

roki_get_error

Explain a status code or error message, with the fix.

roki_get_webhook_guide

Registration, events, HMAC verification, idempotency.

roki_get_integration_example

Runnable example for Laravel, Node, Python or plain PHP.

roki_choose_integration_mode

Hosted checkout, embedded components or saved cards - which fits, and why.

roki_get_doc_section

Any section of the guide in full, subsections included.

roki_get_quickstart

The minimum end-to-end path, manual portal steps included.

roki_get_authentication_guide

Keys, environments, storage and rotation without redeploying.

roki_verify_webhook_signature

Signature failing? It reproduces your exact mistake and names it.

roki_scaffold_integration

The full skeleton for your stack, ready to fill in.

roki_audit_integration

Audit existing code against the verified contract.

roki_check_result

Compares the payment that came back against the body you sent. Catches what validation cannot: the field name was right and the value was wrong.

roki_sandbox_try

Run a real sandbox call and see the real response - no key needed.

roki_sandbox_info

What the playground allows, and its limits.

Coming from Stripe or Mercado Pago?

Your habits follow you into the code. Forty-five field names from both gateways are mapped to what ROKI actually calls them - or to an honest "there is no equivalent, do this instead".

What you write

amount_cents: 150000
currency: "HNL"
payment_method_types: ["card"]
external_reference: "order-1001"
service_fee: true

What you get back, before sending

amount_cents -> amount, in decimal units: 1500.00
currency -> currency_code, ISO numeric as a string: "340"
payment_method_types no equivalent - the mode is the endpoint you call
external_reference correct, and required here
service_fee -> service_fee_enabled  (a 201 would have hidden this)

Or start from a client that already knows all of this

One file, generated from the same specification and regenerated on every deploy. It refuses the unknown field before the request leaves your process. All ten are executed against the sandbox before publishing - the same 20 checks each - and all ten compute the same webhook signature over the same body, which is the one thing no client can verify on its own.

PHPRokiConnect.php PHP 8.0+, curl. Drop it in and call it.TypeScriptroki-connect.ts Node 18+ or any runtime with fetch.Pythonroki_connect.py Python 3.10+, standard library only.C# / .NETRokiConnect.cs .NET 6+, no NuGet packages.Gorokiconnect.go Go 1.21+, standard library only.JavaRokiConnect.java Java 17+, no dependencies.KotlinRokiConnect.kt Kotlin 2.0+, with kotlinx-coroutines.SwiftRokiConnect.swift Swift 5.9+. On Linux, swift-crypto.Rubyroki_connect.rb Ruby 3.0+, no gems.Dartroki_connect.dart Dart 3.0+, no packages.

Not going to write any code?

If the store or the system already exists, the integration is a download. Fourteen connectors across two families - online stores and business systems - plus a payment button, a QR and a printable poster for whoever has no website at all.

See the connectors →

Two ways in

Both reach the same hosted server. They differ only in whether your client is Claude Code.

Recommended

A. Install the plugin

Claude Code only. Connects this server and adds four commands. Nothing else to configure.

/plugin marketplace add ROKImcp/roki-plugins
/plugin install roki-connect@roki

Any client

B. Point your client at the URL

One entry in your client's MCP config. The exact file and keys for each client are in the section above.

https://mcp.roki.la/mcp

Running it yourself instead (optional, and not the recommended path)

Only worth it to audit the server or to work offline. Node 20 or newer. Everyone else should use the hosted endpoint above - it is the same server.

git clone https://github.com/ROKImcp/roki-plugins
npm install && npm run build
npm run start:http

Then just ask

Open your project and say what you want. The agent looks up the real contract instead of guessing.

Integrate ROKI Connect payments into this application.

Why this matters: the ROKI API ignores unknown fields - a misspelled name returns 201 Created with the feature switched off, and only then names what it dropped. An agent writing another gateway's field names produces code that passes a smoke test and charges the wrong thing. This server catches it before the request is ever sent.