Lenco API

https://lenco-api.readme.io/v2.0
Admin
Lenco API provides developers with access to accounts, sub-accounts, and transaction histories,...
Tokens:109,057
Snippets:189
Trust Score:9.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Standard Response Format

Source: https://lenco-api.readme.io/v2.0/reference/get-started

Understand the structure of responses from the Lenco API, including status, message, data, and meta information.

```APIDOC
## Standard Response Format

### Description
All responses from the Lenco API follow a consistent JSON format, providing details about the request's success, a message, and the requested data.

### Method
All HTTP Methods (GET, POST, PUT, DELETE, etc.)

### Endpoint
All API Endpoints

### Parameters
None for response format description.

### Request Example
N/A

### Response
#### Success Response (200)
- **status** (boolean) - `true` if the request was processed successfully, `false` otherwise.
- **message** (string) - A human-readable explanation of the response status. This is informational and should not be used for checks.
- **data** (object | array) - Contains the actionable result of the request. This can be an object (for single items) or an array (for lists).
- **meta** (object) - Optional. Provides context for the `data` field, commonly used for pagination information.
  - **total** (number) - The total number of records available.
  - **perPage** (number) - The maximum number of records returned per request.
  - **currentPage** (number) - The current page number being returned (default: 1).
  - **pageCount** (number) - The total number of pages available based on `perPage`.

#### Response Example (Success)
```json
{
  "status": true,
  "message": "Recipients retrieved",
  "data": [
    {
      "id": "recipient_123",
      "name": "John Doe"
    }
  ],
  "meta": {
    "total": 100,
    "perPage": 50,
    "currentPage": 1,
    "pageCount": 2
  }
}
```

#### Response Example (Error)
```json
{
  "status": false,
  "message": "Failed to retrieve recipients due to invalid parameters.",
  "data": null
}
```
```

--------------------------------

### API Authentication

Source: https://lenco-api.readme.io/v2.0/reference/get-started

All API requests must be authenticated using an API token. Include your token in the Authorization header.

```APIDOC
## API Authentication

### Description
All API requests must be authenticated using an API token. The token should be included in the `Authorization` header of every request.

### Method
All HTTP Methods (GET, POST, PUT, DELETE, etc.)

### Endpoint
All API Endpoints

### Parameters
#### Headers
- **Authorization** (string) - Required - The API token in the format `Bearer API_TOKEN`.

### Request Example
```bash
curl -H "Authorization: Bearer xo+CAiijrIy9XvZCYyhjrv0fpSAL6CfU8CgA+up1NXqK" \
  [YOUR_API_ENDPOINT]
```

### Response
#### Error Response (401)
- **status** (boolean) - `false`
- **message** (string) - "Unauthorized. Please provide a valid API token."
- **data** (object) - `null`
```

--------------------------------

### Lenco API JSON Response Structure

Source: https://lenco-api.readme.io/v2.0/reference/get-started

Illustrates the standard JSON structure for responses from the Lenco API. This format includes status, message, and data fields, with an optional meta key for pagination context.

```json
{
  "status": [boolean],  // Only true if the details provided could be processed and no error occured while processing
  "message": [string], // Explains why status is false... Entirely informational. Please only log this but do not use for your checks
  "data": [object]    // contains actionable result of processing if present
}

```

--------------------------------

### Authenticate API Calls with cURL

Source: https://lenco-api.readme.io/v2.0/reference/get-started

Demonstrates how to authenticate API requests using cURL by including the API token in the Authorization header. Ensure your token is replaced with your actual API token.

```curl
curl -H "Authorization: Bearer xo+CAiijrIy9XvZCYyhjrv0fpSAL6CfU8CgA+up1NXqK"

```

--------------------------------

### API Error Codes

Source: https://lenco-api.readme.io/v2.0/reference/get-started

This section outlines the standard HTTP response codes used by the Lenco API and provides details on specific error codes returned in the response body when an error occurs.

```APIDOC
## API Error Handling

### Description
Lenco's API follows RESTful principles, utilizing conventional HTTP response codes to signify the success or failure of requests. When an HTTP response code is not 200 (or 201), the response may optionally include an `errorCode` for more specific error details.

### HTTP Status Codes

- **200, 201**: Request successful and the intended action was carried out. A 200 will always be sent for transfer or collection requests. Check the data object for the request's specific outcome.
- **400**: A validation or client-side error occurred; the request was not fulfilled.
- **401**: The request was not authorized. This can be due to an invalid or missing API token in the authorization header.
- **404**: Request could not be fulfilled as the requested resource does not exist.
- **500, 501, 502, 503, 504**: Request could not be fulfilled due to an error on Lenco's end. Please report these instances.

### Error Codes

When the HTTP response code is not 200 or 201, the response may optionally include an `errorCode`. Possible values for `errorCode` are:

| Error Code | Details                                                      |
| :--------- | :----------------------------------------------------------- |
| 01         | Validation error. One or more parameters could not be validated correctly. |
| 02         | Insufficient funds in account.                               |
| 03         | The transfer limit on the account has been exceeded.         |
| 04         | Invalid or duplicate reference.                              |
| 05         | Invalid recipient account.                                   |
| 06         | Restriction on debit account.                                |
| 07         | Invalid or duplicate bulk transfer reference.                |
| 08         | Invalid number of objects in bulk transfer `transfers` parameter. |
| 09         | Invalid auth token or authorization denied.                  |
| 10         | General error.                                               |
| 11         | Resource not found.                                          |
| 12         | Invalid mobile number.                                       |
| 13         | Access to resource denied.                                   |

### Response Example (Error)

```json
{
  "status": "error",
  "message": "A validation error occurred.",
  "errorCode": "01"
}
```

```

--------------------------------

### Introduction to Lenco API

Source: https://lenco-api.readme.io/v2.0/index

This section provides an overview of the Lenco API, its capabilities, and how to get started. It covers accessing accounts, sub-accounts, and transaction histories for integrating payment experiences.

```APIDOC
## Introduction to Lenco API

### Description
Welcome to Lenco's API documentation. With the Lenco API, you can access all your accounts and sub-accounts and their transaction histories. You’ll learn how to build amazing web and mobile integration payment experiences with the Lenco API.

These docs will cover the available endpoints and provide example code for using the API. They will hopefully help you build your own admin tools or automate processes that previously had to be performed manually.

### Contact
If you have any questions, just send us an email at support@lenco.co.
```

--------------------------------

### Lenco API Meta Key Structure for Pagination

Source: https://lenco-api.readme.io/v2.0/reference/get-started

Details the structure of the 'meta' object within API responses, which provides pagination information such as total records, records per page, current page, and total page count.

```json
{
  "meta": {
    "total": 2,
    "perPage": 50,
    "currentPage": 1,
    "pageCount": 1
  }
}

```

--------------------------------

### Get List of Banks - Node.js

Source: https://lenco-api.readme.io/v2.0/reference/banks

Example of how to retrieve a list of banks using Node.js. This requires the 'axios' library and authentication via headers.

```javascript
const axios = require('axios');

const getBanks = async () => {
  try {
    const response = await axios.get('https://api.lenco.co/access/v2/banks', {
      headers: {
        'Authorization': 'Bearer YOUR_API_TOKEN'
      }
    });
    console.log(response.data);
  } catch (error) {
    console.error('Error fetching banks:', error);
  }
};

getBanks();
```

--------------------------------

### Get Transactions (Node.js)

Source: https://lenco-api.readme.io/v2.0/reference/transactions

Example Node.js code to fetch transactions from the Lenco API using the 'axios' library. It demonstrates setting up the request with the correct URL and headers.

```javascript
const axios = require('axios');

const options = {
  method: 'GET',
  url: 'https://api.lenco.co/access/v2/transactions',
  params: { page: '1' },
  headers: {
    'Authorization': 'Bearer xo+CAiijrIy9XvZCYyhjrv0fpSAL6CfU8CgA+up1NXqK',
    'accept': 'application/json'
  }
};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});
```

--------------------------------

### Get List of Banks - Python

Source: https://lenco-api.readme.io/v2.0/reference/banks

Example of how to retrieve a list of banks using Python. This uses the 'requests' library and requires authentication via headers.

```python
import requests

url = "https://api.lenco.co/access/v2/banks"
token = "YOUR_API_TOKEN"

headers = {
    "Authorization": f"Bearer {token}"
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code} - {response.text}")
```

--------------------------------

### Get List of Banks - Shell

Source: https://lenco-api.readme.io/v2.0/reference/banks

Example of how to retrieve a list of banks using a shell command. This method requires authentication via headers.

```shell
curl -X GET https://api.lenco.co/access/v2/banks \
     -H "Authorization: Bearer YOUR_API_TOKEN"
```

--------------------------------

### Get Transactions (Python)

Source: https://lenco-api.readme.io/v2.0/reference/transactions

Example Python code to retrieve transactions using the 'requests' library. It shows how to construct the request with the API endpoint, query parameters, and authentication headers.

```python
import requests

url = "https://api.lenco.co/access/v2/transactions"
params = {
    "page": "1"
}
headers = {
    "Authorization": "Bearer xo+CAiijrIy9XvZCYyhjrv0fpSAL6CfU8CgA+up1NXqK",
    "accept": "application/json"
}

response = requests.get(url, params=params, headers=headers)

print(response.json())
```

--------------------------------

### Retrieve Bank Accounts (Ruby)

Source: https://lenco-api.readme.io/v2.0/reference/accounts

This example illustrates how to retrieve bank account details using Ruby. It uses the 'net/http' library for making the GET request and includes the API key in the request headers.

```Ruby
require 'net/http'
require 'uri'

uri = URI.parse('https://api.lenco.co/access/v2/accounts')

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end

puts response.body
```

--------------------------------

### Get Transactions (PHP)

Source: https://lenco-api.readme.io/v2.0/reference/transactions

Example PHP code using Guzzle HTTP client to fetch transactions. It demonstrates setting the request method, URL, query parameters, and authorization headers.

```php
<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Request;

$client = new Client();

$request = new Request('GET', 'https://api.lenco.co/access/v2/transactions?page=1', [
    'Authorization' => 'Bearer xo+CAiijrIy9XvZCYyhjrv0fpSAL6CfU8CgA+up1NXqK',
    'accept' => 'application/json'
]);

$response = $client->sendAsync($request)->wait();

echo $response->getBody();

```

--------------------------------

### Initiate Payment with Lenco Widget (HTML/JavaScript)

Source: https://lenco-api.readme.io/v2.0/reference/accept-payments

This snippet shows how to include the Lenco payment script and use the `getPaid` function to initiate a payment. It requires your Lenco public key and customer details, and defines callbacks for success, closure, and pending confirmation. Note that for the sandbox environment, a different script source should be used.

```html
<script src="https://pay.lenco.co/js/v1/inline.js"></script>

<script>
function getPaidWithLenco() {
	LencoPay.getPaid({
		key: 'YOUR_PUBLIC_KEY', // your Lenco public key
		reference: 'ref-' + Date.now(), // a unique reference you generated
		email: 'customer@email.com', // the customer's email address
		amount: 1000, // the amount the customer is to pay
		currency: "ZMW",
		channels: ["card", "mobile-money"],
		customer: {
			firstName: "John",
			lastName: "Doe",
			phone: "0971111111",
		},
		onSuccess: function (response) {
			//this happens after the payment is completed successfully
			const reference = response.reference;
			alert('Payment complete! Reference: ' + reference);
			// Make an AJAX call to your server with the reference to verify the payment
		},
		onClose: function () {
			alert('Payment was not completed, window closed.');
		},
		onConfirmationPending: function () {
			alert('Your purchase will be completed when the payment is confirmed');
		},
	});
}
</script>
```

--------------------------------

### Initiate Payment with Lenco Widget

Source: https://lenco-api.readme.io/v2.0/reference/accept-payments

This section details how to use the Lenco JavaScript SDK to initiate a payment and display the popup widget to the customer.

```APIDOC
## Initiate Payment with Lenco Widget

### Description
Use the Lenco JavaScript SDK to initiate a payment. This will display a popup widget to the customer for completing the transaction.

### Method
Client-side JavaScript (function call)

### Endpoint
N/A (uses a script URL: `https://pay.lenco.co/js/v1/inline.js` or `https://pay.sandbox.lenco.co/js/v1/inline.js` for sandbox)

### Parameters
#### JavaScript Function Parameters (`LencoPay.getPaid`)
- **key** (string) - Required - Your Lenco public key.
- **reference** (string) - Required - A unique reference generated for this payment.
- **email** (string) - Required - The customer's email address.
- **amount** (number) - Required - The amount the customer is to pay (e.g., `10.75`).
- **currency** (string) - Required - The currency code (e.g., "ZMW").
- **channels** (array of strings) - Optional - Payment channels to display (e.g., `["card", "mobile-money"]`).
- **customer** (object) - Optional - Customer details.
  - **firstName** (string) - Required (if customer object is provided) - Customer's first name.
  - **lastName** (string) - Required (if customer object is provided) - Customer's last name.
  - **phone** (string) - Required (if customer object is provided) - Customer's phone number.
- **onSuccess** (function) - Required - Callback function executed upon successful payment.
- **onClose** (function) - Required - Callback function executed if the widget is closed before payment completion.
- **onConfirmationPending** (function) - Required - Callback function executed if the payment confirmation is pending.

### Request Example
```javascript
function getPaidWithLenco() {
	LencoPay.getPaid({
		key: 'YOUR_PUBLIC_KEY',
		reference: 'ref-' + Date.now(),
		email: 'customer@email.com',
		amount: 1000,
		currency: "ZMW",
		channels: ["card", "mobile-money"],
		customer: {
			firstName: "John",
			lastName: "Doe",
			phone: "0971111111",
		},
		onSuccess: function (response) {
			// Handle success
		},
		onClose: function () {
			// Handle close
		},
		onConfirmationPending: function () {
			// Handle pending confirmation
		},
	});
}
```

### Response
#### Callbacks
The `onSuccess`, `onClose`, and `onConfirmationPending` callback functions receive specific responses or execute defined actions.
```

--------------------------------

### Get Transactions (cURL)

Source: https://lenco-api.readme.io/v2.0/reference/transactions

Example cURL request to retrieve transactions from the Lenco API. It includes the GET method, URL with a page parameter, and authorization and accept headers.

```shell
curl --request GET \
     --url 'https://api.lenco.co/access/v2/transactions?page=1' \
     --header 'Authorization: Bearer xo+CAiijrIy9XvZCYyhjrv0fpSAL6CfU8CgA+up1NXqK' \
     --header 'accept: application/json'
```

--------------------------------

### Payment Widget Integration

Source: https://lenco-api.readme.io/v2.0/reference/accept-payments

This section details how to initiate a payment using the Lenco popup widget. It outlines the required and optional parameters for collecting customer information and configuring the payment process.

```APIDOC
## POST /payment (Initiate Payment)

### Description
Initiates a payment process using the Lenco popup widget. This endpoint requires customer information and payment details to be passed.

### Method
POST

### Endpoint
/payment

### Parameters
#### Query Parameters
- **key** (string) - Required - Your public key from Lenco.
- **email** (string) - Required - Email address of the customer.
- **reference** (string) - Required - Unique case-sensitive reference for the transaction. Allowed characters: `-`, `.`, `_`, and alphanumeric.
- **amount** (number) - Required - The amount the customer is to pay. Can include decimals (e.g., 10.75).
- **currency** (string) - Optional - ISO 3-Letter Currency Code (e.g., `ZMW`, `USD`). Defaults to your dashboard setting.
- **label** (string) - Optional - Text to display on the widget (e.g., checkout form name).
- **bearer** (string) - Optional - Determines who bears the fee: `merchant` or `customer`. Overrides dashboard setting if provided.
- **channels** (array) - Optional - An array of payment channels to offer customers. Available: `["card", "mobile-money"]`.
- **onSuccess** (javascript function) - Optional - Javascript function executed upon successful payment. Should ideally include a call to the verify endpoint.
- **onClose** (javascript function) - Optional - Javascript function executed if the customer closes the payment window.
- **onConfirmationPending** (javascript function) - Optional - Javascript function executed if the customer closes the window before payment is verified.

#### Request Body
- **customer** (object) - Optional - Customer details.
  - **firstName** (string) - Optional - The first name of the customer.
  - **lastName** (string) - Optional - The last name of the customer.
  - **phone** (string) - Optional - The phone number of the customer.
- **billing** (object) - Optional - Customer's billing address.
  - **streetAddress** (string) - Optional - The street address.
  - **city** (string) - Optional - The city.
  - **state** (string) - Optional - The state or province (2-letter code for US/Canada, or blank if not applicable).
  - **postalCode** (string) - Optional - The postal code.
  - **country** (string) - Optional - 2-letter country code (e.g., `US`).

### Request Example
```json
{
  "customer": {
    "firstName": "John",
    "lastName": "Doe",
    "phone": "+2348012345678"
  },
  "billing": {
    "streetAddress": "123 Main St",
    "city": "Anytown",
    "state": "CA",
    "postalCode": "90210",
    "country": "US"
  }
}
```

### Response
#### Success Response (200)
- **payment_url** (string) - The URL to redirect the customer to for payment.

#### Response Example
```json
{
  "payment_url": "https://sandbox.lenco.co/pay/xxxxxxxxxxxxxxxxxxxx"
}
```
```

--------------------------------

### Get Transactions (Ruby)

Source: https://lenco-api.readme.io/v2.0/reference/transactions

Example Ruby code using the 'httparty' gem to make a GET request to the Lenco API for transactions. It includes setting the URL, query parameters, and necessary headers.

```ruby
require 'httparty'

url = 'https://api.lenco.co/access/v2/transactions'
options = {
  query: { page: '1' },
  headers: {
    'Authorization' => 'Bearer xo+CAiijrIy9XvZCYyhjrv0fpSAL6CfU8CgA+up1NXqK',
    'accept' => 'application/json'
  }
}

response = HTTParty.get(url, options)

puts response.body
```

--------------------------------

### Get List of Banks - PHP

Source: https://lenco-api.readme.io/v2.0/reference/banks

Example of how to retrieve a list of banks using PHP. This uses cURL and requires authentication via headers.

```php
<?php

$url = 'https://api.lenco.co/access/v2/banks';
$token = 'YOUR_API_TOKEN';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
    'Authorization: Bearer ' . $token
));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}

cost $data = json_decode($response, true);
print_r($data);

cost curl_close($ch);
?>
```

--------------------------------

### Get List of Banks - Ruby

Source: https://lenco-api.readme.io/v2.0/reference/banks

Example of how to retrieve a list of banks using Ruby. This requires the 'httparty' gem and authentication via headers.

```ruby
require 'httparty'

uri = 'https://api.lenco.co/access/v2/banks'
options = {
  headers: { 'Authorization' => 'Bearer YOUR_API_TOKEN' }
}

response = HTTParty.get(uri, options)
puts response.parsed_response
```

--------------------------------

### Testing Card Collections

Source: https://lenco-api.readme.io/v2.0/reference/initiate-collection-from-card

Provides a link to a resource listing test cards and accounts that can be used for testing card collections in the Lenco API sandbox environment.

```APIDOC
## Testing Card Collections

### Description
Information on how to test card collections in the sandbox environment.

### Resource
- You can use any of the cards [listed here](https://lenco-api.readme.io/v2.0/reference/test-cards-and-accounts) to test card collections in the sandbox environment.
```

--------------------------------

### Project: /websites/lenco-api_readme_io_v2_0

Source: https://lenco-api.readme.io/v2.0/reference/create-transfer-recipient-as-mobile-money

This section details the structure of a response, including status, message, and data fields.

```APIDOC
## Response Structure

### Description
This describes the general structure of API responses, indicating success or failure and providing relevant information.

### Method
N/A (Response structure description)

### Endpoint
N/A (Response structure description)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **status** (boolean) - Indicates if the operation was successful.
- **message** (string) - A message describing the outcome of the operation.
- **data** (object) - Contains the payload of the response. The structure varies depending on the specific endpoint.

#### Response Example
```json
{
  "status": false,
  "message": "Account Details could not be verified",
  "data": {}
}
```
```

--------------------------------

### POST /transfers/bank-account

Source: https://lenco-api.readme.io/v2.0/reference/initiate-transfer-to-bank-account

Initiates a transfer to a specified bank account. It returns the status of the operation along with detailed data about the initiated transfer.

```APIDOC
## POST /transfers/bank-account

### Description
Initiates a transfer to a specified bank account. It returns the status of the operation along with detailed data about the initiated transfer.

### Method
POST

### Endpoint
/transfers/bank-account

### Parameters
#### Request Body
- **amount** (string) - Required - The amount to transfer.
- **currency** (string) - Required - The currency of the transfer (e.g., "NGN").
- **narration** (string) - Required - A description for the transfer.
- **accountId** (string) - Required - The ID of the source account for the transfer.
- **accountName** (string) - Required - The name of the beneficiary.
- **accountNumber** (string) - Required - The account number of the beneficiary.
- **bankId** (string) - Required - The ID of the beneficiary's bank.

### Request Example
```json
{
  "amount": "10000",
  "currency": "NGN",
  "narration": "Payment for services",
  "accountId": "acc_12345",
  "accountName": "John Doe",
  "accountNumber": "1234567890",
  "bankId": "bank_abcde"
}
```

### Response
#### Success Response (200)
- **status** (boolean) - Indicates if the transfer initiation was successful.
- **message** (string) - A message describing the result of the operation.
- **data** (object) - Contains detailed information about the initiated transfer:
  - **id** (string) - Unique identifier for the transfer.
  - **amount** (string) - The amount transferred.
  - **fee** (string) - The fee charged for the transfer.
  - **currency** (string) - The currency of the transfer.
  - **narration** (string) - The description of the transfer.
  - **initiatedAt** (date-time) - Timestamp when the transfer was initiated.
  - **completedAt** (date-time | null) - Timestamp when the transfer was completed, or null if not yet completed.
  - **accountId** (string) - The ID of the source account.
  - **creditAccount** (object) - Details of the beneficiary's bank account:
    - **type** (string) - Always "bank-account".
    - **accountName** (string) - The name of the beneficiary.
    - **accountNumber** (string) - The account number of the beneficiary.
    - **bank** (object) - Details of the beneficiary's bank:
      - **id** (string) - Unique identifier for the bank.
      - **name** (string) - The name of the bank.
      - **country** (string) - The country of the bank.
  - **status** (string) - The current status of the transfer ("pending", "successful", or "failed").
  - **reasonForFailure** (string | null) - If the status is "failed", this provides the reason.
  - **reference** (string | null) - An external reference number, if applicable.
  - **lencoReference** (string) - Lenco's internal reference number for the transfer.
  - **extraData** (object) - Additional data related to the transfer:
    - **nipSessionId** (string | null) - The NIP session ID, if applicable.
  - **source** (string) - The source of the transfer initiation.

#### Response Example
```json
{
    "status": true,
    "message": "Transfer initiated successfully",
    "data": {
        "id": "txn_abcdef123",
        "amount": "10000",
        "fee": "100",
        "currency": "NGN",
        "narration": "Payment for services",
        "initiatedAt": "2023-10-27T10:00:00Z",
        "completedAt": null,
        "accountId": "acc_12345",
        "creditAccount": {
            "type": "bank-account",
            "accountName": "John Doe",
            "accountNumber": "1234567890",
            "bank": {
                "id": "bank_abcde",
                "name": "Example Bank",
                "country": "NG"
            }
        },
        "status": "pending",
        "reasonForFailure": null,
        "reference": "EXTREF789",
        "lencoReference": "LNX123456789",
        "extraData": {
            "nipSessionId": "nip_xyz789"
        },
        "source": "API"
    }
}
```
```

--------------------------------

### POST /transfers/lenco-money

Source: https://lenco-api.readme.io/v2.0/reference/initiate-transfer-to-lenco-money

Initiates a Lenco Money transfer. This endpoint allows users to send funds using Lenco's internal money transfer system.

```APIDOC
## POST /transfers/lenco-money

### Description
Initiates a Lenco Money transfer. This endpoint allows users to send funds using Lenco's internal money transfer system.

### Method
POST

### Endpoint
/transfers/lenco-money

### Parameters
#### Request Body
- **amount** (string) - Required - The amount to transfer.
- **currency** (string) - Required - The currency of the transfer.
- **narration** (string) - Required - A description for the transfer.
- **creditAccount** (object) - Required - Details of the credit account.
  - **type** (string) - Required - Must be 'lenco-money'.
  - **accountName** (string) - Required - The name of the account holder.
  - **walletNumber** (string) - Required - The Lenco wallet number.

### Request Example
```json
{
  "amount": "100.50",
  "currency": "NGN",
  "narration": "Payment for services",
  "creditAccount": {
    "type": "lenco-money",
    "accountName": "John Doe",
    "walletNumber": "0123456789"
  }
}
```

### Response
#### Success Response (200)
- **status** (boolean) - Indicates if the operation was successful.
- **message** (string) - A message describing the outcome of the operation.
- **data** (object) - Contains the details of the transfer.
  - **id** (string) - Unique identifier for the transfer.
  - **amount** (string) - The transferred amount.
  - **fee** (string) - The fee charged for the transfer.
  - **currency** (string) - The currency of the transfer.
  - **narration** (string) - Description of the transfer.
  - **initiatedAt** (date-time) - Timestamp when the transfer was initiated.
  - **completedAt** (date-time | null) - Timestamp when the transfer was completed, or null if not completed.
  - **accountId** (string) - The ID of the source account.
  - **creditAccount** (object) - Details of the credit account.
    - **type** (string) - Type of the credit account ('lenco-money').
    - **accountName** (string) - Name of the account holder.
    - **walletNumber** (string) - Lenco wallet number.
  - **status** (string) - Current status of the transfer ('pending', 'successful', 'failed').
  - **reasonForFailure** (string | null) - Reason for failure, if applicable.
  - **reference** (string | null) - External reference number, if applicable.
  - **lencoReference** (string) - Lenco's internal reference number.
  - **extraData** (object) - Additional data related to the transfer.
    - **nipSessionId** (string | null) - NIP session ID, if applicable.
  - **source** (string) - The source of the transfer.

#### Response Example
```json
{
    "status": true,
    "message": "Transfer initiated successfully",
    "data": {
        "id": "txn_12345abcde",
        "amount": "100.50",
        "fee": "1.00",
        "currency": "NGN",
        "narration": "Payment for services",
        "initiatedAt": "2023-10-27T10:00:00Z",
        "completedAt": null,
        "accountId": "acc_abcdef123",
        "creditAccount": {
            "type": "lenco-money",
            "accountName": "John Doe",
            "walletNumber": "0123456789"
        },
        "status": "pending",
        "reasonForFailure": null,
        "reference": null,
        "lencoReference": "LNC789XYZ",
        "extraData": {
            "nipSessionId": null
        },
        "source": "mobile-app"
    }
}
```
```

--------------------------------

### Retrieve Transfer Recipients (Python)

Source: https://lenco-api.readme.io/v2.0/reference/transfer-recipients

Example of how to retrieve transfer recipients using Python with the 'requests' library. This snippet shows how to construct the GET request with query parameters and headers.

```python
import requests

url = "https://api.lenco.co/access/v2/transfer-recipients"
params = {
    "page": "1"
}
headers = {
    "Authorization": "Bearer xo+CAiijrIy9XvZCYyhjrv0fpSAL6CfU8CgA+up1NXqK",
    "accept": "application/json"
}

response = requests.get(url, params=params, headers=headers)

print(response.json())
```
Tokens:
Raw