> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mangopay.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction

export const Aml = ({content}) => <Tooltip tip="Regulations which require companies like Mangopay to implement measures that help ensure the money transacting through their system is legitimate.">
        {content}
    </Tooltip>;

export const WorkingDay = ({content}) => <Tooltip tip="Monday to Friday, excluding weekends and public holidays">
        {content}
    </Tooltip>;

export const Dropdown_Currency_PayoutRails = () => {
  const paymentData = {
    AED: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "10:30",
        deliveryTime: "1-4 business days"
      }]
    },
    AUD: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "11:00",
        deliveryTime: "1-4 business days"
      }]
    },
    CAD: {
      local: [{
        rail: "EFT",
        cutoffTime: "17:00",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "12:00",
        deliveryTime: "1-4 business days"
      }]
    },
    CHF: {
      local: [{
        rail: "SIC",
        cutoffTime: "16:15",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "12:30",
        deliveryTime: "1-4 business days"
      }]
    },
    CNH: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "09:00",
        deliveryTime: "1-4 business days"
      }]
    },
    CZK: {
      local: [{
        rail: "Certis",
        cutoffTime: "09:00",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "09:00",
        deliveryTime: "1-4 business days"
      }]
    },
    DKK: {
      local: [{
        rail: "Intradag",
        cutoffTime: "11:30",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "08:00",
        deliveryTime: "1-4 business days"
      }]
    },
    EUR: {
      local: [{
        rail: "SCT",
        cutoffTime: "12:30",
        deliveryTime: "Same business day"
      }, {
        rail: "SCT Inst",
        cutoffTime: "Always open",
        deliveryTime: "Instant"
      }, {
        rail: "T2",
        cutoffTime: "16:15",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "16:00",
        deliveryTime: "1-4 business days"
      }]
    },
    GBP: {
      local: [{
        rail: "FPS",
        cutoffTime: "Always open",
        deliveryTime: "Instant"
      }, {
        rail: "CHAPS (RTGS)",
        cutoffTime: "17:30",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "17:45",
        deliveryTime: "1-4 business days"
      }]
    },
    HKD: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "14:30",
        deliveryTime: "1-4 business days"
      }]
    },
    HUF: {
      local: [{
        rail: "Intergiro",
        cutoffTime: "13:15",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "14:00",
        deliveryTime: "1-4 business days"
      }]
    },
    ILS: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "12:00",
        deliveryTime: "1-4 business days"
      }]
    },
    JPY: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "08:00",
        deliveryTime: "1-4 (+1) business days"
      }]
    },
    MXN: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "16:30",
        deliveryTime: "1-4 business days"
      }]
    },
    NOK: {
      local: [{
        rail: "NICS",
        cutoffTime: "11:30",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "08:00",
        deliveryTime: "1-4 business days"
      }]
    },
    NZD: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "17:00",
        deliveryTime: "1-4 (+1) business days"
      }]
    },
    PLN: {
      local: [{
        rail: "Sorbnet",
        cutoffTime: "16:00",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "11:00",
        deliveryTime: "1-4 business days"
      }]
    },
    RON: {
      local: [{
        rail: "ReGIS",
        cutoffTime: "12:15",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "11:30",
        deliveryTime: "1-4 business days"
      }]
    },
    SAR: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "08:00",
        deliveryTime: "1-4 business days"
      }]
    },
    SEK: {
      local: [{
        rail: "RIX-INST",
        cutoffTime: "Always open",
        deliveryTime: "Instant"
      }, {
        rail: "RIX (RGTS)",
        cutoffTime: "16:15",
        deliveryTime: "Within 5 minutes"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "08:00",
        deliveryTime: "1-4 business days"
      }]
    },
    SGD: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "18:30",
        deliveryTime: "1-4 (+1) business days"
      }]
    },
    TRY: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "10:00",
        deliveryTime: "1-4 business days"
      }]
    },
    USD: {
      local: [{
        rail: "ACH",
        cutoffTime: "21:45",
        deliveryTime: "Same business day"
      }],
      international: [{
        rail: "SWIFT",
        cutoffTime: "18:30",
        deliveryTime: "1-4 business days"
      }]
    },
    ZAR: {
      local: [],
      international: [{
        rail: "SWIFT",
        cutoffTime: "09:30",
        deliveryTime: "1-4 business days"
      }]
    }
  };
  const currencyCodes = Object.keys(paymentData);
  const currencyOptionsForSelect = [{
    value: "",
    label: "All currencies"
  }, ...currencyCodes.map(code => ({
    value: code,
    label: code
  }))];
  const allCurrencyDetails = currencyCodes.map(code => {
    const currencyData = paymentData[code];
    const combinedRoutes = [];
    (currencyData.local || []).forEach(route => {
      combinedRoutes.push({
        ...route,
        type: "Domestic",
        originalType: "local"
      });
    });
    (currencyData.international || []).forEach(route => {
      combinedRoutes.push({
        ...route,
        type: "Non-domestic",
        originalType: "international"
      });
    });
    return {
      value: code,
      label: code,
      routes: combinedRoutes
    };
  });
  const [selectedValue, setSelectedValue] = useState(currencyOptionsForSelect[0].value);
  const handleChange = event => {
    setSelectedValue(event.target.value);
  };
  const selectedCurrencyData = selectedValue ? allCurrencyDetails.find(opt => opt.value === selectedValue) : null;
  const hasAnyRoutesToDisplay = selectedValue && selectedCurrencyData && selectedCurrencyData.routes && selectedCurrencyData.routes.length > 0 || !selectedValue && allCurrencyDetails.some(cd => cd.routes && cd.routes.length > 0);
  return <div className="currency-dropdown-container w-full">
      <label htmlFor="currency-routes-list" className="currency-dropdown-label">
        Available payout routes by currency:
      </label>
      <select id="currency-routes-list" value={selectedValue} onChange={handleChange} className="currency-dropdown-select">
        {currencyOptionsForSelect.map(option => <option key={option.value} value={option.value}>
            {option.label}
          </option>)}
      </select>

      <div className="currency-details-section mt-4">
        {hasAnyRoutesToDisplay ? <div>
            <div className="grid grid-cols-5 gap-x-3 items-baseline font-semibold py-2 border-b-2 border-gray-300">
              <div className="px-3">Currency</div>
              <div className="px-3">Type</div>
              <div className="px-3">Name</div>
              <div className="px-3">Cutoff time (CET)</div>
              <div className="px-3">Delivery time (typical)</div>
            </div>

            {selectedValue && selectedCurrencyData ? <div className="mt-3">
                {selectedCurrencyData.routes.length > 0 ? selectedCurrencyData.routes.map((route, index) => {
    const isLastItem = index === selectedCurrencyData.routes.length - 1;
    return <div key={`${selectedCurrencyData.label}-${route.originalType}-${route.rail}-${index}`} className={`
                          grid grid-cols-5 gap-x-3 items-baseline py-3
                          ${isLastItem ? 'border-b-2 border-gray-300' : 'border-b border-gray-200'}
                        `}>
                        <div className="px-3">{selectedCurrencyData.label}</div>
                        <div className="px-3">{route.type}</div>
                        <div className="px-3">{route.rail}</div>
                        <div className="px-3">{route.cutoffTime}</div>
                        <div className="px-3">{route.deliveryTime}</div>
                      </div>;
  }) : <p className="text-gray-500 italic py-3 text-center">
                    No specific routes listed for {selectedCurrencyData.label}.
                  </p>}
              </div> : <div className="mt-3">
                {allCurrencyDetails.map(currencyDetailItem => <div key={currencyDetailItem.label} className="mb-1">
                    {currencyDetailItem.routes.map((route, index) => {
    const isLastInGroup = index === currencyDetailItem.routes.length - 1;
    return <div key={`${currencyDetailItem.label}-${route.originalType}-${route.rail}-${index}`} className={`
                            grid grid-cols-5 gap-x-3 items-baseline py-3
                            ${isLastInGroup ? 'border-b-2 border-gray-300' : 'border-b border-gray-200'}
                          `}>
                          <div className="px-3">{currencyDetailItem.label}</div>
                          <div className="px-3">{route.type}</div>
                          <div className="px-3">{route.rail}</div>
                          <div className="px-3">{route.cutoffTime}</div>
                          <div className="px-3">{route.deliveryTime}</div>
                        </div>;
  })}
                  </div>)}
              </div>}
          </div> : <p>No currency data available.</p>}
      </div>
    </div>;
};

A payout is the process of withdrawing funds from a Mangopay wallet in the Mangopay environment to an external bank account opened in the name of the user (the Mangopay Account holder).

The user's external bank account must be registered in advance of the payout request as a [Recipient](/guides/sca/recipients). The country and currency of the Recipient impacts [payout routing](#how-mangopay-routes-funds).

The Natural User or Legal User registered with Mangopay must have:

* The `UserCategory` of `OWNER` (see [categories](/guides/users/categories))
* The necessary [KYC/KYB verification](/guides/users/verification) depending on the [limits applicable to your platform](/guides/users/limits) (for example, they must have `KYCLevel` of `REGULAR` for payment services platforms).

<Note>
  **Note – Verification of Payee may impact payouts**

  If your platform offers User-Owned Accounts (Virtual Account or Banking Alias) to your end users, Verification of Payee (VOP) may impact their payouts. [Read more](/guides/vop) **→**

  There is no impact on payouts for platforms not offering User-Owned Accounts.
</Note>

## Payout rails

Mangopay offers a wide range of payout rails for local and international bank wire transfers.

Payout rails, also called routes, refer to the infrastructure and technology that facilitate the transfer of funds between bank accounts.

The payout rails available to your platform depend on your contract – contact Mangopay <a href="https://hub.mangopay.com/" target="_blank">via the Dashboard</a> to discuss activation of a local payout rail for your users.

### Domestic

Domestic rails rely on local networks used within a country or region. Because both banks are in the same jurisdiction and use the same local networks, the funds can generally be sent much more quickly and cheaply.

Sending a domestic payout requires Mangopay to hold and send funds from an account in the same jurisdiction as the user.

### Non-domestic

Non-domestic rails rely on shared messaging services such as SWIFT to transfer funds. SWIFT processing times depend on a number of factors including cutoff times and correspondent banks. SWIFT payments can arrive same day, they are frequently next day but can also take several days.

Mangopay works with partner banks to send the funds to the user's account. Depending on where the user's account is registered, Mangopay's partners may themselves need to rely on additional correspondent banks to enable the connection with the end user's bank.

## How Mangopay routes funds

Mangopay attempts to use a given payout rail depending on:

* The Payout's `Currency` and `RecipientId` (or `BankAccountId`)
* The Recipient's `Currency` and `Country`

**Mangopay always attempts to use the domestic rail if the currency and country correspond.**

This is true for all currencies except EUR, where your platform can impact the rail used by setting the `PayoutModeRequested` parameter at the moment of the payout request – see [instant schemes](#instant-schemes) and [RTGS](#real-time-gross-settlement-rtgs) below.

For example, to use:

* SCT, SCT Inst, or T2, the Recipient `Currency` must be `EUR` and the `Country` must be in the SEPA zone
* FPS, the Recipient `Currency` must be `GBP` and its `Country` `GB`
* ACH, the Recipient `Currency` must be `USD` and its `Country` `US`

If the `Currency` and `Country` do not match, the payout is attempted via SWIFT **but only if** the Recipient has the `PayoutMethodType` of `InternationalBankTransfer`.

A non-domestic payout attempt to a `LocalBankTransfer` Recipient returns an HTTP 400 error.

<Check>
  **Best practice – Use multi-currency Recipients**

  If your users may wish to receive multiple currencies to the same account, register the Recipient with the `InternationalBankTransfer` value set for its `PayoutMethodType`.

  Mangopay applies a smart routing logic to always use the domestic rail if a local currency is sent, thereby optimizing routing costs and speeds while allowing you to operate one `RecipientId` for a user.
</Check>

Note that [legacy Bank Accounts](#migration-of-legacy-bank-accounts) migrated to Recipients may have the `LocalBankTransfer` payout method type and accept SWIFT payouts. New account registrations for multi-currency use must use `InternationalBankTransfer`.

## All payout rails by currency

The table below shows all local and international payout rails offered by Mangopay – contact Mangopay <a href="https://hub.mangopay.com/" target="_blank">via the Dashboard</a> to discuss activation.

<Dropdown_Currency_PayoutRails />

### Delivery times

The delivery times shown in the table above are typical for the rail used. Some payouts are subject to manual review by Mangopay's teams for reasons of risk management or AML/CFT - these payouts may take longer than shown.

Payouts created before the cutoff times outlined below are transferred to the user's bank account within the corresponding processing times. Payouts created after the cutoff are processed next working day – meaning Monday to Friday excluding weekends and [public holidays](/support/public-holidays).

Some SWIFT payouts are sent the day after the cutoff, and therefore delivery can take a day longer. These routes are marked **+1** in the table above.

<Note>
  **Note – Timings displayed are indicative**

  The delivery times shown on this page are indicative. For all schemes, the actual delivery time of an specific individual payout depends on various factors, many of which are out of Mangopay's control.
</Note>

### Instant schemes

Mangopay provides a number of instant local schemes, for example:

* SEPA Instant Credit Transfer for EUR payouts to EUR Recipients in SEPA countries
* Faster Payments System (FPS) for GBP payouts to local GB Recipients
* RIX-INST for SEK payouts to local SE recipients

These typically allow payouts to be processed within 10 seconds (the `Status` changes from `CREATED` to `SUCCEEDED`) but there can be a delay in some circumstances.

With the exception of EUR local payouts, instant schemes are used automatically by Mangopay.

**In the SEPA zone and for EUR only**, platforms can take advantage of a choice of schemes (SCT, SCT Inst, and T2), and so you need to use the `PayoutModeRequested` parameter to specify the scheme for each payout request. Mangopay also offers a fallback mechanism for SCT Inst to be processed as SCT if the instant request fails. See [initiate an SCT Inst payout](/guides/payouts/integration#initiate-an-sct-inst-payout) for details.

### Real-time gross settlement (RTGS)

For high-value EUR payouts in the SEPA zone, Mangopay offers real-time gross settlement (RTGS) via the Eurozone's T2 scheme (formerly called TARGET2). This functionality was previously known as Express Payouts.

To request RTGS, set the `PayoutModeRequested` to `RTGS_PAYMENT` in calls to the [POST Create a Payout](/api-reference/payouts/create-payout) endpoint.

Funds are usually processed the same working day. Payout requests received outside the scheme opening hours are processed the next working day.

The T2 scheme is open 07:00 – 16:15 CET, 5 days a week. The T2 scheme is closed at weekends and on the following days if they fall on a weekday: 1 January (New Year's Day), Good Friday, Easter Monday, 1 May (Labour Day), 25 December (Christmas Day), 26 December.

### Fees for international payouts

International bank wires that rely on the **SWIFT network** have three options for managing expectations for processing fees:

* **SHA** – The fees are shared between the remitter (sender) and the beneficiary
* **BEN** – The beneficiary bears all fees
* **OUR** – The remitter bears all fees

By default, Mangopay uses the **SHA** option for SWIFT payouts. This means that the SWIFT fees are shared between the remitter and the beneficiary, and the beneficiary’s share is deducted from the payout amount that arrives on their account.

For SWIFT payouts, your platform can request that Mangopay use the **OUR** option. This allows the beneficiary to receive the full `CreditedFunds.Amount` of the payout on their recipient account. Mangopay recovers the fees from your platform during the usual billing cycle.

To take advantage of this and activate charge-bearing for your platform, contact our teams <a href="https://hub.mangopay.com/" target="_blank">via the Dashboard</a>.

Once activated, your platform can set `ChargeBearer` parameter to `OUR` in your call to [POST Create a Payout](/api-reference/payouts/create-payout) to ask Mangopay to use the OUR configuration.

The OUR setting is available:

* On SWIFT non-domestic payouts, not any local scheme
* For any currency and recipient country (if supported)

When `ChargeBearer` is set to `OUR`, Mangopay checks whether its network of partners is able to fulfill cost-bearing for the given currency and recipient country before requesting the payout.

If OUR is not supported, a **400 HTTP error** is returned to allow your platform to decide how to proceed with the user – for example whether to make the request with `SHA` (default value), register a different recipient, or even convert the funds first thanks to Mangopay's [FX features](/guides/fx).

The `ChargeBearer` parameter is only returned on the [GET View a Payout and check mode applied](/api-reference/payouts/view-payout-check-mode-applied) endpoint, not the [GET View a Payout endpoint](/api-reference/payouts/view-payout).

## Other payout considerations

### Country restrictions

Due to AML policy, Mangopay doesn't allow payouts to some countries – see the [country restrictions](/guides/users/country-restrictions) article for more information.

### Minimum amount

Mangopay does not impose a minimum amount on payouts. The minimum amount possible is dictated by the rules of the underlying scheme used to send the payout. For example, the SEPA Credit Transfer (SCT) scheme accepts a minimum amount of EUR 0.01 (`Amount` value `1`), and the Faster Payments System (FPS) in the UK allows GBP 0.01 (`Amount` value `1`). Other schemes may impose different minimum amounts.

## Migration of legacy bank accounts

The Payout request's `BankAccountId` field can contain the `Id` of a Recipient or a legacy Bank Account.

Active legacy bank accounts, created before the Recipient feature was released, were migrated to recipients.

### Obtain Recipient data of an active legacy bank account

To retrieve data of active legacy bank accounts you can use the [GET View a Recipient](/api-reference/recipients/view-recipient) endpoint and specify the legacy `BankAccountId` as the `RecipientId` path parameter. For example, if the legacy Bank Account was `bankacc_m_01JCN1X2EHWG0JNJNPNQ21CW5G`, call the endpoint with that ID:

> **GET /v2.01/\{ClientId}/recipients/**`bankacc_m_01JCN1X2EHWG0JNJNPNQ21CW5G`

The API responds with a Recipient object containing the information of the legacy Bank Account:

#### Recipient API response - Migrated legacy Bank Account

```json theme={null}
{
    "Id": "bankacc_m_01JCN1X2EHWG0JNJNPNQ21CW5G",
    "Status": "ACTIVE",
    "CreationDate": 1731578464,
    "DisplayName": null,
    "PayoutMethodType": "LocalBankTransfer",
    "RecipientType": "Individual",
    "Currency": "EUR",
    "Country": "FR",
    "UserId": "user_m_01J9KR16BG7EDC8RNEY2M18EXK",
    "Tag": null,
    "RecipientScope": "PAYOUT",
    "IndividualRecipient": {
        "FirstName": "Alex",
        "LastName": "Smith",
        "Address": {
            "AddressLine1": "1 rue de Rivoli",
            "City": "Paris",
            "PostalCode": "75001",
            "Country": "FR"
        }
    },
    "LocalBankTransfer": {
        "EUR": {
            "IBAN": "FR7630004000031234567890143",
            "BIC": "BNPAFRPP"
        }
    }
}
```

### Migration data mapping

Legacy Bank Account objects had no currency property, and so they could be used for payouts in multiple currencies. The Recipients feature has a `Currency` for each Recipient to improve payout deliverability, meaning that the same real-life account can be registered multiple times (with different `PayoutMethod` values).

<Note>
  **Note – Legacy local accounts accept SWIFT payouts**

  A legacy Bank Account accepts non-domestic SWIFT payouts, even though its migrated Recipient object indicates `LocalBankTransfer` in the `PayoutMethodType`.

  New Recipients must have `InternationalBankTransfer` to accept non-domestic payouts, otherwise an error is returned – [read more](#how-mangopay-routes-funds).
</Note>

The table below shows the values assigned to legacy Bank Accounts when Mangopay migrated them to Recipients. In addition to the data below, the `RecipientScope` assigned was `PAYOUT` for all accounts (which can be used for `PAYIN` [use cases](/guides/sca/recipients#recipient-scopes)).

<table>
  <thead>
    <tr>
      <th class="header">Bank Account `Type`</th>
      <th class="header">Recipient `PayoutMethod`</th>
      <th class="header">Recipient `Currency`</th>
      <th class="header">Recipient `Country`</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td class="table-content">`IBAN`</td>
      <td class="table-content">`LocalBankTransfer` if `IBAN` indicates a SEPA country, `InternationalBankTransfer` if not</td>
      <td class="table-content">Based on the `IBAN` country (`EUR` if SEPA country or local non-EUR)</td>
      <td class="table-content">Based on the `IBAN`</td>
    </tr>

    <tr>
      <td class="table-content">`GB`</td>
      <td class="table-content">`LocalBankTransfer`</td>
      <td class="table-content">`GBP`</td>
      <td class="table-content">`GB`</td>
    </tr>

    <tr>
      <td class="table-content">`US`</td>
      <td class="table-content">`LocalBankTransfer`</td>
      <td class="table-content">`USD`</td>
      <td class="table-content">`US`</td>
    </tr>

    <tr>
      <td class="table-content">`CA`</td>
      <td class="table-content">`LocalBankTransfer`</td>
      <td class="table-content">`CAD`</td>
      <td class="table-content">`CA`</td>
    </tr>

    <tr>
      <td class="table-content">`OTHER`</td>
      <td class="table-content">`InternationalBankTransfer`</td>
      <td class="table-content">Based on the `BIC`</td>
      <td class="table-content">Based on the `BIC`</td>
    </tr>
  </tbody>
</table>

### Migration of non-EUR accounts in SEPA countries

The process that was followed for IBAN type bank accounts was:

1. Country code extracted from the `IBAN` (not the `BIC`)
2. If IBAN country is in SEPA and the local currency is EUR, the Recipient was assigned:
   * `PayoutMethodType` = `LocalBankTransfer`
   * `Currency` = `EUR`
3. If IBAN country is in SEPA and the local currency is not EUR (e.g. Denmark, Poland, etc), the Recipient was assigned:
   * `PayoutMethodType` = `InternationalBankTransfer`
   * `Currency` = Local currency based on predefined list (e.g. `DKK`, `PLN`, etc)