Layup endpoints v1.4.16

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Welcome to The Layup Documentation page. This page contains detailed explanations with code examples. For an interactive approach see the Swagger page at api-documentation.layup.co.za.

Introduction

What is LayUp

LayUp is a lay-by payment solution. LayUp Schedules payments and ensures that your clients pay securely, effectively and on time. Depending on your parameters LayUp schedules a payment plan for your clients. Once a payment plan has been completed we notify you. There are 3 stories that are of importance to a merchant:

Order Creation
Deposit Received (and holding Stock for your client)
Order Completion.

LayUp allows you to take full control over the entire payment process if you wish to do so. We also provide a convenient front-end for users to use. The front-end should significantly reduce the time to integrate and get you started using LayUp as soon as possible.

Once an order is completed a notification will be sent to the merchant so that you can provide the client with their product.

How to use LayUp

As a merchant who wants to place an order through LayUp, you want to send the relevant information to the LayUp API to create the order. The API will return an order ID. Unless your integration is using a custom user interface, you want to send the user to the LayUp customer payment widget. The URL for this widget is https://shopper.layup.co.za/order/{orderId} for production and https://sandbox.layup.co.za/order/{orderId} for sandbox.

Terminology

Term	Description
Client	A merchant client, someone who is looking to purchase something from a merchant.
User	Anyone who interacts with LayUp’s UI or API.
LayUp API	Often interchanged with “back-end”. A REST-ful based api which the front-end and other integrations use to access the LayUp’s payment and other business applications.
LayUp UI	Often referred to as the “front-end” is the external interface users can use to interact with the LayUp API.
Database	Internal Storage for LayUp, containing all data stored and used within the LayUp API.
Lay-by	A payment plan where you reserve a article for purchase at the available price. You pay a small deposit then pay instalments and get the item once its paid off.
Code	Compiled or translated, the building blocks that make up the means of interaction between a user and a database or set of rules.
Order	Goods to be purchased along with the terms of the LayBy agreement set within the parameters of the LayUp API.
Payment Plan	Frequency and quantity of scheduled payments for an order. All payments must be linked to a payment plan.
Payment	Paid or to be paid in the future, the aggregate of which should eventually complete the Payment Plan and Order alike.
Payment Types	Contribution, Deposit, Recurring or Refund.
Payment Methods	Card, EFT, Offline, DebiCheck or Transfer.
Documentation	The API Documentation provided to you by a LayUp consultant and can also be found at: https://documentation.layup.co.za
Split Payments	The process of dividing an order among multiple payment plans owned by multiple users.
Weekly Payments	Weekly frequency of instalments as opposed to the default monthly.
Order Cloning	Cloning allows multiple copies of the same Order.
Deposit Types	Percentage, Flat or First Instalment.
Grace Period	How far a customer can be behind on their payments before the order is finally cancelled through auto cancellation.
Cancellation	Void the order, refunding the client. The customer can request a cancellation from the merchant but only the merchant can cancel the order.
Auto Cancellation	Automatically cancel any order when a customer is missing payments.
Cancellation Type	Trigger auto cancellation through either number of missed instalments or the paid percentage by a certain time.
Cancellation Policy	Deposit, percentage or flat fee.
Cancellation Fee	On cancellation a fee is determined through the cancellation policy and added as a product on the order (negative).
Cancellation Interval	Time interval over which the percentage cancellation type applies. A certain percentage must be paid a number of days before the final payment day.
Order Expiry	If the deposit is not paid in full by a configurable time, the order will expire.
Good Standing	Order is in good standing if the cancellation terms are not breached.
Notifications	Each notification can be disabled, enabled or enabled to be sent to a specific email.
Payment Notifications	Successful payment, failing to collect or missed instalment.
Order Notifications	New, amended, expired, cancelled, percentage completed, completed order and cancellation request.
Order Amendment	Amendments can only be done by the merchant. Types: 'PRODUCT:CREATE', 'PRODUCT:UPDATE', 'PRODUCT:DELETE', 'ENDDATE:UPDATE'
Additional Contribution	If the client makes an additional contribution it reduces the amount due for their next instalment. (This continues until all instalments are paid)

Cancellation Term

A cancellation term can be configured by a merchant. If the client accepts the terms then the client will have an option to cancel an order. If the terms has not been configured then the client will not be able to start the cancellation process and will have to wait for the order to cancel automatically due to missed payments.

Additionally a merchant can configure a global default term along with additional terms on a per order basis. Orders that do not have terms configured specifically for it will apply the global default term automatically.

Typical User Journeys

Success Journey

A typical successful client journey:

Client clicks checkout with LayUp on Merchant’s website.
Merchant creates an Order on LayUp

Parameters that dictates the structure of the payment plans:
1. Products - The list that determines the total value of the Order
2. Reference and name - Descriptions which will be included in notifications
3. Dates (max and min) - A range of dates that determines the payment plan length.
4. notifyUrl - optional query parameter to return the customer after making their deposit payment.

Client is directed to the LayUp customer app
Client selects payment period
Client pays deposit
Client is redirected back to the merchant
Merchant is notified of deposit being paid successfully
Merchant withholds stock for the client.
Client pays monthly on billing cycle.
Client Payment Plan is completed
Merchant is notified
Payments are settled to the merchant based on settlement options.

Failed Journey (Deposit Missed)

What happens when a client fails to meet the deposit value:

Client clicks checkout with LayUp on Merchant’s website.
Merchant creates an Order on LayUp with 2 hours expire option
Client is directed to the LayUp customer app
Client selects payment period
Client drops off
Client does not Pay within 2 hours
Order is expired (merchant notified)

Failed Journey (Cancellation)

What happens when a client exceeds his payment period and does not meet the Order full amount:

Client clicks checkout with LayUp on Merchant’s website.
Merchant creates an Order on LayUp
Client is directed to the LayUp customer app
Client selects payment period
Client pays deposit
Client is redirected back to the merchant
Merchant is notified of deposit being paid successfully
Merchant withholds stock for the client.
Client fails to make the required number of instalments.
Order enters grace period
Client fails to catch up on payments
Order is cancelled
Cancellation fee is sent to merchant
Remainder is refunded to client

WebHooks

Webhooks can be viewed as a basic remote trigger or event notification.

Webhook remote endpoints are not verified by the system as this would require manual input every time webhook is defined or changed. If a merchant enters an incorrect endpoint the webhook will, as one would expect, send the payload to the wrong destination. This is one example why webhook payloads will only contain basic information and references.

Failed webhooks will retry up to 5 times with an exponential back off delay each time the webhook fails.

Optionally if a merchant's network infrastructure makes use of an Access Control List (ACL) please make sure that the following address: 99.81.244.160 is allowed to send network traffic. Webhook requests will always be sent from that address.

For more information see the modelWebHookPayload and modelWebHookPaymentPayload under the Schemas section.

Order Webhooks

Order webhooks will send notifications when an order changes state.

The MerchantService notifyUrl definitions shows how to set a remote endpoint for order webhooks.

Payment Webhooks

Payment webhooks will send notifications when a payment changes state.

The MerchantService paymentNotifyUrl definitions shows how to set a remote endpoint for payment webhooks.

API Keys

The primary method of authentication with the Layup API is API-key based. It should be possible to use sessions but is not a supported method when interacting with the API.

API-keys are set with a HTTP-header and should always be present in queries to interact with the RESTful web interface.

The response "Unauthorized" will typically be shown when your API-key is missing or invalid.

An API key will be generated once the merchant sign up process is complete.

How to set a API key header using cURL:

curl -X GET https://sandbox-api.layup.co.za/v1/users -H 'Accept: application/json' -H 'apikey: your-unique-api-key'

Note: In practice the host domain would point to Staging or Production since the sandbox environment does not use API keys.

Suspended

A suspended order can be seen as soft cancel or pause. This usually happens as a result of missed payments. No collections wil be made on suspended orders

An order can only be suspended by the merchant.
An order can be suspended at any time.
If suspendOnCancel is set an order will be suspended automatically any time it is breaching the cancellation terms.
If a payment is made to the order and cancellation terms are no longer breached the order will be unsuspended automatically.
When an order goes into or comes out of suspension a webhook and email / sms notifications will be sent.

Setting suspendOnCancel on an existing order:

const orderId = '123orderId';
const apikey = '123apikey';
const inputBody = '{"suspendOnCancel": true}';
const headers = { 'Content-Type': 'application/json', Accept: 'application/json', apikey: apikey };
fetch('https://sandbox-api.layup.co.za/v1/orders/' + orderId, { method: 'PUT', body: inputBody, headers: headers });

Amortisation

`amortiseOnMissed`

Used to set the way missed payments are handled.

`amortiseOnMissed:true` (default)

When a payment is missed the payment amount is split equally and added to remaining payments.

`amortiseOnMissed:false`

(fixed instalment plans) When a payment is missed then payments continue as normal. The order will stay in a suspended state until an additional contribution is made for the missed payment.

`amortiseOnAmend`

Used to set how payment plans are re-created after amendments.

`amortiseOnAmend:true` (default)

When the order value changes all future instalment amounts are changed.

`amortiseOnAmend:false`

When the order value changes do not update affecting individual instalment amounts. (If the order value increases, the due amount will increase)

Examples

A customer has a payment plan of R100 per month for 4 months. The customer misses their second instalment. At the moment the payment is missed the payments will be in this state:

Due	Amount	Paid	Missed
28/01	R100.00	true	false
28/02	R100.00	false	true
28/03	R100.00	false	false
28/04	R100.00	false	false

If amortiseOnMissed is true the missed payment value will be divided into the remaining payments. Order stays in suspended. | Due | Amount | Paid | Missed | | ----- | ------- | ----- | ------ | | 28/01 | R100.00 | true | false | | 28/02 | R100.00 | false | true | | 28/03 | R150.00 | false | false | | 28/04 | R150.00 | false | false |

If amortiseOnMissed is false then the payment original state will not change. Order stays in suspended. | Due | Amount | Paid | Missed | | ----- | ------- | ----- | ------ | | 28/01 | R100.00 | true | false | | 28/02 | R100.00 | false | true | | 28/03 | R100.00 | false | false | | 28/04 | R100.00 | false | false |

If the merchant and customer comes to an agreement that month 2 will be skipped and the payment plan resumed the merchant can amend the order by reducing the total order value to R300.

If amortiseOnAmend is true. Reduced order value is split over remaining payments. The order is unsuspended. | Due | Amount | Paid | Missed | | ----- | ------- | ----- | ------ | | 28/01 | R100.00 | true | false | | 28/02 | R0.00 | false | false | | 28/03 | R150.00 | false | false | | 28/03 | R150.00 | false | false |

If amortiseOnAmend is false. Reduced order value is split order missed and remaining payments. The order stays suspended. | Due | Amount | Paid | Missed | | ----- | ------- | ----- | ------ | | 28/01 | R100.00 | true | false | | 28/02 | R66.66 | false | true | | 28/03 | R66.66 | false | false | | 28/04 | R66.66 | false | false |

Code examples

Some bash examples, take notice of variables such us merchantApiKey and orderId. One of the example also use a tool called jq, which is just a simple json parser.

orderResponse=$(curl 'https://sandbox-api.layup.co.za/v1/orders' -X POST -H 'Content-Type: application/json;charset=utf-8' -H "apikey: $merchantApiKey" \
--data-binary @- << EOF
{
   "endDateMax":"2022-09-28",
   "endDateMin":"2022-07-26",
   "products":[{"amount":30000,"sku":"sku-5555","name":"amortiseOnAmend"}],
   "state":"PARTIAL",
   "depositType":"FLAT",
   "depositAmount":10000,
   "name":"amortiseOnAmend",
   "reference":"amortiseOnAmend reference",
   "amortiseOnAmend": true,
   "amortiseOnMissed": false,
   "suspendOnCancel": true
}
EOF
)
orderId=$(echo $orderResponse | jq -r ._id)

Send customer to payment widget https://sandbox.layup.co.za/order/$orderId

echo "https://sandbox.layup.co.za/order/$orderId"

To increase the order period and instalments amend date and products. The payment plan will be extended by 1 month for each month the order end date is extended. End dates cannot be set less than the current end date.

curl "https://sandbox-api.layup.co.za/v1/orders/$orderId" -X PUT -H 'Content-Type: application/json;charset=utf-8' -H "apikey: $merchantApiKey" \
--data-binary @- << EOF
{
   "endDateMax":"2022-11-30",
   "products":[{"amount":40000,"sku":"sku-5555","name":"amortiseOnAmend"}]
}
EOF

The instalment amount can be increased without adding extra instalments. For example 10% increase.

curl "https://sandbox-api.layup.co.za/v1/orders/$orderId" -X PUT -H 'Content-Type: application/json;charset=utf-8' -H "apikey: $merchantApiKey" \
--data-binary @- << EOF
{
   "products":[{"amount":43000,"sku":"sku-5555","name":"amortiseOnAmend"}]
}
EOF

When order is suspended due to a breach of terms, merchant user can un-suspend by moving the order to a "PLACED" state, or cancel by moving to "CANCELLED" state.

curl "https://sandbox-api.layup.co.za/v1/orders/$orderId" -X PUT -H 'Content-Type: application/json;charset=utf-8' -H "apikey: $merchantApiKey" \
--data-binary '{"state":"PLACED"}'
curl "https://sandbox-api.layup.co.za/v1/orders/$orderId" -X PUT -H 'Content-Type: application/json;charset=utf-8' -H "apikey: $merchantApiKey" \
--data-binary '{"state":"CANCELLED"}'

If the order is suspended for a month and the instalment for that month needs to be skipped. Simply reduce the order value. Due to the amortise on amend option the unpaid amount will be distributed to future instalments only.

curl "https://sandbox-api.layup.co.za/v1/orders/$orderId" -X PUT -H 'Content-Type: application/json;charset=utf-8' -H "apikey: $merchantApiKey" \
--data-binary @- << EOF
{
   "products":[{"amount":30000,"sku":"sku-5555","name":"amortiseOnAmend"}]
}
EOF

Base URLs:

Authentication

API Key (apiKey)
- Parameter Name: apikey, in: header.

authService

authService_GenerateApikey

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/auth/apikey \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/auth/apikey HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/auth/apikey',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/auth/apikey', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/auth/apikey',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/auth/apikey", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/auth/apikey

Warning: Calling this endpoint will replace any existing apikeys on your account.

Example responses

200 Response

{
  "apikey": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelApikeyResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

authService_Login

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/auth/login \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/auth/login HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "username": "string",
  "password": "pa$$word",
  "rememberMe": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/auth/login',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/auth/login', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/auth/login',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/auth/login", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/auth/login

Body parameter

{
  "username": "string",
  "password": "pa$$word",
  "rememberMe": true
}

Parameters

Name	In	Type	Required	Description
body	body	modelLoginRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "active": true,
  "merchantId": "string",
  "cellNumber": "string",
  "dateOfBirth": "string",
  "name": "string",
  "verified": true,
  "timestamp": 0.1,
  "hasPassword": true,
  "verifiedEmail": true,
  "verifiedMobile": true,
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "oneTimePass": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "merchants": [
    {
      "_id": "string",
      "name": "string"
    }
  ],
  "isMerchantOwner": true,
  "twoFactorAuthenticationRequired": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelUserResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

authService_Register

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/auth/register \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/auth/register HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "password": "string",
  "name": "string",
  "dateOfBirth": "string",
  "cellNumber": "string",
  "redirectTo": "string",
  "apikey": "string",
  "shouldWelcome": true,
  "merchantCreatePlan": true,
  "merchantId": "string",
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "isMerchantOwner": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/auth/register',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/auth/register', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/auth/register',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/auth/register", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/auth/register

Body parameter

{
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "password": "string",
  "name": "string",
  "dateOfBirth": "string",
  "cellNumber": "string",
  "redirectTo": "string",
  "apikey": "string",
  "shouldWelcome": true,
  "merchantCreatePlan": true,
  "merchantId": "string",
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "isMerchantOwner": true
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
avs	query	string	false	none
isRealtimeVerification	query	boolean	false	none
body	body	modelUserRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "active": true,
  "merchantId": "string",
  "cellNumber": "string",
  "dateOfBirth": "string",
  "name": "string",
  "verified": true,
  "timestamp": 0.1,
  "hasPassword": true,
  "verifiedEmail": true,
  "verifiedMobile": true,
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "oneTimePass": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "merchants": [
    {
      "_id": "string",
      "name": "string"
    }
  ],
  "isMerchantOwner": true,
  "twoFactorAuthenticationRequired": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelUserResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

authService_GenerateTerminalKey

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/auth/terminal-key \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/auth/terminal-key HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/auth/terminal-key',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/auth/terminal-key', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/auth/terminal-key',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/auth/terminal-key", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/auth/terminal-key

Example responses

200 Response

{
  "terminalKey": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelTerminalKeyResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

authService_ForgotPassword

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/request-password-reset \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/request-password-reset HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "value": "string",
  "channel": "string",
  "redirectTo": "string",
  "isRealtimeVerification": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/request-password-reset',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/request-password-reset', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/request-password-reset',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/request-password-reset", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/request-password-reset

Body parameter

{
  "value": "string",
  "channel": "string",
  "redirectTo": "string",
  "isRealtimeVerification": true
}

Parameters

Name	In	Type	Required	Description
body	body	modelForgotPasswordRequest	true	none

Example responses

200 Response

{
  "status": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelForgotPasswordResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

authService_MerchantBillingChangesRequest

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/send-billing-settlements-change-request \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/send-billing-settlements-change-request HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "merchantName": "string",
  "userName": "string",
  "userEmail": "string",
  "merchantId": "string",
  "merchantContactNumber": "string",
  "message": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/send-billing-settlements-change-request',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/send-billing-settlements-change-request', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/send-billing-settlements-change-request',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/send-billing-settlements-change-request", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/send-billing-settlements-change-request

Body parameter

{
  "merchantName": "string",
  "userName": "string",
  "userEmail": "string",
  "merchantId": "string",
  "merchantContactNumber": "string",
  "message": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelMerchantBillingSettlementRequest	true	none

Example responses

200 Response

{
  "status": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelMerchantBillingSettlementResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

UserService

UserService_GetMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/users \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/users HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/users',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/users', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/users',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/users", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/users

Parameters

Name	In	Type	Required	Description
limit	query	integer(int32)	false	none
orderId	query	string	false	none

Example responses

200 Response

{
  "users": [
    {
      "_id": "string",
      "username": "string",
      "email": "[email protected]",
      "idNumber": "string",
      "address": "string",
      "postalCode": "string",
      "city": "string",
      "province": "string",
      "country": "string",
      "role": "CLIENT",
      "active": true,
      "merchantId": "string",
      "cellNumber": "string",
      "dateOfBirth": "string",
      "name": "string",
      "verified": true,
      "timestamp": 0.1,
      "hasPassword": true,
      "verifiedEmail": true,
      "verifiedMobile": true,
      "merchantRole": "string",
      "bankDetails": {
        "bankName": {
          "verified": true,
          "value": "string"
        },
        "account": {
          "verified": true,
          "value": "string"
        },
        "accountType": {
          "verified": true,
          "value": "string"
        },
        "branchCode": {
          "verified": true,
          "value": "string"
        },
        "idNumber": {
          "verified": true,
          "value": "string"
        },
        "verified": true,
        "clientName": {
          "verified": true,
          "value": "string"
        },
        "cellNumber": {
          "verified": true,
          "value": "string"
        },
        "initials": {
          "verified": true,
          "value": "string"
        },
        "email": {
          "verified": true,
          "value": "string"
        },
        "validationResponseErrors": [
          "string"
        ]
      },
      "merchantOnboarding": {
        "name": "string",
        "physicalAddress": {
          "country": "string",
          "province": "string",
          "streetAddress": "string",
          "city": "string",
          "postalCode": "string"
        }
      },
      "bankValidationPendingReference": "string",
      "oneTimePass": "string",
      "passportState": "string",
      "passportNumber": "string",
      "profileImage": "string",
      "merchantIds": [
        "string"
      ],
      "merchants": [
        {
          "_id": "string",
          "name": "string"
        }
      ],
      "isMerchantOwner": true,
      "twoFactorAuthenticationRequired": true
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelUserResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

UserService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/users \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/users HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "password": "string",
  "name": "string",
  "dateOfBirth": "string",
  "cellNumber": "string",
  "redirectTo": "string",
  "apikey": "string",
  "shouldWelcome": true,
  "merchantCreatePlan": true,
  "merchantId": "string",
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "isMerchantOwner": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/users',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/users', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/users',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/users", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/users

Description

Body parameter

{
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "password": "string",
  "name": "string",
  "dateOfBirth": "string",
  "cellNumber": "string",
  "redirectTo": "string",
  "apikey": "string",
  "shouldWelcome": true,
  "merchantCreatePlan": true,
  "merchantId": "string",
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "isMerchantOwner": true
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
avs	query	string	false	none
isRealtimeVerification	query	boolean	false	none
body	body	modelUserRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "active": true,
  "merchantId": "string",
  "cellNumber": "string",
  "dateOfBirth": "string",
  "name": "string",
  "verified": true,
  "timestamp": 0.1,
  "hasPassword": true,
  "verifiedEmail": true,
  "verifiedMobile": true,
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "oneTimePass": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "merchants": [
    {
      "_id": "string",
      "name": "string"
    }
  ],
  "isMerchantOwner": true,
  "twoFactorAuthenticationRequired": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelUserResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

UserService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/users/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/users/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/users/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/users/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/users/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/users/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/users/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "active": true,
  "merchantId": "string",
  "cellNumber": "string",
  "dateOfBirth": "string",
  "name": "string",
  "verified": true,
  "timestamp": 0.1,
  "hasPassword": true,
  "verifiedEmail": true,
  "verifiedMobile": true,
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "oneTimePass": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "merchants": [
    {
      "_id": "string",
      "name": "string"
    }
  ],
  "isMerchantOwner": true,
  "twoFactorAuthenticationRequired": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelUserResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

UserService_Del

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/users/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/users/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/users/{_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/users/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/users/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/users/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/users/{_id}

Description

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "active": true,
  "merchantId": "string",
  "cellNumber": "string",
  "dateOfBirth": "string",
  "name": "string",
  "verified": true,
  "timestamp": 0.1,
  "hasPassword": true,
  "verifiedEmail": true,
  "verifiedMobile": true,
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "oneTimePass": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "merchants": [
    {
      "_id": "string",
      "name": "string"
    }
  ],
  "isMerchantOwner": true,
  "twoFactorAuthenticationRequired": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelUserResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

UserService_Update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/users/{_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/users/{_id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "password": "string",
  "name": "string",
  "dateOfBirth": "string",
  "cellNumber": "string",
  "redirectTo": "string",
  "apikey": "string",
  "shouldWelcome": true,
  "merchantCreatePlan": true,
  "merchantId": "string",
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "isMerchantOwner": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/users/{_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/users/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/users/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/users/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/users/{_id}

Body parameter

{
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "password": "string",
  "name": "string",
  "dateOfBirth": "string",
  "cellNumber": "string",
  "redirectTo": "string",
  "apikey": "string",
  "shouldWelcome": true,
  "merchantCreatePlan": true,
  "merchantId": "string",
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "isMerchantOwner": true
}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
avs	query	string	false	none
isRealtimeVerification	query	boolean	false	none
body	body	modelUserRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "active": true,
  "merchantId": "string",
  "cellNumber": "string",
  "dateOfBirth": "string",
  "name": "string",
  "verified": true,
  "timestamp": 0.1,
  "hasPassword": true,
  "verifiedEmail": true,
  "verifiedMobile": true,
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "oneTimePass": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "merchants": [
    {
      "_id": "string",
      "name": "string"
    }
  ],
  "isMerchantOwner": true,
  "twoFactorAuthenticationRequired": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelUserResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService

PaymentPlanService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payment-plan \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payment-plan HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "orderId": "string",
  "benefactorId": "string",
  "quantity": 0,
  "automaticBilling": true,
  "frequency": "string",
  "offset": 0,
  "token": "string",
  "agreedToTerms": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payment-plan', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payment-plan',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payment-plan", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payment-plan

Body parameter

{
  "orderId": "string",
  "benefactorId": "string",
  "quantity": 0,
  "automaticBilling": true,
  "frequency": "string",
  "offset": 0,
  "token": "string",
  "agreedToTerms": true
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelPaymentPlanRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "orderId": "string",
  "benefactorId": "string",
  "completed": true,
  "quantity": 0,
  "depositDue": 0,
  "amountDue": 0,
  "automaticBilling": true,
  "timestamp": 0.1,
  "payments": [
    {
      "_id": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "pending": true,
      "failed": true,
      "reconciliated": true,
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "_id": "string",
        "amount": 0,
        "paymentProviderPaymentId": "string",
        "paymentReference": "string",
        "paymentMethod": "string",
        "paymentProvider": "string",
        "paymentProviderResponses": {}
      },
      "verifiedAt": "string"
    }
  ],
  "benefactor": {
    "_id": "string",
    "name": "string",
    "email": "string"
  },
  "frequency": "WEEKLY",
  "offset": 0,
  "depositDueExcludingFee": 0,
  "amountDueExcludingFee": 0,
  "order": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "debicheckStatus": "string",
  "debicheckLastFailedReasons": [
    "string"
  ],
  "debicheckMandateActiveId": "string",
  "debicheckMandateIds": [
    "string"
  ],
  "payAtReferenceNumber": "string",
  "agreedToTerms": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService_sendPaymentPlanNotification

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payment-plan-send-notification \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payment-plan-send-notification HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan-send-notification',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payment-plan-send-notification', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payment-plan-send-notification',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payment-plan-send-notification", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payment-plan-send-notification

Body parameter

{
  "_id": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelPaymentPlanSendNotificationRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "orderId": "string",
  "benefactorId": "string",
  "completed": true,
  "quantity": 0,
  "depositDue": 0,
  "amountDue": 0,
  "automaticBilling": true,
  "timestamp": 0.1,
  "payments": [
    {
      "_id": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "pending": true,
      "failed": true,
      "reconciliated": true,
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "_id": "string",
        "amount": 0,
        "paymentProviderPaymentId": "string",
        "paymentReference": "string",
        "paymentMethod": "string",
        "paymentProvider": "string",
        "paymentProviderResponses": {}
      },
      "verifiedAt": "string"
    }
  ],
  "benefactor": {
    "_id": "string",
    "name": "string",
    "email": "string"
  },
  "frequency": "WEEKLY",
  "offset": 0,
  "depositDueExcludingFee": 0,
  "amountDueExcludingFee": 0,
  "order": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "debicheckStatus": "string",
  "debicheckLastFailedReasons": [
    "string"
  ],
  "debicheckMandateActiveId": "string",
  "debicheckMandateIds": [
    "string"
  ],
  "payAtReferenceNumber": "string",
  "agreedToTerms": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService_CreateSplitPayment

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payment-plan-split \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payment-plan-split HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "clients": [
    {
      "email": "[email protected]",
      "name": "string",
      "cellNumber": "string"
    }
  ],
  "paymentPlan": {
    "orderId": "string",
    "benefactorId": "string",
    "quantity": 0,
    "automaticBilling": true,
    "frequency": "string",
    "offset": 0,
    "token": "string",
    "agreedToTerms": true
  },
  "redirectTo": "string",
  "verificationRedirect": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan-split',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payment-plan-split', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payment-plan-split',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payment-plan-split", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payment-plan-split

Body parameter

{
  "clients": [
    {
      "email": "[email protected]",
      "name": "string",
      "cellNumber": "string"
    }
  ],
  "paymentPlan": {
    "orderId": "string",
    "benefactorId": "string",
    "quantity": 0,
    "automaticBilling": true,
    "frequency": "string",
    "offset": 0,
    "token": "string",
    "agreedToTerms": true
  },
  "redirectTo": "string",
  "verificationRedirect": "string"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelPaymentPlanSplitBody	true	none

Example responses

200 Response

{
  "paymentPlans": [
    {
      "_id": "string",
      "orderId": "string",
      "benefactorId": "string",
      "completed": true,
      "quantity": 0,
      "depositDue": 0,
      "amountDue": 0,
      "automaticBilling": true,
      "timestamp": 0.1,
      "payments": [
        {
          "_id": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "pending": true,
          "failed": true,
          "reconciliated": true,
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "_id": "string",
            "amount": 0,
            "paymentProviderPaymentId": "string",
            "paymentReference": "string",
            "paymentMethod": "string",
            "paymentProvider": "string",
            "paymentProviderResponses": {}
          },
          "verifiedAt": "string"
        }
      ],
      "benefactor": {
        "_id": "string",
        "name": "string",
        "email": "string"
      },
      "frequency": "WEEKLY",
      "offset": 0,
      "depositDueExcludingFee": 0,
      "amountDueExcludingFee": 0,
      "order": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [
          {}
        ],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "debicheckStatus": "string",
      "debicheckLastFailedReasons": [
        "string"
      ],
      "debicheckMandateActiveId": "string",
      "debicheckMandateIds": [
        "string"
      ],
      "payAtReferenceNumber": "string",
      "agreedToTerms": true
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService_CreatePreview

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payment-plan/preview \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payment-plan/preview HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "amountDue": 0,
  "depositPerc": 0,
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "absorbsFee": true,
  "frequency": "WEEKLY",
  "offset": 0,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "flatFee": 0.1,
  "percFee": 0.1,
  "paymentPlanId": "string",
  "quantity": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan/preview',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payment-plan/preview', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payment-plan/preview',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payment-plan/preview", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payment-plan/preview

Body parameter

{
  "amountDue": 0,
  "depositPerc": 0,
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "absorbsFee": true,
  "frequency": "WEEKLY",
  "offset": 0,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "flatFee": 0.1,
  "percFee": 0.1,
  "paymentPlanId": "string",
  "quantity": 0
}

Parameters

Name	In	Type	Required	Description
body	body	modelPaymentPlanPreviewRequest	true	none

Example responses

200 Response

{
  "amountDue": 0,
  "merchant": "string",
  "merchantTermsLink": "string",
  "reference": "string",
  "orderName": "string",
  "depositDue": 0,
  "endDateMax": "string",
  "imageUrl": "string",
  "enablesSplit": true,
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "paymentPlans": [
    {
      "months": 0,
      "deposit": 0,
      "payments": [
        {
          "_id": "string",
          "paymentPlanId": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "userId": "string",
          "locked": true,
          "pending": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "note": "string",
          "reference": "string",
          "orderStatus": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "failed": true,
          "verifyError": "string",
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "paymentProvider": "string",
            "paymentMethod": "string"
          },
          "destinationId": "string",
          "destinationType": "string"
        }
      ],
      "quantity": 0,
      "orderState": "string"
    }
  ],
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "flatFee": 0.1,
  "percFee": 0.1,
  "validDays": [
    0
  ],
  "validDates": [
    0
  ],
  "amountDueExcludingFee": 0,
  "depositDueExcludingFee": 0,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "weeklyPayments": true,
  "orderState": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "orderToClone": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "initiatorId": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "monthlyPayments": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanPreviewResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService_GetPreview

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/payment-plan/preview/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/payment-plan/preview/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan/preview/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/payment-plan/preview/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/payment-plan/preview/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/payment-plan/preview/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/payment-plan/preview/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
frequency	query	string	false	none
offset	query	integer(int32)	false	none
paymentPlanId	query	string	false	none

Example responses

200 Response

{
  "amountDue": 0,
  "merchant": "string",
  "merchantTermsLink": "string",
  "reference": "string",
  "orderName": "string",
  "depositDue": 0,
  "endDateMax": "string",
  "imageUrl": "string",
  "enablesSplit": true,
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "paymentPlans": [
    {
      "months": 0,
      "deposit": 0,
      "payments": [
        {
          "_id": "string",
          "paymentPlanId": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "userId": "string",
          "locked": true,
          "pending": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "note": "string",
          "reference": "string",
          "orderStatus": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "failed": true,
          "verifyError": "string",
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "paymentProvider": "string",
            "paymentMethod": "string"
          },
          "destinationId": "string",
          "destinationType": "string"
        }
      ],
      "quantity": 0,
      "orderState": "string"
    }
  ],
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "flatFee": 0.1,
  "percFee": 0.1,
  "validDays": [
    0
  ],
  "validDates": [
    0
  ],
  "amountDueExcludingFee": 0,
  "depositDueExcludingFee": 0,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "weeklyPayments": true,
  "orderState": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "orderToClone": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "initiatorId": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "monthlyPayments": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanPreviewResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/payment-plan/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/payment-plan/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/payment-plan/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/payment-plan/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/payment-plan/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/payment-plan/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
populate	query	array[string]	false	none

Example responses

200 Response

{
  "_id": "string",
  "orderId": "string",
  "benefactorId": "string",
  "completed": true,
  "quantity": 0,
  "depositDue": 0,
  "amountDue": 0,
  "automaticBilling": true,
  "timestamp": 0.1,
  "payments": [
    {
      "_id": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "pending": true,
      "failed": true,
      "reconciliated": true,
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "_id": "string",
        "amount": 0,
        "paymentProviderPaymentId": "string",
        "paymentReference": "string",
        "paymentMethod": "string",
        "paymentProvider": "string",
        "paymentProviderResponses": {}
      },
      "verifiedAt": "string"
    }
  ],
  "benefactor": {
    "_id": "string",
    "name": "string",
    "email": "string"
  },
  "frequency": "WEEKLY",
  "offset": 0,
  "depositDueExcludingFee": 0,
  "amountDueExcludingFee": 0,
  "order": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "debicheckStatus": "string",
  "debicheckLastFailedReasons": [
    "string"
  ],
  "debicheckMandateActiveId": "string",
  "debicheckMandateIds": [
    "string"
  ],
  "payAtReferenceNumber": "string",
  "agreedToTerms": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService_Del

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/payment-plan/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/payment-plan/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan/{_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/payment-plan/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/payment-plan/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/payment-plan/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/payment-plan/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "orderId": "string",
  "benefactorId": "string",
  "completed": true,
  "quantity": 0,
  "depositDue": 0,
  "amountDue": 0,
  "automaticBilling": true,
  "payments": [
    {
      "_id": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "pending": true,
      "failed": true,
      "reconciliated": true,
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "_id": "string",
        "amount": 0,
        "paymentProviderPaymentId": "string",
        "paymentReference": "string",
        "paymentMethod": "string",
        "paymentProvider": "string",
        "paymentProviderResponses": {}
      },
      "verifiedAt": "string"
    }
  ],
  "active": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanDelResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService_Update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/payment-plan/{_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/payment-plan/{_id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "orderId": "string",
  "benefactorId": "string",
  "quantity": 0,
  "automaticBilling": true,
  "frequency": "string",
  "offset": 0,
  "token": "string",
  "agreedToTerms": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan/{_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/payment-plan/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/payment-plan/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/payment-plan/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/payment-plan/{_id}

Body parameter

{
  "orderId": "string",
  "benefactorId": "string",
  "quantity": 0,
  "automaticBilling": true,
  "frequency": "string",
  "offset": 0,
  "token": "string",
  "agreedToTerms": true
}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
body	body	modelPaymentPlanRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "orderId": "string",
  "benefactorId": "string",
  "completed": true,
  "quantity": 0,
  "depositDue": 0,
  "amountDue": 0,
  "automaticBilling": true,
  "timestamp": 0.1,
  "payments": [
    {
      "_id": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "pending": true,
      "failed": true,
      "reconciliated": true,
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "_id": "string",
        "amount": 0,
        "paymentProviderPaymentId": "string",
        "paymentReference": "string",
        "paymentMethod": "string",
        "paymentProvider": "string",
        "paymentProviderResponses": {}
      },
      "verifiedAt": "string"
    }
  ],
  "benefactor": {
    "_id": "string",
    "name": "string",
    "email": "string"
  },
  "frequency": "WEEKLY",
  "offset": 0,
  "depositDueExcludingFee": 0,
  "amountDueExcludingFee": 0,
  "order": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "debicheckStatus": "string",
  "debicheckLastFailedReasons": [
    "string"
  ],
  "debicheckMandateActiveId": "string",
  "debicheckMandateIds": [
    "string"
  ],
  "payAtReferenceNumber": "string",
  "agreedToTerms": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentPlanService_getByMsisdnAndToken

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/payment-plan/{token} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/payment-plan/{token} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payment-plan/{token}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/payment-plan/{token}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/payment-plan/{token}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/payment-plan/{token}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/payment-plan/{token}

Parameters

Name	In	Type	Required	Description
token	path	string	true	none
msisdn	query	string	false	none
populate	query	array[string]	false	none

Example responses

200 Response

{
  "_id": "string",
  "orderId": "string",
  "benefactorId": "string",
  "completed": true,
  "quantity": 0,
  "depositDue": 0,
  "amountDue": 0,
  "automaticBilling": true,
  "timestamp": 0.1,
  "payments": [
    {
      "_id": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "pending": true,
      "failed": true,
      "reconciliated": true,
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "_id": "string",
        "amount": 0,
        "paymentProviderPaymentId": "string",
        "paymentReference": "string",
        "paymentMethod": "string",
        "paymentProvider": "string",
        "paymentProviderResponses": {}
      },
      "verifiedAt": "string"
    }
  ],
  "benefactor": {
    "_id": "string",
    "name": "string",
    "email": "string"
  },
  "frequency": "WEEKLY",
  "offset": 0,
  "depositDueExcludingFee": 0,
  "amountDueExcludingFee": 0,
  "order": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "debicheckStatus": "string",
  "debicheckLastFailedReasons": [
    "string"
  ],
  "debicheckMandateActiveId": "string",
  "debicheckMandateIds": [
    "string"
  ],
  "payAtReferenceNumber": "string",
  "agreedToTerms": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentPlanResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService

PaymentService_refund

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/generate-refund \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/generate-refund HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/generate-refund',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/generate-refund', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/generate-refund',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/generate-refund", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/generate-refund

Parameters

Name	In	Type	Required	Description
body.amount	query	integer(int32)	false	none
body.refundReference	query	string	false	none
body.paymentId	query	string	false	none
body.excludeFees	query	boolean	false	none
body.refundMethod	query	string	false	none
body.autoRefund	query	boolean	false	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_manualRefund

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/manual-refund \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/manual-refund HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/manual-refund',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/manual-refund', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/manual-refund',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/manual-refund", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/manual-refund

Parameters

Name	In	Type	Required	Description
body.amount	query	integer(int32)	false	none
body.refundReference	query	string	false	none
body.paymentId	query	string	false	none
body.excludeFees	query	boolean	false	none
body.refundMethod	query	string	false	none
body.autoRefund	query	boolean	false	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_CreateOffline

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/offline-payments \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/offline-payments HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "amount": 13333,
  "note": "Processed by employeeX",
  "paymentPlanId": "123f7f1496bd78001d6852f3",
  "reference": "Cash in hand",
  "verifiedAt": "2022-01-27T14:00:00.000Z"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/offline-payments',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/offline-payments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/offline-payments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/offline-payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/offline-payments

Body parameter

{
  "amount": 13333,
  "note": "Processed by employeeX",
  "paymentPlanId": "123f7f1496bd78001d6852f3",
  "reference": "Cash in hand",
  "verifiedAt": "2022-01-27T14:00:00.000Z"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelOfflinePaymentRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_DeleteOffline

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/offline-payments/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/offline-payments/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/offline-payments/{_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/offline-payments/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/offline-payments/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/offline-payments/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/offline-payments/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_GetMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/payments \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/payments HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payments',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/payments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/payments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/payments

Parameters

Name	In	Type	Required	Description
skip	query	integer(int32)	false	none
limit	query	integer(int32)	false	none
paid	query	boolean	false	none
orderId	query	string	false	none
paymentPlanId	query	string	false	none
userId	query	string	false	none
fromDate	query	string(date)	false	none
toDate	query	string(date)	false	none
method	query	string	false	none
type	query	string	false	none
search	query	string	false	none
fromDatePayments	query	string	false	none
toDatePayments	query	string	false	none
settled	query	string	false	none
sort	query	array[string]	false	none
failed	query	boolean	false	none
provider	query	string	false	none
destinationId	query	string	false	none
destinationType	query	string	false	none

Example responses

200 Response

{
  "payments": [
    {
      "_id": "string",
      "paymentPlanId": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "userId": "string",
      "locked": true,
      "pending": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "note": "string",
      "reference": "string",
      "orderStatus": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "failed": true,
      "verifyError": "string",
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "paymentProvider": "string",
        "paymentMethod": "string"
      },
      "destinationId": "string",
      "destinationType": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_Delete

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/payments \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/payments HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payments',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/payments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/payments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/payments

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payments \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payments HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "paymentPlanId": "string",
  "amount": 0,
  "notifyUrl": "string",
  "useSavedCard": true,
  "eft": true,
  "checkout": true,
  "save": true,
  "suspenseId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "paid": true,
  "failed": true,
  "payAt": true,
  "paymentMethod": "string",
  "paymentProviderSettlementId": "string",
  "destinationType": "string",
  "destinationId": "string",
  "isEmbeddedCheckout": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payments',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payments

Body parameter

{
  "paymentPlanId": "string",
  "amount": 0,
  "notifyUrl": "string",
  "useSavedCard": true,
  "eft": true,
  "checkout": true,
  "save": true,
  "suspenseId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "paid": true,
  "failed": true,
  "payAt": true,
  "paymentMethod": "string",
  "paymentProviderSettlementId": "string",
  "destinationType": "string",
  "destinationId": "string",
  "isEmbeddedCheckout": true
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
secret	query	string	false	none
body	body	modelPaymentRequest	true	none

Example responses

200 Response

{
  "url": "string",
  "parameters": [
    {
      "name": "string",
      "value": "string"
    }
  ],
  "method": "string",
  "_id": "string",
  "checkoutId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentRedirectResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/payments/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/payments/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payments/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/payments/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/payments/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/payments/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/payments/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
verify	query	string	false	none
force	query	string	false	none
msisdn	query	string	false	none
token	query	string	false	none
isEmbeddedCheckout	query	boolean	false	none
registrationId	query	string	false	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_UpdateById

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/payments/{_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/payments/{_id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "paymentPlanId": "string",
  "amount": 0,
  "notifyUrl": "string",
  "useSavedCard": true,
  "eft": true,
  "checkout": true,
  "save": true,
  "suspenseId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "paid": true,
  "failed": true,
  "payAt": true,
  "paymentMethod": "string",
  "paymentProviderSettlementId": "string",
  "destinationType": "string",
  "destinationId": "string",
  "isEmbeddedCheckout": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payments/{_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/payments/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/payments/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/payments/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/payments/{_id}

Body parameter

{
  "paymentPlanId": "string",
  "amount": 0,
  "notifyUrl": "string",
  "useSavedCard": true,
  "eft": true,
  "checkout": true,
  "save": true,
  "suspenseId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "paid": true,
  "failed": true,
  "payAt": true,
  "paymentMethod": "string",
  "paymentProviderSettlementId": "string",
  "destinationType": "string",
  "destinationId": "string",
  "isEmbeddedCheckout": true
}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
secret	query	string	false	none
body	body	modelPaymentRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_realtimeRefund

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/realtime-refund \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/realtime-refund HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/realtime-refund',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/realtime-refund', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/realtime-refund',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/realtime-refund", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/realtime-refund

Parameters

Name	In	Type	Required	Description
body.amount	query	integer(int32)	false	none
body.refundReference	query	string	false	none
body.paymentId	query	string	false	none
body.excludeFees	query	boolean	false	none
body.refundMethod	query	string	false	none
body.autoRefund	query	boolean	false	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_RefundPaymentMailer

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/refund-payments/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/refund-payments/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/refund-payments/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/refund-payments/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/refund-payments/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/refund-payments/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/refund-payments/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_TransferPayment

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/transfer-payments \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/transfer-payments HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "_id": "string",
  "_destinationPaymentPlanId": "string",
  "amount": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/transfer-payments',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/transfer-payments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/transfer-payments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/transfer-payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/transfer-payments

Body parameter

{
  "_id": "string",
  "_destinationPaymentPlanId": "string",
  "amount": 0
}

Parameters

Name	In	Type	Required	Description
body	body	modelTransferPaymentRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentService_UndoTransfer

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/undo-transfer-payments \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/undo-transfer-payments HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "_id": "string",
  "_destinationPaymentPlanId": "string",
  "amount": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/undo-transfer-payments',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/undo-transfer-payments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/undo-transfer-payments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/undo-transfer-payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/undo-transfer-payments

Body parameter

{
  "_id": "string",
  "_destinationPaymentPlanId": "string",
  "amount": 0
}

Parameters

Name	In	Type	Required	Description
body	body	modelTransferPaymentRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentServiceV2

PaymentServiceV2_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v2/payments \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v2/payments HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "destinationId": "string",
  "amount": 0,
  "redirectUrl": "string",
  "paymentMethod": "string",
  "paymentProvider": "string",
  "destinationType": "string",
  "connectorData": {
    "bankTransactionId": "string"
  },
  "save": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v2/payments',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v2/payments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v2/payments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v2/payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v2/payments

Body parameter

{
  "destinationId": "string",
  "amount": 0,
  "redirectUrl": "string",
  "paymentMethod": "string",
  "paymentProvider": "string",
  "destinationType": "string",
  "connectorData": {
    "bankTransactionId": "string"
  },
  "save": true
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelPaymentRequestV2	true	none

Example responses

200 Response

{
  "url": "string",
  "parameters": [
    {
      "name": "string",
      "value": "string"
    }
  ],
  "method": "string",
  "_id": "string",
  "checkoutId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentRedirectResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentServiceV2_GetReport

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v2/payments-report \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v2/payments-report HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v2/payments-report',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v2/payments-report', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v2/payments-report',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v2/payments-report", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v2/payments-report

Parameters

Name	In	Type	Required	Description
merchantId	query	string	false	none
skip	query	integer(int32)	false	none
limit	query	integer(int32)	false	none
paid	query	boolean	false	none
orderId	query	string	false	none
paymentPlanId	query	string	false	none
userId	query	string	false	none
fromDate	query	string	false	none
toDate	query	string	false	none
method	query	string	false	none
type	query	string	false	none
search	query	string	false	none
fromDatePayments	query	string	false	none
toDatePayments	query	string	false	none
settled	query	string	false	none
sort	query	array[string]	false	none
failed	query	boolean	false	none
provider	query	string	false	none
destinationId	query	string	false	none
destinationType	query	string	false	none

Example responses

200 Response

{
  "payments": [
    {
      "id": "string",
      "amount": 0.1,
      "client": "string",
      "createdAt": "string",
      "datePaid": "string",
      "due": "string",
      "fee": 0.1,
      "fees": [
        {
          "id": "string",
          "productName": "string",
          "amountExcludingVAT": 0.1,
          "amountVAT": 0.1,
          "amountTotal": 0.1,
          "merchantId": "string",
          "createdAt": "string",
          "updatedAt": "string",
          "settlementId": "string",
          "paymentId": "string"
        }
      ],
      "feesPerProduct": [
        {
          "quantity": 0.1,
          "amountTotal": 0.1,
          "amountExcludingVAT": 0.1,
          "amountVAT": 0.1,
          "product": {
            "_id": "string",
            "name": "string",
            "displayName": "string",
            "feeType": "string",
            "method": "string",
            "billingType": "string"
          }
        }
      ],
      "locked": true,
      "orderName": "string",
      "orderReference": "string",
      "paymentMethod": "string",
      "paymentStatus": "string",
      "paymentType": "string",
      "settlementBatch": "string",
      "state": "string",
      "updatedAt": "string",
      "verifiedAt": "string",
      "dateSettled": "string"
    }
  ],
  "export": [
    {
      "client": "string",
      "amount": 0.1,
      "createdAt": "string",
      "verifiedAt": "string",
      "due": "string",
      "fee": 0.1,
      "orderName": "string",
      "orderReference": "string",
      "paymentStatus": "string",
      "paymentType": "string",
      "settlementBatch": "string",
      "state": "string",
      "updatedAt": "string",
      "datePaid": "string",
      "dateSettled": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentReportResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

JournalService

JournalService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/journals \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/journals HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "orderId": "string",
  "participantId": "string",
  "note": "string",
  "amount": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/journals',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/journals', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/journals',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/journals", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/journals

Body parameter

{
  "orderId": "string",
  "participantId": "string",
  "note": "string",
  "amount": 0
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelJournalRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "orderId": "string",
  "participantId": "string",
  "note": "string",
  "amount": 0,
  "amountExcludingFee": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelJournalResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

JournalFeeService

JournalFeeService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/journal-fees \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/journal-fees HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "_id": "string",
  "productName": "string",
  "amountTotal": 0.1,
  "amountExcludingVAT": 0.1,
  "amountVAT": 0.1,
  "orderId": "string",
  "paymentPlanId": "string",
  "paymentId": "string",
  "merchantId": "string",
  "settled": true,
  "reconciled": true,
  "settlementId": "string",
  "invoiceId": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/journal-fees',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/journal-fees', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/journal-fees',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/journal-fees", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/journal-fees

Body parameter

{
  "_id": "string",
  "productName": "string",
  "amountTotal": 0.1,
  "amountExcludingVAT": 0.1,
  "amountVAT": 0.1,
  "orderId": "string",
  "paymentPlanId": "string",
  "paymentId": "string",
  "merchantId": "string",
  "settled": true,
  "reconciled": true,
  "settlementId": "string",
  "invoiceId": "string"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelJournalFeeResponse	true	none

Example responses

200 Response

{
  "_id": "string",
  "productName": "string",
  "amountTotal": 0.1,
  "amountExcludingVAT": 0.1,
  "amountVAT": 0.1,
  "orderId": "string",
  "paymentPlanId": "string",
  "paymentId": "string",
  "merchantId": "string",
  "settled": true,
  "reconciled": true,
  "settlementId": "string",
  "invoiceId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelJournalFeeResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService

OrderService_GetMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/orders \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/orders HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/orders', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/orders',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/orders", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/orders

Parameters

Name	In	Type	Required	Description
populate	query	array[string]	false	none
limit	query	integer(int32)	false	none
skip	query	integer(int32)	false	none
userId	query	string	false	none
state	query	string	false	See the Enumerated Values below
from	query	string(date)	false	none
to	query	string(date)	false	none
select	query	string	false	none
populateObject.path	query	string	false	none
populateObject.select	query	string	false	none
populateObject.populate.path	query	string	false	none
populateObject.populate.select	query	string	false	none
search	query	string	false	none
reference	query	string	false	none
sort	query	string	false	none
stateUpdatedAt	query	string	false	none
cloneOriginalId	query	string	false	none
groupPaymentPlan	query	string	false	none

Enumerated Values

Parameter	Value
state	PARTIAL
state	EXPIRED
state	PLACED
state	COMPLETED
state	SUSPENDED
state	CANCELLING
state	CANCELLED

Example responses

200 Response

{
  "orders": [
    {
      "_id": "string",
      "endDateMax": "2019-08-24T14:15:22Z",
      "endDateMin": "2019-08-24T14:15:22Z",
      "initiatorId": "string",
      "products": [
        {
          "_id": "string",
          "amount": 0,
          "link": "http://example.com",
          "sku": "string",
          "name": "string",
          "depositType": "string"
        }
      ],
      "state": "PARTIAL",
      "supplierId": "string",
      "cancelledBy": "string",
      "amountDue": 0,
      "flatFee": 0,
      "percFee": 0.1,
      "depositPerc": 0.1,
      "absorbsFee": true,
      "reference": "string",
      "name": "string",
      "imageUrl": "string",
      "plans": [
        {
          "_id": "string",
          "orderId": "string",
          "benefactorId": "string",
          "completed": true,
          "quantity": 0,
          "depositDue": 0,
          "amountDue": 0,
          "automaticBilling": true,
          "timestamp": 0.1,
          "payments": [
            {
              "_id": "string",
              "due": "string",
              "amount": 0,
              "paid": true,
              "timestamp": 0.1,
              "paymentMethod": "string",
              "paymentType": "string",
              "amountExcludingFee": 0,
              "fee": 0,
              "pending": true,
              "failed": true,
              "reconciliated": true,
              "refundedAmount": 0,
              "refundPaymentId": "string",
              "connectorData": {
                "_id": "string",
                "amount": 0,
                "paymentProviderPaymentId": "string",
                "paymentReference": "string",
                "paymentMethod": "string",
                "paymentProvider": "string",
                "paymentProviderResponses": {}
              },
              "verifiedAt": "string"
            }
          ],
          "benefactor": {
            "_id": "string",
            "name": "string",
            "email": "string"
          },
          "frequency": "WEEKLY",
          "offset": 0,
          "depositDueExcludingFee": 0,
          "amountDueExcludingFee": 0,
          "order": {},
          "debicheckStatus": "string",
          "debicheckLastFailedReasons": [
            "string"
          ],
          "debicheckMandateActiveId": "string",
          "debicheckMandateIds": [
            "string"
          ],
          "payAtReferenceNumber": "string",
          "agreedToTerms": true
        }
      ],
      "createdAt": "string",
      "timestamp": 0.1,
      "enablesSplit": true,
      "depositAmount": 0,
      "depositType": "INSTALMENT",
      "expire": "string",
      "cancellationTerms": {
        "active": true,
        "definition": [
          {
            "type": {
              "name": "string",
              "definition": {
                "missed": 0,
                "percentage": 0
              },
              "finalPaymentMissed": true
            },
            "policy": {
              "name": "Deposit",
              "definition": {
                "deposit": true,
                "percentage": 0,
                "flatFee": 0,
                "percentageShouldUseTotalPaid": true
              }
            },
            "start": 0,
            "end": 0,
            "gracePeriod": 0
          }
        ]
      },
      "weeklyPayments": true,
      "paymentMethods": {
        "creditOrDebitCard": true,
        "eft": true,
        "debiCheck": true,
        "payAt": true,
        "capitecPay": true,
        "dashpay": true,
        "terminalCard": true,
        "offline": true,
        "embeddedCheckout": true
      },
      "stateUpdatedAt": "string",
      "updatedAt": "string",
      "groupPaymentPlan": {
        "enabled": true,
        "cloneLimit": 0,
        "expiry": 0
      },
      "cloneExpiry": 0,
      "cloneCount": 0,
      "orderCancellationRequest": "string",
      "notifications": [
        {
          "change": "string",
          "date": "string",
          "name": "string",
          "reason": "string",
          "details": "string",
          "read": true,
          "userId": "string",
          "type": "string",
          "hide": true,
          "unread": true
        }
      ],
      "acceptedProposedCancellationTerms": true,
      "customFeatures": {
        "logo": {
          "enabled": true,
          "value": "string"
        },
        "imageUrl": {
          "enabled": true,
          "value": "string"
        },
        "paymentWidget": {
          "enabled": true,
          "value": "string"
        }
      },
      "merchantName": "string",
      "merchantTermsLink": "string",
      "merchantLink": "string",
      "debiCheckMinimum": {
        "enabled": true,
        "value": 0
      },
      "supplier": {
        "_id": "string",
        "name": "string",
        "merchantId": "string"
      },
      "orderRefundRequest": "string",
      "orderRefundAmount": 0,
      "orderRefundFee": 0,
      "monthlyPayments": true,
      "type": "string",
      "balance": 0,
      "description": "string",
      "isIncreasedDepositAmountAllowed": true,
      "suspendOnCancel": true,
      "voucherSettings": {
        "active": true,
        "minimumSavingGoalInCents": 0,
        "maximumSavingGoalInCents": 0,
        "rewardType": "string",
        "rewardFlatAmountInCents": 0,
        "rewardPercentage": 0,
        "voucherProvider": "string"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/orders \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/orders HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "products": "ProductCreateRequest",
  "endDateMax": "2019-08-24T14:15:22Z",
  "depositPerc": 5,
  "reference": "string",
  "name": "string",
  "depositType": "INSTALMENT"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/orders', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/orders',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/orders", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/orders

Body parameter

{
  "products": "ProductCreateRequest",
  "endDateMax": "2019-08-24T14:15:22Z",
  "depositPerc": 5,
  "reference": "string",
  "name": "string",
  "depositType": "INSTALMENT"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
clone	query	string	false	none
body	body	modelOrderRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "initiatorId": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "state": "PARTIAL",
  "supplierId": "string",
  "cancelledBy": "string",
  "amountDue": 0,
  "flatFee": 0,
  "percFee": 0.1,
  "depositPerc": 0.1,
  "absorbsFee": true,
  "reference": "string",
  "name": "string",
  "imageUrl": "string",
  "plans": [
    {
      "_id": "string",
      "orderId": "string",
      "benefactorId": "string",
      "completed": true,
      "quantity": 0,
      "depositDue": 0,
      "amountDue": 0,
      "automaticBilling": true,
      "timestamp": 0.1,
      "payments": [
        {
          "_id": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "pending": true,
          "failed": true,
          "reconciliated": true,
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "_id": "string",
            "amount": 0,
            "paymentProviderPaymentId": "string",
            "paymentReference": "string",
            "paymentMethod": "string",
            "paymentProvider": "string",
            "paymentProviderResponses": {}
          },
          "verifiedAt": "string"
        }
      ],
      "benefactor": {
        "_id": "string",
        "name": "string",
        "email": "string"
      },
      "frequency": "WEEKLY",
      "offset": 0,
      "depositDueExcludingFee": 0,
      "amountDueExcludingFee": 0,
      "order": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "debicheckStatus": "string",
      "debicheckLastFailedReasons": [
        "string"
      ],
      "debicheckMandateActiveId": "string",
      "debicheckMandateIds": [
        "string"
      ],
      "payAtReferenceNumber": "string",
      "agreedToTerms": true
    }
  ],
  "createdAt": "string",
  "timestamp": 0.1,
  "enablesSplit": true,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "expire": "string",
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "stateUpdatedAt": "string",
  "updatedAt": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "cloneExpiry": 0,
  "cloneCount": 0,
  "orderCancellationRequest": "string",
  "notifications": [
    {
      "change": "string",
      "date": "string",
      "name": "string",
      "reason": "string",
      "details": "string",
      "read": true,
      "userId": "string",
      "type": "string",
      "hide": true,
      "unread": true
    }
  ],
  "acceptedProposedCancellationTerms": true,
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "merchantName": "string",
  "merchantTermsLink": "string",
  "merchantLink": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "supplier": {
    "_id": "string",
    "name": "string",
    "merchantId": "string"
  },
  "orderRefundRequest": "string",
  "orderRefundAmount": 0,
  "orderRefundFee": 0,
  "monthlyPayments": true,
  "type": "string",
  "balance": 0,
  "description": "string",
  "isIncreasedDepositAmountAllowed": true,
  "suspendOnCancel": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProvider": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_SendOrderRequest

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/orders-send-request \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/orders-send-request HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "amount": 10000,
  "paymentMethod": "CARD",
  "type": "sms",
  "orderId": "123f7f1496bd78001d6852f3",
  "customerId": "123f7f1496bd78001d6852f3",
  "message": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders-send-request',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/orders-send-request', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/orders-send-request',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/orders-send-request", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/orders-send-request

Body parameter

{
  "amount": 10000,
  "paymentMethod": "CARD",
  "type": "sms",
  "orderId": "123f7f1496bd78001d6852f3",
  "customerId": "123f7f1496bd78001d6852f3",
  "message": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelOrderSendRequest	true	none

Example responses

200 Response

{
  "success": true,
  "orderUrl": "https://sandbox.layup.co.za/order/123f7f1496bd78001d6852f3?paymentMethod=CARD&amount=10000"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderSendRequestResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_Attach

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/orders/attach/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/orders/attach/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders/attach/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/orders/attach/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/orders/attach/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/orders/attach/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/orders/attach/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "initiatorId": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "state": "PARTIAL",
  "supplierId": "string",
  "cancelledBy": "string",
  "amountDue": 0,
  "flatFee": 0,
  "percFee": 0.1,
  "depositPerc": 0.1,
  "absorbsFee": true,
  "reference": "string",
  "name": "string",
  "imageUrl": "string",
  "plans": [
    {
      "_id": "string",
      "orderId": "string",
      "benefactorId": "string",
      "completed": true,
      "quantity": 0,
      "depositDue": 0,
      "amountDue": 0,
      "automaticBilling": true,
      "timestamp": 0.1,
      "payments": [
        {
          "_id": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "pending": true,
          "failed": true,
          "reconciliated": true,
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "_id": "string",
            "amount": 0,
            "paymentProviderPaymentId": "string",
            "paymentReference": "string",
            "paymentMethod": "string",
            "paymentProvider": "string",
            "paymentProviderResponses": {}
          },
          "verifiedAt": "string"
        }
      ],
      "benefactor": {
        "_id": "string",
        "name": "string",
        "email": "string"
      },
      "frequency": "WEEKLY",
      "offset": 0,
      "depositDueExcludingFee": 0,
      "amountDueExcludingFee": 0,
      "order": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "debicheckStatus": "string",
      "debicheckLastFailedReasons": [
        "string"
      ],
      "debicheckMandateActiveId": "string",
      "debicheckMandateIds": [
        "string"
      ],
      "payAtReferenceNumber": "string",
      "agreedToTerms": true
    }
  ],
  "createdAt": "string",
  "timestamp": 0.1,
  "enablesSplit": true,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "expire": "string",
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "stateUpdatedAt": "string",
  "updatedAt": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "cloneExpiry": 0,
  "cloneCount": 0,
  "orderCancellationRequest": "string",
  "notifications": [
    {
      "change": "string",
      "date": "string",
      "name": "string",
      "reason": "string",
      "details": "string",
      "read": true,
      "userId": "string",
      "type": "string",
      "hide": true,
      "unread": true
    }
  ],
  "acceptedProposedCancellationTerms": true,
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "merchantName": "string",
  "merchantTermsLink": "string",
  "merchantLink": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "supplier": {
    "_id": "string",
    "name": "string",
    "merchantId": "string"
  },
  "orderRefundRequest": "string",
  "orderRefundAmount": 0,
  "orderRefundFee": 0,
  "monthlyPayments": true,
  "type": "string",
  "balance": 0,
  "description": "string",
  "isIncreasedDepositAmountAllowed": true,
  "suspendOnCancel": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProvider": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_GetByReferenceAndCellNumber

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/orders/reference/{reference}/cellNumber/{cellNumber} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/orders/reference/{reference}/cellNumber/{cellNumber} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders/reference/{reference}/cellNumber/{cellNumber}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/orders/reference/{reference}/cellNumber/{cellNumber}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/orders/reference/{reference}/cellNumber/{cellNumber}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/orders/reference/{reference}/cellNumber/{cellNumber}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/orders/reference/{reference}/cellNumber/{cellNumber}

Parameters

Name	In	Type	Required	Description
reference	path	string	true	none
cellNumber	path	string	true	none

Example responses

200 Response

{
  "orders": [
    {
      "_id": "string",
      "endDateMax": "2019-08-24T14:15:22Z",
      "endDateMin": "2019-08-24T14:15:22Z",
      "initiatorId": "string",
      "products": [
        {
          "_id": "string",
          "amount": 0,
          "link": "http://example.com",
          "sku": "string",
          "name": "string",
          "depositType": "string"
        }
      ],
      "state": "PARTIAL",
      "supplierId": "string",
      "cancelledBy": "string",
      "amountDue": 0,
      "flatFee": 0,
      "percFee": 0.1,
      "depositPerc": 0.1,
      "absorbsFee": true,
      "reference": "string",
      "name": "string",
      "imageUrl": "string",
      "plans": [
        {
          "_id": "string",
          "orderId": "string",
          "benefactorId": "string",
          "completed": true,
          "quantity": 0,
          "depositDue": 0,
          "amountDue": 0,
          "automaticBilling": true,
          "timestamp": 0.1,
          "payments": [
            {
              "_id": "string",
              "due": "string",
              "amount": 0,
              "paid": true,
              "timestamp": 0.1,
              "paymentMethod": "string",
              "paymentType": "string",
              "amountExcludingFee": 0,
              "fee": 0,
              "pending": true,
              "failed": true,
              "reconciliated": true,
              "refundedAmount": 0,
              "refundPaymentId": "string",
              "connectorData": {
                "_id": "string",
                "amount": 0,
                "paymentProviderPaymentId": "string",
                "paymentReference": "string",
                "paymentMethod": "string",
                "paymentProvider": "string",
                "paymentProviderResponses": {}
              },
              "verifiedAt": "string"
            }
          ],
          "benefactor": {
            "_id": "string",
            "name": "string",
            "email": "string"
          },
          "frequency": "WEEKLY",
          "offset": 0,
          "depositDueExcludingFee": 0,
          "amountDueExcludingFee": 0,
          "order": {},
          "debicheckStatus": "string",
          "debicheckLastFailedReasons": [
            "string"
          ],
          "debicheckMandateActiveId": "string",
          "debicheckMandateIds": [
            "string"
          ],
          "payAtReferenceNumber": "string",
          "agreedToTerms": true
        }
      ],
      "createdAt": "string",
      "timestamp": 0.1,
      "enablesSplit": true,
      "depositAmount": 0,
      "depositType": "INSTALMENT",
      "expire": "string",
      "cancellationTerms": {
        "active": true,
        "definition": [
          {
            "type": {
              "name": "string",
              "definition": {
                "missed": 0,
                "percentage": 0
              },
              "finalPaymentMissed": true
            },
            "policy": {
              "name": "Deposit",
              "definition": {
                "deposit": true,
                "percentage": 0,
                "flatFee": 0,
                "percentageShouldUseTotalPaid": true
              }
            },
            "start": 0,
            "end": 0,
            "gracePeriod": 0
          }
        ]
      },
      "weeklyPayments": true,
      "paymentMethods": {
        "creditOrDebitCard": true,
        "eft": true,
        "debiCheck": true,
        "payAt": true,
        "capitecPay": true,
        "dashpay": true,
        "terminalCard": true,
        "offline": true,
        "embeddedCheckout": true
      },
      "stateUpdatedAt": "string",
      "updatedAt": "string",
      "groupPaymentPlan": {
        "enabled": true,
        "cloneLimit": 0,
        "expiry": 0
      },
      "cloneExpiry": 0,
      "cloneCount": 0,
      "orderCancellationRequest": "string",
      "notifications": [
        {
          "change": "string",
          "date": "string",
          "name": "string",
          "reason": "string",
          "details": "string",
          "read": true,
          "userId": "string",
          "type": "string",
          "hide": true,
          "unread": true
        }
      ],
      "acceptedProposedCancellationTerms": true,
      "customFeatures": {
        "logo": {
          "enabled": true,
          "value": "string"
        },
        "imageUrl": {
          "enabled": true,
          "value": "string"
        },
        "paymentWidget": {
          "enabled": true,
          "value": "string"
        }
      },
      "merchantName": "string",
      "merchantTermsLink": "string",
      "merchantLink": "string",
      "debiCheckMinimum": {
        "enabled": true,
        "value": 0
      },
      "supplier": {
        "_id": "string",
        "name": "string",
        "merchantId": "string"
      },
      "orderRefundRequest": "string",
      "orderRefundAmount": 0,
      "orderRefundFee": 0,
      "monthlyPayments": true,
      "type": "string",
      "balance": 0,
      "description": "string",
      "isIncreasedDepositAmountAllowed": true,
      "suspendOnCancel": true,
      "voucherSettings": {
        "active": true,
        "minimumSavingGoalInCents": 0,
        "maximumSavingGoalInCents": 0,
        "rewardType": "string",
        "rewardFlatAmountInCents": 0,
        "rewardPercentage": 0,
        "voucherProvider": "string"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/orders/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/orders/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/orders/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/orders/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/orders/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/orders/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
populate	query	array[string]	false	none

Example responses

200 Response

{
  "_id": "string",
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "initiatorId": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "state": "PARTIAL",
  "supplierId": "string",
  "cancelledBy": "string",
  "amountDue": 0,
  "flatFee": 0,
  "percFee": 0.1,
  "depositPerc": 0.1,
  "absorbsFee": true,
  "reference": "string",
  "name": "string",
  "imageUrl": "string",
  "plans": [
    {
      "_id": "string",
      "orderId": "string",
      "benefactorId": "string",
      "completed": true,
      "quantity": 0,
      "depositDue": 0,
      "amountDue": 0,
      "automaticBilling": true,
      "timestamp": 0.1,
      "payments": [
        {
          "_id": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "pending": true,
          "failed": true,
          "reconciliated": true,
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "_id": "string",
            "amount": 0,
            "paymentProviderPaymentId": "string",
            "paymentReference": "string",
            "paymentMethod": "string",
            "paymentProvider": "string",
            "paymentProviderResponses": {}
          },
          "verifiedAt": "string"
        }
      ],
      "benefactor": {
        "_id": "string",
        "name": "string",
        "email": "string"
      },
      "frequency": "WEEKLY",
      "offset": 0,
      "depositDueExcludingFee": 0,
      "amountDueExcludingFee": 0,
      "order": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "debicheckStatus": "string",
      "debicheckLastFailedReasons": [
        "string"
      ],
      "debicheckMandateActiveId": "string",
      "debicheckMandateIds": [
        "string"
      ],
      "payAtReferenceNumber": "string",
      "agreedToTerms": true
    }
  ],
  "createdAt": "string",
  "timestamp": 0.1,
  "enablesSplit": true,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "expire": "string",
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "stateUpdatedAt": "string",
  "updatedAt": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "cloneExpiry": 0,
  "cloneCount": 0,
  "orderCancellationRequest": "string",
  "notifications": [
    {
      "change": "string",
      "date": "string",
      "name": "string",
      "reason": "string",
      "details": "string",
      "read": true,
      "userId": "string",
      "type": "string",
      "hide": true,
      "unread": true
    }
  ],
  "acceptedProposedCancellationTerms": true,
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "merchantName": "string",
  "merchantTermsLink": "string",
  "merchantLink": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "supplier": {
    "_id": "string",
    "name": "string",
    "merchantId": "string"
  },
  "orderRefundRequest": "string",
  "orderRefundAmount": 0,
  "orderRefundFee": 0,
  "monthlyPayments": true,
  "type": "string",
  "balance": 0,
  "description": "string",
  "isIncreasedDepositAmountAllowed": true,
  "suspendOnCancel": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProvider": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_Del

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/orders/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/orders/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders/{_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/orders/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/orders/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/orders/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/orders/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "initiatorId": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "state": "PARTIAL",
  "supplierId": "string",
  "cancelledBy": "string",
  "amountDue": 0,
  "flatFee": 0,
  "percFee": 0.1,
  "depositPerc": 0.1,
  "absorbsFee": true,
  "reference": "string",
  "name": "string",
  "imageUrl": "string",
  "plans": [
    {
      "_id": "string",
      "orderId": "string",
      "benefactorId": "string",
      "completed": true,
      "quantity": 0,
      "depositDue": 0,
      "amountDue": 0,
      "automaticBilling": true,
      "timestamp": 0.1,
      "payments": [
        {
          "_id": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "pending": true,
          "failed": true,
          "reconciliated": true,
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "_id": "string",
            "amount": 0,
            "paymentProviderPaymentId": "string",
            "paymentReference": "string",
            "paymentMethod": "string",
            "paymentProvider": "string",
            "paymentProviderResponses": {}
          },
          "verifiedAt": "string"
        }
      ],
      "benefactor": {
        "_id": "string",
        "name": "string",
        "email": "string"
      },
      "frequency": "WEEKLY",
      "offset": 0,
      "depositDueExcludingFee": 0,
      "amountDueExcludingFee": 0,
      "order": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "debicheckStatus": "string",
      "debicheckLastFailedReasons": [
        "string"
      ],
      "debicheckMandateActiveId": "string",
      "debicheckMandateIds": [
        "string"
      ],
      "payAtReferenceNumber": "string",
      "agreedToTerms": true
    }
  ],
  "createdAt": "string",
  "timestamp": 0.1,
  "enablesSplit": true,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "expire": "string",
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "stateUpdatedAt": "string",
  "updatedAt": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "cloneExpiry": 0,
  "cloneCount": 0,
  "orderCancellationRequest": "string",
  "notifications": [
    {
      "change": "string",
      "date": "string",
      "name": "string",
      "reason": "string",
      "details": "string",
      "read": true,
      "userId": "string",
      "type": "string",
      "hide": true,
      "unread": true
    }
  ],
  "acceptedProposedCancellationTerms": true,
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "merchantName": "string",
  "merchantTermsLink": "string",
  "merchantLink": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "supplier": {
    "_id": "string",
    "name": "string",
    "merchantId": "string"
  },
  "orderRefundRequest": "string",
  "orderRefundAmount": 0,
  "orderRefundFee": 0,
  "monthlyPayments": true,
  "type": "string",
  "balance": 0,
  "description": "string",
  "isIncreasedDepositAmountAllowed": true,
  "suspendOnCancel": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProvider": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_Update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/orders/{_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/orders/{_id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "state": "PLACED"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders/{_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/orders/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/orders/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/orders/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/orders/{_id}

Body parameter

{
  "state": "PLACED"
}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
collectMissed	query	string	false	now, next or ISO 8601 Date
body	body	modelOrderUpdateRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "initiatorId": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "state": "PARTIAL",
  "supplierId": "string",
  "cancelledBy": "string",
  "amountDue": 0,
  "flatFee": 0,
  "percFee": 0.1,
  "depositPerc": 0.1,
  "absorbsFee": true,
  "reference": "string",
  "name": "string",
  "imageUrl": "string",
  "plans": [
    {
      "_id": "string",
      "orderId": "string",
      "benefactorId": "string",
      "completed": true,
      "quantity": 0,
      "depositDue": 0,
      "amountDue": 0,
      "automaticBilling": true,
      "timestamp": 0.1,
      "payments": [
        {
          "_id": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "pending": true,
          "failed": true,
          "reconciliated": true,
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "_id": "string",
            "amount": 0,
            "paymentProviderPaymentId": "string",
            "paymentReference": "string",
            "paymentMethod": "string",
            "paymentProvider": "string",
            "paymentProviderResponses": {}
          },
          "verifiedAt": "string"
        }
      ],
      "benefactor": {
        "_id": "string",
        "name": "string",
        "email": "string"
      },
      "frequency": "WEEKLY",
      "offset": 0,
      "depositDueExcludingFee": 0,
      "amountDueExcludingFee": 0,
      "order": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "debicheckStatus": "string",
      "debicheckLastFailedReasons": [
        "string"
      ],
      "debicheckMandateActiveId": "string",
      "debicheckMandateIds": [
        "string"
      ],
      "payAtReferenceNumber": "string",
      "agreedToTerms": true
    }
  ],
  "createdAt": "string",
  "timestamp": 0.1,
  "enablesSplit": true,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "expire": "string",
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "stateUpdatedAt": "string",
  "updatedAt": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "cloneExpiry": 0,
  "cloneCount": 0,
  "orderCancellationRequest": "string",
  "notifications": [
    {
      "change": "string",
      "date": "string",
      "name": "string",
      "reason": "string",
      "details": "string",
      "read": true,
      "userId": "string",
      "type": "string",
      "hide": true,
      "unread": true
    }
  ],
  "acceptedProposedCancellationTerms": true,
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "merchantName": "string",
  "merchantTermsLink": "string",
  "merchantLink": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "supplier": {
    "_id": "string",
    "name": "string",
    "merchantId": "string"
  },
  "orderRefundRequest": "string",
  "orderRefundAmount": 0,
  "orderRefundFee": 0,
  "monthlyPayments": true,
  "type": "string",
  "balance": 0,
  "description": "string",
  "isIncreasedDepositAmountAllowed": true,
  "suspendOnCancel": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProvider": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_GetCancellationTerms

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/orders/{_id}/cancellation-terms \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/orders/{_id}/cancellation-terms HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/orders/{_id}/cancellation-terms',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/orders/{_id}/cancellation-terms', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/orders/{_id}/cancellation-terms',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/orders/{_id}/cancellation-terms", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/orders/{_id}/cancellation-terms

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "autoCancellation": true,
  "definition": [
    {
      "type": {
        "name": "string",
        "definition": {
          "missed": 0,
          "percentage": 0
        },
        "finalPaymentMissed": true
      },
      "policy": {
        "name": "Deposit",
        "definition": {
          "deposit": true,
          "percentage": 0,
          "flatFee": 0,
          "percentageShouldUseTotalPaid": true
        }
      },
      "start": 0,
      "end": 0,
      "gracePeriod": 0
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderCancellationTermsResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderService_StatementRequest

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/statement \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/statement HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "type": "string",
  "orderId": "string",
  "email": "string",
  "paymentPlanId": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/statement',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/statement', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/statement',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/statement", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/statement

Body parameter

{
  "type": "string",
  "orderId": "string",
  "email": "string",
  "paymentPlanId": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelStatementRequest	true	none

Example responses

200 Response

{
  "success": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelStatementRequestResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderAmendmentService

OrderAmendmentService_GetMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/order-amendments \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/order-amendments HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/order-amendments',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/order-amendments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/order-amendments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/order-amendments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/order-amendments

Parameters

Name	In	Type	Required	Description
orderId	query	string	false	none

Example responses

200 Response

{
  "orderAmendments": [
    {
      "_id": "string",
      "userId": "string",
      "orderId": "string",
      "amendmentType": "string",
      "products": [
        {
          "_id": "string",
          "amount": 0,
          "link": "http://example.com",
          "sku": "string",
          "name": "string",
          "depositType": "string"
        }
      ],
      "endDate": "string",
      "from": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [
          {
            "_id": "string",
            "orderId": "string",
            "benefactorId": "string",
            "completed": true,
            "quantity": 0,
            "depositDue": 0,
            "amountDue": 0,
            "automaticBilling": true,
            "timestamp": 0.1,
            "payments": [
              {
                "_id": "string",
                "due": "string",
                "amount": 0,
                "paid": true,
                "timestamp": 0.1,
                "paymentMethod": "string",
                "paymentType": "string",
                "amountExcludingFee": 0,
                "fee": 0,
                "pending": true,
                "failed": true,
                "reconciliated": true,
                "refundedAmount": 0,
                "refundPaymentId": "string",
                "connectorData": {
                  "_id": "string",
                  "amount": 0,
                  "paymentProviderPaymentId": "string",
                  "paymentReference": "string",
                  "paymentMethod": "string",
                  "paymentProvider": "string",
                  "paymentProviderResponses": {}
                },
                "verifiedAt": "string"
              }
            ],
            "benefactor": {
              "_id": "string",
              "name": "string",
              "email": "string"
            },
            "frequency": "WEEKLY",
            "offset": 0,
            "depositDueExcludingFee": 0,
            "amountDueExcludingFee": 0,
            "order": {},
            "debicheckStatus": "string",
            "debicheckLastFailedReasons": [
              "string"
            ],
            "debicheckMandateActiveId": "string",
            "debicheckMandateIds": [
              "string"
            ],
            "payAtReferenceNumber": "string",
            "agreedToTerms": true
          }
        ],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "createdAt": "string",
      "updatedAt": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderAmendmentResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderAmendmentService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/order-amendments \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/order-amendments HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "orderId": "123f7f1496bd78001d6852f3",
  "amendmentType": "PRODUCT:UPDATE",
  "products": "ProductCreateRequest"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/order-amendments',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/order-amendments', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/order-amendments',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/order-amendments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/order-amendments

Body parameter

{
  "orderId": "123f7f1496bd78001d6852f3",
  "amendmentType": "PRODUCT:UPDATE",
  "products": "ProductCreateRequest"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelOrderAmendmentRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "userId": "string",
  "orderId": "string",
  "amendmentType": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "endDate": "string",
  "from": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderAmendmentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

OrderAmendmentService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/order-amendments/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/order-amendments/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/order-amendments/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/order-amendments/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/order-amendments/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/order-amendments/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/order-amendments/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "userId": "string",
  "orderId": "string",
  "amendmentType": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "endDate": "string",
  "from": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelOrderAmendmentResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

IntegrationService

IntegrationService_GetCueOrders

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/integrations/cue/user/{cellNumber}/orders \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/integrations/cue/user/{cellNumber}/orders HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/integrations/cue/user/{cellNumber}/orders',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/integrations/cue/user/{cellNumber}/orders', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/integrations/cue/user/{cellNumber}/orders',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/integrations/cue/user/{cellNumber}/orders", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/integrations/cue/user/{cellNumber}/orders

Parameters

Name	In	Type	Required	Description
cellNumber	path	string	true	none

Example responses

200 Response

{
  "orders": [
    {
      "reference": "string",
      "endDateMax": "string",
      "dueDate": "string",
      "balance": 0,
      "cancellationFee": 0
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelCueOrderResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

CardService

CardService_GetMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/cards \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/cards HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/cards',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/cards', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/cards',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/cards", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/cards

Parameters

Name	In	Type	Required	Description
limit	query	integer(int32)	false	none

Example responses

200 Response

{
  "clientCards": [
    {
      "_id": "string",
      "userId": "string",
      "nameOnCard": "string",
      "cardType": "string",
      "cardDigits": "string",
      "defaultCard": true,
      "expiryMonth": "string",
      "expiryYear": "string",
      "timestamp": 0.1,
      "checkoutId": "string",
      "resourcePath": "string",
      "merchantId": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelCardResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

CardService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/cards \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/cards HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "userId": "string",
  "defaultCard": true,
  "redirectUrl": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/cards',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/cards', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/cards',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/cards", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/cards

Body parameter

{
  "userId": "string",
  "defaultCard": true,
  "redirectUrl": "string"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelCardRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "userId": "string",
  "nameOnCard": "string",
  "cardType": "string",
  "cardDigits": "string",
  "defaultCard": true,
  "expiryMonth": "string",
  "expiryYear": "string",
  "timestamp": 0.1,
  "checkoutId": "string",
  "resourcePath": "string",
  "merchantId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelCardResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

CardService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/cards/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/cards/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/cards/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/cards/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/cards/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/cards/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/cards/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "userId": "string",
  "nameOnCard": "string",
  "cardType": "string",
  "cardDigits": "string",
  "defaultCard": true,
  "expiryMonth": "string",
  "expiryYear": "string",
  "timestamp": 0.1,
  "checkoutId": "string",
  "resourcePath": "string",
  "merchantId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelCardResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

CardService_Remove

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/cards/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/cards/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/cards/{_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/cards/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/cards/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/cards/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/cards/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	Inline
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

Response Schema

CardService_Update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/cards/{_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/cards/{_id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "userId": "string",
  "defaultCard": true,
  "redirectUrl": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/cards/{_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/cards/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/cards/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/cards/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/cards/{_id}

Body parameter

{
  "userId": "string",
  "defaultCard": true,
  "redirectUrl": "string"
}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
body	body	modelCardRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "userId": "string",
  "nameOnCard": "string",
  "cardType": "string",
  "cardDigits": "string",
  "defaultCard": true,
  "expiryMonth": "string",
  "expiryYear": "string",
  "timestamp": 0.1,
  "checkoutId": "string",
  "resourcePath": "string",
  "merchantId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelCardResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

MerchantService

MerchantService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/merchants \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/merchants HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "expire": 0,
  "merchantTermsLink": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "settlementFrequency": "string",
  "settlementType": "string",
  "settlementDay": 0,
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "absorbsFee": true,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "simulated": true,
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/merchants',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/merchants', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/merchants',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/merchants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/merchants

Body parameter

{
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "expire": 0,
  "merchantTermsLink": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "settlementFrequency": "string",
  "settlementType": "string",
  "settlementDay": 0,
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "absorbsFee": true,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "simulated": true,
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
avs	query	string	false	none
body	body	modelMerchantRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "users": [
    {
      "_id": "string",
      "username": "string",
      "email": "[email protected]",
      "idNumber": "string",
      "address": "string",
      "postalCode": "string",
      "city": "string",
      "province": "string",
      "country": "string",
      "role": "CLIENT",
      "active": true,
      "merchantId": "string",
      "cellNumber": "string",
      "dateOfBirth": "string",
      "name": "string",
      "verified": true,
      "verifiedEmail": true,
      "verifiedMobile": true,
      "merchantRole": "string",
      "merchantIds": [
        "string"
      ]
    }
  ],
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "timestamp": 0.1,
  "merchantTermsLink": "string",
  "settlementDay": 0,
  "settlementFrequency": "string",
  "settlementType": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "absorbsFee": true,
  "expire": 0,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "merchantName": "string",
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "accountSettings": {
    "numberOfUsers": 0,
    "apiAccess": true
  },
  "feeSystem": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelMerchantResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

MerchantService_getShops

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/merchants/shop-directory \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/merchants/shop-directory HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/merchants/shop-directory',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/merchants/shop-directory', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/merchants/shop-directory',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/merchants/shop-directory", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/merchants/shop-directory

Parameters

Name	In	Type	Required	Description
featured	query	boolean	false	none

Example responses

200 Response

{
  "categories": [
    "string"
  ],
  "shops": [
    {
      "_id": "string",
      "name": "string",
      "domain": "string",
      "displayOnWeb": {
        "enabled": true,
        "webAvailability": "string",
        "webLogoImage": "string",
        "webCategory": [
          "string"
        ],
        "featured": true
      },
      "createdAt": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelMerchantResponseShops
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

MerchantService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/merchants/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/merchants/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/merchants/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/merchants/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/merchants/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/merchants/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/merchants/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "users": [
    {
      "_id": "string",
      "username": "string",
      "email": "[email protected]",
      "idNumber": "string",
      "address": "string",
      "postalCode": "string",
      "city": "string",
      "province": "string",
      "country": "string",
      "role": "CLIENT",
      "active": true,
      "merchantId": "string",
      "cellNumber": "string",
      "dateOfBirth": "string",
      "name": "string",
      "verified": true,
      "verifiedEmail": true,
      "verifiedMobile": true,
      "merchantRole": "string",
      "merchantIds": [
        "string"
      ]
    }
  ],
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "timestamp": 0.1,
  "merchantTermsLink": "string",
  "settlementDay": 0,
  "settlementFrequency": "string",
  "settlementType": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "absorbsFee": true,
  "expire": 0,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "merchantName": "string",
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "accountSettings": {
    "numberOfUsers": 0,
    "apiAccess": true
  },
  "feeSystem": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelMerchantResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

MerchantService_Del

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/merchants/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/merchants/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/merchants/{_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/merchants/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/merchants/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/merchants/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/merchants/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "users": [
    {
      "_id": "string",
      "username": "string",
      "email": "[email protected]",
      "idNumber": "string",
      "address": "string",
      "postalCode": "string",
      "city": "string",
      "province": "string",
      "country": "string",
      "role": "CLIENT",
      "active": true,
      "merchantId": "string",
      "cellNumber": "string",
      "dateOfBirth": "string",
      "name": "string",
      "verified": true,
      "verifiedEmail": true,
      "verifiedMobile": true,
      "merchantRole": "string",
      "merchantIds": [
        "string"
      ]
    }
  ],
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "timestamp": 0.1,
  "merchantTermsLink": "string",
  "settlementDay": 0,
  "settlementFrequency": "string",
  "settlementType": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "absorbsFee": true,
  "expire": 0,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "merchantName": "string",
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "accountSettings": {
    "numberOfUsers": 0,
    "apiAccess": true
  },
  "feeSystem": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelMerchantResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

MerchantService_Update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/merchants/{_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/merchants/{_id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "expire": 0,
  "merchantTermsLink": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "settlementFrequency": "string",
  "settlementType": "string",
  "settlementDay": 0,
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "absorbsFee": true,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "simulated": true,
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/merchants/{_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/merchants/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/merchants/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/merchants/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/merchants/{_id}

Body parameter

{
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "expire": 0,
  "merchantTermsLink": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "settlementFrequency": "string",
  "settlementType": "string",
  "settlementDay": 0,
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "absorbsFee": true,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "simulated": true,
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
avs	query	string	false	none
body	body	modelMerchantRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "users": [
    {
      "_id": "string",
      "username": "string",
      "email": "[email protected]",
      "idNumber": "string",
      "address": "string",
      "postalCode": "string",
      "city": "string",
      "province": "string",
      "country": "string",
      "role": "CLIENT",
      "active": true,
      "merchantId": "string",
      "cellNumber": "string",
      "dateOfBirth": "string",
      "name": "string",
      "verified": true,
      "verifiedEmail": true,
      "verifiedMobile": true,
      "merchantRole": "string",
      "merchantIds": [
        "string"
      ]
    }
  ],
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "timestamp": 0.1,
  "merchantTermsLink": "string",
  "settlementDay": 0,
  "settlementFrequency": "string",
  "settlementType": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "absorbsFee": true,
  "expire": 0,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "merchantName": "string",
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "accountSettings": {
    "numberOfUsers": 0,
    "apiAccess": true
  },
  "feeSystem": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelMerchantResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

SettlementService

SettlementService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v2/settlements \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v2/settlements HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "merchantId": "string",
  "to": "string",
  "from": "string",
  "batchType": "string",
  "automatic": true,
  "negative": true,
  "preview": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v2/settlements',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v2/settlements', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v2/settlements',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v2/settlements", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v2/settlements

Body parameter

{
  "merchantId": "string",
  "to": "string",
  "from": "string",
  "batchType": "string",
  "automatic": true,
  "negative": true,
  "preview": true
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelSettlementRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "amount": 0.1,
  "fee": 0.1,
  "batch": "string",
  "merchantId": "string",
  "merchantAccountId": "string",
  "reference": "string",
  "dateSettled": "string",
  "reconciled": true,
  "settled": true,
  "paymentIds": [
    "string"
  ],
  "journalFees": [
    "string"
  ],
  "batchType": "string",
  "absaEftFile": "string",
  "bankTransactionId": "string",
  "createdAt": "string",
  "updatedAt": "string",
  "draft": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelSettlementResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

SettlementService_GetReport

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v2/settlements-report \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v2/settlements-report HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v2/settlements-report',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v2/settlements-report', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v2/settlements-report',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v2/settlements-report", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v2/settlements-report

Parameters

Name	In	Type	Required	Description
limit	query	integer(int32)	false	none
skip	query	integer(int32)	false	none
fromDate	query	string	false	none
toDate	query	string	false	none
search	query	string	false	none
sort	query	string	false	none

Example responses

200 Response

{
  "settlements": [
    {
      "id": "string",
      "amount": 0.1,
      "batch": 0.1,
      "batchType": "string",
      "merchantId": "string",
      "status": "string",
      "reference": "string",
      "settledAt": "string",
      "reconciled": true
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelSettlementReportResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

TokenService

TokenService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/tokens \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/tokens HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "action": "VERIFYACCOUNT",
  "cellNumber": "string",
  "reference": "string",
  "email": "string",
  "_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/tokens',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/tokens', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/tokens',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/tokens", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/tokens

Body parameter

{
  "action": "VERIFYACCOUNT",
  "cellNumber": "string",
  "reference": "string",
  "email": "string",
  "_id": "string"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelTokenRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	Inline
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

Response Schema

VerifyService

VerifyService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/verify \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/verify HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/verify',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/verify', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/verify',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/verify", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/verify

Parameters

Name	In	Type	Required	Description
token	query	string	false	none
msisdn	query	string	false	none

Example responses

200 Response

{
  "userId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelVerifyResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

DebicheckService

DebicheckService_GetMandateList

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/debicheck/list/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/debicheck/list/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/debicheck/list/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/debicheck/list/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/debicheck/list/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/debicheck/list/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/debicheck/list/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "status": "string",
  "debicheckFailedReasons": [
    "string"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelDebicheckMandateListResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

DebicheckService_GetMandate

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/debicheck/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/debicheck/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/debicheck/{_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/debicheck/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/debicheck/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/debicheck/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/debicheck/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "customer": {
    "name": "string",
    "identification": "string",
    "identificationType": "string",
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "contact": [
      {
        "medium": 0,
        "value": "string"
      }
    ],
    "simulated": true
  },
  "createdAt": "string",
  "simulation": true
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelDebicheckMandateResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InternationalMsisdnService

InternationalMsisdnService_Create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/debicheck \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/debicheck HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "msisdn": "string",
  "countryCode": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/debicheck',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/debicheck', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/debicheck',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/debicheck", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/debicheck

Body parameter

{
  "msisdn": "string",
  "countryCode": "string"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelInternationalMsisdnRequest	true	none

Example responses

200 Response

{
  "msisdn": "string",
  "countryCode": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInternationalMsisdnResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InternationalMsisdnService_GetMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/debicheck/collection \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/debicheck/collection HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/debicheck/collection',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/debicheck/collection', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/debicheck/collection',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/debicheck/collection", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/debicheck/collection

Parameters

Name	In	Type	Required	Description
countryCode	query	string	false	none
msisdn	query	string	false	none

Example responses

200 Response

{
  "internationalMsisdns": [
    {
      "msisdn": "string",
      "countryCode": "string",
      "createdAt": "string",
      "updatedAt": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInternationalMsisdnResponseMany
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InternationalMsisdnService_Update

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/debicheck/collection \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/debicheck/collection HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "msisdn": "string",
  "countryCode": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/debicheck/collection',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/debicheck/collection', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/debicheck/collection',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/debicheck/collection", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/debicheck/collection

Body parameter

{
  "msisdn": "string",
  "countryCode": "string"
}

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none
body	body	modelInternationalMsisdnRequest	true	none

Example responses

200 Response

{
  "msisdn": "string",
  "countryCode": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInternationalMsisdnResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InternationalMsisdnService_Del

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/debicheck/list/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/debicheck/list/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/debicheck/list/{_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/debicheck/list/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/debicheck/list/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/debicheck/list/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/debicheck/list/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "msisdn": "string",
  "countryCode": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInternationalMsisdnResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InternationalMsisdnService_Get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/debicheck/{_id_1} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/debicheck/{_id_1} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/debicheck/{_id_1}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/debicheck/{_id_1}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/debicheck/{_id_1}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/debicheck/{_id_1}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/debicheck/{_id_1}

Parameters

Name	In	Type	Required	Description
_id_1	path	string	true	none

Example responses

200 Response

{
  "msisdn": "string",
  "countryCode": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInternationalMsisdnResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PayAtService

PayAtService_adviseTransaction

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payAt/adviseTransaction \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payAt/adviseTransaction HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "tenderType": "string",
  "repeatIndicator": true,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "issuerTransactionID": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payAt/adviseTransaction',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payAt/adviseTransaction', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payAt/adviseTransaction',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payAt/adviseTransaction", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payAt/adviseTransaction

Body parameter

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "tenderType": "string",
  "repeatIndicator": true,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "issuerTransactionID": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelPayAtTransactionAdviceRequest	true	none

Example responses

200 Response

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "tenderType": "string",
  "repeatIndicator": true,
  "amount": 0,
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "networkTransactionID": "string",
  "issuerTransactionID": "string",
  "responseCode": "string",
  "responseText": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPayAtTransactionAdviceResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PayAtService_authorize

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payAt/authorize \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payAt/authorize HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payAt/authorize',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payAt/authorize', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payAt/authorize',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payAt/authorize", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payAt/authorize

Body parameter

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  }
}

Parameters

Name	In	Type	Required	Description
body	body	modelPayAtAuthorizationRequest	true	none

Example responses

200 Response

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "networkTransactionID": "string",
  "responseCode": "string",
  "responseText": "string",
  "issuerTransactionID": "string",
  "customerData": {
    "firstName": "string",
    "lastName": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPayAtAuthorizationResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PayAtService_echoTest

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payAt/echoTest \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payAt/echoTest HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "messageID": "string",
  "transmissionDateTime": "string",
  "echoData": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payAt/echoTest',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payAt/echoTest', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payAt/echoTest',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payAt/echoTest", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payAt/echoTest

Body parameter

{
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "messageID": "string",
  "transmissionDateTime": "string",
  "echoData": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelPayAtEchoTestRequest	true	none

Example responses

200 Response

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "echoData": "string",
  "responseCode": "string",
  "responseText": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPayAtEchoTestResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PayAtService_enquiry

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payAt/enquire \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payAt/enquire HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payAt/enquire',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payAt/enquire', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payAt/enquire',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payAt/enquire", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payAt/enquire

Body parameter

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  }
}

Parameters

Name	In	Type	Required	Description
body	body	modelPayAtEnquiryRequest	true	none

Example responses

200 Response

{
  "amount": 0,
  "dueDate": "string",
  "exactAmount": true,
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "customerData": {
    "firstName": "string",
    "lastName": "string"
  },
  "responseText": "string",
  "responseCode": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPayAtEnquiryResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PayAtService_reverseAuthorization

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/payAt/reverseAuthorization \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/payAt/reverseAuthorization HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "issuerTransactionID": "string",
  "repeatIndicator": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/payAt/reverseAuthorization',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/payAt/reverseAuthorization', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/payAt/reverseAuthorization',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/payAt/reverseAuthorization", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/payAt/reverseAuthorization

Body parameter

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "issuerTransactionID": "string",
  "repeatIndicator": true
}

Parameters

Name	In	Type	Required	Description
body	body	modelPayAtReverseAuthorizationRequest	true	none

Example responses

200 Response

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "networkTransactionID": "string",
  "responseCode": "string",
  "responseText": "string",
  "issuerTransactionID": "string",
  "repeatIndicator": true,
  "customerData": {
    "firstName": "string",
    "lastName": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPayAtReverseAuthorizationResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

BankService

BankService_getMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/banks \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/banks HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/banks',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/banks', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/banks',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/banks", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/banks

Example responses

200 Response

{
  "banks": [
    {
      "_id": "string",
      "name": "string",
      "displayName": "string",
      "shortName": "string",
      "branchCode": "string",
      "avsInstitutionCode": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelBankGetManyResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

BankService_create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/banks \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/banks HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/banks',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/banks', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/banks',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/banks", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/banks

Body parameter

{
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelBankCreateRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelBankResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

BankService_delete

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/v1/banks/{_id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

DELETE http://localhost:3000/v1/banks/{_id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/banks/{_id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.delete('http://localhost:3000/v1/banks/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.delete 'http://localhost:3000/v1/banks/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "http://localhost:3000/v1/banks/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /v1/banks/{_id}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none

Example responses

200 Response

{
  "_id": "string",
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelBankResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

BankService_update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/banks/{_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/banks/{_id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/banks/{_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/banks/{_id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/banks/{_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/banks/{_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/banks/{_id}

Body parameter

{
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}

Parameters

Name	In	Type	Required	Description
_id	path	string	true	none
body	body	modelBankUpdateRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelBankResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentProviderSettlementService

PaymentProviderSettlementService_create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/paymentProviderSettlements \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/paymentProviderSettlements HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "paymentProviderSettlements": [
    {
      "amountInCents": 0,
      "bankTransactionReference": "string",
      "paymentProvider": "string",
      "paymentProviderPaymentId": "string",
      "transactionDate": "string",
      "paymentReference": "string",
      "fileStorageReference": "string",
      "paymentMethod": "string",
      "feeInCents": 0
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/paymentProviderSettlements',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/paymentProviderSettlements', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/paymentProviderSettlements',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/paymentProviderSettlements", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/paymentProviderSettlements

Body parameter

{
  "paymentProviderSettlements": [
    {
      "amountInCents": 0,
      "bankTransactionReference": "string",
      "paymentProvider": "string",
      "paymentProviderPaymentId": "string",
      "transactionDate": "string",
      "paymentReference": "string",
      "fileStorageReference": "string",
      "paymentMethod": "string",
      "feeInCents": 0
    }
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	modelPaymentProviderSettlementsRequest	true	none

Example responses

200 Response

{
  "settlements": [
    {
      "amountInCents": 0,
      "bankTransactionReference": "string",
      "paymentProvider": "string",
      "paymentProviderPaymentId": "string",
      "transactionDate": "string",
      "paymentReference": "string",
      "fileStorageReference": "string",
      "paymentMethod": "string",
      "feeInCents": 0,
      "_id": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentProviderSettlementsResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

PaymentProviderSettlementService_linkPayment

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/paymentProviderSettlements/{id}/linkPayment/{paymentId} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/paymentProviderSettlements/{id}/linkPayment/{paymentId} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/paymentProviderSettlements/{id}/linkPayment/{paymentId}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/paymentProviderSettlements/{id}/linkPayment/{paymentId}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/paymentProviderSettlements/{id}/linkPayment/{paymentId}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/paymentProviderSettlements/{id}/linkPayment/{paymentId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/paymentProviderSettlements/{id}/linkPayment/{paymentId}

Parameters

Name	In	Type	Required	Description
id	path	string	true	none
paymentId	path	string	true	none

Example responses

200 Response

{
  "amountInCents": 0,
  "bankTransactionReference": "string",
  "paymentProvider": "string",
  "paymentProviderPaymentId": "string",
  "transactionDate": "string",
  "paymentReference": "string",
  "fileStorageReference": "string",
  "paymentMethod": "string",
  "feeInCents": 0,
  "_id": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelPaymentProviderSettlementResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

BankTransactionService

BankTransactionService_create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/bank-transactions \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/bank-transactions HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "bankTransactions": [
    {
      "date": "string",
      "description": "string",
      "reference": "string",
      "amountInCents": 0,
      "balanceInCents": 0,
      "bank": "string",
      "fileStorageReference": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/bank-transactions',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/bank-transactions', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/bank-transactions',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/bank-transactions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/bank-transactions

Body parameter

{
  "bankTransactions": [
    {
      "date": "string",
      "description": "string",
      "reference": "string",
      "amountInCents": 0,
      "balanceInCents": 0,
      "bank": "string",
      "fileStorageReference": "string"
    }
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	modelBankTransactionCreateRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelBankTransactionResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

BankTransactionService_createPayment

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/bank-transactions/{id}/payment \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/bank-transactions/{id}/payment HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "destinationId": "string",
  "destinationType": "string",
  "amount": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/bank-transactions/{id}/payment',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/bank-transactions/{id}/payment', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/bank-transactions/{id}/payment',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/bank-transactions/{id}/payment", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/bank-transactions/{id}/payment

Body parameter

{
  "destinationId": "string",
  "destinationType": "string",
  "amount": 0
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	none
body	body	modelBankTransactionPaymentRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelBankTransactionResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

BankTransactionService_update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/release-suspense \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/release-suspense HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "bankTransactionIds": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/release-suspense',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/release-suspense', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/release-suspense',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/release-suspense", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/release-suspense

Body parameter

{
  "bankTransactionIds": [
    "string"
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	modelBankTransactionUpdate	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelBankTransactionResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

TerminalPaymentAppsService

TerminalPaymentAppsService_getMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/terminalPaymentApps \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/terminalPaymentApps HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/terminalPaymentApps',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/terminalPaymentApps', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/terminalPaymentApps',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/terminalPaymentApps", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/terminalPaymentApps

Example responses

200 Response

{
  "terminalPaymentApps": [
    {
      "_id": "string",
      "merchantId": "string",
      "packageName": "string",
      "paymentMethod": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelTerminalPaymentAppsGetManyResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InvoicesService

InvoicesService_updatePdf

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/invoice/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/invoice/{id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "accountingPdfLocation": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/invoice/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/invoice/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/invoice/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/invoice/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/invoice/{id}

Body parameter

{
  "accountingPdfLocation": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	none
body	body	modelInvoiceUpdatePdfRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInvoiceResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InvoicesService_getMany

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/invoices \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/invoices HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/invoices',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/invoices', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/invoices',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/invoices", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/invoices

Parameters

Name	In	Type	Required	Description
from	query	string	false	none
to	query	string	false	none
reference	query	string	false	none
status	query	string	false	none

Example responses

200 Response

{
  "invoices": [
    {
      "_id": "string",
      "merchantId": "string",
      "exVatAmount": 0,
      "vatAmount": 0,
      "totalAmount": 0,
      "settled": true,
      "reconciled": true,
      "bankTransactionId": "string",
      "reference": "string",
      "accountingInvoiceId": "string",
      "accountingInvoiceNumber": "string",
      "status": "string",
      "createdAt": "string",
      "billingMethod": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInvoiceGetManyResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InvoicesService_create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/invoices \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/invoices HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "fromDateTime": "string",
  "toDateTime": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/invoices',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/invoices', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/invoices',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/invoices", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/invoices

Body parameter

{
  "fromDateTime": "string",
  "toDateTime": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelDateTimeRange	true	none

Example responses

200 Response

{
  "invoiceIds": [
    "string"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInvoicesResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InvoicesService_update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/invoices \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/invoices HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "invoiceId": "string",
  "accountingInvoiceId": "string",
  "accountingInvoiceNumber": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/invoices',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/invoices', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/invoices',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/invoices", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/invoices

Body parameter

{
  "invoiceId": "string",
  "accountingInvoiceId": "string",
  "accountingInvoiceNumber": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelInvoiceUpdateRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInvoiceResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InvoicesService_getPdf

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/invoices/:id/pdf \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/invoices/:id/pdf HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/invoices/:id/pdf',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/invoices/:id/pdf', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/invoices/:id/pdf',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/invoices/:id/pdf", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/invoices/:id/pdf

Parameters

Name	In	Type	Required	Description
_id	query	string	false	none

Example responses

200 Response

{
  "redirectUrl": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInvoicePdfResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InvoicesService_createByFees

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/invoices/fees \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/invoices/fees HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "feeIds": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/invoices/fees',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/invoices/fees', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/invoices/fees',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/invoices/fees", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/invoices/fees

Body parameter

{
  "feeIds": [
    "string"
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	modelInvoiceFeesCreateRequest	true	none

Example responses

200 Response

{
  "invoiceIds": [
    "string"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInvoicesResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InvoicesService_getInvoiceById

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/invoices/{id} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/invoices/{id} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/invoices/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/invoices/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/invoices/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/invoices/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/invoices/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	none

Example responses

200 Response

{
  "id": "string",
  "merchantId": "string",
  "exVatAmount": 0,
  "vatAmount": 0,
  "totalAmount": 0,
  "settled": true,
  "reconciled": true,
  "bankTransactionId": "string",
  "reference": "string",
  "accountingInvoiceId": "string",
  "accountingInvoiceNumber": "string",
  "status": "string",
  "createdAt": "string",
  "feesPerProduct": [
    {
      "quantity": 0,
      "amountTotal": 0.1,
      "amountExcludingVAT": 0.1,
      "amountVAT": 0.1,
      "product": {
        "_id": "string",
        "name": "string",
        "displayName": "string",
        "feeType": "string",
        "method": "string",
        "billingType": "string"
      }
    }
  ],
  "report": {
    "totalFeesAmount": 0,
    "totalFeesExtAmount": 0,
    "totalAmountVAT": 0,
    "feesPerProductExcludingVATTotal": 0,
    "feesPerProductVATTotal": 0,
    "feesPerProductTotal": 0,
    "fees": [
      {
        "id": "string",
        "productName": "string",
        "amountExcludingVAT": 0.1,
        "amountVAT": 0.1,
        "amountTotal": 0.1,
        "merchantId": "string",
        "createdAt": "string",
        "updatedAt": "string",
        "settlementId": "string",
        "paymentId": "string"
      }
    ]
  },
  "billingMethod": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelInvoiceReport
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

InvoicesService_getInvoiceReportById

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/invoices/{id}/report \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/invoices/{id}/report HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/invoices/{id}/report',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/invoices/{id}/report', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/invoices/{id}/report',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/invoices/{id}/report", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/invoices/{id}/report

Parameters

Name	In	Type	Required	Description
id	path	string	true	none

Example responses

200 Response

{
  "report": {
    "id": "string",
    "merchantId": "string",
    "exVatAmount": 0,
    "vatAmount": 0,
    "totalAmount": 0,
    "settled": true,
    "reconciled": true,
    "bankTransactionId": "string",
    "reference": "string",
    "accountingInvoiceId": "string",
    "accountingInvoiceNumber": "string",
    "status": "string",
    "createdAt": "string",
    "feesPerProduct": [
      {
        "quantity": 0,
        "amountTotal": 0.1,
        "amountExcludingVAT": 0.1,
        "amountVAT": 0.1,
        "product": {
          "_id": "string",
          "name": "string",
          "displayName": "string",
          "feeType": "string",
          "method": "string",
          "billingType": "string"
        }
      }
    ],
    "report": {
      "totalFeesAmount": 0,
      "totalFeesExtAmount": 0,
      "totalAmountVAT": 0,
      "feesPerProductExcludingVATTotal": 0,
      "feesPerProductVATTotal": 0,
      "feesPerProductTotal": 0,
      "fees": [
        {
          "id": "string",
          "productName": "string",
          "amountExcludingVAT": 0.1,
          "amountVAT": 0.1,
          "amountTotal": 0.1,
          "merchantId": "string",
          "createdAt": "string",
          "updatedAt": "string",
          "settlementId": "string",
          "paymentId": "string"
        }
      ]
    },
    "billingMethod": "string"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelGenerateReportResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

ConnectorService

ConnectorService_Update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/connectors/{paymentProviderPaymentId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/connectors/{paymentProviderPaymentId} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "paymentProviderPaymentId": "string",
  "connector": {
    "_id": "string",
    "paymentMethod": "string",
    "paymentProvider": "string"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/connectors/{paymentProviderPaymentId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/connectors/{paymentProviderPaymentId}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/connectors/{paymentProviderPaymentId}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/connectors/{paymentProviderPaymentId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/connectors/{paymentProviderPaymentId}

Body parameter

{
  "paymentProviderPaymentId": "string",
  "connector": {
    "_id": "string",
    "paymentMethod": "string",
    "paymentProvider": "string"
  }
}

Parameters

Name	In	Type	Required	Description
paymentProviderPaymentId	path	string	true	none
body	body	modelConnectorRequest	true	none

Example responses

200 Response

{
  "_id": "string",
  "paymentMethod": "string",
  "paymentProvider": "string",
  "amount": 0,
  "paymentProviderPaymentId": "string",
  "paymentReference": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelConnectorResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

TerminalService

TerminalService_get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/terminals \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/terminals HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/terminals',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/terminals', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/terminals',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/terminals", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/terminals

Example responses

200 Response

{
  "terminals": [
    {
      "id": "string",
      "provider": "string",
      "serial": "string",
      "model": "string",
      "active": true,
      "billable": true,
      "merchantId": "string",
      "location": "string",
      "createdAt": "string",
      "updatedAt": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelTerminalsResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

TerminalService_create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/terminals \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/terminals HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "provider": "string",
  "serial": "string",
  "model": "string",
  "productId": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/terminals',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/terminals', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/terminals',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/terminals", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/terminals

Body parameter

{
  "provider": "string",
  "serial": "string",
  "model": "string",
  "productId": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelTerminalCreateRequest	true	none

Example responses

200 Response

{
  "id": "string",
  "provider": "string",
  "serial": "string",
  "model": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelTerminalResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

TerminalService_update

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/v1/terminals/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

PUT http://localhost:3000/v1/terminals/{id} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "productId": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/terminals/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.put('http://localhost:3000/v1/terminals/{id}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.put 'http://localhost:3000/v1/terminals/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://localhost:3000/v1/terminals/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /v1/terminals/{id}

Body parameter

{
  "productId": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	none
body	body	modelTerminalServiceupdateBody	true	none

Example responses

200 Response

{
  "id": "string",
  "provider": "string",
  "serial": "string",
  "model": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelTerminalResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

TerminalService_getBySerial

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/terminals/{serial} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/terminals/{serial} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/terminals/{serial}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/terminals/{serial}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/terminals/{serial}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/terminals/{serial}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/terminals/{serial}

Parameters

Name	In	Type	Required	Description
serial	path	string	true	none

Example responses

200 Response

{
  "id": "string",
  "provider": "string",
  "serial": "string",
  "model": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelTerminalResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

DebitOrderMandateService

DebitOrderMandateService_create

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/debit-order-mandates \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/debit-order-mandates HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "merchantId": "string",
  "reference": "string",
  "holderName": "string",
  "holderSurname": "string",
  "contact": "string",
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "identificationType": "string",
  "identificationNumber": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/debit-order-mandates',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/debit-order-mandates', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/debit-order-mandates',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/debit-order-mandates", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/debit-order-mandates

Body parameter

{
  "merchantId": "string",
  "reference": "string",
  "holderName": "string",
  "holderSurname": "string",
  "contact": "string",
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "identificationType": "string",
  "identificationNumber": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelDebitOrderMandateCreateRequest	true	none

Example responses

200 Response

{
  "mandateId": "string",
  "merchantId": "string",
  "reference": "string",
  "holderName": "string",
  "holderSurname": "string",
  "contact": "string",
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "identificationType": "string",
  "identificationNumber": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelDebitOrderMandateResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

DebitOrderMandateService_get

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/merchants/{merchantId}/debit-order-mandates \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/merchants/{merchantId}/debit-order-mandates HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/merchants/{merchantId}/debit-order-mandates',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/merchants/{merchantId}/debit-order-mandates', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/merchants/{merchantId}/debit-order-mandates',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/merchants/{merchantId}/debit-order-mandates", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/merchants/{merchantId}/debit-order-mandates

Parameters

Name	In	Type	Required	Description
merchantId	path	string	true	none

Example responses

200 Response

{
  "mandateId": "string",
  "merchantId": "string",
  "reference": "string",
  "holderName": "string",
  "holderSurname": "string",
  "contact": "string",
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "identificationType": "string",
  "identificationNumber": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelDebitOrderMandateResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

AbsaEftService

AbsaEftService_output

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/absa/eft/output \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/absa/eft/output HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "transmissionNumber": 0,
  "fileStoragePath": "string",
  "rejectedTransactions": [
    {
      "transmissionDate": "string",
      "originalSequenceNumber": 0,
      "amount": 0,
      "userReference": "string",
      "rejectionReason": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/absa/eft/output',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/absa/eft/output', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/absa/eft/output',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/absa/eft/output", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/absa/eft/output

Body parameter

{
  "transmissionNumber": 0,
  "fileStoragePath": "string",
  "rejectedTransactions": [
    {
      "transmissionDate": "string",
      "originalSequenceNumber": 0,
      "amount": 0,
      "userReference": "string",
      "rejectionReason": "string"
    }
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	modelAbsaEftOutputRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelAbsaEftResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

AbsaEftService_reply

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/absa/eft/reply \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/absa/eft/reply HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "ldCode": "string",
  "transmissionNumber": 0,
  "transmissionStatus": "string",
  "fileStoragePath": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/absa/eft/reply',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/absa/eft/reply', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/absa/eft/reply',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/absa/eft/reply", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/absa/eft/reply

Body parameter

{
  "ldCode": "string",
  "transmissionNumber": 0,
  "transmissionStatus": "string",
  "fileStoragePath": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	modelAbsaEftReplyRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelAbsaEftResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

AbsaDebiCheckService

AbsaDebiCheckService_output

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/absa/debicheck/output \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/absa/debicheck/output HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "transmissionDate": "string",
  "fileStoragePath": "string",
  "transactions": [
    {
      "paymentId": "string",
      "accepted": true,
      "contractReference": "string",
      "mandateReference": "string",
      "sequenceType": "string",
      "amountInCents": 0,
      "effectiveDate": "string",
      "originalEndToEndTransactionIdentifier": "string",
      "error": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/absa/debicheck/output',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/absa/debicheck/output', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/absa/debicheck/output',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/absa/debicheck/output", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/absa/debicheck/output

Body parameter

{
  "transmissionDate": "string",
  "fileStoragePath": "string",
  "transactions": [
    {
      "paymentId": "string",
      "accepted": true,
      "contractReference": "string",
      "mandateReference": "string",
      "sequenceType": "string",
      "amountInCents": 0,
      "effectiveDate": "string",
      "originalEndToEndTransactionIdentifier": "string",
      "error": "string"
    }
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	modelAbsaDebiCheckOutputRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelAbsaDebiCheckResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

AbsaDebiCheckService_reply

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/absa/debicheck/reply \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/absa/debicheck/reply HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "transmissionNumber": "string",
  "transmissionDate": "string",
  "transmissionStatus": "string",
  "fileStoragePath": "string",
  "rejectedReasons": [
    {
      "contractReference": "string",
      "reason": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/absa/debicheck/reply',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/absa/debicheck/reply', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/absa/debicheck/reply',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/absa/debicheck/reply", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/absa/debicheck/reply

Body parameter

{
  "transmissionNumber": "string",
  "transmissionDate": "string",
  "transmissionStatus": "string",
  "fileStoragePath": "string",
  "rejectedReasons": [
    {
      "contractReference": "string",
      "reason": "string"
    }
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	modelAbsaDebiCheckReplyRequest	true	none

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelAbsaDebiCheckResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

ShopifyService

ShopifyService_calculateShipping

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/integrations/shopify/calculate-shipping \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/integrations/shopify/calculate-shipping HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/integrations/shopify/calculate-shipping',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/integrations/shopify/calculate-shipping', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/integrations/shopify/calculate-shipping',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/integrations/shopify/calculate-shipping", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/integrations/shopify/calculate-shipping

Parameters

Name	In	Type	Required	Description
customerData.firstName	query	string	false	none
customerData.lastName	query	string	false	none
customerData.email	query	string	false	none
customerData.phone	query	string	false	none
customerData.address	query	string	false	none
customerData.address2	query	string	false	none
customerData.city	query	string	false	none
customerData.province	query	string	false	none
customerData.postalCode	query	string	false	none
shopDomain	query	string	false	none

Example responses

200 Response

{
  "prices": [
    {
      "title": "string",
      "amount": "string",
      "handle": "string"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelShopifyCalculateShippingResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

ShopifyService_processDiscount

Code samples

# You can also use wget
curl -X GET http://localhost:3000/v1/integrations/shopify/discounts \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

GET http://localhost:3000/v1/integrations/shopify/discounts HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/integrations/shopify/discounts',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.get('http://localhost:3000/v1/integrations/shopify/discounts', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.get 'http://localhost:3000/v1/integrations/shopify/discounts',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://localhost:3000/v1/integrations/shopify/discounts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /v1/integrations/shopify/discounts

Parameters

Name	In	Type	Required	Description
discountCode	query	string	false	none
shopDomain	query	string	false	none

Example responses

200 Response

{
  "status": "string",
  "message": "string",
  "data": {
    "discountType": "string",
    "discountValue": "string",
    "discountAllocation": "string",
    "discountSelection": "string",
    "discountTitle": "string",
    "entitledProductIds": [
      0.1
    ],
    "entitledVariantIds": [
      0.1
    ]
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelShopifyDiscountResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

ShopifyService_linkOrder

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/integrations/shopify/link-order \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/integrations/shopify/link-order HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/integrations/shopify/link-order',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/integrations/shopify/link-order', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/integrations/shopify/link-order',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/integrations/shopify/link-order", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/integrations/shopify/link-order

Parameters

Name	In	Type	Required	Description
shopDomain	query	string	false	none
draftOrder.id	query	string	false	none
draftOrder.status	query	string	false	none
draftOrder.createdAt	query	string	false	none
draftOrder.name	query	string	false	none
draftOrder.customer.name	query	string	false	none
draftOrder.customer.email	query	string	false	none
draftOrder.customer.phone	query	string	false	none
draftOrder.customer.displayName	query	string	false	none
draftOrder.totalPriceSet	query	string	false	none
draftOrder.taxesIncluded	query	boolean	false	none
draftOrder.shippingLine.discountedPriceSet	query	string	false	none
draftOrder.totalTaxSet	query	string	false	none

Example responses

200 Response

{
  "status": "string",
  "message": "string",
  "data": "string",
  "orderId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelShopifyOrderResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

ShopifyService_processOrder

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/integrations/shopify/orders \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/integrations/shopify/orders HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/integrations/shopify/orders',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/integrations/shopify/orders', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/integrations/shopify/orders',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/integrations/shopify/orders", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/integrations/shopify/orders

Parameters

Name	In	Type	Required	Description
shopDomain	query	string	false	none
amount	query	integer(int32)	false	none
shippingData.amount	query	string	false	none
shippingData.handle	query	string	false	none
shippingData.title	query	string	false	none
discount.discountType	query	string	false	none
discount.discountValue	query	string	false	none
discount.discountAllocation	query	string	false	none
discount.discountSelection	query	string	false	none
discount.discountTitle	query	string	false	none
discount.entitledProductIds	query	array[number]	false	none
discount.entitledVariantIds	query	array[number]	false	none
locationData	query	string	false	none
customerData.firstName	query	string	false	none
customerData.lastName	query	string	false	none
customerData.email	query	string	false	none
customerData.phone	query	string	false	none
customerData.address	query	string	false	none
customerData.address2	query	string	false	none
customerData.city	query	string	false	none
customerData.province	query	string	false	none
customerData.postalCode	query	string	false	none

Example responses

200 Response

{
  "status": "string",
  "message": "string",
  "data": "string",
  "orderId": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelShopifyOrderResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

ShopifyService_getShopSettings

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/integrations/shopify/shop-settings/{shopDomain} \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/integrations/shopify/shop-settings/{shopDomain} HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/integrations/shopify/shop-settings/{shopDomain}',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/integrations/shopify/shop-settings/{shopDomain}', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/integrations/shopify/shop-settings/{shopDomain}',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/integrations/shopify/shop-settings/{shopDomain}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/integrations/shopify/shop-settings/{shopDomain}

Parameters

Name	In	Type	Required	Description
shopDomain	path	string	true	none

Example responses

200 Response

{
  "enabledOnAll": true,
  "enabledOnProduct": true,
  "enabledOnCart": true,
  "enabledAccept": true,
  "acceptMsg": "string",
  "acceptBtn": "string",
  "terms": "string",
  "products": [
    {
      "productId": "string",
      "eventDateString": "string",
      "enabledOnLayup": true,
      "minMonths": 0,
      "maxMonths": 0,
      "deposit": 0,
      "depositType": "string",
      "previewTemplate": "string",
      "learnMore": "string",
      "layupType": "string"
    }
  ],
  "logoUrl": "string",
  "learnMore": "string",
  "merchantName": "string",
  "deposit": 0,
  "depositType": "string",
  "minMonths": 0,
  "maxMonths": 0,
  "shopifyLocations": [
    {
      "address": {
        "address1": "string",
        "address2": "string",
        "city": "string",
        "phone": "string",
        "province": "string",
        "zip": "string"
      },
      "id": "string",
      "legacyResourceId": "string",
      "name": "string"
    }
  ],
  "enabledDiscount": true,
  "enabledOnPopupCart": true,
  "popupCartSelector": "string",
  "popupCartQuantitySelector": "string",
  "popupCartRemoveSelector": "string",
  "buttonLayout": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelShopifyGetShopSettingsResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

ShopifyService_getOrderNotes

Code samples

# You can also use wget
curl -X POST http://localhost:3000/v1/integrations/shopify/shopify-order-notes \
  -H 'Accept: application/json' \
  -H 'apikey: API_KEY'

POST http://localhost:3000/v1/integrations/shopify/shopify-order-notes HTTP/1.1
Host: localhost:3000
Accept: application/json


const headers = {
  'Accept':'application/json',
  'apikey':'API_KEY'
};

fetch('http://localhost:3000/v1/integrations/shopify/shopify-order-notes',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'apikey': 'API_KEY'
}

r = requests.post('http://localhost:3000/v1/integrations/shopify/shopify-order-notes', headers = headers)

print(r.json())

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'apikey' => 'API_KEY'
}

result = RestClient.post 'http://localhost:3000/v1/integrations/shopify/shopify-order-notes',
  params: {
  }, headers: headers

p JSON.parse(result)

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "apikey": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://localhost:3000/v1/integrations/shopify/shopify-order-notes", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /v1/integrations/shopify/shopify-order-notes

Parameters

Name	In	Type	Required	Description
shopDomain	query	string	false	none
orderId	query	string	false	none

Example responses

200 Response

{
  "notes": [
    {
      "name": "string",
      "value": "string"
    }
  ],
  "tags": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	A successful response.	modelShopifyOrderNotesResponse
204	No Content	Successfully processed the request, no content.	None
403	Forbidden	Returned when the user does not have permission to access the resource.	None
404	Not Found	Returned when the resource does not exist.	None

Schemas

modelAbsaDebiCheckOutputRequest

{
  "transmissionDate": "string",
  "fileStoragePath": "string",
  "transactions": [
    {
      "paymentId": "string",
      "accepted": true,
      "contractReference": "string",
      "mandateReference": "string",
      "sequenceType": "string",
      "amountInCents": 0,
      "effectiveDate": "string",
      "originalEndToEndTransactionIdentifier": "string",
      "error": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
transmissionDate	string	false	none	none
fileStoragePath	string	false	none	none
transactions	[modelAbsaDebiCheckOutputTransaction]	false	none	none

modelAbsaDebiCheckOutputTransaction

{
  "paymentId": "string",
  "accepted": true,
  "contractReference": "string",
  "mandateReference": "string",
  "sequenceType": "string",
  "amountInCents": 0,
  "effectiveDate": "string",
  "originalEndToEndTransactionIdentifier": "string",
  "error": "string"
}

Properties

Name	Type	Required	Restrictions	Description
paymentId	string	false	none	none
accepted	boolean	false	none	none
contractReference	string	false	none	none
mandateReference	string	false	none	none
sequenceType	string	false	none	none
amountInCents	integer(int32)	false	none	none
effectiveDate	string	false	none	none
originalEndToEndTransactionIdentifier	string	false	none	none
error	string	false	none	none

modelAbsaDebiCheckReplyRequest

{
  "transmissionNumber": "string",
  "transmissionDate": "string",
  "transmissionStatus": "string",
  "fileStoragePath": "string",
  "rejectedReasons": [
    {
      "contractReference": "string",
      "reason": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
transmissionNumber	string	false	none	none
transmissionDate	string	false	none	none
transmissionStatus	string	false	none	none
fileStoragePath	string	false	none	none
rejectedReasons	[modelRejectedReasons]	false	none	none

modelAbsaDebiCheckResponse

{}

Properties

None

modelAbsaEftOutputRequest

{
  "transmissionNumber": 0,
  "fileStoragePath": "string",
  "rejectedTransactions": [
    {
      "transmissionDate": "string",
      "originalSequenceNumber": 0,
      "amount": 0,
      "userReference": "string",
      "rejectionReason": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
transmissionNumber	integer(int32)	false	none	none
fileStoragePath	string	false	none	none
rejectedTransactions	[modelRejectedTransaction]	false	none	none

modelAbsaEftReplyRequest

{
  "ldCode": "string",
  "transmissionNumber": 0,
  "transmissionStatus": "string",
  "fileStoragePath": "string"
}

Properties

Name	Type	Required	Restrictions	Description
ldCode	string	false	none	none
transmissionNumber	integer(int32)	false	none	none
transmissionStatus	string	false	none	none
fileStoragePath	string	false	none	none

modelAbsaEftResponse

{}

Properties

None

modelApikeyResponse

{
  "apikey": "string"
}

Properties

Name	Type	Required	Restrictions	Description
apikey	string	false	none	none

modelBankCreateRequest

{
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
displayName	string	false	none	none
shortName	string	false	none	none
branchCode	string	false	none	none
avsInstitutionCode	string	false	none	none

modelBankDetails

{
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "bankName": "string",
  "verified": true
}

Properties

Name	Type	Required	Restrictions	Description
accountType	string	false	none	none
accountNumber	string	false	none	none
branchCode	string	false	none	none
bankName	string	false	none	none
verified	boolean	false	none	none

modelBankGetManyResponse

{
  "banks": [
    {
      "_id": "string",
      "name": "string",
      "displayName": "string",
      "shortName": "string",
      "branchCode": "string",
      "avsInstitutionCode": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
banks	[modelBankResponse]	false	none	none

modelBankInfo

{
  "bankName": {
    "verified": true,
    "value": "string"
  },
  "account": {
    "verified": true,
    "value": "string"
  },
  "accountType": {
    "verified": true,
    "value": "string"
  },
  "branchCode": {
    "verified": true,
    "value": "string"
  },
  "idNumber": {
    "verified": true,
    "value": "string"
  },
  "verified": true,
  "clientName": {
    "verified": true,
    "value": "string"
  },
  "cellNumber": {
    "verified": true,
    "value": "string"
  },
  "initials": {
    "verified": true,
    "value": "string"
  },
  "email": {
    "verified": true,
    "value": "string"
  },
  "validationResponseErrors": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
bankName	modelBankValidation	false	none	none
account	modelBankValidation	false	none	none
accountType	modelBankValidation	false	none	none
branchCode	modelBankValidation	false	none	none
idNumber	modelBankValidation	false	none	none
verified	boolean	false	none	none
clientName	modelBankValidation	false	none	none
cellNumber	modelBankValidation	false	none	none
initials	modelBankValidation	false	none	none
email	modelBankValidation	false	none	none
validationResponseErrors	[string]	false	none	none

modelBankResponse

{
  "_id": "string",
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
name	string	false	none	none
displayName	string	false	none	none
shortName	string	false	none	none
branchCode	string	false	none	none
avsInstitutionCode	string	false	none	none

modelBankTransactionCreate

{
  "date": "string",
  "description": "string",
  "reference": "string",
  "amountInCents": 0,
  "balanceInCents": 0,
  "bank": "string",
  "fileStorageReference": "string"
}

Properties

Name	Type	Required	Restrictions	Description
date	string	false	none	none
description	string	false	none	none
reference	string	false	none	none
amountInCents	integer(int32)	false	none	none
balanceInCents	integer(int32)	false	none	none
bank	string	false	none	none
fileStorageReference	string	false	none	none

modelBankTransactionCreateRequest

{
  "bankTransactions": [
    {
      "date": "string",
      "description": "string",
      "reference": "string",
      "amountInCents": 0,
      "balanceInCents": 0,
      "bank": "string",
      "fileStorageReference": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
bankTransactions	[modelBankTransactionCreate]	false	none	none

modelBankTransactionPaymentRequest

{
  "destinationId": "string",
  "destinationType": "string",
  "amount": 0
}

Properties

Name	Type	Required	Restrictions	Description
destinationId	string	false	none	none
destinationType	string	false	none	none
amount	integer(int32)	false	none	none

modelBankTransactionResponse

{}

Properties

None

modelBankTransactionUpdate

{
  "bankTransactionIds": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
bankTransactionIds	[string]	false	none	none

modelBankUpdateRequest

{
  "name": "string",
  "displayName": "string",
  "shortName": "string",
  "branchCode": "string",
  "avsInstitutionCode": "string"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
displayName	string	false	none	none
shortName	string	false	none	none
branchCode	string	false	none	none
avsInstitutionCode	string	false	none	none

modelBankValidation

{
  "verified": true,
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
verified	boolean	false	none	none
value	string	false	none	none

modelBillingAddress

{
  "country": "string",
  "province": "string",
  "streetAddress": "string",
  "city": "string",
  "postalCode": "string"
}

Properties

Name	Type	Required	Restrictions	Description
country	string	false	none	none
province	string	false	none	none
streetAddress	string	false	none	none
city	string	false	none	none
postalCode	string	false	none	none

modelCancellationDefinition

{
  "type": {
    "name": "string",
    "definition": {
      "missed": 0,
      "percentage": 0
    },
    "finalPaymentMissed": true
  },
  "policy": {
    "name": "Deposit",
    "definition": {
      "deposit": true,
      "percentage": 0,
      "flatFee": 0,
      "percentageShouldUseTotalPaid": true
    }
  },
  "start": 0,
  "end": 0,
  "gracePeriod": 0
}

Properties

Name	Type	Required	Restrictions	Description
type	modelCancellationType	false	none	none
policy	modelCancellationPolicy	false	none	none
start	integer(int32)	false	none	none
end	integer(int32)	false	none	none
gracePeriod	integer(int32)	false	none	none

modelCancellationPolicy

{
  "name": "Deposit",
  "definition": {
    "deposit": true,
    "percentage": 0,
    "flatFee": 0,
    "percentageShouldUseTotalPaid": true
  }
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
definition	modelCancellationPolicyDefinition	false	none	none

Enumerated Values

Property	Value
name	Deposit
name	Percentage
name	FlatFee
name	Combination

modelCancellationPolicyDefinition

{
  "deposit": true,
  "percentage": 0,
  "flatFee": 0,
  "percentageShouldUseTotalPaid": true
}

Properties

Name	Type	Required	Restrictions	Description
deposit	boolean	false	none	none
percentage	integer(int32)	false	none	none
flatFee	integer(int32)	false	none	none
percentageShouldUseTotalPaid	boolean	false	none	none

modelCancellationTermRequest

{
  "active": true,
  "definition": [
    {
      "type": {
        "name": "string",
        "definition": {
          "missed": 0,
          "percentage": 0
        },
        "finalPaymentMissed": true
      },
      "policy": {
        "name": "Deposit",
        "definition": {
          "deposit": true,
          "percentage": 0,
          "flatFee": 0,
          "percentageShouldUseTotalPaid": true
        }
      },
      "start": 0,
      "end": 0,
      "gracePeriod": 0
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
active	boolean	false	none	none
definition	[modelCancellationDefinition]	false	none	none

modelCancellationType

{
  "name": "string",
  "definition": {
    "missed": 0,
    "percentage": 0
  },
  "finalPaymentMissed": true
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
definition	modelCancellationTypeDefinition	false	none	none
finalPaymentMissed	boolean	false	none	none

modelCancellationTypeDefinition

{
  "missed": 0,
  "percentage": 0
}

Properties

Name	Type	Required	Restrictions	Description
missed	integer(int32)	false	none	none
percentage	integer(int32)	false	none	none

modelCardRequest

{
  "userId": "string",
  "defaultCard": true,
  "redirectUrl": "string"
}

card

Properties

Name	Type	Required	Restrictions	Description
userId	string	false	none	none
defaultCard	boolean	false	none	none
redirectUrl	string	false	none	none

modelCardResponse

{
  "_id": "string",
  "userId": "string",
  "nameOnCard": "string",
  "cardType": "string",
  "cardDigits": "string",
  "defaultCard": true,
  "expiryMonth": "string",
  "expiryYear": "string",
  "timestamp": 0.1,
  "checkoutId": "string",
  "resourcePath": "string",
  "merchantId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
userId	string	false	none	none
nameOnCard	string	false	none	none
cardType	string	false	none	none
cardDigits	string	false	none	none
defaultCard	boolean	false	none	none
expiryMonth	string	false	none	none
expiryYear	string	false	none	none
timestamp	number(double)	false	none	none
checkoutId	string	false	none	none
resourcePath	string	false	none	none
merchantId	string	false	none	none

modelCardResponseMany

{
  "clientCards": [
    {
      "_id": "string",
      "userId": "string",
      "nameOnCard": "string",
      "cardType": "string",
      "cardDigits": "string",
      "defaultCard": true,
      "expiryMonth": "string",
      "expiryYear": "string",
      "timestamp": 0.1,
      "checkoutId": "string",
      "resourcePath": "string",
      "merchantId": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
clientCards	[modelCardResponse]	false	none	none

modelCommunication

{
  "channels": [
    "string"
  ],
  "messages": {
    "orderExpiryReminder": {
      "enabled": true,
      "daysBeforeExpiryInDays": 0
    },
    "orderActivated": {
      "enabled": true
    },
    "cancellation": {
      "enabled": true
    },
    "refund": {
      "enabled": true
    }
  }
}

Properties

Name	Type	Required	Restrictions	Description
channels	[string]	false	none	none
messages	modelCommunicationMessage	false	none	none

modelCommunicationMessage

{
  "orderExpiryReminder": {
    "enabled": true,
    "daysBeforeExpiryInDays": 0
  },
  "orderActivated": {
    "enabled": true
  },
  "cancellation": {
    "enabled": true
  },
  "refund": {
    "enabled": true
  }
}

Properties

Name	Type	Required	Restrictions	Description
orderExpiryReminder	modelOrderExpiryReminder	false	none	none
orderActivated	modelMessageNotification	false	none	none
cancellation	modelMessageNotification	false	none	none
refund	modelMessageNotification	false	none	none

modelConnector

{
  "_id": "string",
  "paymentMethod": "string",
  "paymentProvider": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
paymentMethod	string	false	none	none
paymentProvider	string	false	none	none

modelConnectorData

{
  "paymentProvider": "string",
  "paymentMethod": "string"
}

Connector data bypasses protobuf conversion to allow any fields.

Properties

Name	Type	Required	Restrictions	Description
paymentProvider	string	false	none	none
paymentMethod	string	false	none	none

modelConnectorDataV2

{
  "bankTransactionId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
bankTransactionId	string	false	none	none

modelConnectorRequest

{
  "paymentProviderPaymentId": "string",
  "connector": {
    "_id": "string",
    "paymentMethod": "string",
    "paymentProvider": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
paymentProviderPaymentId	string	false	none	none
connector	modelConnector	false	none	none

modelConnectorResponse

{
  "_id": "string",
  "paymentMethod": "string",
  "paymentProvider": "string",
  "amount": 0,
  "paymentProviderPaymentId": "string",
  "paymentReference": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
paymentMethod	string	false	none	none
paymentProvider	string	false	none	none
amount	integer(int32)	false	none	none
paymentProviderPaymentId	string	false	none	none
paymentReference	string	false	none	none

modelCueOrder

{
  "reference": "string",
  "endDateMax": "string",
  "dueDate": "string",
  "balance": 0,
  "cancellationFee": 0
}

Properties

Name	Type	Required	Restrictions	Description
reference	string	false	none	none
endDateMax	string	false	none	none
dueDate	string	false	none	none
balance	integer(int32)	false	none	none
cancellationFee	integer(int32)	false	none	none

modelCueOrderResponseMany

{
  "orders": [
    {
      "reference": "string",
      "endDateMax": "string",
      "dueDate": "string",
      "balance": 0,
      "cancellationFee": 0
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
orders	[modelCueOrder]	false	none	none

modelCustomerData

{
  "firstName": "string",
  "lastName": "string",
  "email": "string",
  "phone": "string",
  "address": "string",
  "address2": "string",
  "city": "string",
  "province": "string",
  "postalCode": "string"
}

Properties

Name	Type	Required	Restrictions	Description
firstName	string	false	none	none
lastName	string	false	none	none
email	string	false	none	none
phone	string	false	none	none
address	string	false	none	none
address2	string	false	none	none
city	string	false	none	none
province	string	false	none	none
postalCode	string	false	none	none

modelCustomize

{
  "logo": {
    "enabled": true,
    "value": "string"
  },
  "imageUrl": {
    "enabled": true,
    "value": "string"
  },
  "paymentWidget": {
    "enabled": true,
    "value": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
logo	modelLogo	false	none	none
imageUrl	modelImageUrl	false	none	none
paymentWidget	modelPaymentWidgetLogo	false	none	none

modelDateTimeRange

{
  "fromDateTime": "string",
  "toDateTime": "string"
}

Properties

Name	Type	Required	Restrictions	Description
fromDateTime	string	false	none	none
toDateTime	string	false	none	none

modelDebicheckCollection

{
  "raw": "string"
}

Properties

Name	Type	Required	Restrictions	Description
raw	string	false	none	none

modelDebicheckCollectionRequest

{
  "due": "string"
}

Properties

Name	Type	Required	Restrictions	Description
due	string	false	none	none

modelDebicheckCollectionResponse

{
  "collections": [
    {
      "raw": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
collections	[modelDebicheckCollection]	false	none	none

modelDebicheckContact

{
  "medium": "string",
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
medium	string	false	none	2 for OfficePhone, 11 for EmailAddress.
value	string	false	none	none

modelDebicheckMandateContact

{
  "medium": 0,
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
medium	integer(int32)	false	none	none
value	string	false	none	none

modelDebicheckMandateCustomer

{
  "name": "string",
  "identification": "string",
  "identificationType": "string",
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "contact": [
    {
      "medium": 0,
      "value": "string"
    }
  ],
  "simulated": true
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
identification	string	false	none	none
identificationType	string	false	none	none
accountType	string	false	none	none
accountNumber	string	false	none	none
branchCode	string	false	none	none
contact	[modelDebicheckMandateContact]	false	none	none
simulated	boolean	false	none	none

modelDebicheckMandateListResponse

{
  "status": "string",
  "debicheckFailedReasons": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
status	string	false	none	none
debicheckFailedReasons	[string]	false	none	none

modelDebicheckMandateResponse

{
  "_id": "string",
  "customer": {
    "name": "string",
    "identification": "string",
    "identificationType": "string",
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "contact": [
      {
        "medium": 0,
        "value": "string"
      }
    ],
    "simulated": true
  },
  "createdAt": "string",
  "simulation": true
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
customer	modelDebicheckMandateCustomer	false	none	none
createdAt	string	false	none	none
simulation	boolean	false	none	none

modelDebicheckRequest

{
  "name": "string",
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "contact": [
    {
      "medium": "string",
      "value": "string"
    }
  ],
  "identificationType": "string",
  "identification": "string",
  "paymentPlanId": "string",
  "simulation": true
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
accountType	string	false	none	none
accountNumber	string	false	none	none
branchCode	string	false	none	none
contact	[modelDebicheckContact]	false	none	none
identificationType	string	false	none	none
identification	string	false	none	none
paymentPlanId	string	false	none	none
simulation	boolean	false	none	none

modelDebitOrderMandateCreateRequest

{
  "merchantId": "string",
  "reference": "string",
  "holderName": "string",
  "holderSurname": "string",
  "contact": "string",
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "identificationType": "string",
  "identificationNumber": "string"
}

Properties

Name	Type	Required	Restrictions	Description
merchantId	string	false	none	none
reference	string	false	none	none
holderName	string	false	none	none
holderSurname	string	false	none	none
contact	string	false	none	none
accountType	string	false	none	none
accountNumber	string	false	none	none
branchCode	string	false	none	none
identificationType	string	false	none	none
identificationNumber	string	false	none	none

modelDebitOrderMandateResponse

{
  "mandateId": "string",
  "merchantId": "string",
  "reference": "string",
  "holderName": "string",
  "holderSurname": "string",
  "contact": "string",
  "accountType": "string",
  "accountNumber": "string",
  "branchCode": "string",
  "identificationType": "string",
  "identificationNumber": "string"
}

Properties

Name	Type	Required	Restrictions	Description
mandateId	string	false	none	none
merchantId	string	false	none	none
reference	string	false	none	none
holderName	string	false	none	none
holderSurname	string	false	none	none
contact	string	false	none	none
accountType	string	false	none	none
accountNumber	string	false	none	none
branchCode	string	false	none	none
identificationType	string	false	none	none
identificationNumber	string	false	none	none

modelDefaultDepositType

{
  "depositType": "string",
  "enabled": true,
  "percentage": 0,
  "flat": 0
}

Properties

Name	Type	Required	Restrictions	Description
depositType	string	false	none	none
enabled	boolean	false	none	none
percentage	integer(int32)	false	none	none
flat	integer(int32)	false	none	none

modelFeature

{
  "enableCustomWidgetLogo": true,
  "enableCustomEmailLogo": true,
  "enableDefaultPaymentPlanImage": true,
  "enableDebiCheck": true,
  "enableCreditCard": true,
  "enableInstantEFT": true,
  "enableAutoCancellation": true,
  "enableManualCancellation": true,
  "enableLayupFee": true,
  "enableAmendmentApi": true,
  "enablePayAt": true,
  "enableCapitecPay": true,
  "enableDashpay": true,
  "enableTerminalCard": true,
  "enableOfflinePayment": true,
  "enableEmbeddedCheckout": true
}

Properties

Name	Type	Required	Restrictions	Description
enableCustomWidgetLogo	boolean	false	none	none
enableCustomEmailLogo	boolean	false	none	none
enableDefaultPaymentPlanImage	boolean	false	none	none
enableDebiCheck	boolean	false	none	none
enableCreditCard	boolean	false	none	none
enableInstantEFT	boolean	false	none	none
enableAutoCancellation	boolean	false	none	none
enableManualCancellation	boolean	false	none	none
enableLayupFee	boolean	false	none	none
enableAmendmentApi	boolean	false	none	none
enablePayAt	boolean	false	none	none
enableCapitecPay	boolean	false	none	none
enableDashpay	boolean	false	none	none
enableTerminalCard	boolean	false	none	none
enableOfflinePayment	boolean	false	none	none
enableEmbeddedCheckout	boolean	false	none	none

modelFee

{
  "id": "string",
  "productName": "string",
  "amountExcludingVAT": 0.1,
  "amountVAT": 0.1,
  "amountTotal": 0.1,
  "merchantId": "string",
  "createdAt": "string",
  "updatedAt": "string",
  "settlementId": "string",
  "paymentId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
productName	string	false	none	none
amountExcludingVAT	number(double)	false	none	none
amountVAT	number(double)	false	none	none
amountTotal	number(double)	false	none	none
merchantId	string	false	none	none
createdAt	string	false	none	none
updatedAt	string	false	none	none
settlementId	string	false	none	none
paymentId	string	false	none	none

modelFeePerProduct

{
  "quantity": 0.1,
  "amountTotal": 0.1,
  "amountExcludingVAT": 0.1,
  "amountVAT": 0.1,
  "product": {
    "_id": "string",
    "name": "string",
    "displayName": "string",
    "feeType": "string",
    "method": "string",
    "billingType": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
quantity	number(double)	false	none	none
amountTotal	number(double)	false	none	none
amountExcludingVAT	number(double)	false	none	none
amountVAT	number(double)	false	none	none
product	modelProduct	false	none	none

modelFeesPerProduct

{
  "quantity": 0,
  "amountTotal": 0.1,
  "amountExcludingVAT": 0.1,
  "amountVAT": 0.1,
  "product": {
    "_id": "string",
    "name": "string",
    "displayName": "string",
    "feeType": "string",
    "method": "string",
    "billingType": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
quantity	integer(int32)	false	none	none
amountTotal	number(double)	false	none	none
amountExcludingVAT	number(double)	false	none	none
amountVAT	number(double)	false	none	none
product	modelProduct	false	none	none

modelForgotPasswordRequest

{
  "value": "string",
  "channel": "string",
  "redirectTo": "string",
  "isRealtimeVerification": true
}

Properties

Name	Type	Required	Restrictions	Description
value	string	false	none	none
channel	string	false	none	none
redirectTo	string	false	none	none
isRealtimeVerification	boolean	false	none	none

modelForgotPasswordResponse

{
  "status": "string"
}

Properties

Name	Type	Required	Restrictions	Description
status	string	false	none	none

modelGenerateReportResponse

{
  "report": {
    "id": "string",
    "merchantId": "string",
    "exVatAmount": 0,
    "vatAmount": 0,
    "totalAmount": 0,
    "settled": true,
    "reconciled": true,
    "bankTransactionId": "string",
    "reference": "string",
    "accountingInvoiceId": "string",
    "accountingInvoiceNumber": "string",
    "status": "string",
    "createdAt": "string",
    "feesPerProduct": [
      {
        "quantity": 0,
        "amountTotal": 0.1,
        "amountExcludingVAT": 0.1,
        "amountVAT": 0.1,
        "product": {
          "_id": "string",
          "name": "string",
          "displayName": "string",
          "feeType": "string",
          "method": "string",
          "billingType": "string"
        }
      }
    ],
    "report": {
      "totalFeesAmount": 0,
      "totalFeesExtAmount": 0,
      "totalAmountVAT": 0,
      "feesPerProductExcludingVATTotal": 0,
      "feesPerProductVATTotal": 0,
      "feesPerProductTotal": 0,
      "fees": [
        {
          "id": "string",
          "productName": "string",
          "amountExcludingVAT": 0.1,
          "amountVAT": 0.1,
          "amountTotal": 0.1,
          "merchantId": "string",
          "createdAt": "string",
          "updatedAt": "string",
          "settlementId": "string",
          "paymentId": "string"
        }
      ]
    },
    "billingMethod": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
report	modelInvoiceReport	false	none	none

modelGroupPayment

{
  "enabled": true,
  "cloneLimit": 0,
  "expiry": 0
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
cloneLimit	integer(int32)	false	none	none
expiry	integer(int32)	false	none	none

modelImageUrl

{
  "enabled": true,
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
value	string	false	none	none

modelInternationalMsisdnRequest

{
  "msisdn": "string",
  "countryCode": "string"
}

Properties

Name	Type	Required	Restrictions	Description
msisdn	string	false	none	none
countryCode	string	false	none	none

modelInternationalMsisdnResponse

{
  "msisdn": "string",
  "countryCode": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
msisdn	string	false	none	none
countryCode	string	false	none	none
createdAt	string	false	none	none
updatedAt	string	false	none	none

modelInternationalMsisdnResponseMany

{
  "internationalMsisdns": [
    {
      "msisdn": "string",
      "countryCode": "string",
      "createdAt": "string",
      "updatedAt": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
internationalMsisdns	[modelInternationalMsisdnResponse]	false	none	none

modelInvoice

{
  "_id": "string",
  "merchantId": "string",
  "exVatAmount": 0,
  "vatAmount": 0,
  "totalAmount": 0,
  "settled": true,
  "reconciled": true,
  "bankTransactionId": "string",
  "reference": "string",
  "accountingInvoiceId": "string",
  "accountingInvoiceNumber": "string",
  "status": "string",
  "createdAt": "string",
  "billingMethod": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
merchantId	string	false	none	none
exVatAmount	integer(int32)	false	none	none
vatAmount	integer(int32)	false	none	none
totalAmount	integer(int32)	false	none	none
settled	boolean	false	none	none
reconciled	boolean	false	none	none
bankTransactionId	string	false	none	none
reference	string	false	none	none
accountingInvoiceId	string	false	none	none
accountingInvoiceNumber	string	false	none	none
status	string	false	none	none
createdAt	string	false	none	none
billingMethod	string	false	none	none

modelInvoiceFeesCreateRequest

{
  "feeIds": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
feeIds	[string]	false	none	none

modelInvoiceGetManyResponse

{
  "invoices": [
    {
      "_id": "string",
      "merchantId": "string",
      "exVatAmount": 0,
      "vatAmount": 0,
      "totalAmount": 0,
      "settled": true,
      "reconciled": true,
      "bankTransactionId": "string",
      "reference": "string",
      "accountingInvoiceId": "string",
      "accountingInvoiceNumber": "string",
      "status": "string",
      "createdAt": "string",
      "billingMethod": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
invoices	[modelInvoice]	false	none	none

modelInvoicePdfResponse

{
  "redirectUrl": "string"
}

Properties

Name	Type	Required	Restrictions	Description
redirectUrl	string	false	none	none

modelInvoiceReport

{
  "id": "string",
  "merchantId": "string",
  "exVatAmount": 0,
  "vatAmount": 0,
  "totalAmount": 0,
  "settled": true,
  "reconciled": true,
  "bankTransactionId": "string",
  "reference": "string",
  "accountingInvoiceId": "string",
  "accountingInvoiceNumber": "string",
  "status": "string",
  "createdAt": "string",
  "feesPerProduct": [
    {
      "quantity": 0,
      "amountTotal": 0.1,
      "amountExcludingVAT": 0.1,
      "amountVAT": 0.1,
      "product": {
        "_id": "string",
        "name": "string",
        "displayName": "string",
        "feeType": "string",
        "method": "string",
        "billingType": "string"
      }
    }
  ],
  "report": {
    "totalFeesAmount": 0,
    "totalFeesExtAmount": 0,
    "totalAmountVAT": 0,
    "feesPerProductExcludingVATTotal": 0,
    "feesPerProductVATTotal": 0,
    "feesPerProductTotal": 0,
    "fees": [
      {
        "id": "string",
        "productName": "string",
        "amountExcludingVAT": 0.1,
        "amountVAT": 0.1,
        "amountTotal": 0.1,
        "merchantId": "string",
        "createdAt": "string",
        "updatedAt": "string",
        "settlementId": "string",
        "paymentId": "string"
      }
    ]
  },
  "billingMethod": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
merchantId	string	false	none	none
exVatAmount	integer(int32)	false	none	none
vatAmount	integer(int32)	false	none	none
totalAmount	integer(int32)	false	none	none
settled	boolean	false	none	none
reconciled	boolean	false	none	none
bankTransactionId	string	false	none	none
reference	string	false	none	none
accountingInvoiceId	string	false	none	none
accountingInvoiceNumber	string	false	none	none
status	string	false	none	none
createdAt	string	false	none	none
feesPerProduct	[modelFeesPerProduct]	false	none	none
report	modelReport	false	none	none
billingMethod	string	false	none	none

modelInvoiceResponse

{}

Properties

None

modelInvoiceUpdatePdfRequest

{
  "accountingPdfLocation": "string"
}

Properties

Name	Type	Required	Restrictions	Description
accountingPdfLocation	string	false	none	none

modelInvoiceUpdateRequest

{
  "invoiceId": "string",
  "accountingInvoiceId": "string",
  "accountingInvoiceNumber": "string"
}

Properties

Name	Type	Required	Restrictions	Description
invoiceId	string	false	none	none
accountingInvoiceId	string	false	none	none
accountingInvoiceNumber	string	false	none	none

modelInvoicesResponse

{
  "invoiceIds": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
invoiceIds	[string]	false	none	none

modelJournalFeeResponse

{
  "_id": "string",
  "productName": "string",
  "amountTotal": 0.1,
  "amountExcludingVAT": 0.1,
  "amountVAT": 0.1,
  "orderId": "string",
  "paymentPlanId": "string",
  "paymentId": "string",
  "merchantId": "string",
  "settled": true,
  "reconciled": true,
  "settlementId": "string",
  "invoiceId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
productName	string	false	none	none
amountTotal	number(double)	false	none	none
amountExcludingVAT	number(double)	false	none	none
amountVAT	number(double)	false	none	none
orderId	string	false	none	none
paymentPlanId	string	false	none	none
paymentId	string	false	none	none
merchantId	string	false	none	none
settled	boolean	false	none	none
reconciled	boolean	false	none	none
settlementId	string	false	none	none
invoiceId	string	false	none	none

modelJournalFees

{
  "id": "string",
  "productName": "string",
  "amountExcludingVAT": 0.1,
  "amountVAT": 0.1,
  "amountTotal": 0.1,
  "merchantId": "string",
  "createdAt": "string",
  "updatedAt": "string",
  "settlementId": "string",
  "paymentId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
productName	string	false	none	none
amountExcludingVAT	number(double)	false	none	none
amountVAT	number(double)	false	none	none
amountTotal	number(double)	false	none	none
merchantId	string	false	none	none
createdAt	string	false	none	none
updatedAt	string	false	none	none
settlementId	string	false	none	none
paymentId	string	false	none	none

modelJournalRequest

{
  "orderId": "string",
  "participantId": "string",
  "note": "string",
  "amount": 0
}

Properties

Name	Type	Required	Restrictions	Description
orderId	string	false	none	none
participantId	string	false	none	none
note	string	false	none	none
amount	integer(int32)	false	none	none

modelJournalResponse

{
  "_id": "string",
  "orderId": "string",
  "participantId": "string",
  "note": "string",
  "amount": 0,
  "amountExcludingFee": 0
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
orderId	string	false	none	none
participantId	string	false	none	none
note	string	false	none	none
amount	integer(int32)	false	none	none
amountExcludingFee	integer(int32)	false	none	none

modelLoginRequest

{
  "username": "string",
  "password": "pa$$word",
  "rememberMe": true
}

Properties

Name	Type	Required	Restrictions	Description
username	string	false	none	none
password	string(password)	false	none	none
rememberMe	boolean	false	none	none

modelLogo

{
  "enabled": true,
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
value	string	false	none	none

modelMerchantAccountSettings

{
  "numberOfUsers": 0,
  "apiAccess": true
}

Properties

Name	Type	Required	Restrictions	Description
numberOfUsers	integer(int32)	false	none	none
apiAccess	boolean	false	none	none

modelMerchantBillingSettlementRequest

{
  "merchantName": "string",
  "userName": "string",
  "userEmail": "string",
  "merchantId": "string",
  "merchantContactNumber": "string",
  "message": "string"
}

Properties

Name	Type	Required	Restrictions	Description
merchantName	string	false	none	none
userName	string	false	none	none
userEmail	string	false	none	none
merchantId	string	false	none	none
merchantContactNumber	string	false	none	none
message	string	false	none	none

modelMerchantBillingSettlementResponse

{
  "status": "string"
}

Properties

Name	Type	Required	Restrictions	Description
status	string	false	none	none

modelMerchantOnboarding

{
  "name": "string",
  "physicalAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
physicalAddress	modelBillingAddress	false	none	none

modelMerchantRequest

{
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "expire": 0,
  "merchantTermsLink": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "settlementFrequency": "string",
  "settlementType": "string",
  "settlementDay": 0,
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "absorbsFee": true,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "simulated": true,
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}

-- Communication

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
domain	string	false	none	none
active	boolean	false	none	none
flatFee	integer(int32)	false	none	none
percFee	number(double)	false	none	none
notifyUrl	string	false	none	none
paymentNotifyUrl	string	false	none	none
expire	integer(int32)	false	none	none
merchantTermsLink	string	false	none	none
supportEmail	string	false	none	none
supportMobile	string	false	none	none
imageUrl	string	false	none	none
newOrder	modelNotification	false	none	none
amendmentOrder	modelNotification	false	none	none
cancelledOrder	modelNotification	false	none	none
completedOrder	modelNotification	false	none	none
successfulPayment	modelNotification	false	none	none
failedPayment	modelNotification	false	none	none
missedPayment	modelNotification	false	none	none
autoSettlement	boolean	false	none	none
settlementFrequency	string	false	none	none
settlementType	string	false	none	none
settlementDay	integer(int32)	false	none	none
bankDetails	modelBankDetails	false	none	none
absorbsFee	boolean	false	none	none
cancellationTerms	modelCancellationTermRequest	false	none	none
weeklyPayments	boolean	false	none	none
paymentPlans	modelPaymentPlanSettings	false	none	none
expiredOrder	modelNotification	false	none	none
completedOrder_75	modelNotification_Percentage	false	none	none
customFeatures	modelCustomize	false	none	none
features	modelFeature	false	none	none
cancellationRequest	modelNotification	false	none	none
billingAddress	modelBillingAddress	false	none	none
vatNo	string	false	none	none
registeredEntity	string	false	none	none
settlements	modelNotification	false	none	none
invoices	modelNotification	false	none	none
onboardingState	string	false	none	none
accountType	string	false	none	none
contractDocumentId	string	false	none	none
merchantBankingPercFee	integer(int32)	false	none	none
adminPercFee	integer(int32)	false	none	none
contractUrl	string	false	none	none
contractUpdated	boolean	false	none	none
bankDetailsValidation	modelBankInfo	false	none	none
bankValidationPendingReference	string	false	none	none
merchantContractSigned	string	false	none	none
transfers	modelNotification	false	none	none
refunds	modelNotification	false	none	none
simulated	boolean	false	none	none
suspendedOrder	modelNotification	false	none	none
monthlyPayments	boolean	false	none	none
displayOnWeb	modelshopDirectorySettings	false	none	none
tradingName	string	false	none	none
pricelistId	string	false	none	none
communication	modelCommunication	false	none	none
defaultBillingMethod	string	false	none	none
enableTwoFactorAuthentication	boolean	false	none	none
voucherSettings	modelMerchantVoucherSettings	false	none	none
settlementBatchReferencePrefix	string	false	none	none

modelMerchantResponse

{
  "_id": "string",
  "name": "string",
  "domain": "string",
  "active": true,
  "flatFee": 0,
  "percFee": 0.1,
  "users": [
    {
      "_id": "string",
      "username": "string",
      "email": "[email protected]",
      "idNumber": "string",
      "address": "string",
      "postalCode": "string",
      "city": "string",
      "province": "string",
      "country": "string",
      "role": "CLIENT",
      "active": true,
      "merchantId": "string",
      "cellNumber": "string",
      "dateOfBirth": "string",
      "name": "string",
      "verified": true,
      "verifiedEmail": true,
      "verifiedMobile": true,
      "merchantRole": "string",
      "merchantIds": [
        "string"
      ]
    }
  ],
  "notifyUrl": "string",
  "paymentNotifyUrl": "string",
  "timestamp": 0.1,
  "merchantTermsLink": "string",
  "settlementDay": 0,
  "settlementFrequency": "string",
  "settlementType": "string",
  "supportEmail": "string",
  "supportMobile": "string",
  "imageUrl": "string",
  "newOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "amendmentOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "cancelledOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "successfulPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "failedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "missedPayment": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "autoSettlement": true,
  "absorbsFee": true,
  "expire": 0,
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentPlans": {
    "weeklyPayments": true,
    "splitPayments": true,
    "orderExpiry": {
      "enabled": true,
      "value": 0
    },
    "maxMonths": {
      "enabled": true,
      "value": 0
    },
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "editPaymentPlanSettings": true,
    "defaultDepositType": {
      "depositType": "string",
      "enabled": true,
      "percentage": 0,
      "flat": 0
    },
    "minMonths": {
      "enabled": true,
      "value": 0
    },
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "monthlyPayments": true,
    "suspendOnCancel": true
  },
  "expiredOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "completedOrder_75": {
    "enabled": true,
    "emails": [
      "string"
    ],
    "value": 0
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "features": {
    "enableCustomWidgetLogo": true,
    "enableCustomEmailLogo": true,
    "enableDefaultPaymentPlanImage": true,
    "enableDebiCheck": true,
    "enableCreditCard": true,
    "enableInstantEFT": true,
    "enableAutoCancellation": true,
    "enableManualCancellation": true,
    "enableLayupFee": true,
    "enableAmendmentApi": true,
    "enablePayAt": true,
    "enableCapitecPay": true,
    "enableDashpay": true,
    "enableTerminalCard": true,
    "enableOfflinePayment": true,
    "enableEmbeddedCheckout": true
  },
  "cancellationRequest": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "merchantName": "string",
  "billingAddress": {
    "country": "string",
    "province": "string",
    "streetAddress": "string",
    "city": "string",
    "postalCode": "string"
  },
  "vatNo": "string",
  "registeredEntity": "string",
  "bankDetails": {
    "accountType": "string",
    "accountNumber": "string",
    "branchCode": "string",
    "bankName": "string",
    "verified": true
  },
  "settlements": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "invoices": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "onboardingState": "string",
  "accountType": "string",
  "contractDocumentId": "string",
  "merchantBankingPercFee": 0,
  "adminPercFee": 0,
  "contractUrl": "string",
  "contractUpdated": true,
  "bankDetailsValidation": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "bankValidationPendingReference": "string",
  "merchantContractSigned": "string",
  "transfers": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "refunds": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "suspendedOrder": {
    "enabled": true,
    "emails": [
      "string"
    ]
  },
  "monthlyPayments": true,
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "tradingName": "string",
  "pricelistId": "string",
  "accountSettings": {
    "numberOfUsers": 0,
    "apiAccess": true
  },
  "feeSystem": "string",
  "communication": {
    "channels": [
      "string"
    ],
    "messages": {
      "orderExpiryReminder": {
        "enabled": true,
        "daysBeforeExpiryInDays": 0
      },
      "orderActivated": {
        "enabled": true
      },
      "cancellation": {
        "enabled": true
      },
      "refund": {
        "enabled": true
      }
    }
  },
  "defaultBillingMethod": "string",
  "enableTwoFactorAuthentication": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProviders": [
      {
        "name": "string",
        "apiKey": "string",
        "apiUrl": "string"
      }
    ]
  },
  "settlementBatchReferencePrefix": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
name	string	false	none	none
domain	string	false	none	none
active	boolean	false	none	none
flatFee	integer(int32)	false	none	none
percFee	number(double)	false	none	none
users	[modelUser]	false	none	[This user is loaded in by the authentication middleware.]
notifyUrl	string	false	none	none
paymentNotifyUrl	string	false	none	none
timestamp	number(double)	false	none	none
merchantTermsLink	string	false	none	none
settlementDay	integer(int32)	false	none	none
settlementFrequency	string	false	none	none
settlementType	string	false	none	none
supportEmail	string	false	none	none
supportMobile	string	false	none	none
imageUrl	string	false	none	none
newOrder	modelNotification	false	none	none
amendmentOrder	modelNotification	false	none	none
cancelledOrder	modelNotification	false	none	none
completedOrder	modelNotification	false	none	none
successfulPayment	modelNotification	false	none	none
failedPayment	modelNotification	false	none	none
missedPayment	modelNotification	false	none	none
autoSettlement	boolean	false	none	none
absorbsFee	boolean	false	none	none
expire	integer(int32)	false	none	none
cancellationTerms	modelCancellationTermRequest	false	none	none
weeklyPayments	boolean	false	none	none
paymentPlans	modelPaymentPlanSettings	false	none	none
expiredOrder	modelNotification	false	none	none
completedOrder_75	modelNotification_Percentage	false	none	none
customFeatures	modelCustomize	false	none	none
features	modelFeature	false	none	none
cancellationRequest	modelNotification	false	none	none
merchantName	string	false	none	none
billingAddress	modelBillingAddress	false	none	none
vatNo	string	false	none	none
registeredEntity	string	false	none	none
bankDetails	modelBankDetails	false	none	none
settlements	modelNotification	false	none	none
invoices	modelNotification	false	none	none
onboardingState	string	false	none	none
accountType	string	false	none	none
contractDocumentId	string	false	none	none
merchantBankingPercFee	integer(int32)	false	none	none
adminPercFee	integer(int32)	false	none	none
contractUrl	string	false	none	none
contractUpdated	boolean	false	none	none
bankDetailsValidation	modelBankInfo	false	none	none
bankValidationPendingReference	string	false	none	none
merchantContractSigned	string	false	none	none
transfers	modelNotification	false	none	none
refunds	modelNotification	false	none	none
suspendedOrder	modelNotification	false	none	none
monthlyPayments	boolean	false	none	none
displayOnWeb	modelshopDirectorySettings	false	none	none
tradingName	string	false	none	none
pricelistId	string	false	none	none
accountSettings	modelMerchantAccountSettings	false	none	none
feeSystem	string	false	none	none
communication	modelCommunication	false	none	none
defaultBillingMethod	string	false	none	none
enableTwoFactorAuthentication	boolean	false	none	none
voucherSettings	modelMerchantVoucherSettings	false	none	none
settlementBatchReferencePrefix	string	false	none	none

modelMerchantResponseGetShops

{
  "_id": "string",
  "name": "string",
  "domain": "string",
  "displayOnWeb": {
    "enabled": true,
    "webAvailability": "string",
    "webLogoImage": "string",
    "webCategory": [
      "string"
    ],
    "featured": true
  },
  "createdAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
name	string	false	none	none
domain	string	false	none	none
displayOnWeb	modelshopDirectorySettings	false	none	none
createdAt	string	false	none	none

modelMerchantResponseShops

{
  "categories": [
    "string"
  ],
  "shops": [
    {
      "_id": "string",
      "name": "string",
      "domain": "string",
      "displayOnWeb": {
        "enabled": true,
        "webAvailability": "string",
        "webLogoImage": "string",
        "webCategory": [
          "string"
        ],
        "featured": true
      },
      "createdAt": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
categories	[string]	false	none	none
shops	[modelMerchantResponseGetShops]	false	none	none

modelMerchantVoucherSettings

{
  "active": true,
  "minimumSavingGoalInCents": 0,
  "maximumSavingGoalInCents": 0,
  "rewardType": "string",
  "rewardFlatAmountInCents": 0,
  "rewardPercentage": 0,
  "voucherProviders": [
    {
      "name": "string",
      "apiKey": "string",
      "apiUrl": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
active	boolean	false	none	none
minimumSavingGoalInCents	integer(int32)	false	none	none
maximumSavingGoalInCents	integer(int32)	false	none	none
rewardType	string	false	none	none
rewardFlatAmountInCents	integer(int32)	false	none	none
rewardPercentage	integer(int32)	false	none	none
voucherProviders	[modelVoucherProvider]	false	none	none

modelMerchants

{
  "_id": "string",
  "name": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
name	string	false	none	none

modelMessageNotification

{
  "enabled": true
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none

modelNameAndValue

{
  "name": "string",
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
value	string	false	none	none

modelNote

{
  "change": "string",
  "date": "string",
  "name": "string",
  "reason": "string",
  "details": "string",
  "read": true,
  "userId": "string",
  "type": "string",
  "hide": true,
  "unread": true
}

Properties

Name	Type	Required	Restrictions	Description
change	string	false	none	none
date	string	false	none	none
name	string	false	none	none
reason	string	false	none	none
details	string	false	none	none
read	boolean	false	none	none
userId	string	false	none	none
type	string	false	none	none
hide	boolean	false	none	none
unread	boolean	false	none	none

modelNotification

{
  "enabled": true,
  "emails": [
    "string"
  ]
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
emails	[string]	false	none	none

modelNotification_Percentage

{
  "enabled": true,
  "emails": [
    "string"
  ],
  "value": 0
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
emails	[string]	false	none	none
value	integer(int32)	false	none	none

modelOfflinePaymentRequest

{
  "amount": 13333,
  "note": "Processed by employeeX",
  "paymentPlanId": "123f7f1496bd78001d6852f3",
  "reference": "Cash in hand",
  "verifiedAt": "2022-01-27T14:00:00.000Z"
}

Properties

Name	Type	Required	Restrictions	Description
amount	integer(int32)	false	none	none
paymentPlanId	string	false	none	none
reference	string	false	none	none
note	string	false	none	none
verifiedAt	string	false	none	none
paymentType	string	false	none	none
excludeFees	boolean	false	none	none
settled	boolean	false	none	none

modelOrderAmendmentRequest

{
  "orderId": "123f7f1496bd78001d6852f3",
  "amendmentType": "PRODUCT:UPDATE",
  "products": "ProductCreateRequest"
}

Properties

Name	Type	Required	Restrictions	Description
orderId	string	false	none	none
amendmentType	string	false	none	none
products	[modelProductCreateRequest]	false	none	none
endDate	string	false	none	none

modelOrderAmendmentResponse

{
  "_id": "string",
  "userId": "string",
  "orderId": "string",
  "amendmentType": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "endDate": "string",
  "from": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "createdAt": "string",
  "updatedAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
userId	string	false	none	none
orderId	string	false	none	none
amendmentType	string	false	none	none
products	[modelProductResponse]	false	none	none
endDate	string	false	none	none
from	modelOrderResponse	false	none	none
createdAt	string	false	none	none
updatedAt	string	false	none	none

modelOrderAmendmentResponseMany

{
  "orderAmendments": [
    {
      "_id": "string",
      "userId": "string",
      "orderId": "string",
      "amendmentType": "string",
      "products": [
        {
          "_id": "string",
          "amount": 0,
          "link": "http://example.com",
          "sku": "string",
          "name": "string",
          "depositType": "string"
        }
      ],
      "endDate": "string",
      "from": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [
          {
            "_id": "string",
            "orderId": "string",
            "benefactorId": "string",
            "completed": true,
            "quantity": 0,
            "depositDue": 0,
            "amountDue": 0,
            "automaticBilling": true,
            "timestamp": 0.1,
            "payments": [
              {
                "_id": "string",
                "due": "string",
                "amount": 0,
                "paid": true,
                "timestamp": 0.1,
                "paymentMethod": "string",
                "paymentType": "string",
                "amountExcludingFee": 0,
                "fee": 0,
                "pending": true,
                "failed": true,
                "reconciliated": true,
                "refundedAmount": 0,
                "refundPaymentId": "string",
                "connectorData": {
                  "_id": "string",
                  "amount": 0,
                  "paymentProviderPaymentId": "string",
                  "paymentReference": "string",
                  "paymentMethod": "string",
                  "paymentProvider": "string",
                  "paymentProviderResponses": {}
                },
                "verifiedAt": "string"
              }
            ],
            "benefactor": {
              "_id": "string",
              "name": "string",
              "email": "string"
            },
            "frequency": "WEEKLY",
            "offset": 0,
            "depositDueExcludingFee": 0,
            "amountDueExcludingFee": 0,
            "order": {},
            "debicheckStatus": "string",
            "debicheckLastFailedReasons": [
              "string"
            ],
            "debicheckMandateActiveId": "string",
            "debicheckMandateIds": [
              "string"
            ],
            "payAtReferenceNumber": "string",
            "agreedToTerms": true
          }
        ],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "createdAt": "string",
      "updatedAt": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
orderAmendments	[modelOrderAmendmentResponse]	false	none	none

modelOrderCancellationTermsResponse

{
  "autoCancellation": true,
  "definition": [
    {
      "type": {
        "name": "string",
        "definition": {
          "missed": 0,
          "percentage": 0
        },
        "finalPaymentMissed": true
      },
      "policy": {
        "name": "Deposit",
        "definition": {
          "deposit": true,
          "percentage": 0,
          "flatFee": 0,
          "percentageShouldUseTotalPaid": true
        }
      },
      "start": 0,
      "end": 0,
      "gracePeriod": 0
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
autoCancellation	boolean	false	none	none
definition	[modelCancellationDefinition]	false	none	none

modelOrderExpiry

{
  "enabled": true,
  "value": 0
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
value	integer(int32)	false	none	none

modelOrderExpiryReminder

{
  "enabled": true,
  "daysBeforeExpiryInDays": 0
}

Communication

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
daysBeforeExpiryInDays	integer(int32)	false	none	none

modelOrderRequest

{
  "products": "ProductCreateRequest",
  "endDateMax": "2019-08-24T14:15:22Z",
  "depositPerc": 5,
  "reference": "string",
  "name": "string",
  "depositType": "INSTALMENT"
}

Properties

Name	Type	Required	Restrictions	Description
depositAmount	integer(int32)	false	none	none
products	[modelProductCreateRequest]	false	none	none
endDateMax	string(date-time)	false	none	none
endDateMin	string(date-time)	false	none	none
depositPerc	number(double)	false	none	none
reference	string	false	none	none
name	string	false	none	none
imageUrl	string	false	none	none
absorbsFee	boolean	false	none	none
enablesSplit	boolean	false	none	none
depositType	string	false	none	none
expire	integer(int32)	false	none	none
cancellationTerms	modelCancellationTermRequest	false	none	none
weeklyPayments	boolean	false	none	none
paymentMethods	modelPaymentMethod	false	none	none
cancellationPolicy	modelCancellationPolicy	false	none	none
groupPaymentPlan	modelGroupPayment	false	none	none
cloneExpiry	integer(int32)	false	none	none
orderCancellationRequest	string	false	none	none
notifications	[modelNote]	false	none	none
acceptedProposedCancellationTerms	boolean	false	none	none
customFeatures	modelCustomize	false	none	none
amortiseOnMissed	boolean	false	none	none
amortiseOnAmend	boolean	false	none	none
suspendOnCancel	boolean	false	none	none
orderRefundRequest	string	false	none	none
completedOrderRefundRequest	boolean	false	none	none
orderRefundAmount	integer(int32)	false	none	none
orderRefundFee	integer(int32)	false	none	none
monthlyPayments	boolean	false	none	none
type	string	false	none	none
description	string	false	none	none
voucherSettings	modelVoucherSettings	false	none	none
merchantId	string	false	none	none

Enumerated Values

Property	Value
depositType	INSTALMENT
depositType	FLAT
depositType	PERCENTAGE

modelOrderResponse

{
  "_id": "string",
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "initiatorId": "string",
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "state": "PARTIAL",
  "supplierId": "string",
  "cancelledBy": "string",
  "amountDue": 0,
  "flatFee": 0,
  "percFee": 0.1,
  "depositPerc": 0.1,
  "absorbsFee": true,
  "reference": "string",
  "name": "string",
  "imageUrl": "string",
  "plans": [
    {
      "_id": "string",
      "orderId": "string",
      "benefactorId": "string",
      "completed": true,
      "quantity": 0,
      "depositDue": 0,
      "amountDue": 0,
      "automaticBilling": true,
      "timestamp": 0.1,
      "payments": [
        {
          "_id": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "pending": true,
          "failed": true,
          "reconciliated": true,
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "_id": "string",
            "amount": 0,
            "paymentProviderPaymentId": "string",
            "paymentReference": "string",
            "paymentMethod": "string",
            "paymentProvider": "string",
            "paymentProviderResponses": {}
          },
          "verifiedAt": "string"
        }
      ],
      "benefactor": {
        "_id": "string",
        "name": "string",
        "email": "string"
      },
      "frequency": "WEEKLY",
      "offset": 0,
      "depositDueExcludingFee": 0,
      "amountDueExcludingFee": 0,
      "order": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "debicheckStatus": "string",
      "debicheckLastFailedReasons": [
        "string"
      ],
      "debicheckMandateActiveId": "string",
      "debicheckMandateIds": [
        "string"
      ],
      "payAtReferenceNumber": "string",
      "agreedToTerms": true
    }
  ],
  "createdAt": "string",
  "timestamp": 0.1,
  "enablesSplit": true,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "expire": "string",
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "weeklyPayments": true,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "stateUpdatedAt": "string",
  "updatedAt": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "cloneExpiry": 0,
  "cloneCount": 0,
  "orderCancellationRequest": "string",
  "notifications": [
    {
      "change": "string",
      "date": "string",
      "name": "string",
      "reason": "string",
      "details": "string",
      "read": true,
      "userId": "string",
      "type": "string",
      "hide": true,
      "unread": true
    }
  ],
  "acceptedProposedCancellationTerms": true,
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "merchantName": "string",
  "merchantTermsLink": "string",
  "merchantLink": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "supplier": {
    "_id": "string",
    "name": "string",
    "merchantId": "string"
  },
  "orderRefundRequest": "string",
  "orderRefundAmount": 0,
  "orderRefundFee": 0,
  "monthlyPayments": true,
  "type": "string",
  "balance": 0,
  "description": "string",
  "isIncreasedDepositAmountAllowed": true,
  "suspendOnCancel": true,
  "voucherSettings": {
    "active": true,
    "minimumSavingGoalInCents": 0,
    "maximumSavingGoalInCents": 0,
    "rewardType": "string",
    "rewardFlatAmountInCents": 0,
    "rewardPercentage": 0,
    "voucherProvider": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
endDateMax	string(date-time)	false	none	none
endDateMin	string(date-time)	false	none	none
initiatorId	string	false	none	none
products	[modelProductResponse]	false	none	none
state	any	false	none	none
supplierId	string	false	none	none
cancelledBy	string	false	none	none
amountDue	integer(int32)	false	none	none
flatFee	integer(int32)	false	none	none
percFee	number(double)	false	none	none
depositPerc	number(double)	false	none	none
absorbsFee	boolean	false	none	none
reference	string	false	none	none
name	string	false	none	none
imageUrl	string	false	none	none
plans	[modelPaymentPlanResponse]	false	none	none
createdAt	string	false	none	none
timestamp	number(double)	false	none	none
enablesSplit	boolean	false	none	none
depositAmount	integer(int32)	false	none	none
depositType	string	false	none	none
expire	string	false	none	none
cancellationTerms	modelCancellationTermRequest	false	none	none
weeklyPayments	boolean	false	none	none
paymentMethods	modelPaymentMethod	false	none	none
stateUpdatedAt	string	false	none	none
updatedAt	string	false	none	none
groupPaymentPlan	modelGroupPayment	false	none	none
cloneExpiry	integer(int32)	false	none	none
cloneCount	integer(int32)	false	none	none
orderCancellationRequest	string	false	none	none
notifications	[modelNote]	false	none	none
acceptedProposedCancellationTerms	boolean	false	none	none
customFeatures	modelCustomize	false	none	none
merchantName	string	false	none	none
merchantTermsLink	string	false	none	none
merchantLink	string	false	none	none
debiCheckMinimum	modelValueEnabledPair	false	none	none
supplier	modelSupplier	false	none	none
orderRefundRequest	string	false	none	none
orderRefundAmount	integer(int32)	false	none	none
orderRefundFee	integer(int32)	false	none	none
monthlyPayments	boolean	false	none	none
type	string	false	none	none
balance	integer(int32)	false	none	none
description	string	false	none	none
isIncreasedDepositAmountAllowed	boolean	false	none	none
suspendOnCancel	boolean	false	none	none
voucherSettings	modelVoucherSettings	false	none	none

Enumerated Values

Property	Value
state	PARTIAL
state	PLACED
state	COMPLETED
state	CANCELLED
state	CANCELLING
state	EXPIRED
state	SUSPENDED
depositType	INSTALMENT
depositType	FLAT
depositType	PERCENTAGE

modelOrderResponseMany

{
  "orders": [
    {
      "_id": "string",
      "endDateMax": "2019-08-24T14:15:22Z",
      "endDateMin": "2019-08-24T14:15:22Z",
      "initiatorId": "string",
      "products": [
        {
          "_id": "string",
          "amount": 0,
          "link": "http://example.com",
          "sku": "string",
          "name": "string",
          "depositType": "string"
        }
      ],
      "state": "PARTIAL",
      "supplierId": "string",
      "cancelledBy": "string",
      "amountDue": 0,
      "flatFee": 0,
      "percFee": 0.1,
      "depositPerc": 0.1,
      "absorbsFee": true,
      "reference": "string",
      "name": "string",
      "imageUrl": "string",
      "plans": [
        {
          "_id": "string",
          "orderId": "string",
          "benefactorId": "string",
          "completed": true,
          "quantity": 0,
          "depositDue": 0,
          "amountDue": 0,
          "automaticBilling": true,
          "timestamp": 0.1,
          "payments": [
            {
              "_id": "string",
              "due": "string",
              "amount": 0,
              "paid": true,
              "timestamp": 0.1,
              "paymentMethod": "string",
              "paymentType": "string",
              "amountExcludingFee": 0,
              "fee": 0,
              "pending": true,
              "failed": true,
              "reconciliated": true,
              "refundedAmount": 0,
              "refundPaymentId": "string",
              "connectorData": {
                "_id": "string",
                "amount": 0,
                "paymentProviderPaymentId": "string",
                "paymentReference": "string",
                "paymentMethod": "string",
                "paymentProvider": "string",
                "paymentProviderResponses": {}
              },
              "verifiedAt": "string"
            }
          ],
          "benefactor": {
            "_id": "string",
            "name": "string",
            "email": "string"
          },
          "frequency": "WEEKLY",
          "offset": 0,
          "depositDueExcludingFee": 0,
          "amountDueExcludingFee": 0,
          "order": {},
          "debicheckStatus": "string",
          "debicheckLastFailedReasons": [
            "string"
          ],
          "debicheckMandateActiveId": "string",
          "debicheckMandateIds": [
            "string"
          ],
          "payAtReferenceNumber": "string",
          "agreedToTerms": true
        }
      ],
      "createdAt": "string",
      "timestamp": 0.1,
      "enablesSplit": true,
      "depositAmount": 0,
      "depositType": "INSTALMENT",
      "expire": "string",
      "cancellationTerms": {
        "active": true,
        "definition": [
          {
            "type": {
              "name": "string",
              "definition": {
                "missed": 0,
                "percentage": 0
              },
              "finalPaymentMissed": true
            },
            "policy": {
              "name": "Deposit",
              "definition": {
                "deposit": true,
                "percentage": 0,
                "flatFee": 0,
                "percentageShouldUseTotalPaid": true
              }
            },
            "start": 0,
            "end": 0,
            "gracePeriod": 0
          }
        ]
      },
      "weeklyPayments": true,
      "paymentMethods": {
        "creditOrDebitCard": true,
        "eft": true,
        "debiCheck": true,
        "payAt": true,
        "capitecPay": true,
        "dashpay": true,
        "terminalCard": true,
        "offline": true,
        "embeddedCheckout": true
      },
      "stateUpdatedAt": "string",
      "updatedAt": "string",
      "groupPaymentPlan": {
        "enabled": true,
        "cloneLimit": 0,
        "expiry": 0
      },
      "cloneExpiry": 0,
      "cloneCount": 0,
      "orderCancellationRequest": "string",
      "notifications": [
        {
          "change": "string",
          "date": "string",
          "name": "string",
          "reason": "string",
          "details": "string",
          "read": true,
          "userId": "string",
          "type": "string",
          "hide": true,
          "unread": true
        }
      ],
      "acceptedProposedCancellationTerms": true,
      "customFeatures": {
        "logo": {
          "enabled": true,
          "value": "string"
        },
        "imageUrl": {
          "enabled": true,
          "value": "string"
        },
        "paymentWidget": {
          "enabled": true,
          "value": "string"
        }
      },
      "merchantName": "string",
      "merchantTermsLink": "string",
      "merchantLink": "string",
      "debiCheckMinimum": {
        "enabled": true,
        "value": 0
      },
      "supplier": {
        "_id": "string",
        "name": "string",
        "merchantId": "string"
      },
      "orderRefundRequest": "string",
      "orderRefundAmount": 0,
      "orderRefundFee": 0,
      "monthlyPayments": true,
      "type": "string",
      "balance": 0,
      "description": "string",
      "isIncreasedDepositAmountAllowed": true,
      "suspendOnCancel": true,
      "voucherSettings": {
        "active": true,
        "minimumSavingGoalInCents": 0,
        "maximumSavingGoalInCents": 0,
        "rewardType": "string",
        "rewardFlatAmountInCents": 0,
        "rewardPercentage": 0,
        "voucherProvider": "string"
      }
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
orders	[modelOrderResponse]	false	none	none

modelOrderSendRequest

{
  "amount": 10000,
  "paymentMethod": "CARD",
  "type": "sms",
  "orderId": "123f7f1496bd78001d6852f3",
  "customerId": "123f7f1496bd78001d6852f3",
  "message": "string"
}

Properties

Name	Type	Required	Restrictions	Description
type	string	false	none	none
orderId	string	false	none	none
orderUrl	string	false	none	none
contact	string	false	none	none
message	string	false	none	none
customerId	string	false	none	none
amount	integer(int32)	false	none	none
paymentMethod	string	false	none	none

Enumerated Values

Property	Value
type	sms
type	email
type	none
paymentMethod	CARD
paymentMethod	EFT
paymentMethod	DEBICHECK

modelOrderSendRequestResponse

{
  "success": true,
  "orderUrl": "https://sandbox.layup.co.za/order/123f7f1496bd78001d6852f3?paymentMethod=CARD&amount=10000"
}

Properties

Name	Type	Required	Restrictions	Description
success	boolean	false	none	none
orderUrl	string	false	none	none

modelOrderUpdateRequest

{
  "state": "PLACED"
}

Properties

Name	Type	Required	Restrictions	Description
depositAmount	integer(int32)	false	none	none
products	[modelProductCreateRequest]	false	none	none
endDateMax	string	false	none	none
endDateMin	string	false	none	none
state	string	false	none	none
depositPerc	number(double)	false	none	none
reference	string	false	none	none
name	string	false	none	none
imageUrl	string	false	none	none
absorbsFee	boolean	false	none	none
enablesSplit	boolean	false	none	none
depositType	string	false	none	none
expire	integer(int32)	false	none	none
cancellationTerms	modelCancellationTermRequest	false	none	none
weeklyPayments	boolean	false	none	none
paymentMethods	modelPaymentMethod	false	none	none
cancellationPolicy	modelCancellationPolicy	false	none	none
groupPaymentPlan	modelGroupPayment	false	none	none
cloneExpiry	integer(int32)	false	none	none
orderCancellationRequest	string	false	none	none
notifications	[modelNote]	false	none	none
acceptedProposedCancellationTerms	boolean	false	none	none
customFeatures	modelCustomize	false	none	none
amortiseOnMissed	boolean	false	none	none
amortiseOnAmend	boolean	false	none	none
suspendOnCancel	boolean	false	none	none
orderRefundRequest	string	false	none	none
completedOrderRefundRequest	boolean	false	none	none
orderRefundAmount	integer(int32)	false	none	none
orderRefundFee	integer(int32)	false	none	none
monthlyPayments	boolean	false	none	none
type	string	false	none	none
description	string	false	none	none

modelPayAtAuthorizationRequest

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
accountNumber	string	false	none	none
amount	integer(int32)	false	none	none
networkTransactionID	string	false	none	none
networkData	modelPayAtNetworkData	false	none	none

modelPayAtAuthorizationResponse

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "networkTransactionID": "string",
  "responseCode": "string",
  "responseText": "string",
  "issuerTransactionID": "string",
  "customerData": {
    "firstName": "string",
    "lastName": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
accountNumber	string	false	none	none
networkData	modelPayAtNetworkData	false	none	none
networkTransactionID	string	false	none	none
responseCode	string	false	none	none
responseText	string	false	none	none
issuerTransactionID	string	false	none	none
customerData	modelPayAtCustomerData	false	none	none

modelPayAtCustomerData

{
  "firstName": "string",
  "lastName": "string"
}

Properties

Name	Type	Required	Restrictions	Description
firstName	string	false	none	none
lastName	string	false	none	none

modelPayAtEchoTestRequest

{
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "messageID": "string",
  "transmissionDateTime": "string",
  "echoData": "string"
}

Properties

Name	Type	Required	Restrictions	Description
securityData	modelPayAtSecurityData	false	none	none
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
echoData	string	false	none	none

modelPayAtEchoTestResponse

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "echoData": "string",
  "responseCode": "string",
  "responseText": "string"
}

Properties

Name	Type	Required	Restrictions	Description
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
echoData	string	false	none	none
responseCode	string	false	none	none
responseText	string	false	none	none

modelPayAtEnquiryRequest

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
accountNumber	string	false	none	none
amount	integer(int32)	false	none	none
networkData	modelPayAtNetworkData	false	none	none

modelPayAtEnquiryResponse

{
  "amount": 0,
  "dueDate": "string",
  "exactAmount": true,
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "customerData": {
    "firstName": "string",
    "lastName": "string"
  },
  "responseText": "string",
  "responseCode": "string"
}

Properties

Name	Type	Required	Restrictions	Description
amount	integer(int32)	false	none	none
dueDate	string	false	none	none
exactAmount	boolean	false	none	none
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
accountNumber	string	false	none	none
networkData	modelPayAtNetworkData	false	none	none
customerData	modelPayAtCustomerData	false	none	none
responseText	string	false	none	none
responseCode	string	false	none	none

modelPayAtLoginData

{
  "loginID": "string",
  "password": "string"
}

Properties

Name	Type	Required	Restrictions	Description
loginID	string	false	none	none
password	string	false	none	none

modelPayAtNetworkData

{
  "networkId": 0,
  "networkName": "string"
}

Properties

Name	Type	Required	Restrictions	Description
networkId	integer(int32)	false	none	none
networkName	string	false	none	none

modelPayAtReverseAuthorizationRequest

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "issuerTransactionID": "string",
  "repeatIndicator": true
}

Properties

Name	Type	Required	Restrictions	Description
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
accountNumber	string	false	none	none
amount	integer(int32)	false	none	none
networkTransactionID	string	false	none	none
networkData	modelPayAtNetworkData	false	none	none
issuerTransactionID	string	false	none	none
repeatIndicator	boolean	false	none	none

modelPayAtReverseAuthorizationResponse

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "networkTransactionID": "string",
  "responseCode": "string",
  "responseText": "string",
  "issuerTransactionID": "string",
  "repeatIndicator": true,
  "customerData": {
    "firstName": "string",
    "lastName": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
accountNumber	string	false	none	none
networkData	modelPayAtNetworkData	false	none	none
networkTransactionID	string	false	none	none
responseCode	string	false	none	none
responseText	string	false	none	none
issuerTransactionID	string	false	none	none
repeatIndicator	boolean	false	none	none
customerData	modelPayAtCustomerData	false	none	none

modelPayAtSecurityData

{
  "login": {
    "loginID": "string",
    "password": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
login	modelPayAtLoginData	false	none	none

modelPayAtTransactionAdviceRequest

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "amount": 0,
  "tenderType": "string",
  "repeatIndicator": true,
  "networkTransactionID": "string",
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "issuerTransactionID": "string"
}

Properties

Name	Type	Required	Restrictions	Description
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
accountNumber	string	false	none	none
amount	integer(int32)	false	none	none
tenderType	string	false	none	none
repeatIndicator	boolean	false	none	none
networkTransactionID	string	false	none	none
networkData	modelPayAtNetworkData	false	none	none
issuerTransactionID	string	false	none	none

modelPayAtTransactionAdviceResponse

{
  "messageID": "string",
  "transmissionDateTime": "string",
  "securityData": {
    "login": {
      "loginID": "string",
      "password": "string"
    }
  },
  "accountNumber": "string",
  "tenderType": "string",
  "repeatIndicator": true,
  "amount": 0,
  "networkData": {
    "networkId": 0,
    "networkName": "string"
  },
  "networkTransactionID": "string",
  "issuerTransactionID": "string",
  "responseCode": "string",
  "responseText": "string"
}

Properties

Name	Type	Required	Restrictions	Description
messageID	string	false	none	none
transmissionDateTime	string	false	none	none
securityData	modelPayAtSecurityData	false	none	none
accountNumber	string	false	none	none
tenderType	string	false	none	none
repeatIndicator	boolean	false	none	none
amount	integer(int32)	false	none	none
networkData	modelPayAtNetworkData	false	none	none
networkTransactionID	string	false	none	none
issuerTransactionID	string	false	none	none
responseCode	string	false	none	none
responseText	string	false	none	none

modelPaymentMethod

{
  "creditOrDebitCard": true,
  "eft": true,
  "debiCheck": true,
  "payAt": true,
  "capitecPay": true,
  "dashpay": true,
  "terminalCard": true,
  "offline": true,
  "embeddedCheckout": true
}

Properties

Name	Type	Required	Restrictions	Description
creditOrDebitCard	boolean	false	none	none
eft	boolean	false	none	none
debiCheck	boolean	false	none	none
payAt	boolean	false	none	none
capitecPay	boolean	false	none	none
dashpay	boolean	false	none	none
terminalCard	boolean	false	none	none
offline	boolean	false	none	none
embeddedCheckout	boolean	false	none	none

modelPaymentPlanBenefactor

{
  "_id": "string",
  "name": "string",
  "email": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
name	string	false	none	none
email	string	false	none	none

modelPaymentPlanDelResponse

{
  "_id": "string",
  "orderId": "string",
  "benefactorId": "string",
  "completed": true,
  "quantity": 0,
  "depositDue": 0,
  "amountDue": 0,
  "automaticBilling": true,
  "payments": [
    {
      "_id": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "pending": true,
      "failed": true,
      "reconciliated": true,
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "_id": "string",
        "amount": 0,
        "paymentProviderPaymentId": "string",
        "paymentReference": "string",
        "paymentMethod": "string",
        "paymentProvider": "string",
        "paymentProviderResponses": {}
      },
      "verifiedAt": "string"
    }
  ],
  "active": true
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
orderId	string	false	none	none
benefactorId	string	false	none	none
completed	boolean	false	none	none
quantity	integer(int32)	false	none	none
depositDue	integer(int32)	false	none	none
amountDue	integer(int32)	false	none	none
automaticBilling	boolean	false	none	none
payments	[modelPlanPayment]	false	none	none
active	boolean	false	none	none

modelPaymentPlanPreviewRequest

{
  "amountDue": 0,
  "depositPerc": 0,
  "endDateMax": "2019-08-24T14:15:22Z",
  "endDateMin": "2019-08-24T14:15:22Z",
  "absorbsFee": true,
  "frequency": "WEEKLY",
  "offset": 0,
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "flatFee": 0.1,
  "percFee": 0.1,
  "paymentPlanId": "string",
  "quantity": 0
}

Properties

Name	Type	Required	Restrictions	Description
amountDue	integer	false	none	none
depositPerc	number	false	none	none
endDateMax	string(date-time)	false	none	none
endDateMin	string(date-time)	false	none	none
absorbsFee	boolean	false	none	none
frequency	string	false	none	none
offset	integer(int32)	false	none	none
depositAmount	integer(int32)	false	none	none
depositType	string	false	none	none
flatFee	number(double)	false	none	none
percFee	number(double)	false	none	none
paymentPlanId	string	false	none	none
quantity	integer(int32)	false	none	none

Enumerated Values

Property	Value
frequency	WEEKLY
frequency	MONTHLY
depositType	INSTALMENT
depositType	FLAT
depositType	PERCENTAGE

modelPaymentPlanPreviewResponse

{
  "months": 0,
  "deposit": 0,
  "payments": [
    {
      "_id": "string",
      "paymentPlanId": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "userId": "string",
      "locked": true,
      "pending": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "note": "string",
      "reference": "string",
      "orderStatus": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "failed": true,
      "verifyError": "string",
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "paymentProvider": "string",
        "paymentMethod": "string"
      },
      "destinationId": "string",
      "destinationType": "string"
    }
  ],
  "quantity": 0,
  "orderState": "string"
}

Properties

Name	Type	Required	Restrictions	Description
months	integer(int32)	false	none	none
deposit	integer(int32)	false	none	none
payments	[modelPaymentResponse]	false	none	none
quantity	integer(int32)	false	none	none
orderState	string	false	none	none

modelPaymentPlanPreviewResponseMany

{
  "amountDue": 0,
  "merchant": "string",
  "merchantTermsLink": "string",
  "reference": "string",
  "orderName": "string",
  "depositDue": 0,
  "endDateMax": "string",
  "imageUrl": "string",
  "enablesSplit": true,
  "products": [
    {
      "_id": "string",
      "amount": 0,
      "link": "http://example.com",
      "sku": "string",
      "name": "string",
      "depositType": "string"
    }
  ],
  "paymentPlans": [
    {
      "months": 0,
      "deposit": 0,
      "payments": [
        {
          "_id": "string",
          "paymentPlanId": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "userId": "string",
          "locked": true,
          "pending": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "note": "string",
          "reference": "string",
          "orderStatus": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "failed": true,
          "verifyError": "string",
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "paymentProvider": "string",
            "paymentMethod": "string"
          },
          "destinationId": "string",
          "destinationType": "string"
        }
      ],
      "quantity": 0,
      "orderState": "string"
    }
  ],
  "depositAmount": 0,
  "depositType": "INSTALMENT",
  "flatFee": 0.1,
  "percFee": 0.1,
  "validDays": [
    0
  ],
  "validDates": [
    0
  ],
  "amountDueExcludingFee": 0,
  "depositDueExcludingFee": 0,
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "weeklyPayments": true,
  "orderState": "string",
  "groupPaymentPlan": {
    "enabled": true,
    "cloneLimit": 0,
    "expiry": 0
  },
  "orderToClone": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "customFeatures": {
    "logo": {
      "enabled": true,
      "value": "string"
    },
    "imageUrl": {
      "enabled": true,
      "value": "string"
    },
    "paymentWidget": {
      "enabled": true,
      "value": "string"
    }
  },
  "cancellationTerms": {
    "active": true,
    "definition": [
      {
        "type": {
          "name": "string",
          "definition": {
            "missed": 0,
            "percentage": 0
          },
          "finalPaymentMissed": true
        },
        "policy": {
          "name": "Deposit",
          "definition": {
            "deposit": true,
            "percentage": 0,
            "flatFee": 0,
            "percentageShouldUseTotalPaid": true
          }
        },
        "start": 0,
        "end": 0,
        "gracePeriod": 0
      }
    ]
  },
  "initiatorId": "string",
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "monthlyPayments": true
}

Properties

Name	Type	Required	Restrictions	Description
amountDue	integer(int32)	false	none	none
merchant	string	false	none	none
merchantTermsLink	string	false	none	none
reference	string	false	none	none
orderName	string	false	none	none
depositDue	integer(int32)	false	none	none
endDateMax	string	false	none	none
imageUrl	string	false	none	none
enablesSplit	boolean	false	none	none
products	[modelProductResponse]	false	none	none
paymentPlans	[modelPaymentPlanPreviewResponse]	false	none	none
depositAmount	integer(int32)	false	none	none
depositType	string	false	none	none
flatFee	number(double)	false	none	none
percFee	number(double)	false	none	none
validDays	[integer]	false	none	none
validDates	[integer]	false	none	none
amountDueExcludingFee	integer(int32)	false	none	none
depositDueExcludingFee	integer(int32)	false	none	none
paymentMethods	modelPaymentMethod	false	none	none
weeklyPayments	boolean	false	none	none
orderState	string	false	none	none
groupPaymentPlan	modelGroupPayment	false	none	none
orderToClone	modelOrderResponse	false	none	none
customFeatures	modelCustomize	false	none	none
cancellationTerms	modelCancellationTermRequest	false	none	none
initiatorId	string	false	none	none
debiCheckMinimum	modelValueEnabledPair	false	none	none
monthlyPayments	boolean	false	none	none

Enumerated Values

Property	Value
depositType	INSTALMENT
depositType	FLAT
depositType	PERCENTAGE

modelPaymentPlanRequest

{
  "orderId": "string",
  "benefactorId": "string",
  "quantity": 0,
  "automaticBilling": true,
  "frequency": "string",
  "offset": 0,
  "token": "string",
  "agreedToTerms": true
}

Properties

Name	Type	Required	Restrictions	Description
orderId	string	false	none	none
benefactorId	string	false	none	none
quantity	integer(int32)	false	none	none
automaticBilling	boolean	false	none	none
frequency	string	false	none	none
offset	integer(int32)	false	none	none
token	string	false	none	none
agreedToTerms	boolean	false	none	none

modelPaymentPlanResponse

{
  "_id": "string",
  "orderId": "string",
  "benefactorId": "string",
  "completed": true,
  "quantity": 0,
  "depositDue": 0,
  "amountDue": 0,
  "automaticBilling": true,
  "timestamp": 0.1,
  "payments": [
    {
      "_id": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "pending": true,
      "failed": true,
      "reconciliated": true,
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "_id": "string",
        "amount": 0,
        "paymentProviderPaymentId": "string",
        "paymentReference": "string",
        "paymentMethod": "string",
        "paymentProvider": "string",
        "paymentProviderResponses": {}
      },
      "verifiedAt": "string"
    }
  ],
  "benefactor": {
    "_id": "string",
    "name": "string",
    "email": "string"
  },
  "frequency": "WEEKLY",
  "offset": 0,
  "depositDueExcludingFee": 0,
  "amountDueExcludingFee": 0,
  "order": {
    "_id": "string",
    "endDateMax": "2019-08-24T14:15:22Z",
    "endDateMin": "2019-08-24T14:15:22Z",
    "initiatorId": "string",
    "products": [
      {
        "_id": "string",
        "amount": 0,
        "link": "http://example.com",
        "sku": "string",
        "name": "string",
        "depositType": "string"
      }
    ],
    "state": "PARTIAL",
    "supplierId": "string",
    "cancelledBy": "string",
    "amountDue": 0,
    "flatFee": 0,
    "percFee": 0.1,
    "depositPerc": 0.1,
    "absorbsFee": true,
    "reference": "string",
    "name": "string",
    "imageUrl": "string",
    "plans": [
      {
        "_id": "string",
        "orderId": "string",
        "benefactorId": "string",
        "completed": true,
        "quantity": 0,
        "depositDue": 0,
        "amountDue": 0,
        "automaticBilling": true,
        "timestamp": 0.1,
        "payments": [
          {
            "_id": "string",
            "due": "string",
            "amount": 0,
            "paid": true,
            "timestamp": 0.1,
            "paymentMethod": "string",
            "paymentType": "string",
            "amountExcludingFee": 0,
            "fee": 0,
            "pending": true,
            "failed": true,
            "reconciliated": true,
            "refundedAmount": 0,
            "refundPaymentId": "string",
            "connectorData": {
              "_id": "string",
              "amount": 0,
              "paymentProviderPaymentId": "string",
              "paymentReference": "string",
              "paymentMethod": "string",
              "paymentProvider": "string",
              "paymentProviderResponses": {}
            },
            "verifiedAt": "string"
          }
        ],
        "benefactor": {
          "_id": "string",
          "name": "string",
          "email": "string"
        },
        "frequency": "WEEKLY",
        "offset": 0,
        "depositDueExcludingFee": 0,
        "amountDueExcludingFee": 0,
        "order": {},
        "debicheckStatus": "string",
        "debicheckLastFailedReasons": [
          "string"
        ],
        "debicheckMandateActiveId": "string",
        "debicheckMandateIds": [
          "string"
        ],
        "payAtReferenceNumber": "string",
        "agreedToTerms": true
      }
    ],
    "createdAt": "string",
    "timestamp": 0.1,
    "enablesSplit": true,
    "depositAmount": 0,
    "depositType": "INSTALMENT",
    "expire": "string",
    "cancellationTerms": {
      "active": true,
      "definition": [
        {
          "type": {
            "name": "string",
            "definition": {
              "missed": 0,
              "percentage": 0
            },
            "finalPaymentMissed": true
          },
          "policy": {
            "name": "Deposit",
            "definition": {
              "deposit": true,
              "percentage": 0,
              "flatFee": 0,
              "percentageShouldUseTotalPaid": true
            }
          },
          "start": 0,
          "end": 0,
          "gracePeriod": 0
        }
      ]
    },
    "weeklyPayments": true,
    "paymentMethods": {
      "creditOrDebitCard": true,
      "eft": true,
      "debiCheck": true,
      "payAt": true,
      "capitecPay": true,
      "dashpay": true,
      "terminalCard": true,
      "offline": true,
      "embeddedCheckout": true
    },
    "stateUpdatedAt": "string",
    "updatedAt": "string",
    "groupPaymentPlan": {
      "enabled": true,
      "cloneLimit": 0,
      "expiry": 0
    },
    "cloneExpiry": 0,
    "cloneCount": 0,
    "orderCancellationRequest": "string",
    "notifications": [
      {
        "change": "string",
        "date": "string",
        "name": "string",
        "reason": "string",
        "details": "string",
        "read": true,
        "userId": "string",
        "type": "string",
        "hide": true,
        "unread": true
      }
    ],
    "acceptedProposedCancellationTerms": true,
    "customFeatures": {
      "logo": {
        "enabled": true,
        "value": "string"
      },
      "imageUrl": {
        "enabled": true,
        "value": "string"
      },
      "paymentWidget": {
        "enabled": true,
        "value": "string"
      }
    },
    "merchantName": "string",
    "merchantTermsLink": "string",
    "merchantLink": "string",
    "debiCheckMinimum": {
      "enabled": true,
      "value": 0
    },
    "supplier": {
      "_id": "string",
      "name": "string",
      "merchantId": "string"
    },
    "orderRefundRequest": "string",
    "orderRefundAmount": 0,
    "orderRefundFee": 0,
    "monthlyPayments": true,
    "type": "string",
    "balance": 0,
    "description": "string",
    "isIncreasedDepositAmountAllowed": true,
    "suspendOnCancel": true,
    "voucherSettings": {
      "active": true,
      "minimumSavingGoalInCents": 0,
      "maximumSavingGoalInCents": 0,
      "rewardType": "string",
      "rewardFlatAmountInCents": 0,
      "rewardPercentage": 0,
      "voucherProvider": "string"
    }
  },
  "debicheckStatus": "string",
  "debicheckLastFailedReasons": [
    "string"
  ],
  "debicheckMandateActiveId": "string",
  "debicheckMandateIds": [
    "string"
  ],
  "payAtReferenceNumber": "string",
  "agreedToTerms": true
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
orderId	string	false	none	none
benefactorId	string	false	none	none
completed	boolean	false	none	none
quantity	integer(int32)	false	none	none
depositDue	integer(int32)	false	none	none
amountDue	integer(int32)	false	none	none
automaticBilling	boolean	false	none	none
timestamp	number(double)	false	none	none
payments	[modelPlanPayment]	false	none	none
benefactor	modelPaymentPlanBenefactor	false	none	none
frequency	string	false	none	none
offset	integer(int32)	false	none	none
depositDueExcludingFee	integer(int32)	false	none	none
amountDueExcludingFee	integer(int32)	false	none	none
order	modelOrderResponse	false	none	none
debicheckStatus	string	false	none	none
debicheckLastFailedReasons	[string]	false	none	none
debicheckMandateActiveId	string	false	none	none
debicheckMandateIds	[string]	false	none	none
payAtReferenceNumber	string	false	none	none
agreedToTerms	boolean	false	none	none

Enumerated Values

Property	Value
frequency	WEEKLY
frequency	MONTHLY

modelPaymentPlanResponseMany

{
  "paymentPlans": [
    {
      "_id": "string",
      "orderId": "string",
      "benefactorId": "string",
      "completed": true,
      "quantity": 0,
      "depositDue": 0,
      "amountDue": 0,
      "automaticBilling": true,
      "timestamp": 0.1,
      "payments": [
        {
          "_id": "string",
          "due": "string",
          "amount": 0,
          "paid": true,
          "timestamp": 0.1,
          "paymentMethod": "string",
          "paymentType": "string",
          "amountExcludingFee": 0,
          "fee": 0,
          "pending": true,
          "failed": true,
          "reconciliated": true,
          "refundedAmount": 0,
          "refundPaymentId": "string",
          "connectorData": {
            "_id": "string",
            "amount": 0,
            "paymentProviderPaymentId": "string",
            "paymentReference": "string",
            "paymentMethod": "string",
            "paymentProvider": "string",
            "paymentProviderResponses": {}
          },
          "verifiedAt": "string"
        }
      ],
      "benefactor": {
        "_id": "string",
        "name": "string",
        "email": "string"
      },
      "frequency": "WEEKLY",
      "offset": 0,
      "depositDueExcludingFee": 0,
      "amountDueExcludingFee": 0,
      "order": {
        "_id": "string",
        "endDateMax": "2019-08-24T14:15:22Z",
        "endDateMin": "2019-08-24T14:15:22Z",
        "initiatorId": "string",
        "products": [
          {
            "_id": "string",
            "amount": 0,
            "link": "http://example.com",
            "sku": "string",
            "name": "string",
            "depositType": "string"
          }
        ],
        "state": "PARTIAL",
        "supplierId": "string",
        "cancelledBy": "string",
        "amountDue": 0,
        "flatFee": 0,
        "percFee": 0.1,
        "depositPerc": 0.1,
        "absorbsFee": true,
        "reference": "string",
        "name": "string",
        "imageUrl": "string",
        "plans": [
          {}
        ],
        "createdAt": "string",
        "timestamp": 0.1,
        "enablesSplit": true,
        "depositAmount": 0,
        "depositType": "INSTALMENT",
        "expire": "string",
        "cancellationTerms": {
          "active": true,
          "definition": [
            {
              "type": {
                "name": "string",
                "definition": {
                  "missed": 0,
                  "percentage": 0
                },
                "finalPaymentMissed": true
              },
              "policy": {
                "name": "Deposit",
                "definition": {
                  "deposit": true,
                  "percentage": 0,
                  "flatFee": 0,
                  "percentageShouldUseTotalPaid": true
                }
              },
              "start": 0,
              "end": 0,
              "gracePeriod": 0
            }
          ]
        },
        "weeklyPayments": true,
        "paymentMethods": {
          "creditOrDebitCard": true,
          "eft": true,
          "debiCheck": true,
          "payAt": true,
          "capitecPay": true,
          "dashpay": true,
          "terminalCard": true,
          "offline": true,
          "embeddedCheckout": true
        },
        "stateUpdatedAt": "string",
        "updatedAt": "string",
        "groupPaymentPlan": {
          "enabled": true,
          "cloneLimit": 0,
          "expiry": 0
        },
        "cloneExpiry": 0,
        "cloneCount": 0,
        "orderCancellationRequest": "string",
        "notifications": [
          {
            "change": "string",
            "date": "string",
            "name": "string",
            "reason": "string",
            "details": "string",
            "read": true,
            "userId": "string",
            "type": "string",
            "hide": true,
            "unread": true
          }
        ],
        "acceptedProposedCancellationTerms": true,
        "customFeatures": {
          "logo": {
            "enabled": true,
            "value": "string"
          },
          "imageUrl": {
            "enabled": true,
            "value": "string"
          },
          "paymentWidget": {
            "enabled": true,
            "value": "string"
          }
        },
        "merchantName": "string",
        "merchantTermsLink": "string",
        "merchantLink": "string",
        "debiCheckMinimum": {
          "enabled": true,
          "value": 0
        },
        "supplier": {
          "_id": "string",
          "name": "string",
          "merchantId": "string"
        },
        "orderRefundRequest": "string",
        "orderRefundAmount": 0,
        "orderRefundFee": 0,
        "monthlyPayments": true,
        "type": "string",
        "balance": 0,
        "description": "string",
        "isIncreasedDepositAmountAllowed": true,
        "suspendOnCancel": true,
        "voucherSettings": {
          "active": true,
          "minimumSavingGoalInCents": 0,
          "maximumSavingGoalInCents": 0,
          "rewardType": "string",
          "rewardFlatAmountInCents": 0,
          "rewardPercentage": 0,
          "voucherProvider": "string"
        }
      },
      "debicheckStatus": "string",
      "debicheckLastFailedReasons": [
        "string"
      ],
      "debicheckMandateActiveId": "string",
      "debicheckMandateIds": [
        "string"
      ],
      "payAtReferenceNumber": "string",
      "agreedToTerms": true
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
paymentPlans	[modelPaymentPlanResponse]	false	none	none

modelPaymentPlanSendNotificationRequest

{
  "_id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none

modelPaymentPlanSettings

{
  "weeklyPayments": true,
  "splitPayments": true,
  "orderExpiry": {
    "enabled": true,
    "value": 0
  },
  "maxMonths": {
    "enabled": true,
    "value": 0
  },
  "paymentMethods": {
    "creditOrDebitCard": true,
    "eft": true,
    "debiCheck": true,
    "payAt": true,
    "capitecPay": true,
    "dashpay": true,
    "terminalCard": true,
    "offline": true,
    "embeddedCheckout": true
  },
  "editPaymentPlanSettings": true,
  "defaultDepositType": {
    "depositType": "string",
    "enabled": true,
    "percentage": 0,
    "flat": 0
  },
  "minMonths": {
    "enabled": true,
    "value": 0
  },
  "debiCheckMinimum": {
    "enabled": true,
    "value": 0
  },
  "monthlyPayments": true,
  "suspendOnCancel": true
}

Properties

Name	Type	Required	Restrictions	Description
weeklyPayments	boolean	false	none	none
splitPayments	boolean	false	none	none
orderExpiry	modelOrderExpiry	false	none	none
maxMonths	modelValueEnabledPair	false	none	none
paymentMethods	modelPaymentMethod	false	none	none
editPaymentPlanSettings	boolean	false	none	none
defaultDepositType	modelDefaultDepositType	false	none	none
minMonths	modelValueEnabledPair	false	none	none
debiCheckMinimum	modelValueEnabledPair	false	none	none
monthlyPayments	boolean	false	none	none
suspendOnCancel	boolean	false	none	none

modelPaymentPlanSplitBody

{
  "clients": [
    {
      "email": "[email protected]",
      "name": "string",
      "cellNumber": "string"
    }
  ],
  "paymentPlan": {
    "orderId": "string",
    "benefactorId": "string",
    "quantity": 0,
    "automaticBilling": true,
    "frequency": "string",
    "offset": 0,
    "token": "string",
    "agreedToTerms": true
  },
  "redirectTo": "string",
  "verificationRedirect": "string"
}

Properties

Name	Type	Required	Restrictions	Description
clients	[modelSplitUser]	false	none	none
paymentPlan	modelPaymentPlanRequest	false	none	none
redirectTo	string	false	none	none
verificationRedirect	string	false	none	none

modelPaymentProviderResponses

{}

Properties

None

modelPaymentProviderSettlement

{
  "amountInCents": 0,
  "bankTransactionReference": "string",
  "paymentProvider": "string",
  "paymentProviderPaymentId": "string",
  "transactionDate": "string",
  "paymentReference": "string",
  "fileStorageReference": "string",
  "paymentMethod": "string",
  "feeInCents": 0
}

Properties

Name	Type	Required	Restrictions	Description
amountInCents	integer(int32)	false	none	none
bankTransactionReference	string	false	none	none
paymentProvider	string	false	none	none
paymentProviderPaymentId	string	false	none	none
transactionDate	string	false	none	none
paymentReference	string	false	none	none
fileStorageReference	string	false	none	none
paymentMethod	string	false	none	none
feeInCents	integer(int32)	false	none	none

modelPaymentProviderSettlementResponse

{
  "amountInCents": 0,
  "bankTransactionReference": "string",
  "paymentProvider": "string",
  "paymentProviderPaymentId": "string",
  "transactionDate": "string",
  "paymentReference": "string",
  "fileStorageReference": "string",
  "paymentMethod": "string",
  "feeInCents": 0,
  "_id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
amountInCents	integer(int32)	false	none	none
bankTransactionReference	string	false	none	none
paymentProvider	string	false	none	none
paymentProviderPaymentId	string	false	none	none
transactionDate	string	false	none	none
paymentReference	string	false	none	none
fileStorageReference	string	false	none	none
paymentMethod	string	false	none	none
feeInCents	integer(int32)	false	none	none
_id	string	false	none	none

modelPaymentProviderSettlementsRequest

{
  "paymentProviderSettlements": [
    {
      "amountInCents": 0,
      "bankTransactionReference": "string",
      "paymentProvider": "string",
      "paymentProviderPaymentId": "string",
      "transactionDate": "string",
      "paymentReference": "string",
      "fileStorageReference": "string",
      "paymentMethod": "string",
      "feeInCents": 0
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
paymentProviderSettlements	[modelPaymentProviderSettlement]	false	none	none

modelPaymentProviderSettlementsResponse

{
  "settlements": [
    {
      "amountInCents": 0,
      "bankTransactionReference": "string",
      "paymentProvider": "string",
      "paymentProviderPaymentId": "string",
      "transactionDate": "string",
      "paymentReference": "string",
      "fileStorageReference": "string",
      "paymentMethod": "string",
      "feeInCents": 0,
      "_id": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
settlements	[modelPaymentProviderSettlementResponse]	false	none	none

modelPaymentRedirectResponse

{
  "url": "string",
  "parameters": [
    {
      "name": "string",
      "value": "string"
    }
  ],
  "method": "string",
  "_id": "string",
  "checkoutId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	none
parameters	[modelNameAndValue]	false	none	none
method	string	false	none	none
_id	string	false	none	none
checkoutId	string	false	none	none

modelPaymentReportResponse

{
  "payments": [
    {
      "id": "string",
      "amount": 0.1,
      "client": "string",
      "createdAt": "string",
      "datePaid": "string",
      "due": "string",
      "fee": 0.1,
      "fees": [
        {
          "id": "string",
          "productName": "string",
          "amountExcludingVAT": 0.1,
          "amountVAT": 0.1,
          "amountTotal": 0.1,
          "merchantId": "string",
          "createdAt": "string",
          "updatedAt": "string",
          "settlementId": "string",
          "paymentId": "string"
        }
      ],
      "feesPerProduct": [
        {
          "quantity": 0.1,
          "amountTotal": 0.1,
          "amountExcludingVAT": 0.1,
          "amountVAT": 0.1,
          "product": {
            "_id": "string",
            "name": "string",
            "displayName": "string",
            "feeType": "string",
            "method": "string",
            "billingType": "string"
          }
        }
      ],
      "locked": true,
      "orderName": "string",
      "orderReference": "string",
      "paymentMethod": "string",
      "paymentStatus": "string",
      "paymentType": "string",
      "settlementBatch": "string",
      "state": "string",
      "updatedAt": "string",
      "verifiedAt": "string",
      "dateSettled": "string"
    }
  ],
  "export": [
    {
      "client": "string",
      "amount": 0.1,
      "createdAt": "string",
      "verifiedAt": "string",
      "due": "string",
      "fee": 0.1,
      "orderName": "string",
      "orderReference": "string",
      "paymentStatus": "string",
      "paymentType": "string",
      "settlementBatch": "string",
      "state": "string",
      "updatedAt": "string",
      "datePaid": "string",
      "dateSettled": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
payments	[modelReportPayment]	false	none	none
export	[modelReportExport]	false	none	none

modelPaymentRequest

{
  "paymentPlanId": "string",
  "amount": 0,
  "notifyUrl": "string",
  "useSavedCard": true,
  "eft": true,
  "checkout": true,
  "save": true,
  "suspenseId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "paid": true,
  "failed": true,
  "payAt": true,
  "paymentMethod": "string",
  "paymentProviderSettlementId": "string",
  "destinationType": "string",
  "destinationId": "string",
  "isEmbeddedCheckout": true
}

Properties

Name	Type	Required	Restrictions	Description
paymentPlanId	string	false	none	none
amount	integer(int32)	false	none	none
notifyUrl	string	false	none	none
useSavedCard	boolean	false	none	none
eft	boolean	false	none	none
checkout	boolean	false	none	none
save	boolean	false	none	none
suspenseId	string	false	none	none
connectorData	modelConnectorData	false	none	Connector data bypasses protobuf conversion to allow any fields.
paid	boolean	false	none	none
failed	boolean	false	none	none
payAt	boolean	false	none	none
paymentMethod	string	false	none	none
paymentProviderSettlementId	string	false	none	none
destinationType	string	false	none	none
destinationId	string	false	none	none
isEmbeddedCheckout	boolean	false	none	none

modelPaymentRequestV2

{
  "destinationId": "string",
  "amount": 0,
  "redirectUrl": "string",
  "paymentMethod": "string",
  "paymentProvider": "string",
  "destinationType": "string",
  "connectorData": {
    "bankTransactionId": "string"
  },
  "save": true
}

Properties

Name	Type	Required	Restrictions	Description
destinationId	string	false	none	none
amount	integer(int32)	false	none	none
redirectUrl	string	false	none	none
paymentMethod	string	false	none	none
paymentProvider	string	false	none	none
destinationType	string	false	none	none
connectorData	modelConnectorDataV2	false	none	none
save	boolean	false	none	none

modelPaymentResponse

{
  "_id": "string",
  "paymentPlanId": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "userId": "string",
  "locked": true,
  "pending": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "note": "string",
  "reference": "string",
  "orderStatus": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "failed": true,
  "verifyError": "string",
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "paymentProvider": "string",
    "paymentMethod": "string"
  },
  "destinationId": "string",
  "destinationType": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
paymentPlanId	string	false	none	none
due	string	false	none	none
amount	integer(int32)	false	none	none
paid	boolean	false	none	none
userId	string	false	none	none
locked	boolean	false	none	none
pending	boolean	false	none	none
timestamp	number(double)	false	none	none
paymentMethod	string	false	none	none
paymentType	string	false	none	none
note	string	false	none	none
reference	string	false	none	none
orderStatus	string	false	none	none
amountExcludingFee	integer(int32)	false	none	none
fee	integer(int32)	false	none	none
failed	boolean	false	none	none
verifyError	string	false	none	none
refundedAmount	integer(int32)	false	none	none
refundPaymentId	string	false	none	none
connectorData	modelConnectorData	false	none	Connector data bypasses protobuf conversion to allow any fields.
destinationId	string	false	none	none
destinationType	string	false	none	none

modelPaymentResponseMany

{
  "payments": [
    {
      "_id": "string",
      "paymentPlanId": "string",
      "due": "string",
      "amount": 0,
      "paid": true,
      "userId": "string",
      "locked": true,
      "pending": true,
      "timestamp": 0.1,
      "paymentMethod": "string",
      "paymentType": "string",
      "note": "string",
      "reference": "string",
      "orderStatus": "string",
      "amountExcludingFee": 0,
      "fee": 0,
      "failed": true,
      "verifyError": "string",
      "refundedAmount": 0,
      "refundPaymentId": "string",
      "connectorData": {
        "paymentProvider": "string",
        "paymentMethod": "string"
      },
      "destinationId": "string",
      "destinationType": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
payments	[modelPaymentResponse]	false	none	none

modelPaymentWidgetLogo

{
  "enabled": true,
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
value	string	false	none	none

modelPlanPayment

{
  "_id": "string",
  "due": "string",
  "amount": 0,
  "paid": true,
  "timestamp": 0.1,
  "paymentMethod": "string",
  "paymentType": "string",
  "amountExcludingFee": 0,
  "fee": 0,
  "pending": true,
  "failed": true,
  "reconciliated": true,
  "refundedAmount": 0,
  "refundPaymentId": "string",
  "connectorData": {
    "_id": "string",
    "amount": 0,
    "paymentProviderPaymentId": "string",
    "paymentReference": "string",
    "paymentMethod": "string",
    "paymentProvider": "string",
    "paymentProviderResponses": {}
  },
  "verifiedAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
due	string	false	none	none
amount	integer(int32)	false	none	none
paid	boolean	false	none	none
timestamp	number(double)	false	none	none
paymentMethod	string	false	none	none
paymentType	string	false	none	none
amountExcludingFee	integer(int32)	false	none	none
fee	integer(int32)	false	none	none
pending	boolean	false	none	none
failed	boolean	false	none	none
reconciliated	boolean	false	none	none
refundedAmount	integer(int32)	false	none	none
refundPaymentId	string	false	none	none
connectorData	modelPlanPaymentConnectorData	false	none	none
verifiedAt	string	false	none	none

modelPlanPaymentConnectorData

{
  "_id": "string",
  "amount": 0,
  "paymentProviderPaymentId": "string",
  "paymentReference": "string",
  "paymentMethod": "string",
  "paymentProvider": "string",
  "paymentProviderResponses": {}
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
amount	integer(int32)	false	none	none
paymentProviderPaymentId	string	false	none	none
paymentReference	string	false	none	none
paymentMethod	string	false	none	none
paymentProvider	string	false	none	none
paymentProviderResponses	modelPaymentProviderResponses	false	none	none

modelPopulate

{
  "path": "string",
  "select": "string",
  "populate": {
    "path": "string",
    "select": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
path	string	false	none	none
select	string	false	none	none
populate	modelPopulateNested	false	none	none

modelPopulateNested

{
  "path": "string",
  "select": "string"
}

Properties

Name	Type	Required	Restrictions	Description
path	string	false	none	none
select	string	false	none	none

modelProduct

{
  "_id": "string",
  "name": "string",
  "displayName": "string",
  "feeType": "string",
  "method": "string",
  "billingType": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
name	string	false	none	none
displayName	string	false	none	none
feeType	string	false	none	none
method	string	false	none	none
billingType	string	false	none	none

modelProductCreateRequest

{
  "_id": "string",
  "amount": 0,
  "link": "http://example.com",
  "sku": "string",
  "name": "string",
  "description": "string",
  "depositType": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
amount	integer(int32)	false	none	none
link	string(uri)	false	none	none
sku	string	false	none	none
name	string	false	none	none
description	string	false	none	none
depositType	string	false	none	none

modelProductResponse

{
  "_id": "string",
  "amount": 0,
  "link": "http://example.com",
  "sku": "string",
  "name": "string",
  "depositType": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
amount	integer(int32)	false	none	none
link	string(uri)	false	none	none
sku	string	false	none	none
name	string	false	none	none
depositType	string	false	none	none

modelRefundPaymentRequest

{
  "amount": 0,
  "refundReference": "string",
  "paymentId": "string",
  "excludeFees": true,
  "refundMethod": "string",
  "autoRefund": true
}

Properties

Name	Type	Required	Restrictions	Description
amount	integer(int32)	false	none	none
refundReference	string	false	none	none
paymentId	string	false	none	none
excludeFees	boolean	false	none	none
refundMethod	string	false	none	none
autoRefund	boolean	false	none	none

modelRejectedReasons

{
  "contractReference": "string",
  "reason": "string"
}

Properties

Name	Type	Required	Restrictions	Description
contractReference	string	false	none	none
reason	string	false	none	none

modelRejectedTransaction

{
  "transmissionDate": "string",
  "originalSequenceNumber": 0,
  "amount": 0,
  "userReference": "string",
  "rejectionReason": "string"
}

Properties

Name	Type	Required	Restrictions	Description
transmissionDate	string	false	none	none
originalSequenceNumber	integer(int32)	false	none	none
amount	integer(int32)	false	none	none
userReference	string	false	none	none
rejectionReason	string	false	none	none

modelReport

{
  "totalFeesAmount": 0,
  "totalFeesExtAmount": 0,
  "totalAmountVAT": 0,
  "feesPerProductExcludingVATTotal": 0,
  "feesPerProductVATTotal": 0,
  "feesPerProductTotal": 0,
  "fees": [
    {
      "id": "string",
      "productName": "string",
      "amountExcludingVAT": 0.1,
      "amountVAT": 0.1,
      "amountTotal": 0.1,
      "merchantId": "string",
      "createdAt": "string",
      "updatedAt": "string",
      "settlementId": "string",
      "paymentId": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
totalFeesAmount	integer(int32)	false	none	none
totalFeesExtAmount	integer(int32)	false	none	none
totalAmountVAT	integer(int32)	false	none	none
feesPerProductExcludingVATTotal	integer(int32)	false	none	none
feesPerProductVATTotal	integer(int32)	false	none	none
feesPerProductTotal	integer(int32)	false	none	none
fees	[modelJournalFees]	false	none	none

modelReportExport

{
  "client": "string",
  "amount": 0.1,
  "createdAt": "string",
  "verifiedAt": "string",
  "due": "string",
  "fee": 0.1,
  "orderName": "string",
  "orderReference": "string",
  "paymentStatus": "string",
  "paymentType": "string",
  "settlementBatch": "string",
  "state": "string",
  "updatedAt": "string",
  "datePaid": "string",
  "dateSettled": "string"
}

Properties

Name	Type	Required	Restrictions	Description
client	string	false	none	none
amount	number(double)	false	none	none
createdAt	string	false	none	none
verifiedAt	string	false	none	none
due	string	false	none	none
fee	number(double)	false	none	none
orderName	string	false	none	none
orderReference	string	false	none	none
paymentStatus	string	false	none	none
paymentType	string	false	none	none
settlementBatch	string	false	none	none
state	string	false	none	none
updatedAt	string	false	none	none
datePaid	string	false	none	none
dateSettled	string	false	none	none

modelReportPayment

{
  "id": "string",
  "amount": 0.1,
  "client": "string",
  "createdAt": "string",
  "datePaid": "string",
  "due": "string",
  "fee": 0.1,
  "fees": [
    {
      "id": "string",
      "productName": "string",
      "amountExcludingVAT": 0.1,
      "amountVAT": 0.1,
      "amountTotal": 0.1,
      "merchantId": "string",
      "createdAt": "string",
      "updatedAt": "string",
      "settlementId": "string",
      "paymentId": "string"
    }
  ],
  "feesPerProduct": [
    {
      "quantity": 0.1,
      "amountTotal": 0.1,
      "amountExcludingVAT": 0.1,
      "amountVAT": 0.1,
      "product": {
        "_id": "string",
        "name": "string",
        "displayName": "string",
        "feeType": "string",
        "method": "string",
        "billingType": "string"
      }
    }
  ],
  "locked": true,
  "orderName": "string",
  "orderReference": "string",
  "paymentMethod": "string",
  "paymentStatus": "string",
  "paymentType": "string",
  "settlementBatch": "string",
  "state": "string",
  "updatedAt": "string",
  "verifiedAt": "string",
  "dateSettled": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
amount	number(double)	false	none	none
client	string	false	none	none
createdAt	string	false	none	none
datePaid	string	false	none	none
due	string	false	none	none
fee	number(double)	false	none	none
fees	[modelFee]	false	none	none
feesPerProduct	[modelFeePerProduct]	false	none	none
locked	boolean	false	none	none
orderName	string	false	none	none
orderReference	string	false	none	none
paymentMethod	string	false	none	none
paymentStatus	string	false	none	none
paymentType	string	false	none	none
settlementBatch	string	false	none	none
state	string	false	none	none
updatedAt	string	false	none	none
verifiedAt	string	false	none	none
dateSettled	string	false	none	none

modelSettlementReport

{
  "id": "string",
  "amount": 0.1,
  "batch": 0.1,
  "batchType": "string",
  "merchantId": "string",
  "status": "string",
  "reference": "string",
  "settledAt": "string",
  "reconciled": true
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
amount	number(double)	false	none	none
batch	number(double)	false	none	none
batchType	string	false	none	none
merchantId	string	false	none	none
status	string	false	none	none
reference	string	false	none	none
settledAt	string	false	none	none
reconciled	boolean	false	none	none

modelSettlementReportResponse

{
  "settlements": [
    {
      "id": "string",
      "amount": 0.1,
      "batch": 0.1,
      "batchType": "string",
      "merchantId": "string",
      "status": "string",
      "reference": "string",
      "settledAt": "string",
      "reconciled": true
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
settlements	[modelSettlementReport]	false	none	none

modelSettlementRequest

{
  "merchantId": "string",
  "to": "string",
  "from": "string",
  "batchType": "string",
  "automatic": true,
  "negative": true,
  "preview": true
}

Properties

Name	Type	Required	Restrictions	Description
merchantId	string	false	none	none
to	string	false	none	none
from	string	false	none	none
batchType	string	false	none	none
automatic	boolean	false	none	none
negative	boolean	false	none	none
preview	boolean	false	none	none

modelSettlementResponse

{
  "_id": "string",
  "amount": 0.1,
  "fee": 0.1,
  "batch": "string",
  "merchantId": "string",
  "merchantAccountId": "string",
  "reference": "string",
  "dateSettled": "string",
  "reconciled": true,
  "settled": true,
  "paymentIds": [
    "string"
  ],
  "journalFees": [
    "string"
  ],
  "batchType": "string",
  "absaEftFile": "string",
  "bankTransactionId": "string",
  "createdAt": "string",
  "updatedAt": "string",
  "draft": true
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
amount	number(double)	false	none	none
fee	number(double)	false	none	none
batch	string	false	none	none
merchantId	string	false	none	none
merchantAccountId	string	false	none	none
reference	string	false	none	none
dateSettled	string	false	none	none
reconciled	boolean	false	none	none
settled	boolean	false	none	none
paymentIds	[string]	false	none	none
journalFees	[string]	false	none	none
batchType	string	false	none	none
absaEftFile	string	false	none	none
bankTransactionId	string	false	none	none
createdAt	string	false	none	none
updatedAt	string	false	none	none
draft	boolean	false	none	none

modelShopifyCalculateShippingResponse

{
  "prices": [
    {
      "title": "string",
      "amount": "string",
      "handle": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
prices	[modelShopifyShippingRate]	false	none	none

modelShopifyDiscountData

{
  "discountType": "string",
  "discountValue": "string",
  "discountAllocation": "string",
  "discountSelection": "string",
  "discountTitle": "string",
  "entitledProductIds": [
    0.1
  ],
  "entitledVariantIds": [
    0.1
  ]
}

Properties

Name	Type	Required	Restrictions	Description
discountType	string	false	none	none
discountValue	string	false	none	none
discountAllocation	string	false	none	none
discountSelection	string	false	none	none
discountTitle	string	false	none	none
entitledProductIds	[number]	false	none	none
entitledVariantIds	[number]	false	none	none

modelShopifyDiscountResponse

{
  "status": "string",
  "message": "string",
  "data": {
    "discountType": "string",
    "discountValue": "string",
    "discountAllocation": "string",
    "discountSelection": "string",
    "discountTitle": "string",
    "entitledProductIds": [
      0.1
    ],
    "entitledVariantIds": [
      0.1
    ]
  }
}

Properties

Name	Type	Required	Restrictions	Description
status	string	false	none	none
message	string	false	none	none
data	modelShopifyDiscountData	false	none	none

modelShopifyGetShopSettingsResponse

{
  "enabledOnAll": true,
  "enabledOnProduct": true,
  "enabledOnCart": true,
  "enabledAccept": true,
  "acceptMsg": "string",
  "acceptBtn": "string",
  "terms": "string",
  "products": [
    {
      "productId": "string",
      "eventDateString": "string",
      "enabledOnLayup": true,
      "minMonths": 0,
      "maxMonths": 0,
      "deposit": 0,
      "depositType": "string",
      "previewTemplate": "string",
      "learnMore": "string",
      "layupType": "string"
    }
  ],
  "logoUrl": "string",
  "learnMore": "string",
  "merchantName": "string",
  "deposit": 0,
  "depositType": "string",
  "minMonths": 0,
  "maxMonths": 0,
  "shopifyLocations": [
    {
      "address": {
        "address1": "string",
        "address2": "string",
        "city": "string",
        "phone": "string",
        "province": "string",
        "zip": "string"
      },
      "id": "string",
      "legacyResourceId": "string",
      "name": "string"
    }
  ],
  "enabledDiscount": true,
  "enabledOnPopupCart": true,
  "popupCartSelector": "string",
  "popupCartQuantitySelector": "string",
  "popupCartRemoveSelector": "string",
  "buttonLayout": "string"
}

Properties

Name	Type	Required	Restrictions	Description
enabledOnAll	boolean	false	none	none
enabledOnProduct	boolean	false	none	none
enabledOnCart	boolean	false	none	none
enabledAccept	boolean	false	none	none
acceptMsg	string	false	none	none
acceptBtn	string	false	none	none
terms	string	false	none	none
products	[modelShopifyProductSettings]	false	none	none
logoUrl	string	false	none	none
learnMore	string	false	none	none
merchantName	string	false	none	none
deposit	integer(int32)	false	none	none
depositType	string	false	none	none
minMonths	integer(int32)	false	none	none
maxMonths	integer(int32)	false	none	none
shopifyLocations	[modelShopifyLocations]	false	none	none
enabledDiscount	boolean	false	none	none
enabledOnPopupCart	boolean	false	none	none
popupCartSelector	string	false	none	none
popupCartQuantitySelector	string	false	none	none
popupCartRemoveSelector	string	false	none	none
buttonLayout	string	false	none	none

modelShopifyLineItem

{
  "title": "string",
  "quantity": 0.1,
  "sku": "string",
  "image": {
    "url": "string"
  },
  "discountedTotalSet": {
    "shopMoney": {
      "amount": "string"
    }
  }
}

Properties

Name	Type	Required	Restrictions	Description
title	string	false	none	none
quantity	number(double)	false	none	none
sku	string	false	none	none
image	modelShopifyOrderImage	false	none	none
discountedTotalSet	modelShopifyPriceSet	false	none	none

modelShopifyLinkDraftOrder

{
  "id": "string",
  "status": "string",
  "createdAt": "string",
  "name": "string",
  "customer": {
    "name": "string",
    "email": "string",
    "phone": "string",
    "displayName": "string"
  },
  "totalPriceSet": "string",
  "taxesIncluded": true,
  "lineItems": [
    {
      "title": "string",
      "quantity": 0.1,
      "sku": "string",
      "image": {
        "url": "string"
      },
      "discountedTotalSet": {
        "shopMoney": {
          "amount": "string"
        }
      }
    }
  ],
  "shippingLine": {
    "discountedPriceSet": "string"
  },
  "totalTaxSet": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
status	string	false	none	none
createdAt	string	false	none	none
name	string	false	none	none
customer	modelShopifyLinkOrderCustomer	false	none	none
totalPriceSet	string	false	none	none
taxesIncluded	boolean	false	none	none
lineItems	[modelShopifyLineItem]	false	none	none
shippingLine	modelShopifyShippingLine	false	none	none
totalTaxSet	string	false	none	none

modelShopifyLinkOrderCustomer

{
  "name": "string",
  "email": "string",
  "phone": "string",
  "displayName": "string"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
email	string	false	none	none
phone	string	false	none	none
displayName	string	false	none	none

modelShopifyLocationAddress

{
  "address1": "string",
  "address2": "string",
  "city": "string",
  "phone": "string",
  "province": "string",
  "zip": "string"
}

Properties

Name	Type	Required	Restrictions	Description
address1	string	false	none	none
address2	string	false	none	none
city	string	false	none	none
phone	string	false	none	none
province	string	false	none	none
zip	string	false	none	none

modelShopifyLocations

{
  "address": {
    "address1": "string",
    "address2": "string",
    "city": "string",
    "phone": "string",
    "province": "string",
    "zip": "string"
  },
  "id": "string",
  "legacyResourceId": "string",
  "name": "string"
}

Properties

Name	Type	Required	Restrictions	Description
address	modelShopifyLocationAddress	false	none	none
id	string	false	none	none
legacyResourceId	string	false	none	none
name	string	false	none	none

modelShopifyOrderImage

{
  "url": "string"
}

Properties

Name	Type	Required	Restrictions	Description
url	string	false	none	none

modelShopifyOrderNote

{
  "name": "string",
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
value	string	false	none	none

modelShopifyOrderNotesResponse

{
  "notes": [
    {
      "name": "string",
      "value": "string"
    }
  ],
  "tags": "string"
}

Properties

Name	Type	Required	Restrictions	Description
notes	[modelShopifyOrderNote]	false	none	none
tags	string	false	none	none

modelShopifyOrderResponse

{
  "status": "string",
  "message": "string",
  "data": "string",
  "orderId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
status	string	false	none	none
message	string	false	none	none
data	string	false	none	none
orderId	string	false	none	none

modelShopifyPriceSet

{
  "shopMoney": {
    "amount": "string"
  }
}

Properties

Name	Type	Required	Restrictions	Description
shopMoney	modelShopifyShopMoney	false	none	none

modelShopifyProduct

{
  "parentId": 0.1,
  "requiresShipping": true,
  "quantity": 0,
  "depositAmount": 0,
  "amount": 0,
  "maxMonths": 0,
  "depositType": "string",
  "link": "string",
  "singleAmount": 0,
  "sku": "string",
  "name": "string",
  "id": 0.1,
  "discounts": [
    {
      "title": "string",
      "amount": 0.1
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
parentId	number(double)	false	none	none
requiresShipping	boolean	false	none	none
quantity	integer(int32)	false	none	none
depositAmount	integer(int32)	false	none	none
amount	integer(int32)	false	none	none
maxMonths	integer(int32)	false	none	none
depositType	string	false	none	none
link	string	false	none	none
singleAmount	integer(int32)	false	none	none
sku	string	false	none	none
name	string	false	none	none
id	number(double)	false	none	none
discounts	[modelShopifyProductDiscount]	false	none	none

modelShopifyProductDiscount

{
  "title": "string",
  "amount": 0.1
}

Properties

Name	Type	Required	Restrictions	Description
title	string	false	none	none
amount	number(float)	false	none	none

modelShopifyProductSettings

{
  "productId": "string",
  "eventDateString": "string",
  "enabledOnLayup": true,
  "minMonths": 0,
  "maxMonths": 0,
  "deposit": 0,
  "depositType": "string",
  "previewTemplate": "string",
  "learnMore": "string",
  "layupType": "string"
}

Properties

Name	Type	Required	Restrictions	Description
productId	string	false	none	none
eventDateString	string	false	none	none
enabledOnLayup	boolean	false	none	none
minMonths	integer(int32)	false	none	none
maxMonths	integer(int32)	false	none	none
deposit	integer(int32)	false	none	none
depositType	string	false	none	none
previewTemplate	string	false	none	none
learnMore	string	false	none	none
layupType	string	false	none	none

modelShopifyShipping

{
  "amount": "string",
  "handle": "string",
  "title": "string"
}

Properties

Name	Type	Required	Restrictions	Description
amount	string	false	none	none
handle	string	false	none	none
title	string	false	none	none

modelShopifyShippingLine

{
  "discountedPriceSet": "string"
}

Properties

Name	Type	Required	Restrictions	Description
discountedPriceSet	string	false	none	none

modelShopifyShippingRate

{
  "title": "string",
  "amount": "string",
  "handle": "string"
}

Properties

Name	Type	Required	Restrictions	Description
title	string	false	none	none
amount	string	false	none	none
handle	string	false	none	none

modelShopifyShopMoney

{
  "amount": "string"
}

Properties

Name	Type	Required	Restrictions	Description
amount	string	false	none	none

modelSplitUser

{
  "email": "[email protected]",
  "name": "string",
  "cellNumber": "string"
}

Properties

Name	Type	Required	Restrictions	Description
email	string(email)	false	none	none
name	string	false	none	none
cellNumber	string	false	none	none

modelStatementRequest

{
  "type": "string",
  "orderId": "string",
  "email": "string",
  "paymentPlanId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
type	string	false	none	none
orderId	string	false	none	none
email	string	false	none	none
paymentPlanId	string	false	none	none

modelStatementRequestResponse

{
  "success": true
}

Properties

Name	Type	Required	Restrictions	Description
success	boolean	false	none	none

modelSupplier

{
  "_id": "string",
  "name": "string",
  "merchantId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
name	string	false	none	none
merchantId	string	false	none	none

modelTerminalCreateRequest

{
  "provider": "string",
  "serial": "string",
  "model": "string",
  "productId": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string"
}

Properties

Name	Type	Required	Restrictions	Description
provider	string	false	none	none
serial	string	false	none	none
model	string	false	none	none
productId	string	false	none	none
active	boolean	false	none	none
billable	boolean	false	none	none
merchantId	string	false	none	none
location	string	false	none	none

modelTerminalKeyResponse

{
  "terminalKey": "string"
}

Properties

Name	Type	Required	Restrictions	Description
terminalKey	string	false	none	none

modelTerminalPaymentAppResponse

{
  "_id": "string",
  "merchantId": "string",
  "packageName": "string",
  "paymentMethod": "string"
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
merchantId	string	false	none	none
packageName	string	false	none	none
paymentMethod	string	false	none	none

modelTerminalPaymentAppsGetManyResponse

{
  "terminalPaymentApps": [
    {
      "_id": "string",
      "merchantId": "string",
      "packageName": "string",
      "paymentMethod": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
terminalPaymentApps	[modelTerminalPaymentAppResponse]	false	none	none

modelTerminalResponse

{
  "id": "string",
  "provider": "string",
  "serial": "string",
  "model": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string",
  "createdAt": "string",
  "updatedAt": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	none
provider	string	false	none	none
serial	string	false	none	none
model	string	false	none	none
active	boolean	false	none	none
billable	boolean	false	none	none
merchantId	string	false	none	none
location	string	false	none	none
createdAt	string	false	none	none
updatedAt	string	false	none	none

modelTerminalServiceupdateBody

{
  "productId": "string",
  "active": true,
  "billable": true,
  "merchantId": "string",
  "location": "string"
}

Properties

Name	Type	Required	Restrictions	Description
productId	string	false	none	none
active	boolean	false	none	none
billable	boolean	false	none	none
merchantId	string	false	none	none
location	string	false	none	none

modelTerminalsResponse

{
  "terminals": [
    {
      "id": "string",
      "provider": "string",
      "serial": "string",
      "model": "string",
      "active": true,
      "billable": true,
      "merchantId": "string",
      "location": "string",
      "createdAt": "string",
      "updatedAt": "string"
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
terminals	[modelTerminalResponse]	false	none	none

modelTokenRequest

{
  "action": "VERIFYACCOUNT",
  "cellNumber": "string",
  "reference": "string",
  "email": "string",
  "_id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
action	string	false	none	none
cellNumber	string	false	none	none
reference	string	false	none	none
email	string	false	none	none
_id	string	false	none	none

Enumerated Values

Property	Value
action	VERIFYACCOUNT
action	CREATEPAYMENTPLAN
action	VIEWPAYMENTPLAN
action	VERIFYACCOUNTCREATEPAYMENTPLAN

modelTransferPaymentRequest

{
  "_id": "string",
  "_destinationPaymentPlanId": "string",
  "amount": 0
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
_destinationPaymentPlanId	string	false	none	none
amount	integer(int32)	false	none	none

modelUser

{
  "_id": "string",
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "active": true,
  "merchantId": "string",
  "cellNumber": "string",
  "dateOfBirth": "string",
  "name": "string",
  "verified": true,
  "verifiedEmail": true,
  "verifiedMobile": true,
  "merchantRole": "string",
  "merchantIds": [
    "string"
  ]
}

This user is loaded in by the authentication middleware.

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
username	string	false	none	none
email	string(email)	false	none	none
idNumber	string	false	none	none
address	string	false	none	none
postalCode	string	false	none	none
city	string	false	none	none
province	string	false	none	none
country	string	false	none	none
role	string	false	none	none
active	boolean	false	none	none
merchantId	string	false	none	none
cellNumber	string	false	none	none
dateOfBirth	string	false	none	none
name	string	false	none	none
verified	boolean	false	none	none
verifiedEmail	boolean	false	none	none
verifiedMobile	boolean	false	none	none
merchantRole	string	false	none	none
merchantIds	[string]	false	none	none

Enumerated Values

Property	Value
role	CLIENT
role	MERCHANT
role	ADMIN

modelUserRequest

{
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "password": "string",
  "name": "string",
  "dateOfBirth": "string",
  "cellNumber": "string",
  "redirectTo": "string",
  "apikey": "string",
  "shouldWelcome": true,
  "merchantCreatePlan": true,
  "merchantId": "string",
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "isMerchantOwner": true
}

Properties

Name	Type	Required	Restrictions	Description
username	string	false	none	none
email	string(email)	false	none	none
idNumber	string	false	none	none
address	string	false	none	none
postalCode	string	false	none	none
city	string	false	none	none
province	string	false	none	none
country	string	false	none	none
role	string	false	none	none
password	string	false	none	none
name	string	false	none	none
dateOfBirth	string	false	none	none
cellNumber	string	false	none	none
redirectTo	string	false	none	none
apikey	string	false	none	none
shouldWelcome	boolean	false	none	none
merchantCreatePlan	boolean	false	none	none
merchantId	string	false	none	none
merchantRole	string	false	none	none
bankDetails	modelBankInfo	false	none	none
merchantOnboarding	modelMerchantOnboarding	false	none	none
bankValidationPendingReference	string	false	none	none
passportState	string	false	none	none
passportNumber	string	false	none	none
profileImage	string	false	none	none
merchantIds	[string]	false	none	none
isMerchantOwner	boolean	false	none	none

Enumerated Values

Property	Value
role	CLIENT
role	MERCHANT
role	ADMIN

modelUserResponse

{
  "_id": "string",
  "username": "string",
  "email": "[email protected]",
  "idNumber": "string",
  "address": "string",
  "postalCode": "string",
  "city": "string",
  "province": "string",
  "country": "string",
  "role": "CLIENT",
  "active": true,
  "merchantId": "string",
  "cellNumber": "string",
  "dateOfBirth": "string",
  "name": "string",
  "verified": true,
  "timestamp": 0.1,
  "hasPassword": true,
  "verifiedEmail": true,
  "verifiedMobile": true,
  "merchantRole": "string",
  "bankDetails": {
    "bankName": {
      "verified": true,
      "value": "string"
    },
    "account": {
      "verified": true,
      "value": "string"
    },
    "accountType": {
      "verified": true,
      "value": "string"
    },
    "branchCode": {
      "verified": true,
      "value": "string"
    },
    "idNumber": {
      "verified": true,
      "value": "string"
    },
    "verified": true,
    "clientName": {
      "verified": true,
      "value": "string"
    },
    "cellNumber": {
      "verified": true,
      "value": "string"
    },
    "initials": {
      "verified": true,
      "value": "string"
    },
    "email": {
      "verified": true,
      "value": "string"
    },
    "validationResponseErrors": [
      "string"
    ]
  },
  "merchantOnboarding": {
    "name": "string",
    "physicalAddress": {
      "country": "string",
      "province": "string",
      "streetAddress": "string",
      "city": "string",
      "postalCode": "string"
    }
  },
  "bankValidationPendingReference": "string",
  "oneTimePass": "string",
  "passportState": "string",
  "passportNumber": "string",
  "profileImage": "string",
  "merchantIds": [
    "string"
  ],
  "merchants": [
    {
      "_id": "string",
      "name": "string"
    }
  ],
  "isMerchantOwner": true,
  "twoFactorAuthenticationRequired": true
}

Properties

Name	Type	Required	Restrictions	Description
_id	string	false	none	none
username	string	false	none	none
email	string(email)	false	none	none
idNumber	string	false	none	none
address	string	false	none	none
postalCode	string	false	none	none
city	string	false	none	none
province	string	false	none	none
country	string	false	none	none
role	string	false	none	none
active	boolean	false	none	none
merchantId	string	false	none	none
cellNumber	string	false	none	none
dateOfBirth	string	false	none	none
name	string	false	none	none
verified	boolean	false	none	none
timestamp	number(double)	false	none	none
hasPassword	boolean	false	none	none
verifiedEmail	boolean	false	none	none
verifiedMobile	boolean	false	none	none
merchantRole	string	false	none	none
bankDetails	modelBankInfo	false	none	none
merchantOnboarding	modelMerchantOnboarding	false	none	none
bankValidationPendingReference	string	false	none	none
oneTimePass	string	false	none	none
passportState	string	false	none	none
passportNumber	string	false	none	none
profileImage	string	false	none	none
merchantIds	[string]	false	none	none
merchants	[modelMerchants]	false	none	none
isMerchantOwner	boolean	false	none	none
twoFactorAuthenticationRequired	boolean	false	none	none

Enumerated Values

Property	Value
role	CLIENT
role	MERCHANT
role	ADMIN

modelUserResponseMany

{
  "users": [
    {
      "_id": "string",
      "username": "string",
      "email": "[email protected]",
      "idNumber": "string",
      "address": "string",
      "postalCode": "string",
      "city": "string",
      "province": "string",
      "country": "string",
      "role": "CLIENT",
      "active": true,
      "merchantId": "string",
      "cellNumber": "string",
      "dateOfBirth": "string",
      "name": "string",
      "verified": true,
      "timestamp": 0.1,
      "hasPassword": true,
      "verifiedEmail": true,
      "verifiedMobile": true,
      "merchantRole": "string",
      "bankDetails": {
        "bankName": {
          "verified": true,
          "value": "string"
        },
        "account": {
          "verified": true,
          "value": "string"
        },
        "accountType": {
          "verified": true,
          "value": "string"
        },
        "branchCode": {
          "verified": true,
          "value": "string"
        },
        "idNumber": {
          "verified": true,
          "value": "string"
        },
        "verified": true,
        "clientName": {
          "verified": true,
          "value": "string"
        },
        "cellNumber": {
          "verified": true,
          "value": "string"
        },
        "initials": {
          "verified": true,
          "value": "string"
        },
        "email": {
          "verified": true,
          "value": "string"
        },
        "validationResponseErrors": [
          "string"
        ]
      },
      "merchantOnboarding": {
        "name": "string",
        "physicalAddress": {
          "country": "string",
          "province": "string",
          "streetAddress": "string",
          "city": "string",
          "postalCode": "string"
        }
      },
      "bankValidationPendingReference": "string",
      "oneTimePass": "string",
      "passportState": "string",
      "passportNumber": "string",
      "profileImage": "string",
      "merchantIds": [
        "string"
      ],
      "merchants": [
        {
          "_id": "string",
          "name": "string"
        }
      ],
      "isMerchantOwner": true,
      "twoFactorAuthenticationRequired": true
    }
  ]
}

Properties

Name	Type	Required	Restrictions	Description
users	[modelUserResponse]	false	none	none

modelValueEnabledPair

{
  "enabled": true,
  "value": 0
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
value	integer(int32)	false	none	none

modelVerifyResponse

{
  "userId": "string"
}

Properties

Name	Type	Required	Restrictions	Description
userId	string	false	none	none

modelVoucherProvider

{
  "name": "string",
  "apiKey": "string",
  "apiUrl": "string"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
apiKey	string	false	none	none
apiUrl	string	false	none	none

modelVoucherSettings

{
  "active": true,
  "minimumSavingGoalInCents": 0,
  "maximumSavingGoalInCents": 0,
  "rewardType": "string",
  "rewardFlatAmountInCents": 0,
  "rewardPercentage": 0,
  "voucherProvider": "string"
}

Properties

Name	Type	Required	Restrictions	Description
active	boolean	false	none	none
minimumSavingGoalInCents	integer(int32)	false	none	none
maximumSavingGoalInCents	integer(int32)	false	none	none
rewardType	string	false	none	none
rewardFlatAmountInCents	integer(int32)	false	none	none
rewardPercentage	integer(int32)	false	none	none
voucherProvider	string	false	none	none

modelshopDirectorySettings

{
  "enabled": true,
  "webAvailability": "string",
  "webLogoImage": "string",
  "webCategory": [
    "string"
  ],
  "featured": true
}

Properties

Name	Type	Required	Restrictions	Description
enabled	boolean	false	none	none
webAvailability	string	false	none	none
webLogoImage	string	false	none	none
webCategory	[string]	false	none	none
featured	boolean	false	none	none

Layup endpoints v1.4.16

Introduction

What is LayUp

How to use LayUp

Terminology

Cancellation Term

Typical User Journeys

Success Journey

Failed Journey (Deposit Missed)

Failed Journey (Cancellation)

WebHooks

Order Webhooks

Payment Webhooks

API Keys

Suspended

Amortisation

amortiseOnMissed

amortiseOnMissed:true (default)

amortiseOnMissed:false

amortiseOnAmend

amortiseOnAmend:true (default)

amortiseOnAmend:false

Examples

Code examples

Authentication

authService

authService_GenerateApikey

Responses

authService_Login

Parameters

Responses

authService_Register

Parameters

Responses

authService_GenerateTerminalKey

Responses

authService_ForgotPassword

Parameters

Responses

authService_MerchantBillingChangesRequest

Parameters

Responses

UserService

UserService_GetMany

Parameters

Responses

UserService_Create

Parameters

Responses

UserService_Get

Parameters

Responses

UserService_Del

Parameters

Responses

UserService_Update

Parameters

Responses

PaymentPlanService

PaymentPlanService_Create

Parameters

Responses

PaymentPlanService_sendPaymentPlanNotification

Parameters

Responses

PaymentPlanService_CreateSplitPayment

Parameters

Responses

PaymentPlanService_CreatePreview

Parameters

Responses

PaymentPlanService_GetPreview

Parameters

Responses

PaymentPlanService_Get

Parameters

Responses

PaymentPlanService_Del

Parameters

Responses

`amortiseOnMissed`

`amortiseOnMissed:true` (default)

`amortiseOnMissed:false`

`amortiseOnAmend`

`amortiseOnAmend:true` (default)

`amortiseOnAmend:false`