> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.sqril.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.sqril.io/_mcp/server.

# Lookup Payment Code

POST https://stg-api.sqril.io/lookupPaymentCode
Content-Type: application/json

Resolves a **typed/manual payment destination** or **merchant / account identifier** into the same decode flow as `decodeQr`: creates a **PENDING** transaction and returns `tx_id`.

Use this endpoint when the payer types a destination instead of scanning a QR. Scanned EMV / local QR strings should continue to use **decodeQr**.

**Authentication**

- **REQUIRED**: Basic Auth `Authorization: Basic base64(client_id:client_secret)`.

**Two request contracts**

### 1. Manual payment destinations (AR, BR, PE, BO, CO, NG, GH, ZM)

Required:

- `customer_id`
- `country_code`
- `payment_method` — must match the corridor:
- `AR`, `BR`, `CO` → `payment_key`
- `PE` → `ewallet`
- `BO`, `NG`, `GH`, `ZM` → `bank_transfer`
- `payment_destination` — the typed destination (PIX key, phone, CBU/CVU/alias, bank account, BREB key, or NG/GH/ZM account / mobile-money number). Legacy alias: `qr_string`.

`payment_destination_code` is required for:

- `PE` — `YAPE` or `PLIN`
- `BR` — must be `PIX`
- `CO` — must be `BREB`
- `BO` — bank code (see `GET /listBanks?country_code=BO`)
- `NG` / `GH` / `ZM` — bank or mobile-money network code (e.g. `058`, `MTN`)

Bolivia-only extras when `payment_method` is `bank_transfer`:

- `account_type` — `SAVINGS` or `CHECKING`
- `recipient` — `name_first`, `name_last`, `ic_number`

Sender is **never** accepted on the request; it is always derived from the registered customer.

### 2. Merchant / account lookup (KE, TZ, VN)

Required:

- `customer_id`
- `country_code` — `KE`, `TZ`, or `VN`
- `merchant_id` — till/paybill (KE/TZ) or bank account number (VN)

Optional:

- `account_reference` — paybill bill reference (KE/TZ) or bank BIN (VN)

**Shared optional fields**

- `amount`, `currency`
- `partner_transaction_id`
- `partner_app_id` (1–64 chars `[a-zA-Z0-9_-]`)
- `wallet_identifier`

**Response**

Same curated public shape as **decodeQr** (`tx_id`, `is_dynamic`, `amount`, `country`, `currency`, fees when amount > 0, `missing_fields`, etc.).

**Payout flow:** **lookupPaymentCode** → **getQuotation** → **executePayout**.

Reference: https://docs.sqril.io/sqril-saa-s-api/payout-endpoints/lookup-payment-code

## Authentication

- `Authorization` header (basic auth, required) — Basic Auth: base64(client_id:client_secret)

## Request

### Query parameters

- `dp` (integer, optional, default: 2) — Decimal places for monetary fields in the response (USD amounts, fees, exchange rates). Default 2, which rounds sub-cent fees to 0. Use dp=4 or higher to reconcile against exact deducted totals: at full precision amount_usd + percentage_fee + fixed_fee equals the amount deducted from your balance. Rounding is applied to the response only; all stored values and balance deductions always use full precision.

### Body (application/json)

- `customer_id` (string, required)
- `country_code` (string, required) — ISO alpha-2. Required. Manual destinations: AR, BR, PE, BO, CO, NG, GH, ZM. Merchant lookup: KE, TZ, VN.
- `payment_method` (enum, optional) — Required for manual payment destinations. Must match the corridor (see endpoint description).
  - Allowed values: `payment_key`, `ewallet`, `bank_transfer`
- `payment_destination` (string, optional) — Typed destination string for manual corridors. Legacy alias: qr_string.
- `payment_destination_code` (string, optional) — Rail or institution code: PIX, BREB, YAPE/PLIN, Bolivia bank code, or NG/GH/ZM bank/network code.
- `account_type` (enum, optional) — Bolivia bank transfers only.
  - Allowed values: `SAVINGS`, `CHECKING`
- `recipient` (object, optional) — Bolivia bank transfers only.
  - `name_first` (string, optional)
  - `name_last` (string, optional)
  - `ic_number` (string, optional)
- `merchant_id` (string, optional) — Till/paybill (KE/TZ) or bank account number (VN). Used by the merchant lookup contract.
- `account_reference` (string, optional) — Paybill bill reference (KE/TZ) or bank BIN (VN).
- `amount` (double, optional) — Optional local-currency amount. When > 0, pricing may be computed on the response.
- `currency` (string, optional) — Optional ISO 4217. Defaults to the corridor currency when omitted.
- `partner_transaction_id` (string, optional)
- `partner_app_id` (string, optional) — Optional partner sub-app id (1–64 chars, [a-zA-Z0-9_-]).
- `wallet_identifier` (string, optional)
- `qr_string` (string, optional) — Legacy alias for payment_destination on manual corridors. Prefer payment_destination.

## Response

### 200

OK — same shape as decodeQr

- `is_dynamic` (boolean, optional)
- `is_business` (boolean, optional)
- `amount` (double, optional)
- `merchant` (string, optional)
- `merchant_id` (string, optional) — Africa (KE/TZ) till or paybill number when returned.
- `merchant_name` (string, optional) — Africa (KE/TZ) verified merchant display name when returned.
- `payment_type` (enum, optional) — Africa (KE/TZ) payment destination type when returned.
  - Allowed values: `till`, `paybill`
- `merchant_info` (object, optional) — Africa (KE/TZ) merchant metadata when returned.
  - `merchant_id` (string, optional)
  - `display_name` (string, optional)
  - `country_code` (string, optional)
  - `payment_type` (enum, optional)
    - Allowed values: `till`, `paybill`
  - `lipa_number` (string, optional)
  - `account_reference` (string, optional)
- `country` (string, optional)
- `tx_id` (string, optional)
- `currency` (string, optional)
- `partner_transaction_id` (string, optional)
- `amount_usd` (double, optional)
- `fee` (double, optional)
- `percentage_fee` (double, optional)
- `fixed_fee` (double, optional)
- `missing_fields` (list of map from string to any, optional)
- `suggested_values` (map from string to any, optional)
- `sender` (map from string to any, optional)
- `recipient` (map from string to any, optional)

## Examples

### Success - Argentina CBU/CVU/alias

**Request**

```json
undefined
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Success - Argentina CBU/CVU/alias
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

response = requests.post(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Success - Argentina CBU/CVU/alias
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {method: 'POST', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success - Argentina CBU/CVU/alias
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	req, _ := http.NewRequest("POST", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Success - Argentina CBU/CVU/alias
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")

response = http.request(request)
puts response.read_body
```

```java Success - Argentina CBU/CVU/alias
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .asString();
```

```php Success - Argentina CBU/CVU/alias
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Success - Argentina CBU/CVU/alias
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

IRestResponse response = client.Execute(request);
```

```swift Success - Argentina CBU/CVU/alias
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Success - 200 OK (Brazil PIX via lookupPaymentCode)

**Request**

```json
undefined
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "BR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "BRL",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Success - 200 OK (Brazil PIX via lookupPaymentCode)
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

response = requests.post(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Success - 200 OK (Brazil PIX via lookupPaymentCode)
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {method: 'POST', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success - 200 OK (Brazil PIX via lookupPaymentCode)
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	req, _ := http.NewRequest("POST", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Success - 200 OK (Brazil PIX via lookupPaymentCode)
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")

response = http.request(request)
puts response.read_body
```

```java Success - 200 OK (Brazil PIX via lookupPaymentCode)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .asString();
```

```php Success - 200 OK (Brazil PIX via lookupPaymentCode)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Success - 200 OK (Brazil PIX via lookupPaymentCode)
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

IRestResponse response = client.Execute(request);
```

```swift Success - 200 OK (Brazil PIX via lookupPaymentCode)
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Success - Peru Yape phone

**Request**

```json
undefined
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "PE",
  "tx_id": "tx_1234567890_abc123",
  "currency": "PEN",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Success - Peru Yape phone
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

response = requests.post(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Success - Peru Yape phone
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {method: 'POST', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success - Peru Yape phone
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	req, _ := http.NewRequest("POST", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Success - Peru Yape phone
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")

response = http.request(request)
puts response.read_body
```

```java Success - Peru Yape phone
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .asString();
```

```php Success - Peru Yape phone
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Success - Peru Yape phone
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

IRestResponse response = client.Execute(request);
```

```swift Success - Peru Yape phone
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Success - Colombia BREB sandbox key

**Request**

```json
undefined
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "CO",
  "tx_id": "tx_1234567890_abc123",
  "currency": "COP",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Success - Colombia BREB sandbox key
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

response = requests.post(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Success - Colombia BREB sandbox key
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {method: 'POST', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success - Colombia BREB sandbox key
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	req, _ := http.NewRequest("POST", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Success - Colombia BREB sandbox key
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")

response = http.request(request)
puts response.read_body
```

```java Success - Colombia BREB sandbox key
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .asString();
```

```php Success - Colombia BREB sandbox key
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Success - Colombia BREB sandbox key
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

IRestResponse response = client.Execute(request);
```

```swift Success - Colombia BREB sandbox key
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Success - 200 OK (Nigeria bank account via lookupPaymentCode)

**Request**

```json
undefined
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 5000,
  "merchant": "",
  "country": "NG",
  "tx_id": "tx_1234567890_abc123",
  "currency": "NGN",
  "partner_transaction_id": "",
  "recipient": {
    "account_no": "0123456789",
    "bank_no": "058"
  }
}
```

**SDK Code**

```python Success - 200 OK (Nigeria bank account via lookupPaymentCode)
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

response = requests.post(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Success - 200 OK (Nigeria bank account via lookupPaymentCode)
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {method: 'POST', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success - 200 OK (Nigeria bank account via lookupPaymentCode)
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	req, _ := http.NewRequest("POST", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Success - 200 OK (Nigeria bank account via lookupPaymentCode)
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")

response = http.request(request)
puts response.read_body
```

```java Success - 200 OK (Nigeria bank account via lookupPaymentCode)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .asString();
```

```php Success - 200 OK (Nigeria bank account via lookupPaymentCode)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Success - 200 OK (Nigeria bank account via lookupPaymentCode)
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

IRestResponse response = client.Execute(request);
```

```swift Success - 200 OK (Nigeria bank account via lookupPaymentCode)
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Success - 200 OK (Africa Kenya till)

**Request**

```json
undefined
```

**Response**

```json
{
  "is_dynamic": true,
  "is_business": true,
  "amount": 0,
  "merchant": "MERCHANT DISPLAY NAME",
  "merchant_id": "888880",
  "merchant_name": "MERCHANT DISPLAY NAME",
  "payment_type": "till",
  "merchant_info": {
    "merchant_id": "888880",
    "display_name": "MERCHANT DISPLAY NAME",
    "country_code": "KE",
    "payment_type": "till",
    "lipa_number": "888880"
  },
  "country": "KE",
  "tx_id": "tx_1234567890_abc123",
  "currency": "KES",
  "partner_transaction_id": ""
}
```

**SDK Code**

```python Success - 200 OK (Africa Kenya till)
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

response = requests.post(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Success - 200 OK (Africa Kenya till)
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {method: 'POST', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success - 200 OK (Africa Kenya till)
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	req, _ := http.NewRequest("POST", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Success - 200 OK (Africa Kenya till)
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")

response = http.request(request)
puts response.read_body
```

```java Success - 200 OK (Africa Kenya till)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .asString();
```

```php Success - 200 OK (Africa Kenya till)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Success - 200 OK (Africa Kenya till)
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

IRestResponse response = client.Execute(request);
```

```swift Success - 200 OK (Africa Kenya till)
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Success - Vietnam account lookup

**Request**

```json
undefined
```

**Response**

```json
{
  "is_dynamic": true,
  "is_business": true,
  "amount": 0,
  "merchant": "NGUYEN VAN A",
  "country": "VN",
  "tx_id": "tx_1234567890_abc123",
  "currency": "VND",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ],
  "recipient": {
    "name": "NGUYEN VAN A",
    "name_first": "NGUYEN",
    "name_last": "VAN A",
    "account_no": "1234567890",
    "bank_no": "970415"
  }
}
```

**SDK Code**

```python Success - Vietnam account lookup
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

response = requests.post(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Success - Vietnam account lookup
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {method: 'POST', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Success - Vietnam account lookup
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	req, _ := http.NewRequest("POST", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Success - Vietnam account lookup
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")

response = http.request(request)
puts response.read_body
```

```java Success - Vietnam account lookup
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .asString();
```

```php Success - Vietnam account lookup
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Success - Vietnam account lookup
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

IRestResponse response = client.Execute(request);
```

```swift Success - Vietnam account lookup
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Argentina — CBU / CVU / alias

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "AR",
  "payment_method": "payment_key",
  "payment_destination": "4310001343800000045110"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Argentina — CBU / CVU / alias
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "AR",
    "payment_method": "payment_key",
    "payment_destination": "4310001343800000045110"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Argentina — CBU / CVU / alias
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"AR","payment_method":"payment_key","payment_destination":"4310001343800000045110"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Argentina — CBU / CVU / alias
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"AR\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"4310001343800000045110\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Argentina — CBU / CVU / alias
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"AR\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"4310001343800000045110\"\n}"

response = http.request(request)
puts response.read_body
```

```java Argentina — CBU / CVU / alias
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"AR\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"4310001343800000045110\"\n}")
  .asString();
```

```php Argentina — CBU / CVU / alias
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "AR",
  "payment_method": "payment_key",
  "payment_destination": "4310001343800000045110"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Argentina — CBU / CVU / alias
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"AR\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"4310001343800000045110\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Argentina — CBU / CVU / alias
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "AR",
  "payment_method": "payment_key",
  "payment_destination": "4310001343800000045110"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Brazil — PIX key

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "BR",
  "payment_method": "payment_key",
  "payment_destination": "user@email.com",
  "payment_destination_code": "PIX"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Brazil — PIX key
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "BR",
    "payment_method": "payment_key",
    "payment_destination": "user@email.com",
    "payment_destination_code": "PIX"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Brazil — PIX key
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"BR","payment_method":"payment_key","payment_destination":"user@email.com","payment_destination_code":"PIX"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Brazil — PIX key
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"BR\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"user@email.com\",\n  \"payment_destination_code\": \"PIX\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Brazil — PIX key
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"BR\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"user@email.com\",\n  \"payment_destination_code\": \"PIX\"\n}"

response = http.request(request)
puts response.read_body
```

```java Brazil — PIX key
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"BR\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"user@email.com\",\n  \"payment_destination_code\": \"PIX\"\n}")
  .asString();
```

```php Brazil — PIX key
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "BR",
  "payment_method": "payment_key",
  "payment_destination": "user@email.com",
  "payment_destination_code": "PIX"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Brazil — PIX key
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"BR\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"user@email.com\",\n  \"payment_destination_code\": \"PIX\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Brazil — PIX key
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "BR",
  "payment_method": "payment_key",
  "payment_destination": "user@email.com",
  "payment_destination_code": "PIX"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Peru — Yape phone

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "PE",
  "payment_method": "ewallet",
  "payment_destination": "+51987654321",
  "payment_destination_code": "YAPE"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Peru — Yape phone
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "PE",
    "payment_method": "ewallet",
    "payment_destination": "+51987654321",
    "payment_destination_code": "YAPE"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Peru — Yape phone
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"PE","payment_method":"ewallet","payment_destination":"+51987654321","payment_destination_code":"YAPE"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Peru — Yape phone
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"PE\",\n  \"payment_method\": \"ewallet\",\n  \"payment_destination\": \"+51987654321\",\n  \"payment_destination_code\": \"YAPE\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Peru — Yape phone
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"PE\",\n  \"payment_method\": \"ewallet\",\n  \"payment_destination\": \"+51987654321\",\n  \"payment_destination_code\": \"YAPE\"\n}"

response = http.request(request)
puts response.read_body
```

```java Peru — Yape phone
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"PE\",\n  \"payment_method\": \"ewallet\",\n  \"payment_destination\": \"+51987654321\",\n  \"payment_destination_code\": \"YAPE\"\n}")
  .asString();
```

```php Peru — Yape phone
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "PE",
  "payment_method": "ewallet",
  "payment_destination": "+51987654321",
  "payment_destination_code": "YAPE"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Peru — Yape phone
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"PE\",\n  \"payment_method\": \"ewallet\",\n  \"payment_destination\": \"+51987654321\",\n  \"payment_destination_code\": \"YAPE\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Peru — Yape phone
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "PE",
  "payment_method": "ewallet",
  "payment_destination": "+51987654321",
  "payment_destination_code": "YAPE"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Bolivia — bank transfer

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "BO",
  "payment_method": "bank_transfer",
  "payment_destination": "1234567890",
  "payment_destination_code": "001",
  "account_type": "SAVINGS",
  "recipient": {
    "name_first": "Maria",
    "name_last": "Lopez",
    "ic_number": "1234567"
  }
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Bolivia — bank transfer
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "BO",
    "payment_method": "bank_transfer",
    "payment_destination": "1234567890",
    "payment_destination_code": "001",
    "account_type": "SAVINGS",
    "recipient": {
        "name_first": "Maria",
        "name_last": "Lopez",
        "ic_number": "1234567"
    }
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Bolivia — bank transfer
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"BO","payment_method":"bank_transfer","payment_destination":"1234567890","payment_destination_code":"001","account_type":"SAVINGS","recipient":{"name_first":"Maria","name_last":"Lopez","ic_number":"1234567"}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Bolivia — bank transfer
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"BO\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"1234567890\",\n  \"payment_destination_code\": \"001\",\n  \"account_type\": \"SAVINGS\",\n  \"recipient\": {\n    \"name_first\": \"Maria\",\n    \"name_last\": \"Lopez\",\n    \"ic_number\": \"1234567\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Bolivia — bank transfer
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"BO\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"1234567890\",\n  \"payment_destination_code\": \"001\",\n  \"account_type\": \"SAVINGS\",\n  \"recipient\": {\n    \"name_first\": \"Maria\",\n    \"name_last\": \"Lopez\",\n    \"ic_number\": \"1234567\"\n  }\n}"

response = http.request(request)
puts response.read_body
```

```java Bolivia — bank transfer
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"BO\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"1234567890\",\n  \"payment_destination_code\": \"001\",\n  \"account_type\": \"SAVINGS\",\n  \"recipient\": {\n    \"name_first\": \"Maria\",\n    \"name_last\": \"Lopez\",\n    \"ic_number\": \"1234567\"\n  }\n}")
  .asString();
```

```php Bolivia — bank transfer
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "BO",
  "payment_method": "bank_transfer",
  "payment_destination": "1234567890",
  "payment_destination_code": "001",
  "account_type": "SAVINGS",
  "recipient": {
    "name_first": "Maria",
    "name_last": "Lopez",
    "ic_number": "1234567"
  }
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Bolivia — bank transfer
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"BO\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"1234567890\",\n  \"payment_destination_code\": \"001\",\n  \"account_type\": \"SAVINGS\",\n  \"recipient\": {\n    \"name_first\": \"Maria\",\n    \"name_last\": \"Lopez\",\n    \"ic_number\": \"1234567\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Bolivia — bank transfer
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "BO",
  "payment_method": "bank_transfer",
  "payment_destination": "1234567890",
  "payment_destination_code": "001",
  "account_type": "SAVINGS",
  "recipient": [
    "name_first": "Maria",
    "name_last": "Lopez",
    "ic_number": "1234567"
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Colombia — BREB key (sandbox dynamic)

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "CO",
  "payment_method": "payment_key",
  "payment_destination": "sqril-breb-qa",
  "payment_destination_code": "BREB"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Colombia — BREB key (sandbox dynamic)
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "CO",
    "payment_method": "payment_key",
    "payment_destination": "sqril-breb-qa",
    "payment_destination_code": "BREB"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Colombia — BREB key (sandbox dynamic)
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"CO","payment_method":"payment_key","payment_destination":"sqril-breb-qa","payment_destination_code":"BREB"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Colombia — BREB key (sandbox dynamic)
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"CO\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"sqril-breb-qa\",\n  \"payment_destination_code\": \"BREB\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Colombia — BREB key (sandbox dynamic)
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"CO\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"sqril-breb-qa\",\n  \"payment_destination_code\": \"BREB\"\n}"

response = http.request(request)
puts response.read_body
```

```java Colombia — BREB key (sandbox dynamic)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"CO\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"sqril-breb-qa\",\n  \"payment_destination_code\": \"BREB\"\n}")
  .asString();
```

```php Colombia — BREB key (sandbox dynamic)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "CO",
  "payment_method": "payment_key",
  "payment_destination": "sqril-breb-qa",
  "payment_destination_code": "BREB"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Colombia — BREB key (sandbox dynamic)
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"CO\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"sqril-breb-qa\",\n  \"payment_destination_code\": \"BREB\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Colombia — BREB key (sandbox dynamic)
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "CO",
  "payment_method": "payment_key",
  "payment_destination": "sqril-breb-qa",
  "payment_destination_code": "BREB"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Colombia — BREB key (sandbox static)

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "CO",
  "payment_method": "payment_key",
  "payment_destination": "sqril-breb-qa-manual-amount",
  "payment_destination_code": "BREB"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Colombia — BREB key (sandbox static)
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "CO",
    "payment_method": "payment_key",
    "payment_destination": "sqril-breb-qa-manual-amount",
    "payment_destination_code": "BREB"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Colombia — BREB key (sandbox static)
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"CO","payment_method":"payment_key","payment_destination":"sqril-breb-qa-manual-amount","payment_destination_code":"BREB"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Colombia — BREB key (sandbox static)
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"CO\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"sqril-breb-qa-manual-amount\",\n  \"payment_destination_code\": \"BREB\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Colombia — BREB key (sandbox static)
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"CO\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"sqril-breb-qa-manual-amount\",\n  \"payment_destination_code\": \"BREB\"\n}"

response = http.request(request)
puts response.read_body
```

```java Colombia — BREB key (sandbox static)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"CO\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"sqril-breb-qa-manual-amount\",\n  \"payment_destination_code\": \"BREB\"\n}")
  .asString();
```

```php Colombia — BREB key (sandbox static)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "CO",
  "payment_method": "payment_key",
  "payment_destination": "sqril-breb-qa-manual-amount",
  "payment_destination_code": "BREB"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Colombia — BREB key (sandbox static)
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"CO\",\n  \"payment_method\": \"payment_key\",\n  \"payment_destination\": \"sqril-breb-qa-manual-amount\",\n  \"payment_destination_code\": \"BREB\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Colombia — BREB key (sandbox static)
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "CO",
  "payment_method": "payment_key",
  "payment_destination": "sqril-breb-qa-manual-amount",
  "payment_destination_code": "BREB"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Nigeria — bank account

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "NG",
  "payment_method": "bank_transfer",
  "payment_destination": "0123456789",
  "payment_destination_code": "058",
  "amount": 5000,
  "currency": "NGN"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Nigeria — bank account
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "NG",
    "payment_method": "bank_transfer",
    "payment_destination": "0123456789",
    "payment_destination_code": "058",
    "amount": 5000,
    "currency": "NGN"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Nigeria — bank account
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"NG","payment_method":"bank_transfer","payment_destination":"0123456789","payment_destination_code":"058","amount":5000,"currency":"NGN"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Nigeria — bank account
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"NG\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"0123456789\",\n  \"payment_destination_code\": \"058\",\n  \"amount\": 5000,\n  \"currency\": \"NGN\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Nigeria — bank account
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"NG\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"0123456789\",\n  \"payment_destination_code\": \"058\",\n  \"amount\": 5000,\n  \"currency\": \"NGN\"\n}"

response = http.request(request)
puts response.read_body
```

```java Nigeria — bank account
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"NG\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"0123456789\",\n  \"payment_destination_code\": \"058\",\n  \"amount\": 5000,\n  \"currency\": \"NGN\"\n}")
  .asString();
```

```php Nigeria — bank account
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "NG",
  "payment_method": "bank_transfer",
  "payment_destination": "0123456789",
  "payment_destination_code": "058",
  "amount": 5000,
  "currency": "NGN"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Nigeria — bank account
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"NG\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"0123456789\",\n  \"payment_destination_code\": \"058\",\n  \"amount\": 5000,\n  \"currency\": \"NGN\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Nigeria — bank account
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "NG",
  "payment_method": "bank_transfer",
  "payment_destination": "0123456789",
  "payment_destination_code": "058",
  "amount": 5000,
  "currency": "NGN"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Ghana — mobile money

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "GH",
  "payment_method": "bank_transfer",
  "payment_destination": "233241234567",
  "payment_destination_code": "MTN",
  "amount": 100,
  "currency": "GHS"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Ghana — mobile money
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "GH",
    "payment_method": "bank_transfer",
    "payment_destination": "233241234567",
    "payment_destination_code": "MTN",
    "amount": 100,
    "currency": "GHS"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Ghana — mobile money
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"GH","payment_method":"bank_transfer","payment_destination":"233241234567","payment_destination_code":"MTN","amount":100,"currency":"GHS"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Ghana — mobile money
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"GH\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"233241234567\",\n  \"payment_destination_code\": \"MTN\",\n  \"amount\": 100,\n  \"currency\": \"GHS\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Ghana — mobile money
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"GH\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"233241234567\",\n  \"payment_destination_code\": \"MTN\",\n  \"amount\": 100,\n  \"currency\": \"GHS\"\n}"

response = http.request(request)
puts response.read_body
```

```java Ghana — mobile money
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"GH\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"233241234567\",\n  \"payment_destination_code\": \"MTN\",\n  \"amount\": 100,\n  \"currency\": \"GHS\"\n}")
  .asString();
```

```php Ghana — mobile money
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "GH",
  "payment_method": "bank_transfer",
  "payment_destination": "233241234567",
  "payment_destination_code": "MTN",
  "amount": 100,
  "currency": "GHS"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Ghana — mobile money
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"GH\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"233241234567\",\n  \"payment_destination_code\": \"MTN\",\n  \"amount\": 100,\n  \"currency\": \"GHS\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Ghana — mobile money
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "GH",
  "payment_method": "bank_transfer",
  "payment_destination": "233241234567",
  "payment_destination_code": "MTN",
  "amount": 100,
  "currency": "GHS"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Zambia — bank account

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "ZM",
  "payment_method": "bank_transfer",
  "payment_destination": "1234567890",
  "payment_destination_code": "001",
  "amount": 200,
  "currency": "ZMW"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Zambia — bank account
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "ZM",
    "payment_method": "bank_transfer",
    "payment_destination": "1234567890",
    "payment_destination_code": "001",
    "amount": 200,
    "currency": "ZMW"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Zambia — bank account
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"ZM","payment_method":"bank_transfer","payment_destination":"1234567890","payment_destination_code":"001","amount":200,"currency":"ZMW"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Zambia — bank account
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"ZM\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"1234567890\",\n  \"payment_destination_code\": \"001\",\n  \"amount\": 200,\n  \"currency\": \"ZMW\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Zambia — bank account
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"ZM\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"1234567890\",\n  \"payment_destination_code\": \"001\",\n  \"amount\": 200,\n  \"currency\": \"ZMW\"\n}"

response = http.request(request)
puts response.read_body
```

```java Zambia — bank account
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"ZM\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"1234567890\",\n  \"payment_destination_code\": \"001\",\n  \"amount\": 200,\n  \"currency\": \"ZMW\"\n}")
  .asString();
```

```php Zambia — bank account
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "ZM",
  "payment_method": "bank_transfer",
  "payment_destination": "1234567890",
  "payment_destination_code": "001",
  "amount": 200,
  "currency": "ZMW"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Zambia — bank account
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"ZM\",\n  \"payment_method\": \"bank_transfer\",\n  \"payment_destination\": \"1234567890\",\n  \"payment_destination_code\": \"001\",\n  \"amount\": 200,\n  \"currency\": \"ZMW\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Zambia — bank account
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "ZM",
  "payment_method": "bank_transfer",
  "payment_destination": "1234567890",
  "payment_destination_code": "001",
  "amount": 200,
  "currency": "ZMW"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Kenya — till lookup

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "KE",
  "merchant_id": "888880"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Kenya — till lookup
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "KE",
    "merchant_id": "888880"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Kenya — till lookup
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"KE","merchant_id":"888880"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Kenya — till lookup
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"KE\",\n  \"merchant_id\": \"888880\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Kenya — till lookup
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"KE\",\n  \"merchant_id\": \"888880\"\n}"

response = http.request(request)
puts response.read_body
```

```java Kenya — till lookup
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"KE\",\n  \"merchant_id\": \"888880\"\n}")
  .asString();
```

```php Kenya — till lookup
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "KE",
  "merchant_id": "888880"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Kenya — till lookup
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"KE\",\n  \"merchant_id\": \"888880\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Kenya — till lookup
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "KE",
  "merchant_id": "888880"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Kenya — paybill lookup

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "KE",
  "merchant_id": "<MERCHANT_ID>",
  "account_reference": "ABC123"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Kenya — paybill lookup
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "KE",
    "merchant_id": "<MERCHANT_ID>",
    "account_reference": "ABC123"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Kenya — paybill lookup
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"KE","merchant_id":"<MERCHANT_ID>","account_reference":"ABC123"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Kenya — paybill lookup
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"KE\",\n  \"merchant_id\": \"<MERCHANT_ID>\",\n  \"account_reference\": \"ABC123\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Kenya — paybill lookup
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"KE\",\n  \"merchant_id\": \"<MERCHANT_ID>\",\n  \"account_reference\": \"ABC123\"\n}"

response = http.request(request)
puts response.read_body
```

```java Kenya — paybill lookup
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"KE\",\n  \"merchant_id\": \"<MERCHANT_ID>\",\n  \"account_reference\": \"ABC123\"\n}")
  .asString();
```

```php Kenya — paybill lookup
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "KE",
  "merchant_id": "<MERCHANT_ID>",
  "account_reference": "ABC123"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Kenya — paybill lookup
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"KE\",\n  \"merchant_id\": \"<MERCHANT_ID>\",\n  \"account_reference\": \"ABC123\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Kenya — paybill lookup
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "KE",
  "merchant_id": "<MERCHANT_ID>",
  "account_reference": "ABC123"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Vietnam — bank account + BIN

**Request**

```json
{
  "customer_id": "{{customer_id}}",
  "country_code": "VN",
  "merchant_id": "1234567890",
  "account_reference": "970415"
}
```

**Response**

```json
{
  "is_dynamic": false,
  "is_business": false,
  "amount": 0,
  "merchant": "",
  "country": "AR",
  "tx_id": "tx_1234567890_abc123",
  "currency": "ARS",
  "partner_transaction_id": "",
  "missing_fields": [
    {
      "field": "amount",
      "type": "numeric",
      "label": "Amount"
    }
  ]
}
```

**SDK Code**

```python Vietnam — bank account + BIN
import requests

url = "https://stg-api.sqril.io/lookupPaymentCode"

payload = {
    "customer_id": "{{customer_id}}",
    "country_code": "VN",
    "merchant_id": "1234567890",
    "account_reference": "970415"
}
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript Vietnam — bank account + BIN
const url = 'https://stg-api.sqril.io/lookupPaymentCode';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"customer_id":"{{customer_id}}","country_code":"VN","merchant_id":"1234567890","account_reference":"970415"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Vietnam — bank account + BIN
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://stg-api.sqril.io/lookupPaymentCode"

	payload := strings.NewReader("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"VN\",\n  \"merchant_id\": \"1234567890\",\n  \"account_reference\": \"970415\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<username>", "<password>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Vietnam — bank account + BIN
require 'uri'
require 'net/http'

url = URI("https://stg-api.sqril.io/lookupPaymentCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"VN\",\n  \"merchant_id\": \"1234567890\",\n  \"account_reference\": \"970415\"\n}"

response = http.request(request)
puts response.read_body
```

```java Vietnam — bank account + BIN
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://stg-api.sqril.io/lookupPaymentCode")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"VN\",\n  \"merchant_id\": \"1234567890\",\n  \"account_reference\": \"970415\"\n}")
  .asString();
```

```php Vietnam — bank account + BIN
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://stg-api.sqril.io/lookupPaymentCode', [
  'body' => '{
  "customer_id": "{{customer_id}}",
  "country_code": "VN",
  "merchant_id": "1234567890",
  "account_reference": "970415"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp Vietnam — bank account + BIN
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://stg-api.sqril.io/lookupPaymentCode");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customer_id\": \"{{customer_id}}\",\n  \"country_code\": \"VN\",\n  \"merchant_id\": \"1234567890\",\n  \"account_reference\": \"970415\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Vietnam — bank account + BIN
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [
  "customer_id": "{{customer_id}}",
  "country_code": "VN",
  "merchant_id": "1234567890",
  "account_reference": "970415"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://stg-api.sqril.io/lookupPaymentCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```