Developers

Build payments into your product.

One REST API for payment acceptance, payouts, currency exchange and reporting. Test in a sandbox, listen for signed webhooks and go live with an engineer who knows your integration.

curl https://api.coypay.com/v1/payments \
  -H "Authorization: Bearer $COYPAY_API_KEY" \
  -H "Idempotency-Key: order-10482-attempt-1" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 24900,
    "currency": "GBP",
    "reference": "order_10482",
    "return_url": "https://shop.example/checkout/complete"
  }'
Response
{
  "id": "pay_01HZX8T4M2",
  "status": "pending",
  "amount": 24900,
  "currency": "GBP",
  "reference": "order_10482"
}

Examples for illustration. See the API reference for exact endpoints and fields.

Integration paths

Four ways to integrate. Mix them as you need.

Start with the simplest route and go deeper later. Payments behave the same way whichever path created them.

Hosted page

Redirect customers to a payment page we host and maintain. You handle the result.

Effort
Lowest effort
Best for
Getting live quickly with minimal development

Embedded flow

Embed the pay-by-bank journey in your own checkout. Customers stay on your site.

Effort
Moderate effort
Best for
A branded checkout with no sensitive data on your servers

Direct API

Server-to-server control of the whole payment, payout and FX lifecycle.

Effort
Most control
Best for
Platforms that want full control

Payment links

Create a link in the dashboard or by API and share it with your customer.

Effort
No integration
Best for
Invoices, assisted sales and one-off payments

API fundamentals

Conventions you already know.

Nothing exotic. The API follows the patterns developers expect from modern payment infrastructure.

REST and JSON

Resource-oriented URLs, JSON bodies and conventional HTTP verbs and status codes.

Authentication

Secret API keys sent as bearer tokens over TLS, with separate keys for sandbox and live.

Idempotency

Send an idempotency key with every request that moves money and retry safely after a timeout.

Webhooks

Signed events for every change of status, retried automatically if your endpoint is unavailable.

Sandbox

A separate test environment with simulated approvals, declines and errors.

Errors and versioning

Structured error codes you can handle in code, and a versioned API with notice of changes.

Go-live checklist

What a production-ready integration looks like.

These are the points our engineers review with you before live credentials are issued.

  1. Run through success, decline, pending and error scenarios in the sandbox.
  2. Treat webhooks as the source of truth for final payment status, not the browser redirect.
  3. Verify the signature on every webhook and acknowledge quickly with a 2xx response.
  4. Send an idempotency key with every request that creates a payment, refund or payout.
  5. Keep secret API keys on your servers and out of client-side code and repositories.
  6. Log Coypay’s identifiers alongside your own references to make reconciliation and support easier.
  7. Review the integration with your Coypay engineer before requesting live credentials.

Support

Engineers on your side of the table.

You get a named integration engineer who helps you plan the build, answers questions as they come up and reviews the result with you.

Start a conversation
  • Planning

    We agree the integration path, the scope and a realistic timeline before you write code.

  • Build

    Sandbox credentials, documentation and direct answers while your team develops.

  • Launch and beyond

    A joint review before go-live, and the same contact once you are processing.

Ready to see the API?

Request sandbox access and we will send credentials and documentation, and introduce your integration engineer.