Our Model Context Protocol (MCP) server lets you use natural language with your chosen Large Language Model (LLM) client (i.e. a coding agent). This allows developers to use natural language to connect with PPRO APIs more easily and build new payment solutions faster.

How it works

Use our MCP server to integrate with our APIs through function calling. This lets you integrate and interact with PPRO APIs seamlessly. The MCP contains a set of tools that lets you interact with the PPRO Platform for common use cases, using your LLM Coding client of choice.

Environment	MCP
Sandbox	https://mcp.sandbox.eu.ppro.com
Production	https://mcp.eu.ppro.com

MCP server setup

Add to ~/.cursor/mcp.json

{
  "mcpServers": {
    "ppro-global-api-sandbox": {
      "url": "https://mcp.sandbox.eu.ppro.com",
      "headers": {
        "Authorization": "Bearer {API_KEY}"
      }
    }
  }
}

Add to claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/
Windows: %APPDATA%\Claude

{
  "mcpServers": {
    "ppro-global-api-sandbox": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@latest",
        "https://mcp.sandbox.eu.ppro.com",
        "--allow-http",
        "--header",
        "Authorization: Bearer {API_KEY}"
      ]
    }
  }
}

Guidance
You can use our llms.txt file to give AI assistants a curated map of our documentation, making it easier for your coding agents to discover and understand our APIs, guides, and resources. Combined with our MCP server, AI agents can go beyond reading documentation and securely interact with our platform to retrieve information and perform supported actions.

Tools

Currently, interactions with the following APIs are supported, we are working on adding more APIs and endpoints.

Payment Charges

Tool	Description	Recommended steps
`CREATE_PAYMENT_CHARGE`	Creates a payment charge for a merchant.	Provide a valid merchant account, amount, currency, and payment method. Use the returned charge ID for subsequent authorization, capture, refund, or void operations.
`GET_PAYMENT_CHARGE`	Retrieves a payment charge by charge ID.	Pass the `chargeId` returned from `CREATE_PAYMENT_CHARGE` or from a webhook. Use this to check the current charge status before capturing, refunding, or voiding.
`LIST_PAYMENT_CHARGES`	Searches charges by merchant reference or agreement ID. Paginated.	Filter by merchant reference or agreement ID. Handle pagination when the result set spans multiple pages.
`UPDATE_PAYMENT_CHARGE_AUTHORIZATION`	Adds data needed to proceed with charge authorization.	Send the additional authentication or consumer data required by the payment method, then continue the authorization flow.
`GET_PAYMENT_CHARGE_AUTHORIZATION`	Retrieves a single authorization on a charge.	Pass the charge ID and authorization ID. Confirm the authorization status is successful before capturing or voiding.
`LIST_PAYMENT_CHARGE_AUTHORIZATIONS`	Lists all authorizations on a charge.	Use when a charge may have multiple authorization attempts. Inspect each authorization status before deciding next steps.
`CAPTURE_PAYMENT_CHARGE`	Captures all or part of an authorized charge.	Ensure the charge is in a capturable state and the amount does not exceed the remaining authorized amount.
`GET_PAYMENT_CHARGE_CAPTURE`	Retrieves a single capture on a charge.	Pass the charge ID and capture ID to verify capture status before issuing a refund.
`LIST_PAYMENT_CHARGE_CAPTURES`	Lists all captures on a charge.	Use to reconcile partial captures and calculate the remaining capturable or refundable amount.
`REFUND_PAYMENT_CHARGE`	Refunds all or part of a captured charge.	Confirm at least one successful capture exists and that the refund amount does not exceed the remaining refundable balance.

Payment Instruments

Tool	Description	Recommended steps
`CREATE_PAYMENT_INSTRUMENT`	Creates a stored payment instrument for a merchant.	Provide the instrument details required by the payment method. Store the returned `instrumentId` for reuse in future charges or agreements.
`GET_PAYMENT_INSTRUMENT`	Retrieves a payment instrument by instrument ID.	Pass a valid `instrumentId` that belongs to the same merchant account before using it on a charge or agreement.
`UPDATE_PAYMENT_INSTRUMENT`	Updates a stored payment instrument.	Send only the fields that need updating. Re-fetch the instrument afterward to confirm the new state.
`DELETE_PAYMENT_INSTRUMENT`	Deletes a stored payment instrument.	Ensure no active agreements or pending charges depend on the instrument before deleting it.

Payment Agreements

Tool	Description	Recommended steps
`CREATE_PAYMENT_AGREEMENT`	Creates a payment agreement for recurring or merchant-initiated payments.	Complete agreement setup and wait until the agreement status is `ACTIVE` before creating charges under it.
`GET_PAYMENT_AGREEMENT`	Retrieves a payment agreement by agreement ID.	Verify the agreement is still active before initiating a new charge against it.
`UPDATE_PAYMENT_AGREEMENT_AUTHORIZATION`	Adds data needed to proceed with agreement authorization.	Send the additional authentication or consumer data required to complete agreement setup, then continue the authorization flow.
`CREATE_PAYMENT_AGREEMENT_CHARGE`	Creates a charge under an existing agreement.	Ensure the agreement status is `ACTIVE`. Use the returned charge ID for subsequent capture, refund, or void operations as needed.
`REVOKE_PAYMENT_AGREEMENT`	Revokes an agreement so no further charges can be made.	Call when the consumer or merchant ends the recurring relationship. Stop scheduling further charges after revoke succeeds.

Payment Sessions

Tool	Description	Recommended steps
`CREATE_PAYMENT_SESSION`	Creates a payment session for a merchant.	Use the returned session details to render or continue the checkout experience for the consumer.
`GET_PAYMENT_SESSION`	Retrieves a payment session by session ID.	Pass the `sessionId` to check session status before updating or authorizing the session.
`UPDATE_PAYMENT_SESSION`	Adds data needed to proceed with session authorization.	Send the additional authentication or consumer data required by the selected payment method, then continue the session flow.
`AUTHORIZE_PAYMENT_SESSION`	Authorizes the charge or agreement behind a session.	Call after the session has all required data. Handle the resulting charge or agreement status via webhooks or follow-up GET calls.

Examples

Type these into your assistant's chat. It picks the tool, builds the payload, and shows you the response.

Create a test charge, then walk the lifecycle

Create a payment charge of 15 EUR using the WERO payment method, country DE. Merchant ID is merch_acme_sandbox.

(Optional) also please show me the actual request payload sent to PPRO.

Open the redirect URL from the response to authorize, then:

Get the charge details.

Refund 10 EUR of the charge.

Look up what happened to a payment charge

Find the charge for merchant merch_acme_sandbox with merchant reference ORDER-88213, and show me its captures and refunds.

Set up a recurring payment

Create a payment agreement with payment method as EPS, a Bank Account instrument containing a Debit Mandate Id and the monthly amount as EUR 10.00;

Build integration code

Using the PPRO MCP tools and PPRO’s llms.txt documentation as the source of truth, implement a Node.js function that creates a payment charge, monitors its authorization status, and captures the full authorized amount. Handle authentication pending by extracting the REDIRECT URL and returning it so the consumer can complete authentication before resuming the flow. Poll the charge status at a reasonable interval, correctly handle successful, pending, failed, and terminal states, and only initiate capture after the charge is fully authorized and eligible for capture. Capture exactly the full authorized amount and verify that the capture succeeds before returning a successful result. Include robust error handling, timeouts, idempotency considerations, and clear return values for both the redirect-required and completed-payment cases.