> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.mangopay.com/api-reference/payouts/check-instant-payout-eligibility/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.mangopay.com/_mcp/server.

# Check Instant Payout eligibility

POST https://api.sandbox.mangopay.com/v2.01/{ClientId}/payouts/reachability
Content-Type: application/json

Check whether the destination bank is reachable for SCT Inst payouts.

**Note – Endpoint only available for SCT Inst payouts in EUR**

You can only use this endpoint to check payouts where:

* The currency is `EUR`
* The `PayoutModeRequested` is `INSTANT_PAYMENT`

All other currencies return the [130001](/errors/codes/130001) `UnreachableReason.Code`.

Reference: https://docs.mangopay.com/api-reference/payouts/check-instant-payout-eligibility

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token. If your platform is using a [proxy](/guides/sca/proxy-management) to take SCA-triggering action on behalf of users, you also need to integrate [mTLS authentication](/guides/sca/platform) and use the `api-mtls` base URL.

## Servers

- `https://api.sandbox.mangopay.com` (Sandbox, default)
- `https://api.mangopay.com` (Production)
- `https://api-mtls.sandbox.mangopay.com` (mTLS Sandbox)
- `https://api-mtls.mangopay.com` (mTLS Production)

## Request

### Path parameters

- `ClientId` (string, required) — Platform's API account identifier, associated with the API key.

### Body (application/json)

This endpoint expects a CheckInstantPayoutEligibilityRequest.

- `PayoutModeRequested` (string, required) — **Allowed values:** `INSTANT_PAYMENT` The mode of payout, which must be `INSTANT_PAYMENT` on this reachability endpoint, even if your subsequent payout request uses `INSTANT_PAYMENT_ONLY`.
- `AuthorId` (string, required) — The unique identifier of the user at the source of the transaction. **Best practice:** When the payout author is different from the bank account owner, the Payout `AuthorId` value must be different from the Recipient `UserId` value as well. Otherwise, Mangopay's Compliance team will reject the payout.
- `DebitedFunds` (CheckInstantPayoutEligibilityRequestDebitedFunds, required) — Information about the debited funds.
- `Fees` (CheckInstantPayoutEligibilityRequestFees, required) — Information about the fees.
- `DebitedWalletId` (string, required) — The unique identifier of the debited wallet.
- `BankAccountId` (string, optional) — The unique identifier of the Bank Account. This property should **not** be used by platforms integrating for the first time – send the `RecipientId` instead.
- `BankWireRef` (string, optional) — Max. length: 255 characters (\< 12 recommended) Custom description to appear on the user's bank statement along with the platform name. The recommended length is 12 characters – strings longer than this may be truncated depending on the bank. For the full structure of the string, see the Customizing bank statement references article.

## Response

### 200

Success

- `Id` (string, optional) — Max length: 128 characters (see [data formats](/api-reference/overview/data-formats) for details) The unique identifier of the object.
- `Tag` (string, optional) — Max. length: 255 characters Custom data that you can add to this object, such as unique identifiers in your system. To store multiple values, you can serialize them into a single string, for example a JSON object: `"{\"id_1\":AB123,\"id_2\":DE456}"`.
- `CreationDate` (integer, optional) — Unix timestamp (UTC) of the date and time the object was created.
- `AuthorId` (string, optional) — The unique identifier of the user at the source of the transaction. **Best practice:** When the payout author is different from the bank account owner, the Payout `AuthorId` value must be different from the Recipient `UserId` value as well. Otherwise, Mangopay's Compliance team will reject the payout.
- `CreditedUserId` (any, optional) — For a payout, the `CreditedUserId` is always `null` as the funds are being paid out of the Mangoapy environment.
- `DebitedFunds` (InstantPayoutEligibilityResponseDebitedFunds, optional) — The reachability result for an SCT Inst payout.

## Errors

### 400 Bad Request Error

Bad Request

- `Message` (string, optional) — Description of the error.
- `Type` (string, optional) — The category of the error.
- `Id` (string, optional) — Unique identifier of the error instance, useful when contacting Mangopay for support.
- `Date` (double, optional) — Unix timestamp (UTC) of the date and time the error was triggered.
- `errors` (map from string to string, optional, nullable) — Object containing one or more field-level errors.

## Types

### CheckInstantPayoutEligibilityRequestDebitedFunds

Information about the debited funds.

- `Currency` (string, required) — **Allowed values:** The three-letter ISO 4217 code (EUR, GBP, etc.) of a supported currency (depends on feature, contract, and activation settings). The currency of the amount.
- `Amount` (integer, required) — The amount of the currency in its minor unit. For example, EUR 12.60 would be represented as `1260` whereas JPY 12 would be represented as just `12`.

### CheckInstantPayoutEligibilityRequestFees

Information about the fees.

- `Currency` (string, required) — **Allowed values:** The three-letter ISO 4217 code (EUR, GBP, etc.) of a supported currency (depends on feature, contract, and activation settings). The currency of the amount.
- `Amount` (integer, required) — The amount of the currency in its minor unit. For example, EUR 12.60 would be represented as `1260` whereas JPY 12 would be represented as just `12`.

### InstantPayoutEligibilityResponseDebitedFunds

The reachability result for an SCT Inst payout.

- `IsReachable` (boolean, optional) — Whether or not the bank is reachable.
- `UnreachableReason` (UnreachableReason_InstantPayoutEligibility, optional, nullable) — Information regarding why the bank is unreachable. Returned `null` when `IsReachable` is `true`.

### UnreachableReason_InstantPayoutEligibility

Information regarding why the bank is unreachable.

- `Code` (string, optional) — The error code for the reason why the bank is not reachable.
- `Message` (string, optional) — The reason why the bank is not reachable.

## Examples

### Reachable

**Request**

```json
{
  "body": {
    "AuthorId": "142036728",
    "BankAccountId": "54682154",
    "BankWireRef": "invoice 7282",
    "DebitedFunds": {
      "Amount": 1200,
      "Currency": "EUR"
    },
    "DebitedWalletId": "145389978",
    "Fees": {
      "Amount": 12,
      "Currency": "EUR"
    },
    "PayoutModeRequested": "INSTANT_PAYMENT"
  }
}
```

**Response**

```json
{
  "InstantPayout": {
    "IsReachable": true,
    "UnreachableReason": null
  }
}
```

**SDK Code**

```javascript Reachable
const mangopayInstance = require('mangopay4-nodejs-sdk')
const mangopay = new mangopayInstance({
  clientId: 'your-client-id',
  clientApiKey: 'your-api-key',
})

let myUser = {
  Id: 'user_m_01J2TZ261WZNDM0ZDRWGDYA4GN',
  WalletId: 'wlt_m_01J3D02K6ETV3BDP88C7PD2NDB',
}

let myBankAccount = {
  Id: 'bankacc_m_01J534QNZZSRCXXAJ1VXP58DDH',
}

let myPayout = {
  DebitedWalletId: myUser.WalletId,
  PaymentType: 'BANK_WIRE',
  BankAccountId: myBankAccount.Id,
  BankWireRef: 'Mangopay Ref',
  PayoutModeRequested: 'INSTANT_PAYMENT',
  AuthorId: myUser.Id,
  DebitedFunds: {
    Currency: 'EUR',
    Amount: 12,
  },
  Fees: {
    Currency: 'EUR',
    Amount: 0,
  },
  Tag: 'Created using Mangopay NodeJS SDK',
}

const checkInstantPayoutEligibility = async (payout) => {
  return await mangopay.PayOuts.checkEligibility(payout)
    .then((response) => {
      console.info(response)
      return response
    })
    .catch((err) => {
      console.log(err)
      return false
    })
}

checkInstantPayoutEligibility(myPayout)

```

```java Reachable
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mangopay.MangoPayApi;
import com.mangopay.core.Money;
import com.mangopay.core.enumerations.CurrencyIso;
import com.mangopay.core.enumerations.PayoutMode;
import com.mangopay.entities.PayOutEligibility;
import com.mangopay.entities.PayOutEligibilityResult;

public class CheckEligibility {
    
    public static void main(String[] args) throws Exception {
        MangoPayApi mangopay = new MangoPayApi();
        mangopay.getConfig().setClientId("your-client-id");
        mangopay.getConfig().setClientPassword("your-api-key");

        var userId = "user_m_01HQK25M6KVHKDV0S36JY9NRKR";
        var bankAccountId = "bankacc_m_01HTJ7P7Y8K9DS5SZ08MDQRHHE";
        
        PayOutEligibility eligibility = new PayOutEligibility();
        eligibility.setAuthorId(userId);
        eligibility.setDebitedFunds(new Money(CurrencyIso.EUR, 500));
        eligibility.setPayoutModeRequested(PayoutMode.INSTANT_PAYMENT);
        eligibility.setBankAccountId(bankAccountId);

        PayOutEligibilityResult result = mangopay.getPayOutApi().checkInstantPayoutEligibility(null, eligibility);

        Gson prettyPrint = new GsonBuilder().setPrettyPrinting().create();
        String prettyJson = prettyPrint.toJson(result);

        System.out.println(prettyJson);
    }
}

```

```csharp Reachable
using MangoPay.SDK;
using MangoPay.SDK.Entities;
using MangoPay.SDK.Entities.POST;
using MangoPay.SDK.Core.Enumerations;
using Newtonsoft.Json;

class Program
{
    static async Task Main(string[] args)
    {
        MangoPayApi api = new MangoPayApi();

        api.Config.ClientId = "your-client-id";
        api.Config.ClientPassword = "your-api-key";

        var payout = new PayOutEligibilityPostDTO {
            AuthorId =  "user_m_01J2TZ261WZNDM0ZDRWGDYA4GN",
            DebitedFunds = new Money { Amount = 1200, Currency = CurrencyIso.EUR },
            Fees = new Money { Amount = 12, Currency = CurrencyIso.EUR },
            PayoutModeRequested =  PayoutModeRequested.INSTANT_PAYMENT,
            BankAccountId = "bankacc_m_01J534QNZZSRCXXAJ1VXP58DDH",
            DebitedWalletId = "wlt_m_01J30991BXBB7VF28PBS82EWD3"
        };

        var checkEligibility = await api.PayOuts.CheckInstantPayoutEligibility(payout);

        string prettyPrint = JsonConvert.SerializeObject(checkEligibility, Formatting.Indented);
        Console.WriteLine(prettyPrint);
	}
}

```

```ruby Reachable
require 'mangopay'

MangoPay.configure do |client|
    client.preproduction = true
    client.client_id = 'your-client-id'
    client.client_apiKey = 'your-api-key'
    client.log_file = File.join(Dir.pwd, 'mangopay.log')
end

def checkReachability(payoutObject)
    begin
        response = MangoPay::PayOut::InstantPayoutEligibility::Reachability.create(payoutObject)
        puts response
        return response
    rescue MangoPay::ResponseError => error
        puts "Failed to check reachability: #{error.message}"
        puts "Error details: #{error.details}"
        return false
    end
end

myUser = {
  Id: '146476890',
  WalletId: '148968396'
}

myBankAccount = {
  Id: '154876798'
}

myPayout = {
  DebitedWalletId: myUser[:WalletId],
  PaymentType: 'BANK_WIRE',
  BankAccountId: myBankAccount[:Id],
  BankWireRef: 'Mangopay Ref',
  PayoutModeRequested: 'INSTANT_PAYMENT',
  AuthorId: myUser[:Id],
  DebitedFunds: {
    Currency: 'EUR',
    Amount: 1200,
  },
  Fees: {
    Currency: 'EUR',
    Amount: 0,
  },
  Tag: 'Created using Mangopay Ruby SDK'
}

checkReachability(myPayout)

```

### Not reachable

**Request**

```json
{
  "body": {
    "AuthorId": "142036728",
    "BankAccountId": "54682154",
    "BankWireRef": "invoice 7282",
    "DebitedFunds": {
      "Amount": 1200,
      "Currency": "EUR"
    },
    "DebitedWalletId": "145389978",
    "Fees": {
      "Amount": 12,
      "Currency": "EUR"
    },
    "PayoutModeRequested": "INSTANT_PAYMENT"
  }
}
```

**Response**

```json
{
  "InstantPayout": {
    "IsReachable": false,
    "UnreachableReason": {
      "Code": "130007",
      "Message": "Destination Bank is not reachable"
    }
  }
}
```

**SDK Code**

```javascript Not reachable
const mangopayInstance = require('mangopay4-nodejs-sdk')
const mangopay = new mangopayInstance({
  clientId: 'your-client-id',
  clientApiKey: 'your-api-key',
})

let myUser = {
  Id: 'user_m_01J2TZ261WZNDM0ZDRWGDYA4GN',
  WalletId: 'wlt_m_01J3D02K6ETV3BDP88C7PD2NDB',
}

let myBankAccount = {
  Id: 'bankacc_m_01J534QNZZSRCXXAJ1VXP58DDH',
}

let myPayout = {
  DebitedWalletId: myUser.WalletId,
  PaymentType: 'BANK_WIRE',
  BankAccountId: myBankAccount.Id,
  BankWireRef: 'Mangopay Ref',
  PayoutModeRequested: 'INSTANT_PAYMENT',
  AuthorId: myUser.Id,
  DebitedFunds: {
    Currency: 'EUR',
    Amount: 12,
  },
  Fees: {
    Currency: 'EUR',
    Amount: 0,
  },
  Tag: 'Created using Mangopay NodeJS SDK',
}

const checkInstantPayoutEligibility = async (payout) => {
  return await mangopay.PayOuts.checkEligibility(payout)
    .then((response) => {
      console.info(response)
      return response
    })
    .catch((err) => {
      console.log(err)
      return false
    })
}

checkInstantPayoutEligibility(myPayout)

```

```java Not reachable
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mangopay.MangoPayApi;
import com.mangopay.core.Money;
import com.mangopay.core.enumerations.CurrencyIso;
import com.mangopay.core.enumerations.PayoutMode;
import com.mangopay.entities.PayOutEligibility;
import com.mangopay.entities.PayOutEligibilityResult;

public class CheckEligibility {
    
    public static void main(String[] args) throws Exception {
        MangoPayApi mangopay = new MangoPayApi();
        mangopay.getConfig().setClientId("your-client-id");
        mangopay.getConfig().setClientPassword("your-api-key");

        var userId = "user_m_01HQK25M6KVHKDV0S36JY9NRKR";
        var bankAccountId = "bankacc_m_01HTJ7P7Y8K9DS5SZ08MDQRHHE";
        
        PayOutEligibility eligibility = new PayOutEligibility();
        eligibility.setAuthorId(userId);
        eligibility.setDebitedFunds(new Money(CurrencyIso.EUR, 500));
        eligibility.setPayoutModeRequested(PayoutMode.INSTANT_PAYMENT);
        eligibility.setBankAccountId(bankAccountId);

        PayOutEligibilityResult result = mangopay.getPayOutApi().checkInstantPayoutEligibility(null, eligibility);

        Gson prettyPrint = new GsonBuilder().setPrettyPrinting().create();
        String prettyJson = prettyPrint.toJson(result);

        System.out.println(prettyJson);
    }
}

```

```csharp Not reachable
using MangoPay.SDK;
using MangoPay.SDK.Entities;
using MangoPay.SDK.Entities.POST;
using MangoPay.SDK.Core.Enumerations;
using Newtonsoft.Json;

class Program
{
    static async Task Main(string[] args)
    {
        MangoPayApi api = new MangoPayApi();

        api.Config.ClientId = "your-client-id";
        api.Config.ClientPassword = "your-api-key";

        var payout = new PayOutEligibilityPostDTO {
            AuthorId =  "user_m_01J2TZ261WZNDM0ZDRWGDYA4GN",
            DebitedFunds = new Money { Amount = 1200, Currency = CurrencyIso.EUR },
            Fees = new Money { Amount = 12, Currency = CurrencyIso.EUR },
            PayoutModeRequested =  PayoutModeRequested.INSTANT_PAYMENT,
            BankAccountId = "bankacc_m_01J534QNZZSRCXXAJ1VXP58DDH",
            DebitedWalletId = "wlt_m_01J30991BXBB7VF28PBS82EWD3"
        };

        var checkEligibility = await api.PayOuts.CheckInstantPayoutEligibility(payout);

        string prettyPrint = JsonConvert.SerializeObject(checkEligibility, Formatting.Indented);
        Console.WriteLine(prettyPrint);
	}
}

```

```ruby Not reachable
require 'mangopay'

MangoPay.configure do |client|
    client.preproduction = true
    client.client_id = 'your-client-id'
    client.client_apiKey = 'your-api-key'
    client.log_file = File.join(Dir.pwd, 'mangopay.log')
end

def checkReachability(payoutObject)
    begin
        response = MangoPay::PayOut::InstantPayoutEligibility::Reachability.create(payoutObject)
        puts response
        return response
    rescue MangoPay::ResponseError => error
        puts "Failed to check reachability: #{error.message}"
        puts "Error details: #{error.details}"
        return false
    end
end

myUser = {
  Id: '146476890',
  WalletId: '148968396'
}

myBankAccount = {
  Id: '154876798'
}

myPayout = {
  DebitedWalletId: myUser[:WalletId],
  PaymentType: 'BANK_WIRE',
  BankAccountId: myBankAccount[:Id],
  BankWireRef: 'Mangopay Ref',
  PayoutModeRequested: 'INSTANT_PAYMENT',
  AuthorId: myUser[:Id],
  DebitedFunds: {
    Currency: 'EUR',
    Amount: 1200,
  },
  Fees: {
    Currency: 'EUR',
    Amount: 0,
  },
  Tag: 'Created using Mangopay Ruby SDK'
}

checkReachability(myPayout)

```

### Insufficient wallet balance

**Request**

```json
{
  "body": {
    "AuthorId": "142036728",
    "BankAccountId": "54682154",
    "BankWireRef": "invoice 7282",
    "DebitedFunds": {
      "Amount": 1200,
      "Currency": "EUR"
    },
    "DebitedWalletId": "145389978",
    "Fees": {
      "Amount": 12,
      "Currency": "EUR"
    },
    "PayoutModeRequested": "INSTANT_PAYMENT"
  }
}
```

**Response**

```json
{
  "InstantPayout": {
    "IsReachable": false,
    "UnreachableReason": {
      "Code": "001001",
      "Message": "Unsufficient wallet balance"
    }
  }
}
```

**SDK Code**

```javascript Insufficient wallet balance
const mangopayInstance = require('mangopay4-nodejs-sdk')
const mangopay = new mangopayInstance({
  clientId: 'your-client-id',
  clientApiKey: 'your-api-key',
})

let myUser = {
  Id: 'user_m_01J2TZ261WZNDM0ZDRWGDYA4GN',
  WalletId: 'wlt_m_01J3D02K6ETV3BDP88C7PD2NDB',
}

let myBankAccount = {
  Id: 'bankacc_m_01J534QNZZSRCXXAJ1VXP58DDH',
}

let myPayout = {
  DebitedWalletId: myUser.WalletId,
  PaymentType: 'BANK_WIRE',
  BankAccountId: myBankAccount.Id,
  BankWireRef: 'Mangopay Ref',
  PayoutModeRequested: 'INSTANT_PAYMENT',
  AuthorId: myUser.Id,
  DebitedFunds: {
    Currency: 'EUR',
    Amount: 12,
  },
  Fees: {
    Currency: 'EUR',
    Amount: 0,
  },
  Tag: 'Created using Mangopay NodeJS SDK',
}

const checkInstantPayoutEligibility = async (payout) => {
  return await mangopay.PayOuts.checkEligibility(payout)
    .then((response) => {
      console.info(response)
      return response
    })
    .catch((err) => {
      console.log(err)
      return false
    })
}

checkInstantPayoutEligibility(myPayout)

```

```java Insufficient wallet balance
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mangopay.MangoPayApi;
import com.mangopay.core.Money;
import com.mangopay.core.enumerations.CurrencyIso;
import com.mangopay.core.enumerations.PayoutMode;
import com.mangopay.entities.PayOutEligibility;
import com.mangopay.entities.PayOutEligibilityResult;

public class CheckEligibility {
    
    public static void main(String[] args) throws Exception {
        MangoPayApi mangopay = new MangoPayApi();
        mangopay.getConfig().setClientId("your-client-id");
        mangopay.getConfig().setClientPassword("your-api-key");

        var userId = "user_m_01HQK25M6KVHKDV0S36JY9NRKR";
        var bankAccountId = "bankacc_m_01HTJ7P7Y8K9DS5SZ08MDQRHHE";
        
        PayOutEligibility eligibility = new PayOutEligibility();
        eligibility.setAuthorId(userId);
        eligibility.setDebitedFunds(new Money(CurrencyIso.EUR, 500));
        eligibility.setPayoutModeRequested(PayoutMode.INSTANT_PAYMENT);
        eligibility.setBankAccountId(bankAccountId);

        PayOutEligibilityResult result = mangopay.getPayOutApi().checkInstantPayoutEligibility(null, eligibility);

        Gson prettyPrint = new GsonBuilder().setPrettyPrinting().create();
        String prettyJson = prettyPrint.toJson(result);

        System.out.println(prettyJson);
    }
}

```

```csharp Insufficient wallet balance
using MangoPay.SDK;
using MangoPay.SDK.Entities;
using MangoPay.SDK.Entities.POST;
using MangoPay.SDK.Core.Enumerations;
using Newtonsoft.Json;

class Program
{
    static async Task Main(string[] args)
    {
        MangoPayApi api = new MangoPayApi();

        api.Config.ClientId = "your-client-id";
        api.Config.ClientPassword = "your-api-key";

        var payout = new PayOutEligibilityPostDTO {
            AuthorId =  "user_m_01J2TZ261WZNDM0ZDRWGDYA4GN",
            DebitedFunds = new Money { Amount = 1200, Currency = CurrencyIso.EUR },
            Fees = new Money { Amount = 12, Currency = CurrencyIso.EUR },
            PayoutModeRequested =  PayoutModeRequested.INSTANT_PAYMENT,
            BankAccountId = "bankacc_m_01J534QNZZSRCXXAJ1VXP58DDH",
            DebitedWalletId = "wlt_m_01J30991BXBB7VF28PBS82EWD3"
        };

        var checkEligibility = await api.PayOuts.CheckInstantPayoutEligibility(payout);

        string prettyPrint = JsonConvert.SerializeObject(checkEligibility, Formatting.Indented);
        Console.WriteLine(prettyPrint);
	}
}

```

```ruby Insufficient wallet balance
require 'mangopay'

MangoPay.configure do |client|
    client.preproduction = true
    client.client_id = 'your-client-id'
    client.client_apiKey = 'your-api-key'
    client.log_file = File.join(Dir.pwd, 'mangopay.log')
end

def checkReachability(payoutObject)
    begin
        response = MangoPay::PayOut::InstantPayoutEligibility::Reachability.create(payoutObject)
        puts response
        return response
    rescue MangoPay::ResponseError => error
        puts "Failed to check reachability: #{error.message}"
        puts "Error details: #{error.details}"
        return false
    end
end

myUser = {
  Id: '146476890',
  WalletId: '148968396'
}

myBankAccount = {
  Id: '154876798'
}

myPayout = {
  DebitedWalletId: myUser[:WalletId],
  PaymentType: 'BANK_WIRE',
  BankAccountId: myBankAccount[:Id],
  BankWireRef: 'Mangopay Ref',
  PayoutModeRequested: 'INSTANT_PAYMENT',
  AuthorId: myUser[:Id],
  DebitedFunds: {
    Currency: 'EUR',
    Amount: 1200,
  },
  Fees: {
    Currency: 'EUR',
    Amount: 0,
  },
  Tag: 'Created using Mangopay Ruby SDK'
}

checkReachability(myPayout)

```