Welcome

Welcome to the Paysend Enterprise API Documentation! Here, you’ll find everything you need to integrate with our Payout API, enabling you to send funds worldwide via Paysend’s global payments network.

Why use the Paysend Enterprise Payout API?

Our Payout API allows you to disburse funds worldwide in seconds. With single API integration, you unlock access to the Paysend payments network, facilitating quick and secure payouts to cards and bank accounts across hundreds of countries.

Getting started

1. Explore the API Reference: Dive into our API documentation for technical details and integration instructions.
2. Test in a Sandbox: Experiment with our API in a sandbox environment, ensuring smooth integration without impacting real transactions.
3. Go Live: Once you’ve fully tested and refined your integration, move to production and start sending payouts globally.

Support & Assistance

Our team is here to help! If you have any questions, need troubleshooting, or require guidance on implementation, feel free to reach out to our support team.

Product overview

Introduction

The Payout API is a global payment solution that enables fund disbursements through a diverse range of payout methods including cards and bank accounts.

With the Payout API, you can:

• Grow your addressable market by quickly expanding your global payment coverage through a single API integration
• Accelerate product innovation and increase speed-to-market with instant, on demand payouts to cards, accounts and wallets
• Scale your payments as you grow your business and embed, and automate, global payouts into your workflows to scale effectively as volume grows 
• Reduce payment processing costs and pass on low fees and favorable FX rates to your clients to gain a competitive advantage
• Reduce your operational costs and decrease the time and resources spent on complex integrations and manual payout processes

The Payout API enables you to: 

• Boost the reach of your global and domestic payouts to over 168+ countries in 48+ currencies
• Expand the types of payout methods you provide to cards, accounts, and wallets through a single API integration
• Integrate Paysend Enterprise with your legacy and existing infrastructure to create a seamless payout experience
• Track and monitor your global payouts in one place
• Generate reports and derive insights in just a few clicks
• Receive statements on daily reconciliation reporting and other payment reports 

Paysend Enterprise supports multiple types of sender and recipient use cases which include B2B, B2C, B2B2C and many more scenarios.

How it works

The Payout API provides access to the Paysend payments network through an API integration. It provides your business with the ability to make outbound payouts across a number of payment schemes via the API. 

For a successful payment to be made, your business provides the payment instruction (including the payment details and beneficiary details) to Paysend via API. Paysend processes the payment instruction and disburses the funds to the recipient using payment schemes and local banking partners. The payment status is updated in real time in the Enterprise dashboard so that you have confidence that payments have been sent.  

Our API reference helps you to explore our API and get started with the technical integration. 

Use cases

The Payout API product is designed to help businesses expand their global coverage, launch new products, target new users and customers and reduce their operational costs. The payments landscape is rapidly evolving and the Payout API enables you to stay ahead of the curve with global payouts to cards, accounts and wallets. 

The global payments provided by the Payout API solves a number of sector and industry problems. Below are some of the use cases and problems which the Payout API can solve: 

• Money transfer — embed global payouts into your existing customer experience to provide new global payout options to your customers
• HR & payroll — pay employees, freelancers and contractors instantly around the world and payout to their preferred local payment method whether it’s cards, accounts or wallets
• Marketplaces and platforms — connect buyers and sellers on marketplaces and disburse funds to users, on demand, around the world to pay them as soon as a service has been provided
• Pension claims — integrate payouts into your workflow to make instant pension payouts to your customers’ preferred payment method across the world
• Insurance payouts — embed claims payouts within your existing claims workflow and payout to your policy holders using multiple payout options
• Vendor management and accounts payable — do business globally and make fast, secure payouts in any currency

Payment methods

The Payout API uniquely enables businesses to payout to cards, accounts and schemes. Paysend is a principal member of some of the largest payment global payment schemes and benefits from direct integration with these schemes.

Explore each payout method to understand the different use cases and learn how you can quickly expand your product or service.

Contact us for a complete list of the corridors and currencies we send to.

Explore our API reference to find out more about the API fields, parameters and more to get started quickly.

Payout to cards

This payout method allows you to make instant payouts to cards around the world. Our proprietary technology connects your product or service to over 12 billion cards worldwide and enables disbursements to these cards. 

Common uses cases include:

• Payout instantly to employee cards to pay their wage
• Payout instantly to beneficiaries of a money transfer service
• Payout instantly to gig economy workers when they have completed a task

Payout to accounts and digital wallets

This payout method allows you to make payouts directly to bank accounts and digital wallets around the world. Our direct relationships with local banks, international payment schemes and local payment schemes enables you to quickly send funds to local bank accounts and digital wallets. 

Common uses cases include:

• Payout to employee bank accounts to pay their wage
• Payout to vendors and suppliers on an ongoing basis
• Payout to beneficiaries of a money transfer service

API overview

The API reference provides the technical descriptions of the Payout API. The API provides multiple services e.g. complete payment processing to cards and accounts, perform a check on the status of a previously requested task/action, create a multi-task request to complete multiple functions. A list of available functions for the API is found in the POST /processing endpoint description (Request body -> payload.tasks).

A unique component of the API is that it allows a partner/customer to independently construct an API request processing flow based on their own requirements. All partners/customers can request the Enterprise product to complete a sequence of available functions. The API reference describes the recommend interaction flow between a partner/customer and the API, API methods and the available functions.

Recommended flow

info

The recommended approach for API interaction is the asynchronous flow.

Asynchronous

Asynchronous flow is the main flow to interact with API. A customer sends a request to process and receives a response with GlobalId for future status checks. After receiving a global identifier, the customer’s system waits for further notification requests (if the URL for notifications was included in the first request). When a notification is received, the customer’s system sends a status check request to obtain the changed information.

The following sequence of actions takes place for the asynchronous flow. The asynchronous interaction with API includes a callback from API to the customer’s system. The URI for the callback is defined in the request. Each request includes a different URI for the call back.

Registering request

Request processing and status retrieval

Synchronous

Synchronous flow is not available for the Enterprise product, however a synchronous flow/interaction can be simulated if required.

warning

If the processing action is completed in less than 2 seconds, a response is provided synchronously. If a response takes longer than 2 seconds to complete, the interactions continue following the asynchronous flow. We do not recommend using this interaction option.

The following sequence of actions takes place for the synchronous flow.

Request

info

Detailed request body description can be found on POST /processing endpoint page.

The API supports programmable requests where each request is formed of a set of task trees. The below diagram is an example of the request structure.

The API request supports both simple and complex logic where a request can contain a single task, multiple tasks or multiple task trees.

Tasks can be linked by their results. A Request supports Success or Fail link types.

Tasks on the same execution level are executed in parallel. Execution of the request is finished when there are no more tasks to execute on the next execution level.

Each task in the diagram above is a function or template. Registry of functions defines the product. The list of available functions is found in the Response section.

A request is described as the following object:

{
    "header": {
        "request": {              
            "id": "string",
            "date": "date"
        },
        "service": {
            "sync": "boolean",
            "waitTime": "enum"
            "result": [
                {
                    "type": "enum",
                    "uri": "string",
                    "method": "enum"
                }
            ]
        }
    },
    "payload": {}
}

payload

This is the most important part of request. This object contains the partner information, configuration for execution and the set of tasks.

Each payload is presented as:

"partner": {
    "identifier": "string",
    "parameters": {
        "anyParamName0": "string",
        "anyParamName1": "string"
    }
},
"settings": {
    "culture": "string",
    "encoding": "string",
    "contact": "string",
    "userIp": "string"
},
"tasks": []

task

A task is an atom element within the Enterprise product. A task is a reference to the function and payload which include links to next level of execution and configuration of the execution process.

Each task can be represented by:

{
    "type": "string",
    "payload": {}, //task details should be here
    "success”: [], //list of task to execute if main task (in payload) succeeds
    "fail": [], //list of task to execute if main task (in payload) fails
    "always”: [], //list of task to execute after main task (in payload) not depending on result
    "expiration": {
        "date": "string"
    }
}

The tree of task helps to program the execution flow of requests. For example, a tree of tasks enables a card payment to be processed and a confirmation email is sent depending on the result of processing e.g. if the payment is successful a confirmation success email is sent, if the payment fails, a payment declined email is sent.

Response

info

Detailed response body description can be found on POST /processing endpoint page.

A Response to processing or status requests is an object and includes all the requested fields and also includes the result or process status information relating to the request. Each of the tasks also includes result{} object with information on task status and data{} object (where applicable) with task-specific fields.

{
    "header": {
        "request": {
            "id": "string",
            "date": "date"
        },
        "response": {
            "globalId": "string",
            "id": "string",
            "date": "date"
        },
        "service": {
            "sync": "boolean",
            "waitingTime": "enum",
            "result": [
                {
                    "type": "enum",
                    "uri": "string",
                    "method": "enum"
                }
            ]
        }
    },
    "result": {
        "status": "enum",
        "code": "integer",
        "comment": "string",
        "interactive": {
            "type": "enum",
            "uri": "string",
            "method": "enum"
        }
    },
    "payload": {}
}

Status

info

Detailed description of task statuses is available on Statuses page.

HTTP Status codes

200 – OK

This code is returned if the response is successful (and a specific response is required). A Response object is returned in the response.

400 – Bad request

This code is returned if there is an issue in the request and an Error object is returned in the response. For example, this code will be returned if a request is sent without a header.request and empty payload.tasks which would be displayed as:

401 – Unauthorized

That code is returned by system if the Signature or other partner information is incorrect.

404 – Not found

This code is returned if the system cannot process the request now. If this code is received, a repeat request is submitted after a few seconds. If the code continues to be returned, this is escalated to the Support team. The system will return a response body with the text Sorry. Can't accept your request now..

Notifications

A requestor can manage notifications in the request. By default, requestor can configure backward notification URL in each request. The requestor can configure more than one URL for notification in each request. In group with flexible parameters set in partner section, requestor can delegate a part of his logic to Paysend system.

The normal notification flow is described below:

1. configure URL for notifications in request;
2. get request on configured URL;
3. request status from Enterprise API.

For example.

{
    "header": {
        …
        "service": {  
            …
            "result": [
                {
                    "type": "Web",
                    "uri": "https://www.company.com/paysend",
                    "method": "GET"
                }
            ]
        }
    },
    …
}

When the processing of a request is finished, all configured result item will get a request with parameter globalId that must be identical as parameter globalId in response.

In our example, when processing will be finished, we receive the request https://www.company.com/paysend?globalId=00000000-0000-0000-0000-000000000000.

If the configured method was POST for notifications, we receive the string globalId=00000000-0000-0000-0000-000000000000 in request body.

In our example, 00000000-0000-0000-0000-000000000000 is an example of globalId value. In real life, we will receive a real value of this key.

warning

Please check X-OPP-Signature header to verify that notification request was sent by API.

Sandbox Mock Service

Overview

The Sandbox mock service is designed to help partners integrate with Paysend Enterprise 3.0 API quickly and with minimal complexity. It allows you to test your integration logic without interacting with the live production environment.

In Sandbox, the service provides predefined, predictable responses, ensuring a consistent testing experience regardless of the request payload content.

---

How It Works

Default Success Response

For any valid request sent to any supported Paysend Enterprise 3.0 API endpoint in the Sandbox environment, the Mock Service will automatically return a success response containing the following structure within the tasks array:

"result": {
  "status": "string",
  "code": 0,
  "data": {
    "traceId": "8878b45bb948490a8971c7ac130e0461",
    "paymentId": "8878b45b-b948-490a-8971-c7ac130e0461"
  },
  "comment": "string"
}

Where:

• «code»: 0 — Indicates a successful response.
• «traceId» and «paymentId» — Static, predefined values in the Sandbox environment for consistency.
• The fields «status» and «comment» contain static placeholder values in the Sandbox environment unless you simulate an error. In the case of a simulated error, these fields will contain values consistent with the predefined error response structure (see below).

Important: The content of your request body does not affect the success response — the Mock Service always returns «code»: 0 unless you explicitly simulate an error (explained below).

Simulating Error Responses

To help you test error-handling in your integration, the Sandbox Mock Service allows you to intentionally trigger predefined error responses based on the value of specific fields in your request payload.

If you set a known error code as the value of a designated «simulation trigger» field, the Mock Service will return a corresponding error response with the «code» set to that value. The rest of the response structure remains unchanged.

Simulation Trigger Fields by API Function

API Function	Trigger Field
pay.toAccount	transferAmount
pay.toCard	amount
fx.rateGet	amountIn
fx.rateGet.p2a	payoutAmount
card.createToken	cardNumber
card.infoGet	pan
partner.statementGet	currency
getBalance	currency
task.statusGet	identifier or invoiceId

Note:

The GET /processing/status/{globalId} endpoint operates differently from the other API functions described above. It does not accept a request body — instead, it uses a globalId as a path parameter. These globalId values are dynamically generated by other API functions in the Sandbox environment and returned in their responses. You can use these values to test the GET /processing/status/ endpoint. The error simulation feature does not apply to this endpoint.

Example for pay.toCard

To simulate an error with code 3002 when calling the pay.toCard API, set the amount field as follows:

"amount": 3002

The Mock Service will respond with:

"result": {
  "status": "Error",
  "code": 3002,
  "comment": "Unable to decrypt tokenised card. Please try again with the corrected card token."
}

Summary of Behavior

Request Content	Response Behavior
Any valid request without a simulation trigger field set to a known error code.	«code»: 0 success response with static identifiers (except for globalId, which is dynamically generated).
Request where a simulation trigger field is set to a valid error code.	Predefined error response with «code» set to the specified error code

Error Code to API Function Mapping

Enterprise API will provide you with a detailed description of an error using error codes provided here.

Notes

• The Sandbox Mock Service is intended for testing purposes only and does not perform actual payment processing.
• The service provides consistent, static responses to simplify integration testing.
• For production environments, actual business logic and real-time payment processing apply.

POST /processing

card.createToken

Template for payload model

info

See the full example in the Endpoints

{
    "cardNumber": "4539025531693033",
    "expDate": "05/23"
}

Possible values

• Fields cardNumber and expDate must be filled in for the successful response
• If one of the specified fields is missing, there will be the 1000 code error

fx.rateGet

Get the live indicative FX rate for a payment method. Use fx.rateGet to get FX for payouts to cards. Use fx.rateGet.p2a to get FX for payouts to bank accounts.📄️ fx.rateGetTemplate for payload model📄️ fx.rateGet.p2aTemplate for payload model

fx.rateGet

Template for payload model

info

See the full example in the Endpoints

{
    "currencyIn": "EUR",
    "currencyOut": "GBP",
    "amountIn": 10,
    "paysystem": "VISA"
}

Possible values of amountIn

• Any for the successful response
• 1000
• 3005

fx.rateGet.p2a

Template for payload model

info

See the full example in the Endpoints

{
    "payoutAmount": "5",
    "payinCurrency": "USD",
    "payoutCountry": "PK",
    "payoutCurrency": "PKR"
}

Possible values of payoutAmount

• Any for the successful response
• 1000
• 3005

card.infoGet

Template for payload model

info

See the full example in the Endpoints

{
    "pan": "4539000000003033"
}

Possible values of amountIn

• Field pan must be filled in for the successful response
• Missing field will result in the 1000 code error

partner.statementGet

Template for payload model

info

See the full example in the Endpoints

{
    "currency": "USD",
    "createdRange": {
        "from": "2024-10-01T00:00:00+01:00",
        "to": "2024-11-13T23:59:59+01:00"
    },
    "pageNumber": 1,
    "pageSize": 20
}

Possible values

• currency
  • Any for a successful response
  • «3006»
• ‘pageNumber’
  • 1 for a successful response with the first page
  • Any for a successful response with the blank page
• Mismatch of fields in the template will result in the 1000 code error

pay.toAccount

Template for payload model

info

See the full example in the Endpoints

{
    "from": {
        "sender": {
            "address": {
                "addressLine1": "123 Main St",
                "addressLine2": "Apt 4B",
                "city": "New York",
                "country": "US",
                "countrySubdivision": "NY",
                "zip": 12345
            },
            "email": "john.doe@example.com",
            "phone": 5551234567,
            "governmentId": {
                "type": "SocialSecurityNumber",
                "number": 1234567890,
                "issuingCountry": "GB",
                "issueDate": "2023-05-05",
                "expirationDate": "2026-01-01"
            },
            "type": "LegalEntity",
            "name": "Compa",
            "countryOfBirth": "EC",
            "dateOfEncorporation": "1982-02-02",
            "placeOfBirth": "Los Angeles",
            "occupation": "tourist",
            "senderRelationshipWithBeneficiary": "brother",
            "nationality": "US",
            "senderAccount": {
                "identifierType": "BAN",
                "accountIdentifier": "GB82WEST12345698765432",
                "accountType": "checking",
                "accountName": "GB82WE",
                "bic": "ABCDGB2L",
                "bankCode": "A",
                "bankCodeType": "default",
                "branchCode": "B",
                "branchName": "London",
                "bankName": "London",
                "country": "US",
                "currency": "USD",
                "provider": "paypal"
            }
        },
        "sourceTransactionInstrument": {
            "identifierType": "PrepaidAccount",
            "accountIdentifier": "52eab379-0bfe-4e04-9285-75fff9085765",
            "currency": "USD"
        }
    },
    "to": {
        "destinationTransactionInstrument": {
            "identifierType": "BAN",
            "accountIdentifier": "GB82WEST12345698765432",
            "accountType": "checking",
            "accountName": "GB82WE",
            "bic": "ABCDGB2L",
            "bankCode": "A",
            "bankCodeType": "default",
            "branchCode": "B",
            "branchName": "Berlin",
            "bankName": "Berlin",
            "country": "EC",
            "currency": "USD",
            "provider": "paypal"
        },
        "recipient": {
            "address": {
                "addressLine1": "123 Business Blvd",
                "addressLine2": "Suite 200",
                "city": "Metropolis",
                "country": "US",
                "countrySubdivision": "CA",
                "zip": 6390
            },
            "type": "Individual",
            "firstName": "Tome",
            "middleName": null,
            "lastName": "Tomen",
            "dateOfBirth": "1980-01-01",
            "countryOfBirth": "EC",
            "placeOfBirth": "Los Angeles",
            "occupation": "securityGuard",
            "nationality": "US",
            "phone": 5551234567,
            "governmentId": {
                "type": "NationalPassport",
                "number": 1234567890,
                "issuingCountry": "GB",
                "issueDate": "2023-05-05",
                "expirationDate": "2026-01-01"
            },
            "email": "tome@example.com"
        }
    },
    "transferAmount": 100,
    "transferCurrency": "USD",
    "purposeOfPayment": "ISCCRD",
    "sourceOfFunds": "salary",
    "paymentType": "B2P",
    "invoiceId": "invoiceId",
    "comment": "This is the test payment!"
}

Possible values of transferAmount

• Any for the successful response
• 1000
• 2000
• 3008
• 4003
• 4006
• 4007
• 4008
• 4009
• 4010
• 4011
• 4012
• 4013
• 4014
• 4015
• 4016
• 4017
• 4018
• 9999

pay.toCard

Template for payload model

info

See the full example in the Endpoints

{
    "to": {
        "cardNumber": "4539025531693033",
        "firstName": "Derufrewe",
        "lastName": "Hecdioht",
        "amount": 15,
        "currency": "840",
        "birthYear": 1979,
        "nationality": "US",
        "countryOfResidence": "US"
    },
    "from": {
        "firstName": "MARTIN",
        "lastName": "THOMPSON",
        "address": {
            "zip": "99201",
            "country": "US",
            "city": "Portland",
            "address": "1812 W Riverside"
        }
    },
    "comment": "test pay.toCard",
    "invoiceId": "Test_TT11"
}

Possible values of to.amount

• Any for the successful response
• 1000
• 2000
• 3008
• 4000
• 4002
• 4003
• 4004
• 4005
• 4006
• 4007
• 9999

getBalance

Template for payload model

info

See the full example in the Endpoints

{
    "currency": "EUR"
}

Possible values of currency

• Blank, missing or any to get all balances
• EUR, GBP or USD to get the certain balance
• «1000» to get the 1000 error code

task.statusGet

Template for payload model

info

See the full example in the Endpoints

{
    "identifier": "3720f209-2f47-4fcc-4003-1526826f97c9"
}

Or

{
    "invoiceId": "INV-P2A-4003"
}

Possible values of identifier

• Any to get the 1000 code error
• pay.toAccount responses
  • b21608ea-181d-4d06-3005-50baf7ef4ea3
  • 9c003618-970d-4ee6-3006-b194c4240207
  • 3720f209-2f47-4fcc-4003-1526826f97c9
  • 28d5cc5a-59f2-4a69-4006-eb51119733b7
  • 6f09bfbd-2787-4be1-4007-736ca9ab3ee0
  • 643134f9-fa3c-421c-4008-9f1da1331e46
  • 0867b07e-27f2-4f33-4009-ac71951c8a86
  • 85acf094-d145-48fd-4010-615ee9382de0
  • a7ca33f8-f84f-4dd6-4011-62ca412940ef
  • 94168944-8a7e-4428-4012-960c63049b0f
  • da49f241-f398-414f-4013-e8b0de0411ef
  • 561e85a1-7339-45b0-4014-318f255aa907
  • 59a33eeb-524e-4646-4015-adcdafc900f3
  • eeb2110b-6e42-48d5-4016-f479622ed79f
  • 1cf50496-bb28-475a-4017-2ad35fa61f17
  • 9f487aed-631a-4646-4018-07dcd592998a
• pay.toCard responses
  • a4589f49-2df2-4081-4000-a0cdca07fdd9
  • 2f0e617a-e683-4d80-4002-2d31e3f8d7b8
  • fd0abd9b-42bb-4553-4003-60b65fcdecd0
  • ef952a9e-c2aa-44ec-4004-8e94069ced00
  • dd05ca6d-caca-4d73-4005-035f91e4c2b2
  • 0f3774d9-2b21-43b1-4006-714b91bad366
  • 61578af5-640d-476b-4007-2114eadb8880

Possible values of invoiceId

• Any to get the 1000 code error
• INV-3005
• INV-3006
• pay.toAccount responses
  • INV-P2A-4003
  • INV-P2A-4006
  • INV-P2A-4007
  • INV-P2A-4008
  • INV-P2A-4009
  • INV-P2A-4010
  • INV-P2A-4011
  • INV-P2A-4012
  • INV-P2A-4013
  • INV-P2A-4014
  • INV-P2A-4015
  • INV-P2A-4016
  • INV-P2A-4017
  • INV-P2A-4018
• pay.toCard responses
  • INV-P2C-4000
  • INV-P2C-4002
  • INV-P2C-4003
  • INV-P2C-4004
  • INV-P2C-4005
  • INV-P2C-4006
  • INV-P2C-4007

Statuses description

Statuses are a key component of the API. A request will either have one of three statuses: Accepted, InProgress, Finished. Within a request, each task will have a status and status code. Therefore, a request has a status and each task has its own status.

Request

Below are the status descriptions specifically for the request’s status. A request is the main item of workflow and understanding the status flow is important. In a simple view all requests always have this flow: Accepted -> InProgress -> Finished.

Accepted

This status assigned to request if the request is successful and passed all incoming checks such as partner checks, signature checks, security checks, finance checks etc. After all checks, the system accepts the request for processing and assigns the status Accepted to the request. At this stage, we understand which processing block will initially process the request and apply all required internal tasks for successful processing resources.

InProgress

As soon as the request is accepted on the previous stage, the processing block starts processing the request and the internal system assigns status InProgress to the request. This status means that the processing block is now working on the request. Remember, that each request can contain a task list, and processing flow can be complex with multiple tasks.

Finished

This status assigned to the request when the request is complete and there are no more tasks which require processing. Important to note, that status Finished don’t mean that all task was successfully finished. This status means only all work finished. For understanding success or fail of each task, please see the task status section.

Task

As outlined previously, each request contains a list of tasks To simplify, each task status flow can be one of the below:

• Accepted -> InProgress -> Success
• Accepted -> InProgress -> Error
• Accepted -> Error

Accepted

All tasks are instantly assigned this status as soon as the request is assigned the Accepted status. After this status is assigned, the processing block starts step-by-step request processing from layer 0 to the end of each tree.

InProgress

When the processing block starts processing a task the InProgress status is assigned to the task and the processing procedures for this task begins.

Success

This status indicates that the task aim was achieved and all required processing actions were successful.

Error

This status indicates that task didn’t achieve its aim and the processing mechanism incurred an error during the processing of the task. Error code and message will be additionally specified in the result object for this task.

List of error codes can be found here: Processing error codes

Task result codes

Code	Description
0	Task is in Accepted status.
1	Task is in InProgress status.
2	Task is in Success status.
3	Task is in Error status. List of error codes can be found here: Processing error codes
5	Task is waiting manual actions but is in Error status.

A manual action is required to clarify information or to continue to process the requested task. For example, if the system identifies a potential match against a sanctions list check the Error status with code 5 with be applied. The transaction is not declined but the task is processed manually. The result of manual action can be received as a result of task.statusGet function.

Guide to Tracking Task and Payment Status

This guide details the correct methods for checking the status of tasks and payments via the Paysend Enterprise API, outlining the specific use cases and limitations of each approach.

Asynchronous Tracking with Webhooks (Recommended)

Webhooks are the preferred method for status tracking. They provide scalable, real-time, event-driven updates without the need for constant polling. We offer two types of webhooks to suit different needs.

Basic Webhooks (For All Task Types)

For general-purpose tasks, you can set a webhook endpoint on a per-request basis. This is configured directly within the API payload of your call.

• How it works: You provide a callBackURI in your API request. Our system sends a notification to this URL when the task’s status changes.
• Use Case: Ideal for tracking the lifecycle of non-payment tasks, like generating a statement, requesting FX for a currency pair, or validating card details.

Expanded Webhooks (For Payment Transactions)

For robust payment tracking, we provide expanded webhook capabilities. These offer more detailed status updates specific to the payment lifecycle.

• How it works: Expanded webhooks are configured once in your back-end settings, not in individual API calls. This creates a persistent, reliable channel for all your payment status notifications. Contact your Customer Experience or Implementation manager to set this up.
• Use Case: This is the highly recommended method for all payment reconciliation and tracking.

warning

Our system processes payouts asynchronously across multiple services. When your payout request receives an initial "accepted" status, there is a brief propagation delay while the transaction details are synchronized internally. During this period, a direct status check may be unable to locate the transaction details immediately, which can result in a 3006: "Unable to find requested data" error. This indicates the data is still in transit within our system, not that the transaction has failed or your request is invalid. To ensure data consistency for exception handling, you must wait at least 3 minutes after receiving the "accepted" status before using the task.statusGet method to query a payout’s status.

Security: Signature Verification

warning

This is a critical security step for all webhooks. Every notification from Paysend includes an X-OPP-Signature in the HTTP header. Your listener endpoint must verify this signature using your shared secret key to confirm the request is authentic. Reject any request that fails verification.

Verification Process

The signature is passed in the X-OPP-Signature HTTP header. The verification process involves recreating this signature on your end and comparing it to the one received.

Here is the step-by-step algorithm:

• Receive the Webhook: Isolate the raw, unmodified JSON body of the incoming POST request and the value of the X-OPP-Signature header.
• Prepare the Input String: Create a new string by concatenating the raw request body with your secret key. The secret key should be appended directly to the end of the body string.
• Compute the Hash: Calculate the hash of the resulting concatenated string.
• Compare Hashes: Compare your computed hash with the value received in the X-OPP-Signature header. If they match exactly, the webhook is authentic.

Step-by-Step Example

Let’s walk through an example.

1. A webhook is sent to your endpoint.

HTTP Header: X-OPP-Signature: 1f373068bd1a17e4ad2ab4462e054d37 Raw Request Body:

{"webhookType":"TransactionStatusUpdate","invoiceId":"MTCN123456789","transactionId":"5d8149f7-9dd5-4784-9f25-3da3215b8a7g","status":"OnHold","statusDateTime":"2025-06-19T00:27:01.810858+03:00","errorCode":"5","errorDescription":"Offline Antifraud check: RFI","rrn":null,"arn":null,"traceId":null}

2. You prepare the input string for hashing. Your Secret Key: 14130906-70e2-44ae-9ac1-e5f0688ebd77

Resulting Concatenated String (Raw Body + Secret Key):

{"webhookType":"TransactionStatusUpdate","invoiceId":"MTCN123456789","transactionId":"5d8149f7-9dd5-4784-9f25-3da3215b8a7g","status":"OnHold","statusDateTime":"2025-06-19T00:27:01.810858+03:00","errorCode":"5","errorDescription":"Offline Antifraud check: RFI","rrn":null,"arn":null,"traceId":null}14130906-70e2-44ae-9ac1-e5f0688ebd77

The resulting hash (using the MD5 algorithm) will be: 1f373068bd1a17e4ad2ab4462e054d37

Synchronous Tracking with Direct API Calls

While webhooks are best for ongoing tracking, direct API calls are available for specific, on-demand checks. It’s crucial to understand the limitations of these methods.

Checking Recent Task Status (Global ID Method)

You can perform a direct status check on a task using its globalId. However, this method has a significant limitation.

• How it works: This endpoint queries the function block that processed the task. This block, and therefore your ability to query it, has a limited lifecycle of only 2-3 hours.
• Use Case: This method is only suitable for immediate, short-term checks. For example, you can use it to provide instant feedback in a user interface right after a transaction is submitted. It cannot be used for historical lookups or for reconciliation after the 2-3 hour window has passed.

Handling Payment Exceptions (task.statusGet)

For handling specific payment exceptions, the task.statusGet method is your tool.

Important: This is a reserved method and should not be used for regular polling, but it is essential for resolving complex situations.

Use task.statusGet only in these two scenarios:

1. Request for Information (RFI): If a payment status changes to OnHold, your system will be notified via your expanded webhook. After you submit the required information, you can use task.statusGet with the paymentId to confirm the RFI has been cleared.
2. Failover for Timeouts: If your system fails to receive a final status webhook for a transaction (e.g., due to a network timeout), task.statusGet should be used as a failover mechanism to retrieve the definitive status and ensure your records are accurate. This is especially important for transactions older than the 2-3 hour globalId lookup window.

Sample request:

   "tasks": [
        {
            "type": "task.statusGet",
            "payload": {
                "identifier": "827eec16-009e-49b7-92ed-dcac6c6b3082"
            }
        }
    ]


   "tasks": [
        {
            "type": "task.statusGet",
            "payload": {
                "invoiceId": "MTCN123456789"
            }
        }
    ]

Processing error codes

Apart from general Error status and corresponding HTTP code, Enterprise API will provide you with a detailed description of an error using error codes provided below.

Error code	Type	Error code description	Reason	Recommendation	Applicable API Function(s)
1000	Final	Processing error occurred.	Some generic processing error, in most cases occurs on the side of our payout partner.	Please try again later, and if this error occurs multiple times, contact customer support providing the transaction ids.	— fx.rateGet — fx.rateGet.p2a — card.createToken — card.infoGet — partner.statementGet — pay.toAccount — pay.toCard — getBalance — task.statusGet
2000	Final	You can receive the 2000 validation error in two formats:                                                - Option 1: Validation error: {field_name}, error: {error_text}. Please try again with corrected payload. - Option 2: {   "data":{     "validationResult": {       "errors": [{         "path": "transferAmount",         "value": "transferAmount",         "errorTypes": [           "0 should be greater than 0"         ]       }],       "status": "Error",       "message": "Validation error."     }   } }	Data in task payload did not pass Paysend’s internal validations.	Please correct the request data according to error description and resend the request.	— pay.toAccount — pay.toCard
3000	Final	Failed to save card.	Paysend tried to tokenize the card but did not succeed.	Please try again later, and if this error occurs multiple times, contact customer support providing the global id.
3001	Final	Tokenised card not found. Please try again with the corrected card token.	Token is valid, but the card was not found.	Please check token data and try again.
3002	Final	Unable to decrypt tokenised card. Please try again with the corrected card token.	Token provided is not valid.	Please check token data and try again.
3003	Final	Single transaction limit reached.	Transaction amount is outside of single transaction limit range.	Please try splitting the transaction amount to several transactions with amount below agreed limit for selected destination.
3004	Final	Aggregate transaction limit reached.	Transaction exeeds aggregate transaction limit.	Please try again later, once the limit will be reset.
3005	Final	Processing error occurred.	Internal error during FX rate calculation.	Please try again later, and if this error occurs multiple times, contact customer support providing the request data.	— fx.rateGet — fx.rateGet.p2a — task.statusGet
3006	Final	Unable to find requested data. Please check the request parameters and try again.	No data was found for id provided.	Please try again later, and if this error occurs multiple times, contact customer support providing the request data.	— partner.statementGet — task.statusGet
3007	Final	Failed to get saved card by token. Please try again later or use other card.	Paysend tried to get tokenized card data but did not succeed.	Please try again later, and if this error occurs multiple times, contact customer support providing the global id.
3008	Final	Wrong Source Transaction Instrument provided (no such account Id)	Source account id provided does not exist.	Please check source account id and correct the error.	— pay.toAccount — pay.toCard
3009	Final	Insufficient Balance	Virtual balance is not enough to fund the transaction.	Please top-up the balance and send transaction creation request again.
3010	Final	Bank with this UUID has been deleted. Please update bank data.	Bank UUID provided is no longer active and cannot be used.	Please stop using this id, and perform bank search request to get an updated bank UUID for your criteria.	— pay.toAccount
3011	Final	Payment with this invoiceId already exists.	There is already a successful payment with such InvoiceId. Given the idempotency rules please send a payment with a different invoiceId.	Please send a new payment with a different invoiceId.	— pay.toAccount — pay.toCard
3012	Final	Declined for compliance or fraud reasons. Please contact customer support for additional information.	Payment has been declined for compliance or fraud reasons.	Please contact customer support for additional information or send a payment to a different recipeint.	— pay.toAccount — pay.toCard
4000	Final	Generic decline. Try again and refer to card issuer if issue persists.	Generic error on Paysend’s payout partner side. Transaction will not be processed and can be resent.	Please resend the transaction.	— pay.toCard — task.statusGet
4002	Final	The issuer is temporarily unavailable or has a system issue.	Error on recepient’s bank side. Transaction was not performed and funds will be returned to source account.	Please resend the transaction.	— pay.toCard — task.statusGet
4003	Final	Approval amount or frequency limit exceeded. Try again later, send a smaller amount or use another card or account.	Transaction amount is above limits for such type of transaction on recepient’s side.	Please try again later, send a smaller amount or use another card or account.	— pay.toAccount — pay.toCard — task.statusGet
4004	Final	Insufficient funds in the recipient account. Please use a different card.	Error on recepient’s bank side. Transaction was not performed and funds will be returned to source account.	Please try again later, send a smaller amount or use another card or account.	— pay.toCard — task.statusGet
4005	Final	Issues with the card information or transaction data.	Error with transaction data.	Check transaction data for any inconsistencies, resend the transaction and contact customer support if error appears again.	— pay.toCard — task.statusGet
4006	Final	Declined due to account restrictions or bank policies. Recipient needs to contact the receiving bank.	Restrictions on receiving side.	Contact the recepient to resolve the problem or use another card.	— pay.toAccount — pay.toCard — task.statusGet
4007	Final	Declined for security or regulatory reasons. Recipient needs to contact the receiving bank.	Restrictions on receiving side.	Contact the recepient to resolve the problem or use another card.	— pay.toAccount — pay.toCard — task.statusGet
4008	Final	Account owner refused incoming money transfer. Please contact the account owner.	Account owner refused incoming transfer, money will be refunded to the account shortly.	Contact the recepient to resolve the problem or use another card/account.	— pay.toAccount — task.statusGet
4009	Final	Issues with the account information or transaction data: {error_text}.	Error with transaction data. Error text (if provided by payout partner) will be provided in error description.	Check transaction data for any inconsistencies, resend the transaction and contact customer support if error appears again.	— pay.toAccount — task.statusGet
4010	Final	Transaction cancelled.	Transaction was cancelled.	Please try again.	— pay.toAccount — task.statusGet
4011	Final	Invalid recipient currency	Recepient currency is incorrect.	Please try again with another currency.	— pay.toAccount — task.statusGet
4012	Final	Transaction amount is greater than maximum allowed for transaction	Transaction amount is too big.	Please split the transaction into several so that the amount will be below limit.	— pay.toAccount — task.statusGet
4013	Final	Incorrect IFSC or BIC code	Incorrect recepient bank’s credentials.	Please check the credentials and repeat the transaction with correct data.	— pay.toAccount — task.statusGet
4014	Final	Sender address is incorrect or invalid	Sender address is required, but the information provided is not correct.	Provide correct sender address and repeat the transaction with correct data.	— pay.toAccount — task.statusGet
4015	Final	Incorrect branch name or code	Incorrect recepient bank’s credentials.	Please check the credentials and repeat the transaction with correct data.	— pay.toAccount — task.statusGet
4016	Final	Recipient name does not match the account	Provided account has another owner name.	Please check recepient name and repeat the transaction with correct data.	— pay.toAccount — task.statusGet
4017	Final	Invalid Recipient bank account number	Account number is not correct (account does not exist).	Please check account number and repeat the transaction with correct data.	— pay.toAccount — task.statusGet
4018	Final	IBAN provided is invalid	IBAN is not correct (account does not exist).	Please check IBAN and repeat the transaction with correct data.	— pay.toAccount — task.statusGet
9999	Not final	Unknown error. Please contact customer support.	Some unexpected response from payout partner.	In most cases, the transaction will get a status update from receiving side automatically with some delay. If transaction will not receive such update, it will be reviewed by our support team. You can get details by contacting our customer support.	— pay.toAccount — task.statusGet

Endpoints

🗃️ POST /processing10 items

fx.rateGet

Get the live indicative FX rate for a payment method. Use fx.rateGet to get FX for payouts to cards. Use fx.rateGet.p2a to get FX for payouts to bank accounts.📄️ fx.rateGetGet the live indicative FX rate for payouts to cards.📄️ fx.rateGet.p2aGet the live indicative FX rate for payouts to bank accounts.

fx.rateGet

POSThttp://enterprise.sandbox.paysend.com/processing

Request

Header Parameters

• X-OPP-Signaturestring

application/json

Body Schema

header object — request header field

• requestobject (required) — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• tasksobject[]
  • Array [
  • typestring
    • Possible values: [fx.rateGet]
  • payloadobject
    • currencyIn string (Example: EUR)
    • currencyOut string (Example: USD)
    • amountIn double (Example: 1)
    • paysystem string (Example: VISA)
  • ]

Responses

Response 200 — This code is returned if the response is successful (and a specific response is required). A Response object is returned in the response.

application/json

Response Schema

header object

• requestobject — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[] (Array)
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
• responseobject
  • globalId uuid (Example: 2837dddc-9a60-4326-a8c8-ce39f07199b1)
  • id uuid (Example: 25e309c2-3a6d-4c02-881d-3d96cb0d17f7)
  • date date-time (Example: 2025-01-24T13:34:53...)
  • statusUri uri

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — dictionary for partner to store info for future use
    • property name* string
• settingsobject — information about executor (important for human interaction)
  • culture string — defines a locale for messages
  • encoding string — defines a text encoding
  • contact email — defines an email address for informational emails
  • userIp ipv4 — user IP address
• tasksobject[] (Array)
  • typestring
    • Possible values: [fx.rateGet]
  • payloadobject
    • currencyIn string (Example: EUR)
    • currencyOut string (Example: USD)
    • amountIn double (Example: 1)
    • paysystem string (Example: VISA)
  • success object[]
  • fail object[]
  • always object[]
  • expirationobject — time in which the response must happen
    • date date-time (Example: 2022-05-31T10:12:41...)

result object — execution result

• statusstring — Accepted, InProgress, Finished
  • Possible values: [Accepted, InProgress, Finished]
• code integer — 0 — Accepted, 1 — InProgress, 2 — Finished (Example: 0)
• comment string — text comment for status
• interactiveobject
  • uri string — endpoint URI for basic webhook
  • methodCallbackMethod — what http method should be used
    • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]

Schema Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "payload": {
          "currencyIn": "EUR",
          "currencyOut": "USD",
          "amountIn": 1,
          "paysystem": "VISA"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "expiration": {
          "date": "2022-05-31T10:12:41.0532311+00:00"
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3930-43ce-8d27-59e1c67b520",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "fa7a4ba8-8dc6-45f4-bb94-20b0cc53748f",
      "id": "092a8509-5c01-48b6-a248-ebf6fe4fa97b",
      "date": "2025-02-19T10:42:39.5915304+00:00",
      "statusUri": "http://host/processing/status/fa7a4ba8-8dc6-45f4-bb94-20b0cc53748f"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "fx.rateGet",
        "payload": {
          "amountIn": 1,
          "paysystem": "paysystem1",
          "currencyIn": "USD",
          "currencyOut": "GBP"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "finance": {
              "to": {
                "amount": 0.78,
                "currency": "GBP"
              },
              "from": {
                "amount": 1,
                "currency": "USD"
              },
              "rate": 0.7773223552894222
            },
            "additionalRates": [
              {
                "to": {
                  "amount": 0.78,
                  "currency": "GBP"
                },
                "from": {
                  "amount": 1,
                  "currency": "USD"
                },
                "name": "paysystem1",
                "rate": 0.778877000000001
              },
              {
                "to": {
                  "amount": 0.77,
                  "currency": "GBP"
                },
                "from": {
                  "amount": 1,
                  "currency": "USD"
                },
                "name": "paysystem2",
                "rate": 0.7690259716989214
              },
              {
                "to": {
                  "amount": 0.76,
                  "currency": "GBP"
                },
                "from": {
                  "amount": 1,
                  "currency": "USD"
                },
                "name": "paysystem3",
                "rate": 0.7633587786259542
              }
            ]
          }
        },
        "expiration": {
          "date": "2025-02-19T11:22:34.9150572+00:00"
        }
      }
    ]
  }
}

Response 400 — This code is returned if there is an issue in the request and an Error object is returned in the response.

Response 401 — That code is returned by system if the Signature or other partner information is incorrect.

Response 404 — This code is returned if the system cannot process the request now. If this code is received, a repeat request is submitted after a few seconds. If the code continues to be returned, this is escalated to the Support team. The system will return a response body with the text Sorry. Can't accept your request now.

javascript examples

FETCH for example from schema

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "currencyIn": "EUR",
          "currencyOut": "USD",
          "amountIn": 1,
          "paysystem": "VISA"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

FETCH for example from sandbox

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "232db864-3930-43ce-8d27-59e1c67b520",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "fx.rateGet",
        "payload": {
          "currencyIn": "USD",
          "currencyOut": "GBP",
          "amountIn": 1,
          "paysystem": "VISA"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

JQUERY for example from schema

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "string",
        "date": "string"
      },
      "service": {
        "sync": false,
        "result": [
          {
            "uri": "string"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "string",
        "parameters": {}
      },
      "tasks": [
        {
          "payload": {
            "currencyIn": "EUR",
            "currencyOut": "USD",
            "amountIn": 1,
            "paysystem": "VISA"
          }
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

JQUERY for example from sandbox

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "232db864-3930-43ce-8d27-59e1c67b520",
        "date": "2022-01-01T00:00:00+03:00"
      },
      "service": {
        "sync": false,
        "waitTime": "WaitFor2000",
        "result": [
          {
            "type": "web",
            "uri": "https://example.com",
            "method": "get"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "universal"
      },
      "tasks": [
        {
          "type": "fx.rateGet",
          "payload": {
            "currencyIn": "USD",
            "currencyOut": "GBP",
            "amountIn": 1,
            "paysystem": "VISA"
          }
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

XHR

// WARNING: For POST requests, body is set to null by browsers.
var data = JSON.stringify({
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "currencyIn": "EUR",
          "currencyOut": "USD",
          "amountIn": 1,
          "paysystem": "VISA"
        }
      }
    ]
  }
});

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://enterprise.sandbox.paysend.com/processing");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Accept", "application/json");

xhr.send(data);

Request

Body

Example from schema

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "currencyIn": "EUR",
          "currencyOut": "USD",
          "amountIn": 1,
          "paysystem": "VISA"
        }
      }
    ]
  }
}

Example from Sandbox

{
  "header": {
    "request": {
      "id": "232db864-3930-43ce-8d27-59e1c67b520",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "fx.rateGet",
        "payload": {
          "currencyIn": "USD",
          "currencyOut": "GBP",
          "amountIn": 1,
          "paysystem": "VISA"
        }
      }
    ]
  }
}

Example from mock sandbox

{
  "header": {
    "request": {
      "id": "a92b5838-11da-4e75-875f-810fec3df810",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "fx.rateGet",
        "payload": {
          "currencyIn": "EUR",
          "currencyOut": "GBP",
          "amountIn": 10,
          "paysystem": "VISA"
        }
      },
      {
        "type": "fx.rateGet",
        "payload": {
          "currencyIn": "USD",
          "currencyOut": "GBP",
          "amountIn": 1000,
          "paysystem": "VISA"
        }
      }
    ]
  }
}

fx.rateGet.p2a

POST http://enterprise.sandbox.paysend.com/processing

Get the live indicative FX rate for payouts to bank accounts.

Request

Header Parameters

• X-OPP-Signature string

application/json

Body Schema (application/json)

header object — request header field

requestobject (required) — identifiers of request

• id string (required) — request identifier (Formed on the requester’s side)
• date datetime — request creation date

• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — dictionary for partner to store information for future use
    • property name* string
• tasksobject[]
  • Array [
  • typestring
    • Possible values: [fx.rateGet.p2a]
  • payloadobject
    • payinCurrency string (required) — The currency of the payin amount (Example: USD)
    • payoutCurrency string (required) — The currency of the payout amount (Example: EUR)
    • payoutAmount string (required) — The amount to be paid out (Example: 100)
    • payoutCountry string (required) — The country where the payout will occur (Example: UK)
    • providerstring — Provider name needed for digital wallet FX rates
      • Possible values: [WECHATPAY, ALIPAY] (Example: WECHATPAY)
  • ]

Responses

200 — This code is returned if the response is successful (and a specific response is required). A Response object is returned in the response.

application/json

Response Schema

header object

• requestobject — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • uri string, method CallbackMethod
• responseobject
  • globalId uuid, id uuid, date date-time, statusUri uri

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner
  • identifier string, parameters object
• settingsobject — information about executor
  • culture, encoding, contact, userIp
• tasksobject[]
  • Array [
  • type string (Possible values: [fx.rateGet.p2a])
  • payloadobject
    • payinCurrency string (required) (Example: USD)
    • payoutCurrency string (required) (Example: EUR)
    • payoutAmount string (required) (Example: 100)
    • payoutCountry string (required) (Example: UK)
    • provider string (Possible values: [WECHATPAY, ALIPAY])
  • success object[], fail object[], always object[]
  • resultobject
    • status string, code integer, comment string
    • dataobject
      • to object (amount double, currency string)
      • from object (amount double, currency string)
      • rate float (Example: 1.4900588123203304)
  • ]

result object — execution result

• statusstring — enumerable info: Accepted, InProgress, Finished
  • Possible values: [Accepted, InProgress, Finished]
• code integer — 0 — Accepted, 1 — InProgress, 2 — Finished
• comment string — text comment for status
• interactiveobject
  • uri string, method CallbackMethod

Schema Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "payload": {
          "payinCurrency": "USD",
          "payoutCurrency": "EUR",
          "payoutAmount": "100",
          "payoutCountry": "UK",
          "provider": "WECHATPAY"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": 0,
          "data": {
            "to": {
              "amount": 0.91,
              "currency": "EUR"
            },
            "from": {
              "amount": 0.91,
              "currency": "EUR"
            },
            "rate": 1.4900588123203304
          },
          "comment": "string"
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

Schema Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3930-43ce-8d27-59e1c67b620",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "ff230b2c-2ca8-4a2d-b49f-9bdf1459cbdb",
      "id": "6c99146e-f1cd-48d6-94e9-18ce8dff369c",
      "date": "2025-02-19T10:48:51.6674562+00:00",
      "statusUri": "http://host/processing/status/ff230b2c-2ca8-4a2d-b49f-9bdf1459cbdb"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "fx.rateGet.p2a",
        "payload": {
          "payoutAmount": "5",
          "payinCurrency": "USD",
          "payoutCountry": "PK",
          "payoutCurrency": "PKR"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "to": {
              "amount": 5,
              "currency": "PKR"
            },
            "from": {
              "amount": 0.02,
              "currency": "USD"
            },
            "rate": 276.8377253814147
          }
        },
        "expiration": {
          "date": "2025-02-19T11:28:50.0486775+00:00"
        }
      }
    ]
  }
}

javascript FETCH for Example from schema

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "payinCurrency": "USD",
          "payoutCurrency": "EUR",
          "payoutAmount": "100",
          "payoutCountry": "UK",
          "provider": "WECHATPAY"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript FETCH for example from Sandbox

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "232db864-3930-43ce-8d27-59e1c67b620",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "fx.rateGet.p2a",
        "payload": {
          "payoutAmount": "5",
          "payinCurrency": "USD",
          "payoutCountry": "PK",
          "payoutCurrency": "PKR"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript JQUERY for example from schema

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "string",
        "date": "string"
      },
      "service": {
        "sync": false,
        "result": [
          {
            "uri": "string"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "string",
        "parameters": {}
      },
      "tasks": [
        {
          "payload": {
            "payinCurrency": "USD",
            "payoutCurrency": "EUR",
            "payoutAmount": "100",
            "payoutCountry": "UK",
            "provider": "WECHATPAY"
          }
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

javascript JQUERY for example from sandbox

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "232db864-3930-43ce-8d27-59e1c67b620",
        "date": "2022-01-01T00:00:00+03:00"
      },
      "service": {
        "sync": false,
        "waitTime": "WaitFor2000",
        "result": [
          {
            "type": "web",
            "uri": "https://example.com",
            "method": "get"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "universal"
      },
      "tasks": [
        {
          "type": "fx.rateGet.p2a",
          "payload": {
            "payoutAmount": "5",
            "payinCurrency": "USD",
            "payoutCountry": "PK",
            "payoutCurrency": "PKR"
          }
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

javascript XHR

// WARNING: For POST requests, body is set to null by browsers.
var data = JSON.stringify({
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "payinCurrency": "USD",
          "payoutCurrency": "EUR",
          "payoutAmount": "100",
          "payoutCountry": "UK",
          "provider": "WECHATPAY"
        }
      }
    ]
  }
});

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://enterprise.sandbox.paysend.com/processing");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Accept", "application/json");

xhr.send(data);

Request

Base URL — http://enterprise.sandbox.paysend.com

Parameters

• X-OPP-Signature — header required (X-OPP-Signature)

Body

Example (from schema)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "payinCurrency": "USD",
          "payoutCurrency": "EUR",
          "payoutAmount": "100",
          "payoutCountry": "UK",
          "provider": "WECHATPAY"
        }
      }
    ]
  }
}

Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3930-43ce-8d27-59e1c67b620",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "fx.rateGet.p2a",
        "payload": {
          "payoutAmount": "5",
          "payinCurrency": "USD",
          "payoutCountry": "PK",
          "payoutCurrency": "PKR"
        }
      }
    ]
  }
}

Example (for mock sandbox)

{
  "header": {
    "request": {
      "id": "8c850bc4-4c35-4f6a-8242-322e8bf98127",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "fx.rateGet.p2a",
        "payload": {
          "payoutAmount": "5",
          "payinCurrency": "USD",
          "payoutCountry": "PK",
          "payoutCurrency": "PKR"
        }
      },
      {
        "type": "fx.rateGet.p2a",
        "payload": {
          "payoutAmount": "1000",
          "payinCurrency": "GBP",
          "payoutCountry": "GB",
          "payoutCurrency": "EUR"
        }
      }
    ]
  }
}

bank.get

POST http://enterprise.sandbox.paysend.com/processing

Get information on a specific bank (including routing code, address and other details) to use in payout transaction.

Request

Body Schema

header object — request header field

• requestobject (required) — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• tasksobject[]
  • Array [
  • typestring
    • Possible values: [bank.get]
  • payloadobject
    • bankId uuid — The code which identifies the bank
  • ]

Responses

header object

• requestobject — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]
• responseobject
  • globalId uuid (Example: 2837dddc-9a60-4326-a8c8-ce39f07199b1)
  • id uuid (Example: 25e309c2-3a6d-4c02-881d-3d96cb0d17f7)
  • date date-time (Example: 2025-01-24T13:34:53.0004766+00:00)
  • statusUri uri

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — dictionary used by partner to store information for future use
    • property name* string
• settingsobject — information about executor, important for human interaction
  • culture string — defines a locale for messages
  • encoding string — defines a text encoding used in processing
  • contact email — defines an email address for informational emails
  • userIp ipv4 — user IP address
• tasksobject[]
  • Array [
  • typestring
    • Possible values: [bank.get]
  • payloadobject
    • bankId uuid — The code which identifies the bank
  • success object[]
  • fail object[]
  • always object[]
  • resultobject
    • status string
    • code integer
    • comment string
  • ]

result object — execution result

• statusstring — enumerable information about execution status
  • Possible values: [Accepted, InProgress, Finished]
• code integer — numeric representation: 0 — Accepted, 1 — InProgress, 2 — Finished (Example: 0)
• comment string — text comment for status
• interactiveobject
  • uri string — endpoint URI for basic webhook
  • methodCallbackMethod — what http method should be used
    • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]

Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "payload": {
          "bankId": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": 0,
          "comment": "string"
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "683a5363-ebfc-4502-8a4f-8b2965e70727",
      "id": "390764b7-cf65-4548-b7b6-d13c4e4f045d",
      "date": "2025-02-20T17:19:07.071869+00:00",
      "statusUri": "http://host/processing/status/683a5363-ebfc-4502-8a4f-8b2965e70727"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "bank.get",
        "payload": {
          "bankId": "33868156-211e-4c64-aa45-e878f2c2a41e"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "result": {
              "id": "33868156-211e-4c64-aa45-e878f2c2a41e",
              "bic": "Credit Consumer",
              "city": "Sao Paulo",
              "natId": null,
              "name": "Banco Citibank SA",
              "address": "Avda Imirim 1166/1170, 2o. e 3o. Pa",
              "postCode": "02464-100",
              "createdAt": null,
              "natIdType": null,
              "branchName": "Casa Verde",
              "countryCode": "BR"
            }
          }
        }
      }
    ]
  }
}

Request

Base URL — http://enterprise.sandbox.paysend.com

Parameters

• X-OPP-Signature — header required (X-OPP-Signature)

Body

javascript FETCH Example (from schema)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "bankId": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript JQUERY Example (from schema)

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "string",
        "date": "string"
      },
      "service": {
        "sync": false,
        "result": [
          {
            "uri": "string"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "string",
        "parameters": {}
      },
      "tasks": [
        {
          "payload": {
            "bankId": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
          }
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

javascript XHR

// WARNING: For POST requests, body is set to null by browsers.
var data = JSON.stringify({
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "bankId": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
        }
      }
    ]
  }
});

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://enterprise.sandbox.paysend.com/processing");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Accept", "application/json");

xhr.send(data);

javascript FETCH Example (from sandbox)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "tasks": [
      {
        "payload": {
          "bankId": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
        }
      }
    ]
  }
}

javascript JQUERY Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "bank.get",
        "payload": {
          "bankId": "33868156-211e-4c64-aa45-e878f2c2a41e"
        }
      }
    ]
  }
}

bank.search

POST http://enterprise.sandbox.paysend.com/processing

Searches across both bank names and BIC/SWIFT codes.

Request Body Schema

header object — request header field

• requestobject (required) — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner
  • identifier string — partner identifier
  • parametersobject — dictionary for partner to store information for future use
    • property name* string
• tasksobject[]
  • Array [
  • typestring
    • Possible values: [bank.search]
  • payloadobject
    • query string — Search query
    • queryTypestring — Type of value in query field (Default: «combined»)
      • Possible values: [combined, name, routingCode] (Example: name)
    • country string — The country code in ISO 3166-1 alpha-2 format (Example: US)
    • limit integer — Maximum results to return per page (Example: 20)
    • page integer — Specifies page of returned search results (Example: 1)
    • bicAvailable boolean — Flag to return only records containing BIC (Default: false)
    • accountIdentifierTypestring
      • Possible values: [BAN, IBAN, SWIFT, CLABE]
    • currency string — Currency for payout (3 characters)
  • ]

Responses

header object

• requestobject — identifiers of request
  • id string (required), date datetime
• serviceobject — additional settings
  • sync boolean (required), waitTime string
  • result object[] (Array) — webhook endpoints
• responseobject
  • globalId uuid, id uuid, date date-time, statusUri uri

payload object

• partner object: identifier, parameters
• settings object: culture, encoding, contact, userIp
• tasksobject[]
  • Array [
  • type string: bank.search
  • payload object: query, queryType, country, limit, page, etc.
  • success/fail/always object[]
  • resultobject
    • status string, code integer, comment string
    • dataobject
      • resultobject
        • dataobject
          • city string (Example: Porto Alegre)
          • name string (Example: Banco Agibank SA)
          • address string, postCode string, branchName string
          • countryCode string (Example: BR)
          • routingCodes object: id, bic, natId, natIdType
        • page integer, resultsCount integer
  • ]

result object — execution result

• status string, code integer, comment string
• interactive object: uri, method

Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "payload": {
          "query": "string",
          "queryType": "name",
          "country": "US",
          "limit": 20,
          "page": 1,
          "bicAvailable": true,
          "accountIdentifierType": "BAN",
          "currency": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": 0,
          "comment": "string"
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "683a5363-ebfc-4502-8a4f-8b2965e70727",
      "id": "390764b7-cf65-4548-b7b6-d13c4e4f045d",
      "date": "2025-02-20T17:19:07.071869+00:00",
      "statusUri": "http://host/processing/status/683a5363-ebfc-4502-8a4f-8b2965e70727"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "bank.search",
        "payload": {
          "country": "US",
          "query": "banco"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "result": {
              "data": {
                "result": {
                  "data": {
                    "city": "Porto Alegre",
                    "name": "Banco Agibank SA",
                    "address": "RUA SERGIO FERNANDES BORGES SOARES",
                    "postCode": "13054-709",
                    "branchName": "Mariante Street, 25",
                    "countryCode": "BR",
                    "routingCodes": {
                      "id": "5635e98e-0a3f-4906-a1d7-1c66b3456ce1",
                      "bic": null,
                      "natId": 1210121,
                      "natIdType": "BRRN"
                    }
                  },
                  "page": 1,
                  "resultsCount": 1
                }
              }
            }
          }
        }
      }
    ]
  }
}

Request

Base URL — http://enterprise.sandbox.paysend.com

Parameters

• X-OPP-Signature — header required (X-OPP-Signature)

javascript FETCH Example (from sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "bank.search",
        "payload": {
          "query": "bank",
          "queryType": "name",
          "country": "US"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript JQUERY Example (from sandbox)

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "232db864-3931-43ce-8d27-59e1c67b4347",
        "date": "2022-01-01T00:00:00+03:00"
      },
      "service": {
        "sync": false,
        "waitTime": "WaitFor2000",
        "result": [
          {
            "type": "web",
            "uri": "https://example.com",
            "method": "get"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "universal"
      },
      "tasks": [
        {
          "type": "bank.search",
          "payload": {
            "query": "bank",
            "queryType": "name",
            "country": "US"
          }
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

javascript XHR Example (from sandbox)

// WARNING: For POST requests, body is set to null by browsers.
var data = JSON.stringify({
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "bank.search",
        "payload": {
          "query": "bank",
          "queryType": "name",
          "country": "US"
        }
      }
    ]
  }
});

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://enterprise.sandbox.paysend.com/processing");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Accept", "application/json");

xhr.send(data);

Body Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "bank.search",
        "payload": {
          "query": "bank",
          "queryType": "name",
          "country": "US"
        }
      }
    ]
  }
}

card.createToken

POST http://enterprise.sandbox.paysend.com/processing

Tokenize a card number before sending a payment instruction.

Request

Body Schema (application/json)

header object — request header field

• requestobject (required) — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• tasksobject[]
  • Array [
  • typestring
    • Possible values: [card.createToken]
  • payloadobject
    • cardNumber string (required) — 16-digit card number to be tokenized
    • expDate string — card expiration date in ‘MM/YY’ format
  • ]

Responses

header object

• requestobject — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]
• responseobject
  • globalId uuid (Example: 2837dddc-9a60-4326-a8c8-ce39f07199b1)
  • id uuid (Example: 25e309c2-3a6d-4c02-881d-3d96cb0d17f7)
  • date date-time (Example: 2025-01-24T13:34:53.0004766+00:00)
  • statusUri uri

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• settingsobject — information about executor, it is important if there is interaction with humans in the request
  • culture string — defines a locale for messages
  • encoding string — defines a text encoding that will be used in processing
  • contact email — defines an email address for informational emails about processing
  • userIp ipv4 — user IP address, knowing on executor’s side
• tasksobject[]
  • Array [
  • typestring
    • Possible values: [card.createToken]
  • payloadobject
    • cardNumber string (required) — 16-digit card number to be tokenized
    • expDate string — card expiration date in ‘MM/YY’ format
  • success object[]
  • fail object[]
  • always object[]
  • resultobject
    • status string
    • code integer
    • dataobject
      • token uuid (Example: 0a2d7bae-e53d-448b-b7bd-60e0774b4daa)
      • cardNumber string — Masked card number (Example: 539307******9854)
      • resultCode integer (Example: 0)
      • countryCode string (Example: 068)
      • paymentSystem string (Example: MASTERCARD)
      • currencyIsoCode string (Example: EUR)
    • comment string
  • ]

result object — execution result

• statusstring — enumerable information about execution status: Accepted, InProgress, Finished
  • Possible values: [Accepted, InProgress, Finished]
• code integer — numeric representation of execution status: 0 — Accepted, 1 — InProgress, 2 — Finished (Example: 0)
• comment string — text comment for status
• interactiveobject
  • uri string — endpoint URI for basic webhook
  • methodCallbackMethod — what http method should be used
    • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]

Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "payload": {
          "cardNumber": "string",
          "expDate": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": 0,
          "data": {
            "token": "0a2d7bae-e53d-448b-b7bd-60e0774b4daa",
            "cardNumber": "539307******9854",
            "resultCode": 0,
            "countryCode": "068",
            "paymentSystem": "MASTERCARD",
            "currencyIsoCode": "EUR"
          },
          "comment": "string"
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

Example (from sandbox)

{
  "header": {
    "request": {
      "id": "d60b5933-9778-4861-95ea-59eac0e3847",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "d9be1e00-77c7-47b1-8c28-697a3eaf7623",
      "id": "da4ee8d1-0c23-4b83-b79c-24b872fb1b8e",
      "date": "2025-02-18T18:58:41.8924668+00:00",
      "statusUri": "http://host/processing/status/d9be1e00-77c7-47b1-8c28-697a3eaf7623"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "card.createToken",
        "payload": {
          "cardNumber": "4539025531693033"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "token": "7b48c86e-b583-4947-8bb6-7cd6b2a3f0ab",
            "cardNumber": "453902******3033",
            "resultCode": 0,
            "countryCode": "040",
            "paymentSystem": "VISA",
            "currencyIsoCode": "EUR"
          }
        },
        "expiration": {
          "date": "2025-02-18T19:38:40.2010407+00:00"
        }
      }
    ]
  }
}

javascript FETCH Example (from sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "d60b5933-9778-4861-95ea-59eac0e3847",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.createToken",
        "payload": {
          "cardNumber": "4539025531693033"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript FETCH Example (for mock sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "13a99165-4444-41b3-b195-9d66a4372b4c",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.createToken",
        "payload": {
          "cardNumber": "4539025531693033",
          "expDate": "05/23"
        }
      },
      {
        "type": "card.createToken",
        "payload": {}
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript JQUERY Example (from sandbox)

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "d60b5933-9778-4861-95ea-59eac0e3847",
        "date": "2022-01-01T00:00:00+03:00"
      },
      "service": {
        "sync": false,
        "waitTime": "WaitFor2000",
        "result": [
          {
            "type": "web",
            "uri": "https://example.com",
            "method": "get"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "universal"
      },
      "tasks": [
        {
          "type": "card.createToken",
          "payload": {
            "cardNumber": "4539025531693033"
          }
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

javascript JQUERY Example (for mock sandbox)

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "13a99165-4444-41b3-b195-9d66a4372b4c",
        "date": "2022-01-01T00:00:00+03:00"
      },
      "service": {
        "sync": false,
        "waitTime": "WaitFor2000",
        "result": [
          {
            "type": "web",
            "uri": "https://example.com",
            "method": "get"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "universal"
      },
      "tasks": [
        {
          "type": "card.createToken",
          "payload": {
            "cardNumber": "4539025531693033",
            "expDate": "05/23"
          }
        },
        {
          "type": "card.createToken",
          "payload": {}
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

javascript XHR

// WARNING: For POST requests, body is set to null by browsers.
var data = JSON.stringify({
  "header": {
    "request": {
      "id": "d60b5933-9778-4861-95ea-59eac0e3847",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.createToken",
        "payload": {
          "cardNumber": "4539025531693033"
        }
      }
    ]
  }
});

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://enterprise.sandbox.paysend.com/processing");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Accept", "application/json");

xhr.send(data);

Request

Base URL — http://enterprise.sandbox.paysend.com

Parameters

• X-OPP-Signature — header required (X-OPP-Signature)

Body Example (from sandbox)

{
  "header": {
    "request": {
      "id": "d60b5933-9778-4861-95ea-59eac0e3847",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.createToken",
        "payload": {
          "cardNumber": "4539025531693033"
        }
      }
    ]
  }
}

Body Example (for mock sandbox)

{
  "header": {
    "request": {
      "id": "13a99165-4444-41b3-b195-9d66a4372b4c",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.createToken",
        "payload": {
          "cardNumber": "4539025531693033",
          "expDate": "05/23"
        }
      },
      {
        "type": "card.createToken",
        "payload": {}
      }
    ]
  }
}

card.infoGet

POST http://enterprise.sandbox.paysend.com/processing

Get information on the card including bank details, card scheme, card product and other details as provided by card schemes.

Currently card.infoGet supports the following payment card systems:

• Visa
• Mastercard
• China Union Pay
• Humo
• Uzcard
• Elcart

For Visa and Mastercard, you should always confirm that a card can receive real-time credits and check if recipients should expect immediate fund availability:

• Fast Funds: Indicates if the card supports faster payment settlement, ensuring real-time funds delivery to the recipient.
• OCT Domestic and OCT Cross Border: Confirms the card is enabled for international Original Credit Transactions (push to card payments).

Other properties include country, payment system, bank name and card product details and are provided in the API response if available in the source file from the card scheme. Validating cards against these properties helps prevent declines, improve user experience, and optimize processing.

Request

Body Schema (application/json)

header object — request header field

• requestobject (required) — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• tasksobject[]
  • Array [
  • typestring
    • Possible values: [card.infoGet]
  • payloadobject
    • pan string — primary account number or card number
  • ]

Response Schema

header object

• requestobject — identifiers of request
  • id string (required), date datetime
• serviceobject — additional settings
  • sync boolean (required), waitTime string
  • result object[] (webhook array: uri, method)
• responseobject
  • globalId uuid, id uuid, date date-time, statusUri uri

payload object — trees of tasks and configurations

• partner object: identifier, parameters
• settings object: culture, encoding, contact, userIp
• tasksobject[]
  • Array [
  • type string: card.infoGet
  • payload object: pan string (primary account number)
  • success/fail/always object[]
  • resultobject
    • status string, code integer, comment string
    • dataobject
      • fees object[]
      • extendedobject
        • octobject (Original Credit Transaction)
          • domestic [Y, N], crossBorder [Y, N]
        • description string
        • fasterFundsobject
          • domestic [Y, N], crossBorder [Y, N]
        • productType string, settlementCurrency string, settlementCurrencyAlphaCode string
      • paysystemobject
        • bank string, country string
        • bin_range object: to string, from string
        • account_type string, paysystem_type string
  • ]

result object — execution result

• status string: [Accepted, InProgress, Finished]
• code integer: 0, 1, 2
• comment string
• interactive object: uri, method

Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "payload": {
          "pan": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": 0,
          "data": {
            "fees": [
              {}
            ],
            "extended": {
              "oct": {},
              "description": "string",
              "fasterFunds": {},
              "productType": "string",
              "settlementCurrency": "string",
              "settlementCurrencyAlphaCode": "string"
            },
            "paysystem": {
              "bank": "string",
              "country": "string",
              "bin_range": {
                "to": "string",
                "from": "string"
              },
              "account_type": "string",
              "paysystem_type": "string"
            }
          }
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "683a5363-ebfc-4502-8a4f-8b2965e70727",
      "id": "390764b7-cf65-4548-b7b6-d13c4e4f045d",
      "date": "2025-02-20T17:19:07.071869+00:00",
      "statusUri": "http://host/processing/status/683a5363-ebfc-4502-8a4f-8b2965e70727"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "card.infoGet",
        "payload": {
          "pan": "4539000000003033"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "fees": [],
            "extended": {
              "oct": {
                "domestic": "Y",
                "crossBorder": "Y"
              },
              "description": "Credit Consumer",
              "fasterFunds": {
                "domestic": "Y",
                "crossBorder": "Y"
              },
              "productType": "Credit",
              "settlementCurrency": "978",
              "settlementCurrencyAlphaCode": "EUR"
            },
            "paysystem": {
              "bank": "PAYSND",
              "country": "040",
              "product": "C",
              "bin_range": {
                "to": "453900000",
                "from": "453999999"
              },
              "account_type": "Unknown",
              "paysystem_type": "PAYMENTSYSTEMNAME"
            }
          }
        },
        "expiration": {
          "date": "2025-02-20T17:59:00.5724279+00:00"
        }
      }
    ]
  }
}

javascript FETCH Example (from sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.infoGet",
        "payload": {
          "pan": "4539000000003033"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript FETCH Example (for mock sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "044c1199-7db1-4239-a5ba-6a0d54d9254c",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.infoGet",
        "payload": {
          "pan": "4539000000003033"
        }
      },
      {
        "type": "card.infoGet",
        "payload": {}
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript JQUERY Example (from sandbox)

var settings = {
  "url": "http://enterprise.sandbox.paysend.com/processing",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Accept": "application/json"
  },
  "data": JSON.stringify({
    "header": {
      "request": {
        "id": "232db864-3931-43ce-8d27-59e1c67b4347",
        "date": "2022-01-01T00:00:00+03:00"
      },
      "service": {
        "sync": false,
        "waitTime": "WaitFor2000",
        "result": [
          {
            "type": "web",
            "uri": "https://example.com",
            "method": "get"
          }
        ]
      }
    },
    "payload": {
      "partner": {
        "identifier": "universal"
      },
      "tasks": [
        {
          "type": "card.infoGet",
          "payload": {
            "pan": "4539000000003033"
          }
        }
      ]
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

javascript XHR Example (from sandbox)

// WARNING: For POST requests, body is set to null by browsers.
var data = JSON.stringify({
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.infoGet",
        "payload": {
          "pan": "4539000000003033"
        }
      }
    ]
  }
});

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function() {
  if(this.readyState === 4) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://enterprise.sandbox.paysend.com/processing");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Accept", "application/json");

xhr.send(data);

Request

Base URL — http://enterprise.sandbox.paysend.com

Parameters

• X-OPP-Signature — header required (X-OPP-Signature)

Body Request Example (from sandbox)

{
  "header": {
    "request": {
      "id": "232db864-3931-43ce-8d27-59e1c67b4347",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.infoGet",
        "payload": {
          "pan": "4539000000003033"
        }
      }
    ]
  }
}

Body Request Example (for mock sandbox)

{
  "header": {
    "request": {
      "id": "044c1199-7db1-4239-a5ba-6a0d54d9254c",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "card.infoGet",
        "payload": {
          "pan": "4539000000003033"
        }
      },
      {
        "type": "card.infoGet",
        "payload": {}
      }
    ]
  }
}

partner.statementGet

POST http://enterprise.sandbox.paysend.com/processing

This method enables clients to request account balance statement with balance and transaction history for any period of time.

Body Schema (application/json)

header object — request header field

• requestobject (required) — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]

payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• tasksobject[]
  • Array [
  • type string — Possible values: [partner.statementGet]
  • payloadobject
    • createdRangeobject
      • from datetime
      • to datetime
    • currency string (Example: EUR)
    • pageNumber integer (Example: 1)
    • pageSize integer (Example: 100)
  • ]

## Response Schema

### header object

• requestobject — identifiers of request
  • id string (required) — request identifier (Formed on the requester’s side)
  • date datetime — request creation date
• serviceobject — additional settings
  • sync boolean (required) — sync/async request (Default value: false)
  • waitTimestring — time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]
    • Array [
    • uri string — endpoint URI for basic webhook
    • methodCallbackMethod — what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
    • ]
• responseobject
  • globalId uuid (Example: 2837dddc-9a60-4326-a8c8-ce39f07199b1)
  • id uuid (Example: 25e309c2-3a6d-4c02-881d-3d96cb0d17f7)
  • date date-time (Example: 2025-01-24T13:34:53.0004766+00:00)
  • statusUri uri

### payload object — trees of tasks and configurations

• partnerobject — properties that describes partner and additional optional parameters
  • identifier string — partner identifier
  • parametersobject — dictionary for partner to store information
    • property name* string
• settingsobject — information about executor (important for human interaction)
  • culture string, encoding string, contact email, userIp ipv4
• tasksobject[]
  • Array [
  • type string — Possible values: [partner.statementGet]
  • payloadobject
    • createdRange object: from datetime, to datetime
    • currency string (Example: EUR)
    • pageNumber integer (Example: 1)
    • pageSize integer (Example: 100)
  • success object[], fail object[], always object[]
  • resultobject
    • status string, code integer
    • dataobject
      • id uuid (Example: d7f34dca-8073-4e26-b69d-71855d409720)
      • lastPage boolean, pageNumber integer, totalPages integer
      • transactionsobject[]
        • Array [
        • id uuid (Example: 58ac34b7-112a-4ffc-b42c-5a7c5b152b8b)
        • tags undefined[] (nullable)
        • type string (Example: transfer)
        • total double (Example: 9943261.18)
        • amount double (Example: 5.08)
        • reason string (nullable)
        • comment string (nullable)
        • createdAt date-time (Example: 2024-11-21T19:23:16.661+03:00)
        • entryType [Possible values: credit, debit] (Example: credit)
        • invoiceId string (nullable) (Example: 1234)
        • reference uuid (Example: 6ba6aab6-14fe-43d1-95c0-fb9179feae7b)
        • paymentDate string (nullable) (Example: 2024-11-21T18:44:47...)
        • paymentType [Possible values: payToCard, payToAccount, preFunding, withdrawal, preFundingManual, withdrawalManual, returnToCard, returnToAccount]
        • publicTransactionId string (nullable)
        • ]
      • debitTurnover double (Example: 1237.7)
      • closingBalance double (Example: 9943261.18)
      • creditTurnover double (Example: 40.64)
      • openingBalance double (Example: 9944458.24)
      • totalTransactions integer (Example: 62)
    • comment string
  • ]

### result object — execution result

• statusstring — Accepted, InProgress, Finished
  • Possible values: [Accepted, InProgress, Finished]
• code integer — 0 — Accepted, 1 — InProgress, 2 — Finished (Example: 0)
• comment string — text comment for status
• interactiveobject
  • uri string, method CallbackMethod

Responses Example (from sandbox)

{
  "header": {
    "request": {
      "id": "237db864-3931-43ce-8d27-59e1c67r60",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "fdce731a-254c-4d08-82cb-a0104a16edba",
      "id": "6b78fbd2-ba84-4342-af20-beaf61082351",
      "date": "2025-02-20T12:02:24.1884874+00:00",
      "statusUri": "http://host/processing/status/fdce731a-254c-4d08-82cb-a0104a16edba"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "partner.statementGet",
        "payload": {
          "currency": "USD",
          "pageSize": 20,
          "pageNumber": 1,
          "createdRange": {
            "to": "2024-11-13T23:59:59+01:00",
            "from": "2024-10-01T00:00:00+01:00"
          }
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "id": "44985bbd-a8c7-4c22-a6cf-6f753ee7e38d",
            "lastPage": false,
            "pageNumber": 1,
            "totalPages": 25,
            "transactions": [
              {
                "id": "402c841f-0138-4013-8ab5-e23132dad5cb",
                "tags": null,
                "type": "transfer",
                "total": 9145503.7,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:17:30.707+03:00",
                "entryType": "credit",
                "invoiceId": null,
                "reference": "707d3903-83e1-422c-9597-f96c102a5382",
                "paymentDate": null,
                "paymentType": "preFunding",
                "publicTransactionId": null
              },
              {
                "id": "ff25489c-8ed9-4dd2-8ea6-78c40b191d5b",
                "tags": null,
                "type": "transfer",
                "total": 9145503.69,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:17:26.949+03:00",
                "entryType": "debit",
                "invoiceId": null,
                "reference": "707d3903-83e1-422c-9597-f96c102a5382",
                "paymentDate": null,
                "paymentType": "withdrawal",
                "publicTransactionId": null
              },
              {
                "id": "235d16b6-bdd8-4f73-8398-8754cec7b08e",
                "tags": null,
                "type": "transfer",
                "total": 9145503.7,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:16:30.926+03:00",
                "entryType": "credit",
                "invoiceId": null,
                "reference": "0f051cb5-ad66-4396-acd0-ac502df58515",
                "paymentDate": null,
                "paymentType": "preFunding",
                "publicTransactionId": null
              },
              {
                "id": "c4cb7f30-fdac-4b61-adda-2ab260baf266",
                "tags": null,
                "type": "transfer",
                "total": 9145503.69,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:16:27.169+03:00",
                "entryType": "debit",
                "invoiceId": null,
                "reference": "0f051cb5-ad66-4396-acd0-ac502df58515",
                "paymentDate": null,
                "paymentType": "withdrawal",
                "publicTransactionId": null
              },
              {
                "id": "b8db594e-44c7-4941-a2ea-99a0eebde181",
                "tags": null,
                "type": "transfer",
                "total": 9145503.7,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:16:13.574+03:00",
                "entryType": "credit",
                "invoiceId": null,
                "reference": "5a640f0f-2091-4fb0-ab37-5e3e525f837f",
                "paymentDate": null,
                "paymentType": "preFunding",
                "publicTransactionId": null
              },
              {
                "id": "d5a397aa-bce9-4466-948e-cc839c6a64a5",
                "tags": null,
                "type": "transfer",
                "total": 9145503.69,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:16:09.919+03:00",
                "entryType": "debit",
                "invoiceId": null,
                "reference": "5a640f0f-2091-4fb0-ab37-5e3e525f837f",
                "paymentDate": null,
                "paymentType": "withdrawal",
                "publicTransactionId": null
              },
              {
                "id": "b3b7152f-a74d-4c84-bd17-e629a6fed14a",
                "tags": null,
                "type": "transfer",
                "total": 9145503.7,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:15:57.531+03:00",
                "entryType": "credit",
                "invoiceId": null,
                "reference": "23a18405-633a-4cd4-b55e-aa169836b4c7",
                "paymentDate": null,
                "paymentType": "preFunding",
                "publicTransactionId": null
              },
              {
                "id": "9d49c45a-ae7f-4c50-b116-9b23ee35e3e1",
                "tags": null,
                "type": "transfer",
                "total": 9145503.69,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:15:53.765+03:00",
                "entryType": "debit",
                "invoiceId": null,
                "reference": "23a18405-633a-4cd4-b55e-aa169836b4c7",
                "paymentDate": null,
                "paymentType": "withdrawal",
                "publicTransactionId": null
              },
              {
                "id": "74160987-9ef5-4f42-b854-d347492adb96",
                "tags": null,
                "type": "transfer",
                "total": 9145503.7,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:14:27.139+03:00",
                "entryType": "credit",
                "invoiceId": null,
                "reference": "909c9479-ef79-472d-bf41-e8473598f9e5",
                "paymentDate": null,
                "paymentType": "preFunding",
                "publicTransactionId": null
              },
              {
                "id": "642662c6-3ff4-417b-a0dd-69be87a61a1b",
                "tags": null,
                "type": "transfer",
                "total": 9145503.69,
                "amount": 0.01,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T12:14:23.576+03:00",
                "entryType": "debit",
                "invoiceId": null,
                "reference": "909c9479-ef79-472d-bf41-e8473598f9e5",
                "paymentDate": null,
                "paymentType": "withdrawal",
                "publicTransactionId": null
              },
              {
                "id": "9d3d3ee0-e893-4f40-9bbe-b63aa566ee74",
                "tags": null,
                "type": "transfer",
                "total": 9145503.7,
                "amount": 86.47,
                "reason": null,
                "comment": null,
                "createdAt": "2024-10-29T11:48:29.425+03:00",
                "entryType": "credit",
                "invoiceId": null,
                "reference": "ba0d90f3-c991-4b54-a9f6-3fd1451706b4",
                "paymentDate": null,
                "paymentType": "preFunding",
                "publicTransactionId": null
              }
            ],
            "debitTurnover": 406305.85,
            "closingBalance": 9145503.7,
            "creditTurnover": 162843.42,
            "openingBalance": 9388966.13,
            "totalTransactions": 498
          }
        },
        "expiration": {
          "date": "2025-02-20T12:42:21.2602559+00:00"
        }
      }
    ]
  }
}

javascript FETCH Example (from sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "237db864-3931-43ce-8d27-59e1c67r60",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "partner.statementGet",
        "payload": {
          "currency": "USD",
          "createdRange": {
            "from": "2024-10-01T00:00:00+01:00",
            "to": "2024-11-13T23:59:59+01:00"
          },
          "pageNumber": 1,
          "pageSize": 20
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

Request Example (from sandbox)

{
  "header": {
    "request": {
      "id": "237db864-3931-43ce-8d27-59e1c67r60",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "partner.statementGet",
        "payload": {
          "currency": "USD",
          "createdRange": {
            "from": "2024-10-01T00:00:00+01:00",
            "to": "2024-11-13T23:59:59+01:00"
          },
          "pageNumber": 1,
          "pageSize": 20
        }
      }
    ]
  }
}

Request Example (for mock sandbox)

{
  "header": {
    "request": {
      "id": "fbd2252a-9caf-419a-8136-6bd3ef8609e5",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "partner.statementGet",
        "payload": {
          "currency": "USD",
          "createdRange": {
            "from": "2024-10-01T00:00:00+01:00",
            "to": "2024-11-13T23:59:59+01:00"
          },
          "pageNumber": 1,
          "pageSize": 20
        }
      },
      {
        "type": "partner.statementGet",
        "payload": {
          "currency": "3006",
          "createdRange": {
            "from": "2024-10-01T00:00:00+01:00",
            "to": "2024-11-13T23:59:59+01:00"
          },
          "pageNumber": 1,
          "pageSize": 20
        }
      },
      {
        "type": "partner.statementGet",
        "payload": {}
      }
    ]
  }
}

pay.toCard

POST http://enterprise.sandbox.paysend.com/processing

Send domestic and cross-border payments to card products.

Responses Schema

header object

• requestobjectidentifiers of request
  • id string (required): request identifier (Formed on the requester’s side)
  • date datetime: request creation date
• serviceobjectadditional settings
  • syncboolean (required): sync/async request
    • Default value: false
  • waitTime: time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]: Array [
    • uri string: endpoint URI for basic webhook
    • methodCallbackMethod: what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
  • ]
• responseobject
  • globalIduuid
    • Example: 2837dddc-9a60-4326-a8c8-ce39f07199b1
  • iduuid
    • Example: 25e309c2-3a6d-4c02-881d-3d96cb0d17f7
  • datedate-time
    • Example: 2025-01-24T13:34:53.0004766+00:00
  • statusUri uri

payload object

trees of tasks and configurations

• partnerobjectproperties that describes partner and additional optional parameters
  • identifier string: partner identifier
  • parametersobject: this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• settingsobjectinformation about executor, it is important if there is interaction with humans in the request
  • culture string: defines a locale for messages
  • encoding string: defines a text encoding that will be used in processing
  • contact email: defines an email address for informational emails about processing
  • userIp ipv4: user IP address, knowing on executor’s side
• tasksobject[]: Array [
  • type:
    • Possible values: [pay.toCard]
  • payloadobject: This function is used to execute payment instructions to a bank card. Each processing request can contain one, or many pay.toCard tasks. The Enterprise product routes the payment in the most optimal payment route.
    • paymentTypestring
      • Example: B2P
    • toobject (anyOf):
      • Option: recepientCard
        • cardNumber string (required): the recipient’s 16 digit card number. Empty when using token.
        • firstName string: the recipient’s first name (of the cardholder)
        • middleName string: the recipient’s middle name (of the cardholder)
        • lastName string: the recipient’s last name (of the cardholder)
        • amount number: amount of payment
        • currency string: currency of recipient card (this value is 3 digits number from ISO 4217)
        • birthYear integer: year of birth of the cardholder
        • nationality string: nationality of cardholder
        • countryOfResidence string: residence country of cardholder
        • addressobject:
          • line1 string: recipient address line
      • Option: recepientToken
        • token string (required): the recipient’s tokenized card number. Empty when using card number
        • paymentSystemstring: the payment system (VISA or MASTERCARD) for tokenized card.
          • Example: VISA
        • firstName, middleName, lastName, amount, currency, birthYear, nationality, countryOfResidence, address (same as above)
    • fromobject: group of fields that describes sender of payment
      • firstName string: the sender’s first name
      • middleName string: the sender’s middle name
      • lastName string: the sender’s last name
      • addressobject:
        • zip string, country string, city string, address string, line1 string
      • currency string: currency of sender account to be used (ISO 4217)
      • accountNumber string: the sender’s account number
      • financialInstitutionobject:
        • name string
      • placeOfBirthobject:
        • country string
      • dateOfBirth string: the sender’s birthdate. Mandatory for VISA P2P payments
      • verificationDocumentsobject:
        • type string, number string
    • comment string: comment or payment description
    • invoiceId string: unique external transaction ID assigned to the transaction by the client and used to reconcile
    • externalSenderId string: original sender identifier
    • purpose string: purpose of payment
  • success object[]
  • fail object[]
  • always object[]
  • resultobject:
    • status string
    • code integer
    • dataobject:
      • arn string. Example: 031550
      • rrn string. Example: 409510596501
      • financeobject:
        • to object: amount double, currency string (3 chars, e.g., EUR)
        • from object: amount double, currency string (3 chars, e.g., EUR)
        • rate float. Example: 0.9114191616766468
      • traceId string. Example: 409510596501
      • paymentId string. Example: c7d832d7-f8fd-4f28-b2ba-01aa02ce6fa8
    • comment string
• ]

result object

execution result

• status: enumerable information about execution status: Accepted, InProgress, Finished
  • Possible values: [Accepted, InProgress, Finished]
• codeinteger: numeric representation of execution status: 0 — Accepted, 1 — InProgress, 2 — Finished
  • Example: 0
• comment string: text comment for status
• interactiveobject:
  • uri string: endpoint URI for basic webhook
  • methodCallbackMethod: what http method should be used
    • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]

Example (from sandbox with token)

{
  "header": {
    "request": {
      "id": "d60b5967-9778-4861-95ea-79eac1e3779",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "fdf02216-17f9-4ccc-b081-69ce711dd17b",
      "id": "fcce793e-e899-4755-897b-a7858cca9ea5",
      "date": "2025-02-18T19:31:55.5989904+00:00",
      "statusUri": "http://host/processing/status/fdf02216-17f9-4ccc-b081-69ce711dd17b"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "interactive": {
        "now": false,
        "type": "Web",
        "return": {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      },
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "pay.toCard",
        "payload": {
          "to": {
            "token": "7b48c86e-b583-4947-8bb6-7cd6b2a3f0ab",
            "amount": 7,
            "currency": "840",
            "lastName": "Hecdioht",
            "birthYear": 1979,
            "firstName": "Derufrewe",
            "nationality": "US",
            "countryOfResidence": "US"
          },
          "from": {
            "address": {
              "zip": "99208",
              "city": "London",
              "address": "1812 W Riverside",
              "country": "GB"
            },
            "lastName": "Hecdioht",
            "firstName": "Derufrewe",
            "governmentId": {},
            "placeOfBirth": {},
            "financialInstitution": {}
          },
          "comment": "test pay.toCard",
          "invoiceId": "Test_pay_11015"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "arn": "031550",
            "rrn": "409510596501",
            "finance": {
              "to": {
                "amount": 7,
                "currency": "USD"
              },
              "from": {
                "amount": 6.43,
                "currency": "EUR"
              },
              "rate": 1.088319
            },
            "traceId": "409510596501",
            "paymentId": "722bf622-6ada-4914-982b-19efb9adaf8c"
          }
        },
        "expiration": {
          "date": "2025-02-18T20:11:46.2606363+00:00"
        }
      }
    ]
  }
}

Example (from sandbox with card)

{
  "header": {
    "request": {
      "id": "d60b5968-9778-4861-95ea-79eac1e37250",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "11e171dd-36a7-406c-abb4-11b3be064b7f",
      "id": "a420a117-488d-4714-9356-5657d5de60eb",
      "date": "2025-02-18T18:50:50.9702002+00:00",
      "statusUri": "http://host/processing/status/11e171dd-36a7-406c-abb4-11b3be064b7f"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "pay.toCard",
        "payload": {
          "to": {
            "amount": 15,
            "currency": "840",
            "lastName": "Hecdioht",
            "birthYear": 1979,
            "firstName": "Derufrewe",
            "cardNumber": "4539025531693033",
            "nationality": "US",
            "countryOfResidence": "US"
          },
          "from": {
            "address": {
              "zip": "99201",
              "city": "Portland",
              "address": "1812 W Riverside",
              "country": "US"
            },
            "lastName": "THOMPSON",
            "firstName": "MARTIN",
            "governmentId": {},
            "placeOfBirth": {},
            "financialInstitution": {}
          },
          "comment": "test pay.toCard",
          "invoiceId": "Test_TT11"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "arn": "031550",
            "rrn": "409510596501",
            "finance": {
              "to": {
                "amount": 15,
                "currency": "USD"
              },
              "from": {
                "amount": 13.78,
                "currency": "EUR"
              },
              "rate": 1.088319
            },
            "traceId": "409510596501",
            "paymentId": "75d4c936-f6de-4cc2-a52b-42f2868415f3"
          }
        },
        "expiration": {
          "date": "2025-02-18T19:30:40.703527+00:00"
        }
      }
    ]
  }
}

Example (with validation error)

{
  "header": {
    "request": {
      "id": "db6648e9-5ef2-4592-b243-e774b6287ede",
      "date": "2025-11-04T13:36:08.652+00:00"
    },
    "response": {
      "globalId": "fbb29199-cd1f-4600-8ee1-1b0fb7bdf983",
      "id": "39e1ac7e-a272-4cbc-a621-bc3e928b9798",
      "date": "2025-11-04T13:36:10.0635359+00:00",
      "statusUri": "http://host/processing/status/fbb29199-cd1f-4600-8ee1-1b0fb7bdf983"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "interactive": {
        "now": false,
        "type": "Web",
        "return": {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      },
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "pay.toCard",
        "payload": {
          "to": {
            "amount": 0,
            "currency": "USD",
            "lastName": "Hecdioht",
            "birthYear": 1967,
            "firstName": "Derufrewe",
            "cardNumber": "4716949985538078",
            "nationality": "CN",
            "countryOfResidence": "CN"
          },
          "from": {
            "address": {
              "zip": "19808",
              "city": "Wilmington",
              "address": "251 Little falls Drive",
              "country": "ES"
            },
            "currency": "EUR",
            "lastName": "Hecdioht",
            "firstName": "Derufrewe",
            "dateOfBirth": "1991-05-05",
            "governmentId": {},
            "placeOfBirth": {
              "country": "US"
            },
            "accountNumber": "IT60X0542811101000000123456",
            "financialInstitution": {
              "name": "Bank Name"
            },
            "verificationDocuments": [
              {
                "type": "PASSPORT",
                "number": "113749263"
              }
            ]
          },
          "paymentType": "P2P",
          "invoiceId": "Test_pay_11015"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Error",
          "code": 2000,
          "comment": "Validation error.",
          "data": {
            "validationResult": {
              "errors": [
                {
                  "path": "to.amount",
                  "value": "amount",
                  "errorTypes": [
                    "0 should be greater than 0"
                  ]
                }
              ],
              "status": "Error",
              "message": "Validation error."
            }
          }
        },
        "expiration": {
          "date": "2025-11-04T14:16:09.3559424+00:00"
        }
      }
    ]
  }
}

javascript FETCH Example (from sandbox with token)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "d60b5967-9778-4861-95ea-79eac1e3779",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "pay.toCard",
        "payload": {
          "to": {
            "token": "7b48c86e-b583-4947-8bb6-7cd6b2a3f0ab",
            "paymentSystem": "visa",
            "firstName": "Derufrewe",
            "lastName": "Hecdioht",
            "amount": 7,
            "currency": "840",
            "birthYear": 1979,
            "nationality": "US",
            "countryOfResidence": "US"
          },
          "from": {
            "firstName": "Derufrewe",
            "lastName": "Hecdioht",
            "address": {
              "zip": "99208",
              "country": "GB",
              "city": "London",
              "address": "1812 W Riverside"
            }
          },
          "comment": "test pay.toCard",
          "invoiceId": "Test_pay_11015"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript FETCH Example (from sandbox with card)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "d60b5968-9778-4861-95ea-79eac1e37250",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "pay.toCard",
        "payload": {
          "to": {
            "cardNumber": "4539025531693033",
            "firstName": "Derufrewe",
            "lastName": "Hecdioht",
            "amount": 15,
            "currency": "840",
            "birthYear": 1979,
            "nationality": "US",
            "countryOfResidence": "US"
          },
          "from": {
            "firstName": "MARTIN",
            "lastName": "THOMPSON",
            "address": {
              "zip": "99201",
              "country": "US",
              "city": "Portland",
              "address": "1812 W Riverside"
            }
          },
          "comment": "test pay.toCard",
          "invoiceId": "Test_TT11"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript FETCH Example (for mock sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "a933f997-fd28-4334-b373-71a2fa9bec51",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "pay.toCard",
        "payload": {
          "to": {
            "cardNumber": "4539025531693033",
            "firstName": "Derufrewe",
            "lastName": "Hecdioht",
            "amount": 15,
            "currency": "840",
            "birthYear": 1979,
            "nationality": "US",
            "countryOfResidence": "US"
          },
          "from": {
            "firstName": "MARTIN",
            "lastName": "THOMPSON",
            "address": {
              "zip": "99201",
              "country": "US",
              "city": "Portland",
              "address": "1812 W Riverside"
            }
          },
          "comment": "test pay.toCard",
          "invoiceId": "Test_TT11"
        }
      },
      {
        "type": "pay.toCard",
        "payload": {
          "to": {
            "amount": 4002,
            "birthYear": 1979,
            "cardNumber": "4539025531693033",
            "countryOfResidence": "US",
            "currency": "EUR",
            "firstName": "Derufrewe",
            "lastName": "Hecdioht",
            "middleName": "Hope",
            "nationality": "US",
            "token": "token"
          },
          "from": {
            "accountNumber": "accountNumber",
            "address": {
              "address": "1812 W Riverside",
              "city": "Portland",
              "country": "US",
              "description": "Description",
              "line1": "Address line1",
              "zip": "99201"
            },
            "cardNumber": "4539025531693033",
            "currency": "EUR",
            "dateOfBirth": "1980-01-01",
            "financialInstitution": {
              "description": "description",
              "name": "name"
            },
            "firstName": "MARTIN",
            "governmentId": {
              "number": "number",
              "type": "type"
            },
            "lastName": "THOMPSON",
            "middleName": "NOPE",
            "placeOfBirth": {
              "country": "US"
            },
            "verificationDocuments": "verificationDocuments"
          },
          "invoiceId": "invoiceId",
          "originatingInstitution": "originatingInstitution",
          "paymentType": "P2P",
          "purpose": "purpose",
          "comment": "test pay.toCard"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

getBalance

POST http://enterprise.sandbox.paysend.com/processing

Get the real-time available balance used for payouts.

Request Body (application/json)

header object

request header field

• requestobject (required)identifiers of request
  • id string (required): request identifier (Formed on the requester’s side)
  • date datetime: request creation date
• serviceobjectadditional settings
  • syncboolean (required): sync/async request
    • Default value: false
  • waitTime: time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]: Array [
    • uri string: endpoint URI for basic webhook
    • methodCallbackMethod: what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
  • ]

payload object

trees of tasks and configurations

• partnerobjectproperties that describes partner and additional optional parameters
  • identifier string: partner identifier
  • parametersobject: this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• tasksobject[]: Array [
  • type:
    • Possible values: [getBalance]
  • payloadobject:
    • currency string: ISO 4217 3-digits currency code to request balance for. If omitted, balances for all available currencies are returned
• ]

Responses

Response Schema

header object

• requestobjectidentifiers of request
  • id string (required): request identifier (Formed on the requester’s side)
  • date datetime: request creation date
• serviceobjectadditional settings
  • syncboolean (required): sync/async request
    • Default value: false
  • waitTime: time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]: Array [
    • uri string: endpoint URI for basic webhook
    • methodCallbackMethod: what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
  • ]
• responseobject
  • globalIduuid
    • Example: 2837dddc-9a60-4326-a8c8-ce39f07199b1
  • iduuid
    • Example: 25e309c2-3a6d-4c02-881d-3d96cb0d17f7
  • datedate-time
    • Example: 2025-01-24T13:34:53.0004766+00:00
  • statusUri uri

payload object

trees of tasks and configurations

• partnerobjectproperties that describes partner and additional optional parameters
  • identifier string: partner identifier
  • parametersobject: this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• settingsobjectinformation about executor, it is important if there is interaction with humans in the request
  • culture string: defines a locale for messages
  • encoding string: defines a text encoding that will be used in processing
  • contact email: defines an email address for informational emails about processing
  • userIp ipv4: user IP address, knowing on executor’s side
• tasksobject[]: Array [
  • type:
    • Possible values: [getBalance]
  • payloadobject:
    • currency string: ISO 4217 3-digits currency code to request balance for. If omitted, balances for all available currencies are returned
  • success object[]
  • fail object[]
  • always object[]
  • resultobject:
    • status string
    • code integer
    • dataobject:
      • balancesobject:
        • property name* double (Dynamic currency keys)
        • Example: 1921.11
    • comment string
• ]

result object

execution result

• status: enumerable information about execution status: Accepted, InProgress, Finished
  • Possible values: [Accepted, InProgress, Finished]
• codeinteger: numeric representation of execution status: 0 — Accepted, 1 — InProgress, 2 — Finished
  • Example: 0
• comment string: text comment for status
• interactiveobject
  • uri string: endpoint URI for basic webhook
  • methodCallbackMethod: what http method should be used
    • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]

Example (from sandbox)

{
  "header": {
    "request": {
      "id": "d65b5933-9258-4861-95ea-59eac0r5000",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "ca7efbe6-f092-419a-b8c6-edaa17522a5b",
      "id": "3c19e447-0d29-49ea-8d3b-e373a9cff9e6",
      "date": "2025-02-18T19:36:35.4256557+00:00",
      "statusUri": "http://host/processing/status/ca7efbe6-f092-419a-b8c6-edaa17522a5b"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "getBalance",
        "payload": {},
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "balances": {
              "EUR": 895983.43,
              "GBP": 10002859.3,
              "USD": 9144479.92
            }
          }
        },
        "expiration": {
          "date": "2025-02-18T20:16:32.69677+00:00"
        }
      }
    ]
  }
}

Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "payload": {
          "currency": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": 0,
          "data": {
            "balances": {}
          },
          "comment": "string"
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

javascript FETCH Example (from sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "d65b5933-9258-4861-95ea-59eac0r5000",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "getBalance",
        "payload": {}
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript FETCH Example (for mock sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "21236b92-4f3e-4710-9783-2b979ffa02fa",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "getBalance",
        "payload": {}
      },
      {
        "type": "getBalance",
        "payload": {
          "currency": "EUR"
        }
      },
      {
        "type": "getBalance",
        "payload": {
          "currency": "1000"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

task.statusGet

POST http://enterprise.sandbox.paysend.com/processing

Example of POST /processing request for task.statusGet task type.

---

warning

This method is designed to be used as a failover method in case no other method is available.

If the globalID is not available (expired after 2hrs or for RFI case management), you can use the paymentID (or invoiceId) to retrieve the latest status of the transaction.

• Use the paymentID for status checking.
• Perform status checks at intervals of 1 minute, gradually increasing the interval.

If both the paymentID and globalID are not available:

• Use the invoiceID for status checking.
• Perform status checks at intervals of 1 minute, gradually increasing the interval.

Request

Body (application/json)

header object

request header field

• requestobject (required)identifiers of request
  • id string (required): request identifier (Formed on the requester’s side)
  • date datetime: request creation date
• serviceobjectadditional settings
  • syncboolean (required): sync/async request
    • Default value: false
  • waitTime: time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]: Array [
    • uri uri: endpoint URI for basic webhook
    • methodCallbackMethod: what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
  • ]

payload object

trees of tasks and configurations

• partnerobjectproperties that describes partner and additional optional parameters
  • identifier string: partner identifier
  • parametersobject: this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• tasksobject[]: Array [
  • type:
    • Possible values: [task.statusGet]
  • payloadobject (oneOf):
    • Option 1: task.statusGet by id
      • identifier string (required): invoice id
    • Option 2: task.statusGet by invoice
      • invoiceId string (required): invoice id
• ]

Complete Response Schema

header object

• requestobjectidentifiers of request
  • id string (required): request identifier (Formed on the requester’s side)
  • date datetime: request creation date
• serviceobjectadditional settings
  • syncboolean (required): sync/async request
    • Default value: false
  • waitTime: time to wait response if sync property set to true
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]: Array [
    • uri uri: endpoint URI for basic webhook
    • methodCallbackMethod: what http method should be used
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
  • ]
• responseobject
  • globalIduuid
    • Example: 2837dddc-9a60-4326-a8c8-ce39f07199b1
  • iduuid
    • Example: 25e309c2-3a6d-4c02-881d-3d96cb0d17f7
  • datedate-time
    • Example: 2025-01-24T13:34:53.0004766+00:00
  • statusUri string

payload object

trees of tasks and configurations

• partnerobjectproperties that describes partner and additional optional parameters
  • identifier string: partner identifier
  • parametersobject: this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received
    • property name* string
• settingsobjectinformation about executor, it is important if there is interaction with humans in the request
  • culture string: defines a locale for messages
  • encoding string: defines a text encoding that will be used in processing
  • contact email: defines an email address for informational emails about processing
  • userIp ipv4: user IP address, knowing on executor’s side
• tasksobject[]: Array [
  • type:
    • Possible values: [task.statusGet]
  • payloadobject (oneOf):
    • Option: task.statusGet by invoice
      • invoiceId string (required): invoice id
    • Option: task.statusGet by id
      • identifier string (required): invoice id
  • success object[]
  • fail object[]
  • always object[]
  • resultobject (anyOf):1. PayToCardResult
    • status string
    • code integer
    • data object:
      • arn string. Example: 031550
      • rrn string. Example: 409510596501
      • code string
      • status object:
        • code string, description string
      • finance object:
        • to object: amount double (Example: 0.91), currency string (Possible values: >= 3 chars, <= 3 chars. Example: EUR)
        • from object: amount double (Example: 0.91), currency string (Possible values: >= 3 chars, <= 3 chars. Example: EUR)
        • rate float. Example: 0.9114191616766468
      • traceId string. Example: 409510596501
      • invoiceId string
      • paymentId string. Example: c7d832d7-f8fd-4f28-b2ba-01aa02ce6fa8
    2. PayToAccountResult
    • status string, code integer, comment string
    • data object:
      • traceId string. Example: 8878b45bb948490a8971c7ac130e0461
      • paymentId string. Example: 8878b45b-b948-490a-8971-c7ac130e0461
    3. CardInfoGetResult
    • status string, code integer, comment string
    4. CardCreateTokenResult
    • status string, code integer, comment string
    • data object:
      • token uuid. Example: 0a2d7bae-e53d-448b-b7bd-60e0774b4daa
      • cardNumber string. Example: 539307******9854
      • resultCode integer. Example: 0
      • countryCode string. Possible values: >= 3 chars, <= 3 chars. Example: 068
      • paymentSystem string. Example: MASTERCARD
      • currencyIsoCode string. Possible values: >= 3 chars, <= 3 chars. Example: EUR
    5. GetBalanceResult
    • status string, code integer, comment string
    • data object:
      • balances object:
        • property name* double. Example: 1921.11
    6. GetAccountStatementResult
    • status string, code integer, comment string
    • data object:
      • id uuid. Example: d7f34dca-8073-4e26-b69d-71855d409720
      • lastPage boolean, pageNumber integer (Example: 1), totalPages integer (Example: 1)
      • transactions object[]: Array [
        • id uuid. Example: 58ac34b7-112a-4ffc-b42c-5a7c5b152b8b
        • tags string[], type string (Example: transfer), total double (Example: 9943261.18), amount double (Example: 5.08), reason string, comment string
        • createdAt date-time. Example: 2024-11-21T19:23:16.661+03:00
        • entryType: Possible values: [Credit, Debit]. Example: Credit
        • invoiceId string. Example: 1234
        • reference uuid. Example: 6ba6aab6-14fe-43d1-95c0-fb9179feae7b
        • paymentDate date-time. Example: 2024-11-21T18:44:47.070863+03:00
        • paymentType: Possible values: [payToCard, payToAccount, preFunding, withdrawal, preFundingManual, withdrawalManual, returnToCard, returnToAccount]. Example: payToCard
        • publicTransactionId uuid. Example: 6ba6aab6-14fe-43d1-95c0-fb9179feae7b
      • ]
      • debitTurnover double (Example: 1237.7), closingBalance double (Example: 9943261.18), creditTurnover double (Example: 40.64), openingBalance double (Example: 9944458.24), totalTransactions integer (Example: 62)
    7. FxRateGetResultp2c
    • status string, code integer, comment string
    • data object:
      • finance object: (to, from, rate as defined in PayToCardResult)
      • additionalRates object[]: Array [
        • to object, from object (amount, currency as defined in finance)
        • name string. Example: VISA
        • rate float. Example: 0.9114191616766468
      • ]
    8. FxRateGetResult
    • status string, code integer, comment string
    • dataobject:
      • finance object: (to, from, rate as defined in PayToCardResult with rate example 1.4900588123203304)
  • expirationobject: information regarding the time in which the response must happen
    • date string. Example: 2022-05-31T10:12:41.0532311+00:00
• ]

result object

execution result

• status: enumerable information about execution status: Accepted, InProgress, Finished
  • Possible values: [Accepted, InProgress, Finished]
• codeinteger: numeric representation of execution status: 0 — Accepted, 1 — InProgress, 2 — Finished
  • Example: 0
• comment string: text comment for status
• interactiveobject
  • uri uri: endpoint URI for basic webhook
  • methodCallbackMethod: what http method should be used
    • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]

response Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": false,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "payload": {
          "invoiceId": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": 0,
          "data": {
            "arn": "031550",
            "rrn": "409510596501",
            "code": "string",
            "status": {
              "code": "string",
              "description": "string"
            },
            "finance": {
              "to": {
                "amount": 0.91,
                "currency": "EUR"
              },
              "from": {
                "amount": 0.91,
                "currency": "EUR"
              },
              "rate": 0.9114191616766468
            },
            "traceId": "409510596501",
            "invoiceId": "string",
            "paymentId": "c7d832d7-f8fd-4f28-b2ba-01aa02ce6fa8"
          }
        },
        "expiration": {
          "date": "2022-05-31T10:12:41.0532311+00:00"
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

response Example (from sandbox, using identifier)

{
  "header": {
    "request": {
      "id": "237db864-3931-43ce-8d27-59e1c67r68",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "030454fb-d333-4cc3-ac88-65147254ed64",
      "id": "4bb719c4-5371-42aa-ba5a-389a050a6507",
      "date": "2025-02-19T12:51:26.9214241+00:00",
      "statusUri": "http://host/processing/status/030454fb-d333-4cc3-ac88-65147254ed64"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "task.statusGet",
        "payload": {
          "identifier": "75d4c936-f6de-4cc2-a52b-42f2868415f3"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "arn": "031550",
            "rrn": "409510596501",
            "code": "0",
            "status": {
              "code": "2",
              "description": "Completed"
            },
            "finance": {
              "to": {
                "amount": 15,
                "currency": "USD"
              },
              "from": {
                "amount": 13.78,
                "currency": "EUR"
              },
              "rate": 1.08853
            },
            "traceId": "409510596501",
            "invoiceId": "Test_TT11",
            "paymentId": "75d4c936-f6de-4cc2-a52b-42f2868415f3"
          }
        },
        "expiration": {
          "date": "2025-02-19T13:31:25.460362+00:00"
        }
      }
    ]
  }
}

response Example (from sandbox, using invoice)

{
  "header": {
    "request": {
      "id": "237db864-3931-43ce-8d27-59e1c67r70",
      "date": "2021-12-31T21:00:00+00:00"
    },
    "response": {
      "globalId": "209060e2-2cb4-4af0-8fc1-bcf392eee0d8",
      "id": "6c6ac2f1-8a56-4b38-8f30-144a7722739b",
      "date": "2025-02-19T12:53:49.6542574+00:00",
      "statusUri": "http://host/processing/status/209060e2-2cb4-4af0-8fc1-bcf392eee0d8"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "Web",
          "uri": "https://example.com",
          "method": "GET"
        }
      ]
    }
  },
  "result": {
    "status": "Finished",
    "code": 2
  },
  "payload": {
    "partner": {
      "identifier": "universal",
      "parameters": {}
    },
    "tasks": [
      {
        "type": "task.statusGet",
        "payload": {
          "invoiceId": "Test_TT11"
        },
        "success": [],
        "fail": [],
        "always": [],
        "result": {
          "status": "Success",
          "code": 0,
          "data": {
            "arn": "031550",
            "rrn": "409510596501",
            "code": "0",
            "status": {
              "code": "2",
              "description": "Completed"
            },
            "finance": {
              "to": {
                "amount": 15,
                "currency": "USD"
              },
              "from": {
                "amount": 13.78,
                "currency": "EUR"
              },
              "rate": 1.08853
            },
            "traceId": "409510596501",
            "invoiceId": "Test_TT11",
            "paymentId": "75d4c936-f6de-4cc2-a52b-42f2868415f3"
          }
        },
        "expiration": {
          "date": "2025-02-19T13:33:48.3690582+00:00"
        }
      }
    ]
  }
}

javascript FETCH Example (from sandbox, using identifier)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "237db864-3931-43ce-8d27-59e1c67r68",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "task.statusGet",
        "payload": {
          "identifier": "75d4c936-f6de-4cc2-a52b-42f2868415f3"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript FETCH Example (from sandbox, using identifier)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "237db864-3931-43ce-8d27-59e1c67r70",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "task.statusGet",
        "payload": {
          "invoiceId": "Test_TT11"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

javascript FETCH Example (for mock sandbox)

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Accept", "application/json");

const raw = JSON.stringify({
  "header": {
    "request": {
      "id": "68828e8a-52dc-4314-a22e-0f4c09f9b10b",
      "date": "2022-01-01T00:00:00+03:00"
    },
    "service": {
      "sync": false,
      "waitTime": "WaitFor2000",
      "result": [
        {
          "type": "web",
          "uri": "https://example.com",
          "method": "get"
        }
      ]
    }
  },
  "payload": {
    "partner": {
      "identifier": "universal"
    },
    "tasks": [
      {
        "type": "task.statusGet",
        "payload": {
          "identifier": "3720f209-2f47-4fcc-4003-1526826f97c9"
        }
      },
      {
        "type": "task.statusGet",
        "payload": {
          "invoiceId": "INV-P2A-4003"
        }
      }
    ]
  }
});

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: raw,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

GET /processing/status/

GET http://enterprise.sandbox.paysend.com/processing/status/:GlobalId

GET /processing/status/

Request

Path Parameters
GlobalId string required
Header Parameters
X-OPP-Signature string required

Responses

Complete API Schema (Full Reconstruction)

header object

• requestobject (required)identifiers of request
  • id string (required): request identifier (Formed on the requester’s side).
  • date datetime: request creation date.
• serviceobjectadditional settings
  • sync boolean (required): sync/async request, true for sync.
  • waitTime: time to wait response if sync property set to true.
    • Possible values: [WaitFor500, WaitFor1000, WaitFor1500, WaitFor2000]
  • resultobject[]: Array [
    • typeCallbackType: interaction type (web, telegram, …) web — default value.
      • Possible values: [web, telegram, email]
      • Default value: web
    • uri string: endpoint URI for callback.
    • methodCallbackMethod: what http method should be used.
      • Possible values: [get, post, put, delete, GET, POST, PUT, DELETE]
  • ]
• responseobject
  • globalId uuid. Example: 2837dddc-9a60-4326-a8c8-ce39f07199b1
  • id uuid. Example: 25e309c2-3a6d-4c02-881d-3d96cb0d17f7
  • date date-time. Example: 2025-01-24T13:34:53.0004766+00:00
  • statusUri uri

payload object

trees of tasks and configurations

• partnerobjectproperties that describes partner and additional optional parameters
  • identifier string: partner identifier.
  • parametersobject: this dictionary contains a set of key value pair that are used by partner to store information in the processing request for future use when the response is received.
    • property name* string
• settingsobjectinformation about executor, it is important if there is interaction with humans in the request
  • culture string: defines a locale for messages.
  • encoding string: defines a text encoding that will be used in processing.
  • contact email: defines an email address for informational emails about processing.
  • userIp ipv4: user IP address, knowing on executor’s side.
• tasks object[]: Array [The tasks array contains objects which can be any of the following (anyOf):

Task Choice 1: ResponsePayToCard

• type: Possible values: [pay.toCard]. Default value: pay.toCard. Example: pay.toCard.
• payloadobject: This function is used to execute payment instructions to a bank card.
  • paymentType string. Possible values: >= 3 characters and <= 3 characters. Example: B2P.
  • toobject: group of fields that describes the recipient of payment.
    • cardNumber string: the recipient’s 16 digit card number. Empty when using token.
    • token string: the recipient’s tokenized card number. Empty when using card number.
    • paymentSystem string: the payment system (VISA or MASTERCARD) for tokenized card. Example: VISA.
    • firstName, middleName, lastName string: names of the cardholder.
    • amount string: amount of payment.
    • currency string: ISO 4217 code.
    • birthYear, nationality, countryOfResidence string.
    • address object: line1 string.
  • from object: group of fields that describes sender of payment. (Includes names, address, currency, accountNumber, financialInstitution, placeOfBirth, dateOfBirth, verificationDocuments).
  • comment, invoiceId, externalSenderId, purpose string.
• resultobject:
  • status string, code string.
  • data object: arn (031550), rrn (409510596501), finance (to/from amount and currency, rate: 0.9114191616766468), traceId (409510596501), paymentId (c7d832d7-f8fd-4f28-b2ba-01aa02ce6fa8).

Task Choice 2: ResponsePayToAccount

• type: Possible values: [pay.ToAccount]. Default value: pay.ToAccount. Example: pay.ToAccount.
• payloadobject:
  • fromobject:
    • sourceTransactionInstrument: identifierType, accountIdentifier (uuid), currency (Possible values: >= 3 characters, <= 3 characters. Example: USD).
    • senderobject (required, oneOf):
      • Option: SenderIndividual
        • type: Possible values: [Individual]. Default: Individual. Example: Individual.
        • firstName, lastName string (required). Possible values: <= 35 characters. Example: Oliver, Paparaliang.
        • middleName string. Possible values: <= 35 characters.
        • taxId string. Possible values: <= 35 characters.
        • dateOfBirth date. Example: 1980-01-01.
        • placeOfBirth string. Possible values: <= 100 characters.
        • nationality string. Possible values: >= 2 characters, <= 2 characters. Example: US.
        • senderAccountobject (required, oneOf):
          • eWallet: identifierType (EWallet), accountIdentifier (<= 100 chars), provider (<= 50 chars), country (ISO 3166-1 alpha-2).
        • address object (required): addressLine1 (required, <= 200 chars), addressLine2, city (required, <= 50 chars), countrySubdivision, zip, country (required, ISO 3166-1 alpha-2).
        • phone string. Possible values: <= 20 characters.
        • governmentIdobject:
          • type: Possible values: [NationalPassport, DrivingLicense, InternationalPassport, SocialSecurityID, TaxID].
          • number string (<= 35 chars), issuingCountry, issueDate, expirationDate.
        • email email. Possible values: <= 35 characters.
        • occupation: Possible values: [GeneralWorker, Businessman, Professional, Supervisor, Tourist, SecurityGuard, HouseMaid, DomesticHelper, HouseWife, Others].
        • senderRelationshipWithBeneficiary string.
        • countryOfBirth string (ISO 3166-1 alpha-2).
      • Option: SenderCompany
        • type: Possible values: [LegalEntity].
        • name string (required, <= 255 chars).
        • dateOfEncorporation date.
        • address object (required): (Structure same as SenderIndividual.address).
        • senderAccount object (required, oneOf): (eWallet structure same as above).
        • governmentId object: (Structure same as above).
  • toobject:
    • destinationTransactionInstrumentobject (required, oneOf):
      • Option: RecepientAccountBAN
        • identifierType (required): Possible values: [BAN]. Example: BAN.
        • accountIdentifier string (required, <= 40 chars). Example: 1234567890.
        • accountType: Possible values: [Checking, Saving, Loan].
        • accountName string (<= 70 chars).
        • bic string (required, <= 11 chars).
        • bankCode string (<= 12 chars).
        • bankCodeType: Possible values: [ABA, SORT_CODE, DEFAULT].
        • branchCode string (<= 20 chars).
        • currency string. Possible values: >= 3 chars, <= 3 chars.
        • country string (required, ISO 3166-1 alpha-2).
        • branchName, bankName string (<= 140 chars).
      • Option: RecepientAccountIBAN
        • identifierType (required): Possible values: [IBAN]. Example: IBAN.
        • accountIdentifier string (required, <= 40 chars). Example: DE89370400440532013000.
        • (Other fields bic, currency, country, etc. same as BAN option).
  • recipientobject (required, oneOf):
    • Option: RecepientIndividual
      • type: Possible values: [Individual].
      • firstName, middleName, lastName, taxId, dateOfBirth, placeOfBirth, nationality, phone, governmentId, email (Structure same as SenderIndividual fields).
      • address object (required): (Structure same as SenderIndividual.address).
    • Option: RecepientCompany
      • type: Possible values: [LegalEntity]. Default: LegalEntity.
      • name string (required, <= 255 chars).
      • governmentRegistrationNumber string (<= 15 chars).
      • dateOfEncorporation date.
      • address object (required): (Structure same as above).
  • transferAmount number (required). Example: 1000.5.
  • transferCurrency string (required). Possible values: >= 3 chars, <= 3 chars. Example: USD.
  • purposeOfPayment (required). Possible values: [Family, GiftsAndDonations, PurchaseOfProperty, MedicalExpenses, PaymentOfBills, Education, Savings, Business, Salary, GoodsAndServices].
  • sourceOfFunds: Possible values: [Salary, Business, Savings, Investments, GovernmentFunding].
  • invoiceId string (required, <= 256 chars).
  • comment string (<= 1024 chars).
• result object: status, code, data (traceId: 8878b45bb948490a8971c7ac130e0461, paymentId: 8878b45b-b948-490a-8971-c7ac130e0461).

Task Choice 3: ResponseFxRateGet (p2a)

• type: Possible values: [fx.rateGet.p2a]. Example: fx.rateGet.p2a.
• payload: payinCurrency (USD), payoutCurrency (EUR), payoutAmount (100), payoutCountry (UK).
• result: data (finance: to/from amount and currency, rate: 1.4900588123203304).

Task Choice 4: ResponseCardInfoGet

• type: Possible values: [card.infoGet]. Example: card.infoGet.
• payload: pan string (primary account number).

Task Choice 5: ResponseTaskStatusGet

• type: Possible values: [task.statusGet]. Example: task.statusGet.
• payload: functionType ([pay.toCard, pay.toAccount, card.infoGet, getBalance, partner.statementGet, card.createToken, fx.rateGet, fx.rateGet.p2a]), identifier (required), invoiceId.
• result (oneOf PayToCardResult, PayToAccountResult, etc. — Includes full data as seen in Choice 1).

Task Choice 6: ResponseGetBalance

• type: Possible values: [getBalance].
• payload: currency string (ISO 4217 3-digits currency code).
• result: data.balances object (property name* double. Example: 1921.11).

Task Choice 7: ResponseCreateCardToken

• type: Possible values: [card.createToken].
• payload: cardNumber string (required), expDate string (‘MM/YY’).
• result: data: token (uuid), cardNumber (539307******9854), resultCode (0), countryCode (068), paymentSystem (MASTERCARD), currencyIsoCode (EUR).

Task Choice 8: ResponseGetAccountStatement

• type: Possible values: [partner.statementGet].
• payload: createdRange (from/to), currency, pageNumber, pageSize (100).
• result: data: id (uuid), lastPageboolean, pageNumber, totalPages, transactionsobject[]: Array [
  • id, tags, type (transfer), total, amount, reason, comment, createdAt, entryType [Credit, Debit], invoiceId, reference, paymentDate, paymentType [payToCard, payToAccount, preFunding, withdrawal, preFundingManual, withdrawalManual, returnToCard, returnToAccount], publicTransactionId.
• ].

Task Choice 9: ResponseFxRateGet (Standard)

• type: Possible values: [fx.rateGet].
• payload: currencyIn (EUR), currencyOut (USD), amountIn (1), paysystem (VISA).
• expiration: date date-time. Example: 2022-05-31T10:12:41.0532311+00:00.
• ]

result object

execution result

• status: enumerable information about execution status.
  • Possible values: [Accepted, InProgress, Finished]
• codeinteger: numeric representation of execution status.
  • Possible values: 0 — Accepted, 1 — InProgress, 2 — Finished. Example: 0.
• comment string: text comment for status.
• interactiveobject:
  • type CallbackType. Possible values: [web, telegram, email]. Default: web.
  • uri string, method CallbackMethod. Possible values: [get, post, put, delete, GET, POST, PUT, DELETE].

Response Example (auto)

{
  "header": {
    "request": {
      "id": "string",
      "date": "string"
    },
    "service": {
      "sync": true,
      "result": [
        {
          "uri": "string"
        }
      ]
    },
    "response": {
      "globalId": "2837dddc-9a60-4326-a8c8-ce39f07199b1",
      "id": "25e309c2-3a6d-4c02-881d-3d96cb0d17f7",
      "date": "2025-01-24T13:34:53.0004766+00:00",
      "statusUri": "string"
    }
  },
  "payload": {
    "partner": {
      "identifier": "string",
      "parameters": {}
    },
    "settings": {
      "culture": "string",
      "encoding": "string",
      "contact": "user@example.com",
      "userIp": "198.51.100.42"
    },
    "tasks": [
      {
        "type": "pay.toCard",
        "payload": {
          "paymentType": "B2P",
          "to": {
            "cardNumber": "string",
            "token": "string",
            "paymentSystem": "VISA",
            "firstName": "string",
            "middleName": "string",
            "lastName": "string",
            "amount": "string",
            "currency": "string",
            "birthYear": "string",
            "nationality": "string",
            "countryOfResidence": "string",
            "address": {
              "line1": "string"
            }
          },
          "from": {
            "firstName": "string",
            "middleName": "string",
            "lastName": "string",
            "address": {
              "zip": "string",
              "country": "string",
              "city": "string",
              "address": "string",
              "line1": "string"
            },
            "currency": "string",
            "accountNumber": "string",
            "financialInstitution": {
              "name": "string"
            },
            "placeOfBirth": {
              "country": "string"
            },
            "dateOfBirth": "string",
            "verificationDocuments": {
              "type": "string",
              "number": "string"
            }
          },
          "comment": "string",
          "invoiceId": "string",
          "externalSenderId": "string",
          "purpose": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": "string",
          "data": {
            "arn": "031550",
            "rrn": "409510596501",
            "finance": {
              "to": {
                "amount": 0.91,
                "currency": "EUR"
              },
              "from": {
                "amount": 0.91,
                "currency": "EUR"
              },
              "rate": 0.9114191616766468
            },
            "traceId": "409510596501",
            "paymentId": "c7d832d7-f8fd-4f28-b2ba-01aa02ce6fa8"
          },
          "comment": "string"
        }
      },
      {
        "type": "pay.ToAccount",
        "payload": {
          "from": {
            "sourceTransactionInstrument": {
              "identifierType": "string",
              "accountIdentifier": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
              "currency": "USD"
            },
            "sender": {
              "type": "Individual",
              "firstName": "Oliver",
              "middleName": "Michael",
              "lastName": "Paparaliang",
              "taxId": "123-45-6789",
              "dateOfBirth": "1980-01-01",
              "placeOfBirth": "New York, USA",
              "nationality": "US",
              "senderAccount": {
                "identifierType": "EWallet",
                "accountIdentifier": "user@example.com",
                "provider": "PaymentProvider",
                "country": "US"
              },
              "address": {
                "addressLine1": "123 Main St",
                "addressLine2": "Apt 4B",
                "city": "New York",
                "countrySubdivision": "NY",
                "zip": "10001",
                "country": "US"
              },
              "phone": "+14155552671",
              "governmentId": {
                "type": "NationalPassport",
                "number": "123456789",
                "issuingCountry": "US",
                "issueDate": "2018-01-01",
                "expirationDate": "2028-01-01"
              },
              "email": "Oliver.Paparaliang@example.com",
              "occupation": "GeneralWorker",
              "senderRelationshipWithBeneficiary": "string",
              "countryOfBirth": "US"
            }
          },
          "to": {
            "destinationTransactionInstrument": {
              "identifierType": "BAN",
              "accountIdentifier": "1234567890",
              "accountType": "Saving",
              "accountName": "Oliver Paparaliang",
              "bic": "BOFAUS3NXXX",
              "bankCode": "026009593",
              "bankCodeType": "DEFAULT",
              "branchCode": "001",
              "currency": "USD",
              "country": "US",
              "branchName": "Main Street Branch",
              "bankName": "Bank of America"
            },
            "recipient": {
              "type": "Individual",
              "firstName": "Jane",
              "middleName": "Alice",
              "lastName": "Smith",
              "taxId": "987-65-4321",
              "dateOfBirth": "1985-05-15",
              "placeOfBirth": "London, UK",
              "nationality": "US",
              "address": {
                "addressLine1": "123 Main St",
                "addressLine2": "Apt 4B",
                "city": "New York",
                "countrySubdivision": "NY",
                "zip": "10001",
                "country": "US"
              },
              "phone": "+447911123456",
              "governmentId": {
                "type": "NationalPassport",
                "number": "123456789",
                "issuingCountry": "US",
                "issueDate": "2018-01-01",
                "expirationDate": "2028-01-01"
              },
              "email": "jane.smith@example.com"
            }
          },
          "transferAmount": 1000.5,
          "transferCurrency": "USD",
          "invoiceId": "INV-2023-001",
          "comment": "FTE salary disbursement"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": "string",
          "data": {
            "traceId": "8878b45bb948490a8971c7ac130e0461",
            "paymentId": "8878b45b-b948-490a-8971-c7ac130e0461"
          },
          "comment": "string"
        }
      },
      {
        "type": "fx.rateGet.p2a",
        "payload": {
          "payinCurrency": "USD",
          "payoutCurrency": "EUR",
          "payoutAmount": "100",
          "payoutCountry": "UK"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": "string",
          "data": {
            "to": {
              "amount": 0.91,
              "currency": "EUR"
            },
            "from": {
              "amount": 0.91,
              "currency": "EUR"
            },
            "rate": 1.4900588123203304
          },
          "comment": "string"
        }
      },
      {
        "type": "card.infoGet",
        "payload": {
          "pan": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": "string",
          "comment": "string"
        }
      },
      {
        "type": "task.statusGet",
        "payload": {
          "functionType": "pay.toCard",
          "identifier": "string",
          "invoiceId": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": "string",
          "data": {
            "arn": "031550",
            "rrn": "409510596501",
            "finance": {
              "to": {
                "amount": 0.91,
                "currency": "EUR"
              },
              "from": {
                "amount": 0.91,
                "currency": "EUR"
              },
              "rate": 0.9114191616766468
            },
            "traceId": "409510596501",
            "paymentId": "c7d832d7-f8fd-4f28-b2ba-01aa02ce6fa8"
          },
          "comment": "string"
        }
      },
      {
        "payload": {
          "currency": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": "string",
          "data": {
            "balances": {}
          },
          "comment": "string"
        }
      },
      {
        "type": "card.createToken",
        "payload": {
          "cardNumber": "string",
          "expDate": "string"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": "string",
          "data": {
            "token": "0a2d7bae-e53d-448b-b7bd-60e0774b4daa",
            "cardNumber": "539307******9854",
            "resultCode": 0,
            "countryCode": "068",
            "paymentSystem": "MASTERCARD",
            "currencyIsoCode": "EUR"
          },
          "comment": "string"
        }
      },
      {
        "type": "partner.statementGet",
        "payload": {
          "createdRange": {
            "from": "string",
            "to": "string"
          },
          "currency": "EUR",
          "pageNumber": 1,
          "pageSize": 100
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "result": {
          "status": "string",
          "code": "string",
          "data": {
            "id": "d7f34dca-8073-4e26-b69d-71855d409720",
            "lastPage": true,
            "pageNumber": 1,
            "totalPages": 1,
            "transactions": [
              {
                "id": "58ac34b7-112a-4ffc-b42c-5a7c5b152b8b",
                "tags": [
                  "string"
                ],
                "type": "transfer",
                "total": 9943261.18,
                "amount": 5.08,
                "reason": "string",
                "comment": "string",
                "createdAt": "2024-11-21T19:23:16.661+03:00",
                "entryType": "Credit",
                "invoiceId": "1234",
                "reference": "6ba6aab6-14fe-43d1-95c0-fb9179feae7b",
                "paymentDate": "2024-11-21T18:44:47.070863+03:00",
                "paymentType": "payToCard",
                "publicTransactionId": "6ba6aab6-14fe-43d1-95c0-fb9179feae7b"
              }
            ],
            "debitTurnover": 1237.7,
            "closingBalance": 9943261.18,
            "creditTurnover": 40.64,
            "openingBalance": 9944458.24,
            "totalTransactions": 62
          },
          "comment": "string"
        }
      },
      {
        "type": "fx.rateGet",
        "payload": {
          "currencyIn": "EUR",
          "currencyOut": "USD",
          "amountIn": 1,
          "paysystem": "VISA"
        },
        "success": [
          {}
        ],
        "fail": [
          {}
        ],
        "always": [
          {}
        ],
        "expiration": {
          "date": "2022-05-31T10:12:41.0532311+00:00"
        }
      }
    ]
  },
  "result": {
    "code": 0,
    "comment": "string",
    "interactive": {
      "uri": "string"
    }
  }
}

Javascript FETCH

const myHeaders = new Headers();
myHeaders.append("Accept", "application/json");

const requestOptions = {
  method: "GET",
  headers: myHeaders,
  redirect: "follow"
};

fetch("http://enterprise.sandbox.paysend.com/processing/status/:GlobalId", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));

Webhook notification service

Basic

To use the Webhook Notification Service, Specify the endpoint URL where the notifications should be sent:

"result": [
  {
    "uri": "https://example.com",
    "method": "get"
  }
]

Basic Notification Format

When the transaction status is updated, the system will send a notification to the configured endpoint with the following format:

"B8719542-fav4-4902-ab2c-11de595ace30"

Expanded

This service provides a webhook with expanded structure. To configure this service, please provide the end-point planned for notification to your Paysend Implementation team.

Expanded Notification Format

When the transaction status is updated, the system will send a notification to the configured endpoint with the following format:

{
  "webhookType": "TransactionStatusUpdate",
  "invoiceId": "ABC_TXN_123456",
  "transactionId": "d78adfce-631d-485f-af32-29cagbf95b70",
  "status": "Completed",
  "statusDateTime": "2024-08-07T20:14:01.85131+03:00",
  "errorCode": "0",
  "errorDescription": null
}

Authentication & Idempotency

Authentication

Authentication

The Paysend Enterprise API uses API keys and digital signatures for authentication and request validation.

API Keys You will receive two sets of API keys:

• A key for inbound requests (your requests to our API)
• A key for outbound requests (our notifications to your systems)

Request Signing

All API requests must include a digital signature in the X-OPP-Signature header. To generate this signature:

1. Construct the source string: {RequestBody}{InboundAPIKey}
2. Apply the agreed-upon hash algorithm to this source string.
3. Convert the resulting hash to a hexadecimal string.

Signing for Status Checks

For status check operations (e.g., when querying a request’s status using the globalId) you must instead compute the hash over the {globalId}{InboundAPIKey} string. This ensures the X-OPP-Signature header is correctly generated for status queries as well as regular API calls, and is required for the Paysend Enterprise API to validate the authenticity of both types of operations.

Supported Hash Algorithms

Paysend Enterprise API supports the following hash algorithms for generating signatures:

• SHA-256
• SHA-512 Choose the algorithm that best fits your security requirements.

Idempotency

Idempotency is a crucial feature in financial APIs that ensures the same operation is not accidentally performed multiple times. This is particularly important for payment transactions to prevent duplicate charges or transfers. The Paysend Enterprise API implements idempotency using a combination of two key elements:

• Idempotency Key: A unique identifier for each API request.
• Request Timestamp: The time at which the request was initiated by the client.

When making a request to the API:

1. Generate a unique idempotency key for each new request.
2. Include the idempotency key in the header.request.id field of your request.
3. Include the current timestamp in the header.request.date field.

Example request header:

"header": {
  "request": {
      "id": "unique-idempotency-key-123",
      "date": "2024-08-15T14:30:00Z"
  }
}

Если есть вопросы или предложения, пишите мне в телеграм @g3nnadych или whatsapp.