1. Wire Transfers
Kushki Docs
English
  • Español
  • English
  • Home
  • Quick Start
    • Frequently Asked Questions
    • Moving to Production
    • Policy for Important API Changes
    • Test Data
    • Error Codes
    • Latest Features
  • Payment Glossary
    • Payments Glossary
  • One-time card payments (Online)
    • Supported card brands
    • Functionalities by business model
    • How do third party commissions work?
    • Integration guide Third Party Commissions
    • Network Tokens
    • One-step Payments
      • How do Card Payments Work?
      • Accept a Card Payment
      • Direct charge (without token)
      • Accept One-Time Payments with OTP
      • OTP Authentication Error Codes
      • Error codes for single card payments
    • Two-steps Payments
      • How do single payments with authorization and capture work?
      • Receive payments with authorization and capture
    • Refunds
      • Returns, cancellations, and refunds
    • 3DS Authentication
      • Introduction to 3DS
      • 3DS API integration
      • 3DS integration with kushki.js library
      • 3DS API integration plus kushki.js library
      • 3DS Error Codes
    • Apple Pay Payments
      • Apple Pay Configuration
      • Apple Pay Sandbox testing
  • Recurring Card Payments (Online)
    • Functionalities by business model
    • External subscriptions to Kushki
    • Authenticate your subscriptions with 3DS
    • Accept one-click payments with 3DS
    • Error codes in recurring charges
    • Apple Pay for Subscriptions
    • Scheduled payments
      • How do Credit or Debit Card Payment Recurring Charges Work?
      • Create a recurring charge
      • Manage your Scheduled Charges
    • OneClick Payments
      • Accepting One-Click Payments
      • How do OneClick payments with authorization and capture work?
      • Receive one-click payments with authorization and capture
  • Card-present payments
    • Card present payments
    • Accept card present payments
    • Test data
    • Webhooks for card present
    • Cloud Terminal API
      • Cloud terminal API overview
      • Take payments
      • Cancel a payment request
      • Check the status of a payment request
      • How to print a customized ticket?
    • App-to-app
      • App-to-app overview
      • Take payments
    • Terminal SDK
      • Terminal SDK Introduction
      • Take payments
    • Raw card-present API
      • Raw card-present API overview
      • Cryptographic key exchange
      • Sample script to encrypt information
      • Take Payments
      • Frequently Asked Questions
      • Error codes for card-present transactions
    • Transactions
      • Transactions
      • Cancel payments
    • Kushki One
      • First Steps
      • Autenticación y Cifrado de Requests
      • Accept payments with Kushki One
      • Amount Format
      • Async services and webhooks
      • Printing on SmartPOS terminal
      • Unified Error Catalog — Kushki ONE Connect
    • Kushki One Payment App
      • Overview
      • Process a payment
      • Split payment on the terminal
      • Refunds and PreAuth & Capture
      • Review Your Transactions
      • Terminal Setup
  • Wire Transfers
    • How do Payments by Wire Transfers Work?
    • Banks and transaction details for bank transfer payments
    • Receive Wire Transfers
    • Check the Status of a Transaction
  • Money Disbursement
    • Wire Transfer
      • How Does a Payment Distribution by Wire Transfer Work?
      • Payment Distribution to Bank Accounts
      • Error codes for transfer dispersions
  • Payment Links
    • Smartlinks
  • Plugins
    • Shopify
      • Shopify
      • Plugin Operation
    • VTEX
      • VTEX Integration Guide
  • Payment forms and buttons
    • Kajita
      • How Does it Work?
      • Payment Kajitas
    • Payment Button
      • Overview
      • Generate a payment button
  • Branch Offices Management
    • How to Onboard Submerchants via API
  • Notifications
    • Webhooks
    • Good Practices
    • Check your Webhooks
    • One-time Payments Webhooks
      • Webhook for One-Time Payments made with a card
      • Webhook for One-Time Payments by Wire Transfer
      • Webhook for One-Time Payments in Cash
    • Recurring Payments Webhooks
      • Webhook for Recurring Payments Made with Card
    • Payment Distribution Webhooks
      • Webhook for payment disbursement through wire transfer
    • Payment button Webhooks
      • Webhooks with Payment Button
    • Smartlinks Webhooks
      • Webhooks with Smartlinks
    • Refunds Webhooks
      • Webhook for Voids and Refunds
      • Chargeback Webhooks
HomeMexico 🇲🇽
Ecuador 🇪🇨Chile 🇨🇱Colombia 🇨🇴Peru 🇵🇪
HomeMexico 🇲🇽
Ecuador 🇪🇨Chile 🇨🇱Colombia 🇨🇴Peru 🇵🇪
Status
Soporte / Support
English
  • Español
  • English
  1. Wire Transfers

Receive Wire Transfers

Your customers will be able to use the balance in their bank account to make purchases on your website
Web
iOS
Android
Allow your customers to use the available balance in their bank account to purchase your products or services from your website via a wire transfer. To do so, you must obtain your paying customer's email address, generate a Clabe account number to your customer, so that they can go to their bank's website and complete the wire transfer.
The payment flow that you will integrate is as shown below:
Flujo_transfer_MX_EN

1. Set up your Front end#

The front end is responsible for collecting the user’s main details, generating a token for such information through Kushki’s servers, and sending that information to the back end to start the payment process.
You have two options to integrate: Kajita and Kushki.js.

Kajita#

Kushki has payment forms ready to collect card information securely. You can use any of our versions:
Cajita: our first version of the payment form. Not customizable.
Kajita: is the second version, which allows you to add customizations from your Administration Console and even have several versions of Kajita, one for each payment method, for example.

Create and customize your Kajitas#

With Kushki you can create your Kajitas from the Administration Console. Click here to learn how to do this.

Set up Kajita#

Include the kushki-checkout.js script in your payment page by adding it to the <head> of your HTML file. Always load kushki-checkout directly from cdn.kushkipagos.com. Do not include the script in a bundle or package or host a copy of it.

Add Kajita to your website#

Kajita needs a place to live on your page. Enter the following code in your website's <body>, where you want the payment form to be displayed.
For Kajita (v.2):
For Cajita (v.1)
Remember to configure the action of the action form according to the corresponding endpoint in your back end, to obtain the token.
Then, add the following script tag.
For Kajita (v.2) you can obtain the script from your Administration Console as here explained.
For Cajita (v.1), add the next script and make sure that the form has been rendered:
This will create a predesigned form on your website to accept payments.
You can use Kajita to offer not only payments through wire transfers, but also in cash and with card.

Kushki.js#

Use Kushki.js if you need more control over the "look & feel" or appearance of your payment form.

Set up Kushki.js#

Option 1 - CDN#
Use the following script tag at the end of the <body> of your payment page.
Option 2 - NPM#
Install the package from npm.
Then import it into your code using the following code.
Set up Kushki object#
Add the following code to your application

Collect User Information and Send it to your Back End#

First, embed the form in your payment page adding the required fields. You can design it as you prefer.
For example:
Send notifications to your customers
If you want your customers to be notified of their transactions, make sure to capture your customer's email address in the payment form. In addition to this, remember to enable the notification option from your administration console.
Then, for the moment when the user submits the form, add a token request and send it to your back end.
Check the full reference on our Kushki.js reference

2. Set up your Back End#

The back end is responsible for receiving the token obtained from your front end and starting the payment process with Kushki.
When the user submits the form, your front end sends a token to an endpoint that you specified previously. With this token, you must make a call to our endpoint to obtain the CLABE account code associated with the email address specified by your customer in the form configured in step 1.
JavaScript
Python
PHP
Check our API Reference for more information.
In response to this call, show your customer the CLABE number generated along with the payment reference so that they can log in to their bank portal and complete the transfer.
{
  "bank": "Transfer Processor",
  "referenceNumber": "1111111",
  "referenceProcessor": "641641241726965121",
  "ticketNumber": "1641241726965127",
  "transactionReference": "fb247919-2c5e-4ef2-ab75-21fc38b5a7e4"
}
You will need to show your customer the Clabe (referenceProcessor) so that they can log into their banking portal and complete the transfer. Be sure to save the other information obtained for future reference.
Importante ❗️⛔️
The Clabe account will not change for your paying customer, as long as the same email address is entered when requesting the token.
If the transaction is not paid, it will remain in initializedTransaction status for up to 7 days. After this period, it will remain as expiredTransaction. Contact us if you wish to reduce this period to less than 7 days (1 day minimum).
If the amount sent when consuming the init differs from the amount paid at the bank, the transfer will be declined. In this case, an immediate refund will be made to the customer. The transaction will remain in initializedTransaction status for up to 7 days. After this period, it will remain as expiredTransaction.

3. Check the transfer status#

To find out the status of the bank transfer made by your customer you can use any of these options:
Webhook for one-time payments by wire transfer.
Use the Kushki API reference.

4. Test your Integration#

The final result of this test data depends on your merchant's configuration: it requires the test environment (sandbox) to be active for your merchant and the assigned processor to support simulating certain statuses. If you don't get the expected result, contact your Kushki account manager or support.
Use the following test data in the UAT environment to make sure your integration is ready.
Approved transaction: send documentNumber: 123456789 when requesting the token (any number other than 999999990 is also approved).
Declined transaction: send documentNumber: 999999990.
Check the result with GET /status/{token}. See more detail in Test data.

4. Prepare your Certification#

Read the following guidelines for technical certification approval (required to obtain productive account credentials):
The calculation of taxes and the total amount must be the correct amount.
Messages displayed on the screen should be aligned with Kushki's responses.
All Kushki responses must be saved and recorded (required in case you need support).
In the event of successful receipt of the Webhook notification, respond to the request with a statusCode 200, and inform your customer.
The "Pay" button is disabled after the first click.
If the result of the transaction is Initialized, a new transaction must not be allowed until approved or rejected.
Kushki's logo must be visible for the customer. You can find our logo in several formats here.
Make sure to send all the variables required, specified in the API reference.

Accept Webhooks
Manage correctly post-payment events.
Check the status of your transactions
With the token you received from the front end, you will also be able to check the status of transactions through our API.
Modificado en 2026-10-21 22:32:56
Anterior
Banks and transaction details for bank transfer payments
Siguiente
Check the Status of a Transaction
Built with