canonical: https://jentic.com/apis/paysend.com/paysend

# Paysend Enterprise API

Jentic publishes the only available OpenAPI specification for Paysend Enterprise API, keeping it validated and agent-ready. Paysend Enterprise API enables global payouts to cards and bank accounts across 100+ countries with real-time FX rate retrieval, bank validation, card tokenization, and transaction status tracking. The API provides 13 endpoints covering the full payout lifecycle from rate quotes through payment execution and balance management.

## For AI agents

Send international payouts to cards and bank accounts, retrieve FX rates, tokenize cards, and track transaction status across 100+ countries.

## Scope

Does not handle payment acceptance, invoicing, or subscription billing - use for outbound payouts, FX rates, and card-to-card transfers only.

## Capabilities

- Send payouts directly to bank accounts in 100+ countries with local currency settlement
- Transfer funds to Visa and Mastercard cards globally
- Retrieve real-time foreign exchange rates for pay-to-card and pay-to-account corridors
- Tokenize card details for secure recurring payout operations
- Look up and validate bank details including SWIFT/BIC and routing information
- Track payout task status from initiation through settlement
- Query partner account balance for available funds verification

## Use cases

### International Payroll Disbursement

Distribute salary payments to employees and contractors in 100+ countries via bank account transfers. Paysend handles currency conversion using real-time FX rates and local payment rail routing. The API allows bulk payout initiation with individual tracking IDs and status polling for each transfer until funds arrive.

Example prompt: Get an FX rate via POST `/processing/fx.rateGet.p2a` for USD to EUR, then execute a payout of $2000 to a European bank account via POST `/processing/pay.toAccount`

### Card-Based Global Transfers

Send money directly to Visa and Mastercard cards worldwide. Paysend settles funds to the recipient's card in their local currency with competitive FX rates. Card tokenization enables repeat transfers without re-entering card details, and the card info endpoint validates card BIN data before transfer.

Example prompt: Tokenize a recipient card via POST `/processing/card.createToken`, get the FX rate via POST `/processing/fx.rateGet`, then send $500 to the card via POST `/processing/pay.toCard`

### FX Rate Management and Quoting

Retrieve real-time foreign exchange rates for both card and bank account payout corridors before executing transfers. Separate rate endpoints exist for pay-to-card (fx.rateGet) and pay-to-account (fx.rateGet.p2a) corridors, reflecting different settlement costs. Rates can be used for customer-facing quotes before committing to a transfer.

Example prompt: Retrieve FX rates for GBP to INR via both POST `/processing/fx.rateGet` (card) and POST `/processing/fx.rateGet.p2a` (bank) to compare corridors

### AI Agent Cross-Border Payment Orchestration

AI agents use the Paysend Enterprise API through Jentic to execute international payouts without managing API key rotation, FX rate selection, or bank validation logic. Jentic handles credential isolation and operation discovery across all 13 endpoints, enabling agents to send global transfers with a single intent query.

Example prompt: Search Jentic for 'send international payout', load the Paysend pay-to-account schema, and execute a transfer of 1000 GBP to a Nigerian bank account

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/processing/pay.toAccount` | Send payout to a bank account |
| POST | `/processing/pay.toCard` | Send payout to a card |
| POST | `/processing/fx.rateGet` | Get FX rate for card transfers |
| POST | `/processing/fx.rateGet.p2a` | Get FX rate for bank transfers |
| POST | `/processing/bank.get` | Validate bank details |
| POST | `/processing/bank.search` | Search for banks by name |
| POST | `/processing/card.createToken` | Tokenize a card for payouts |
| GET | `/processing/status/{taskId}` | Check payout task status |

## Key resources

- **FX Rates** — Retrieve real-time exchange rates for card and bank corridors
- **Bank Operations** — Look up and validate bank details by name or code
- **Card Operations** — Tokenize cards and retrieve card BIN information
- **Payments** — Execute payouts to cards and bank accounts
- **Task Status** — Track payout progress from initiation to settlement
- **Balance** — Query available account balance

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 59 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 90 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 41 / 100
  - Agent Usability: 94 / 100
  - Security: 50 / 100
  - AI Discoverability: 52 / 100
- **View full report:** https://jentic.com/apis/paysend.com/paysend/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Paysend Enterprise API by hand means managing its Authorization API-key header, choosing the sandbox or production host, and sequencing FX rate quotes with corridor validation before a payout yourself. Through Jentic you install once, import Paysend from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Paysend carries its payout and transfer details in the request body, so scope the agent by the operations it needs, such as fetching an FX rate or checking a task status. You choose that set, so money-moving operations like pay.toAccount or pay.toCard are not included unless you add them.
- **Credential handling:** Your Paysend API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'send money to a bank account abroad' or 'get a P2A FX rate', and Jentic returns the matching Paysend operation with its input schema including corridor-specific parameters so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Stripe** — Global payment platform with payout capabilities and broader feature set
- **PayRetailers** — Latin American payment gateway with regional payout focus
- **Flutterwave** — African and emerging market payout platform

## FAQ

### Why is there no official OpenAPI spec for Paysend Enterprise API?

Paysend does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Paysend Enterprise API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Paysend Enterprise API use?

The Paysend Enterprise API uses API key authentication sent in a request header with each call. Through Jentic, API keys are stored encrypted in your Jentic One instance and agents receive scoped access without handling raw credentials.

### Can I send money to both cards and bank accounts?

Yes. The API provides separate endpoints for each corridor: POST `/processing/pay.toCard` sends to Visa and Mastercard cards globally, and POST `/processing/pay.toAccount` sends to bank accounts. Each has its own FX rate endpoint (fx.rateGet for cards, fx.rateGet.p2a for bank accounts) reflecting different settlement costs.

### How do I check a payout status through Jentic?

Use Jentic to search for 'check payout status', load the schema for GET `/processing/status/{taskId}` or POST `/processing/task.statusGet`, and execute with the task ID returned when you initiated the payout. The response shows the current state (pending, completed, failed) and settlement details.

### Can I validate bank details before sending a transfer?

Yes. Use POST `/processing/bank.get` to validate specific bank details by code, or POST `/processing/bank.search` to look up banks by name. This confirms the bank exists and provides routing information before you commit to a transfer, reducing failed payout rates.

### What is card tokenization used for in Paysend?

POST `/processing/card.createToken` converts card details into a secure token that can be reused for future payouts without re-submitting the full card number. This is used for recurring payout recipients (e.g., monthly contractor payments) and reduces PCI scope since raw card data does not need to be stored.

### Can I limit what my agent is allowed to do with the Paysend Enterprise API?

Yes. Because you self-host Jentic One, your own rules decide which Paysend operations and credentials the agent may use, so you can grant read-only calls like fetching an FX rate with POST `/processing/fx.rateGet` or checking a task with GET `/processing/status/{taskId}` while withholding everything else. Money-moving operations such as POST `/processing/pay.toAccount` and POST `/processing/pay.toCard` are only available to the agent if you choose to add them to that set. The API key stays encrypted in your own instance and is injected at execution time, so the agent never sees it.