MENU navbar-image

Introduction

Professional API documentation for AmjadData users.

This documentation aims to provide all the information you need to work with our API.
<aside>As you scroll, you'll see code examples for working with the API in different programming languages in the dark area to the right.</aside>

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {YOUR_AUTH_KEY}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

Please include your API token in the Authorization header as a Bearer token.

General

Handle Airtime Purchase POST /api/airtime

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/airtime" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"network\": \"architecto\",
    \"amount\": 4326.41688,
    \"phone\": \"82256977571\",
    \"airtime_type\": \"Awoof\",
    \"ref\": \"architecto\"
}"

const url = new URL(
    "http://localhost:8000/api/airtime"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "network": "architecto",
    "amount": 4326.41688,
    "phone": "82256977571",
    "airtime_type": "Awoof",
    "ref": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/airtime';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'network' => 'architecto',
            'amount' => 4326.41688,
            'phone' => '82256977571',
            'airtime_type' => 'Awoof',
            'ref' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/airtime'
payload = {
    "network": "architecto",
    "amount": 4326.41688,
    "phone": "82256977571",
    "airtime_type": "Awoof",
    "ref": "architecto"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 60
x-ratelimit-remaining: 59
access-control-allow-origin: *
 

{
    "status": "fail",
    "msg": "Authorization token not found 6g43cv8PD1aE5beadkZfhV6"
}

Request      

POST api/airtime

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

network   string     

Example: architecto

amount   number     

Example: 4326.41688

phone   string     

Must be 11 digits. Example: 82256977571

airtime_type   string     

Example: Awoof

Must be one of:
  • VTU
  • Share And Sell
  • Momo
  • Awoof
ref   string     

Example: architecto

Handle Data Purchase POST /api/data

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/data" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"network\": \"architecto\",
    \"phone\": \"82256977571\",
    \"data_plan\": \"architecto\",
    \"ref\": \"architecto\"
}"

const url = new URL(
    "http://localhost:8000/api/data"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "network": "architecto",
    "phone": "82256977571",
    "data_plan": "architecto",
    "ref": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/data';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'network' => 'architecto',
            'phone' => '82256977571',
            'data_plan' => 'architecto',
            'ref' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/data'
payload = {
    "network": "architecto",
    "phone": "82256977571",
    "data_plan": "architecto",
    "ref": "architecto"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 60
x-ratelimit-remaining: 58
access-control-allow-origin: *
 

{
    "status": "fail",
    "msg": "Authorization token not found 6g43cv8PD1aE5beadkZfhV6"
}

Request      

POST api/data

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

network   string     

Example: architecto

phone   string     

Must be 11 digits. Example: 82256977571

data_plan   string     

Example: architecto

ref   string     

Example: architecto

Register a new user POST /api/v1/auth/register

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/auth/register" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"b\",
    \"last_name\": \"n\",
    \"email\": \"ashly64@example.com\",
    \"phone\": \"vdljnikhwaykcmyu\",
    \"password\": \"Xaz<m5L[)~=NG5a\",
    \"state\": \"l\",
    \"type\": 2
}"

const url = new URL(
    "http://localhost:8000/api/v1/auth/register"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "first_name": "b",
    "last_name": "n",
    "email": "ashly64@example.com",
    "phone": "vdljnikhwaykcmyu",
    "password": "Xaz<m5L[)~=NG5a",
    "state": "l",
    "type": 2
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/auth/register';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'b',
            'last_name' => 'n',
            'email' => 'ashly64@example.com',
            'phone' => 'vdljnikhwaykcmyu',
            'password' => 'Xaz<m5L[)~=NG5a',
            'state' => 'l',
            'type' => 2,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/auth/register'
payload = {
    "first_name": "b",
    "last_name": "n",
    "email": "ashly64@example.com",
    "phone": "vdljnikhwaykcmyu",
    "password": "Xaz<m5L[)~=NG5a",
    "state": "l",
    "type": 2
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (201):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 5
x-ratelimit-remaining: 4
access-control-allow-origin: *
 

{
    "status": "success",
    "message": "Registration successful. Please check your email for the verification code.",
    "data": {
        "email": "ashly64@example.com",
        "expires_at": "2026-01-28T22:38:57.127130Z"
    }
}

Request      

POST api/v1/auth/register

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

first_name   string     

Must not be greater than 50 characters. Example: b

last_name   string     

Must not be greater than 50 characters. Example: n

email   string  optional    

Must be a valid email address. Must not be greater than 50 characters. Example: ashly64@example.com

phone   string     

Must not be greater than 20 characters. Example: vdljnikhwaykcmyu

password   string     

Must be at least 8 characters. Example: Xaz<m5L[)~=NG5a

state   string     

Must not be greater than 50 characters. Example: l

type   integer  optional    

Must be at least 0. Must not be greater than 255. Example: 2

Verify OTP for email verification or password reset POST /api/v1/auth/verify-otp

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/auth/verify-otp" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"gbailey@example.net\",
    \"otp\": \"architecto\",
    \"purpose\": \"registration\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/auth/verify-otp"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "gbailey@example.net",
    "otp": "architecto",
    "purpose": "registration"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/auth/verify-otp';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'gbailey@example.net',
            'otp' => 'architecto',
            'purpose' => 'registration',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/auth/verify-otp'
payload = {
    "email": "gbailey@example.net",
    "otp": "architecto",
    "purpose": "registration"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (422):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 5
x-ratelimit-remaining: 3
access-control-allow-origin: *
 

{
    "message": "The selected email is invalid.",
    "errors": {
        "email": [
            "The selected email is invalid."
        ]
    }
}

Request      

POST api/v1/auth/verify-otp

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

email   string     

Must be a valid email address. The sEmail of an existing record in the subscribers table. Example: gbailey@example.net

otp   string     

Example: architecto

purpose   string     

Example: registration

Must be one of:
  • registration
  • password_reset

Resend OTP code POST /api/v1/auth/resend-otp

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/auth/resend-otp" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"gbailey@example.net\",
    \"purpose\": \"password_reset\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/auth/resend-otp"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "gbailey@example.net",
    "purpose": "password_reset"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/auth/resend-otp';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'gbailey@example.net',
            'purpose' => 'password_reset',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/auth/resend-otp'
payload = {
    "email": "gbailey@example.net",
    "purpose": "password_reset"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (422):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 5
x-ratelimit-remaining: 2
access-control-allow-origin: *
 

{
    "message": "The selected email is invalid.",
    "errors": {
        "email": [
            "The selected email is invalid."
        ]
    }
}

Request      

POST api/v1/auth/resend-otp

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

email   string     

Must be a valid email address. The sEmail of an existing record in the subscribers table. Example: gbailey@example.net

purpose   string     

Example: password_reset

Must be one of:
  • registration
  • password_reset

Login user POST /api/v1/auth/login

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/auth/login" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"identifier\": \"architecto\",
    \"password\": \"|]|{+-\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/auth/login"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "identifier": "architecto",
    "password": "|]|{+-"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/auth/login';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'identifier' => 'architecto',
            'password' => '|]|{+-',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/auth/login'
payload = {
    "identifier": "architecto",
    "password": "|]|{+-"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 5
x-ratelimit-remaining: 1
access-control-allow-origin: *
 

{
    "status": "error",
    "message": "Invalid credentials"
}

Request      

POST api/v1/auth/login

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

identifier   string     

Example: architecto

password   string     

Example: |]|{+-

Request password reset POST /api/v1/auth/forgot-password

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/auth/forgot-password" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"gbailey@example.net\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/auth/forgot-password"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "gbailey@example.net"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/auth/forgot-password';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'gbailey@example.net',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/auth/forgot-password'
payload = {
    "email": "gbailey@example.net"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
x-ratelimit-limit: 5
x-ratelimit-remaining: 0
access-control-allow-origin: *
 

{
    "status": "success",
    "message": "If that email address exists, we have sent a password reset link."
}

Request      

POST api/v1/auth/forgot-password

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

email   string     

Must be a valid email address. Example: gbailey@example.net

Request password reset via OTP POST /api/v1/auth/forgot-password-otp

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/auth/forgot-password-otp" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"gbailey@example.net\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/auth/forgot-password-otp"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "gbailey@example.net"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/auth/forgot-password-otp';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'gbailey@example.net',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/auth/forgot-password-otp'
payload = {
    "email": "gbailey@example.net"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (429):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "fail",
    "msg": "Too Many Requests"
}

Request      

POST api/v1/auth/forgot-password-otp

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

email   string     

Must be a valid email address. The sEmail of an existing record in the subscribers table. Example: gbailey@example.net

Reset password with token POST /api/v1/auth/reset-password

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/auth/reset-password" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"token\": \"architecto\",
    \"email\": \"zbailey@example.net\",
    \"password\": \"-0pBNvYgxw\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/auth/reset-password"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "token": "architecto",
    "email": "zbailey@example.net",
    "password": "-0pBNvYgxw"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/auth/reset-password';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'token' => 'architecto',
            'email' => 'zbailey@example.net',
            'password' => '-0pBNvYgxw',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/auth/reset-password'
payload = {
    "token": "architecto",
    "email": "zbailey@example.net",
    "password": "-0pBNvYgxw"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (429):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "fail",
    "msg": "Too Many Requests"
}

Request      

POST api/v1/auth/reset-password

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

token   string     

Example: architecto

email   string     

Must be a valid email address. The sEmail of an existing record in the subscribers table. Example: zbailey@example.net

password   string     

Must be at least 8 characters. Example: -0pBNvYgxw

Reset password using OTP POST /api/v1/auth/reset-password-otp

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/auth/reset-password-otp" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"gbailey@example.net\",
    \"otp\": \"architecto\",
    \"password\": \"]|{+-0pBNvYg\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/auth/reset-password-otp"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "gbailey@example.net",
    "otp": "architecto",
    "password": "]|{+-0pBNvYg"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/auth/reset-password-otp';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'gbailey@example.net',
            'otp' => 'architecto',
            'password' => ']|{+-0pBNvYg',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/auth/reset-password-otp'
payload = {
    "email": "gbailey@example.net",
    "otp": "architecto",
    "password": "]|{+-0pBNvYg"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (429):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "fail",
    "msg": "Too Many Requests"
}

Request      

POST api/v1/auth/reset-password-otp

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

email   string     

Must be a valid email address. The sEmail of an existing record in the subscribers table. Example: gbailey@example.net

otp   string     

Example: architecto

password   string     

Must be at least 6 characters. Example: ]|{+-0pBNvYg

Get authenticated user's profile GET /api/v1/account/profile

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/account/profile" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/account/profile"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/account/profile';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/account/profile'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/account/profile

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Update authenticated user's profile PUT /api/v1/account/profile

requires authentication

Example request:
curl --request PUT \
    "http://localhost:8000/api/v1/account/profile/update" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"b\",
    \"last_name\": \"n\",
    \"state\": \"g\",
    \"email\": \"rowan.gulgowski@example.com\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/account/profile/update"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "first_name": "b",
    "last_name": "n",
    "state": "g",
    "email": "rowan.gulgowski@example.com"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/account/profile/update';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'b',
            'last_name' => 'n',
            'state' => 'g',
            'email' => 'rowan.gulgowski@example.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/account/profile/update'
payload = {
    "first_name": "b",
    "last_name": "n",
    "state": "g",
    "email": "rowan.gulgowski@example.com"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

PUT api/v1/account/profile/update

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

first_name   string  optional    

Must not be greater than 255 characters. Example: b

last_name   string  optional    

Must not be greater than 255 characters. Example: n

state   string  optional    

Must not be greater than 255 characters. Example: g

email   string  optional    

Must be a valid email address. Must not be greater than 255 characters. Example: rowan.gulgowski@example.com

type   string  optional    
role   string  optional    
wallet   string  optional    
wallet_balance   string  optional    
referral_wallet_balance   string  optional    
sWallet   string  optional    
sRefWallet   string  optional    
sType   string  optional    

Get wallet balance GET /api/v1/wallet/balance

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/wallet/balance" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/wallet/balance"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/wallet/balance';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/wallet/balance'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/wallet/balance

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Get wallet transactions with filters and pagination GET /api/v1/wallet/transactions

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/wallet/transactions" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"status\": \"1\",
    \"service\": \"b\",
    \"date_from\": \"2026-01-28T22:28:57\",
    \"date_to\": \"2052-02-21\",
    \"page\": 22,
    \"per_page\": 7
}"

const url = new URL(
    "http://localhost:8000/api/v1/wallet/transactions"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "status": "1",
    "service": "b",
    "date_from": "2026-01-28T22:28:57",
    "date_to": "2052-02-21",
    "page": 22,
    "per_page": 7
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/wallet/transactions';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'status' => '1',
            'service' => 'b',
            'date_from' => '2026-01-28T22:28:57',
            'date_to' => '2052-02-21',
            'page' => 22,
            'per_page' => 7,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/wallet/transactions'
payload = {
    "status": "1",
    "service": "b",
    "date_from": "2026-01-28T22:28:57",
    "date_to": "2052-02-21",
    "page": 22,
    "per_page": 7
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/wallet/transactions

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

status   integer  optional    

Example: 1

Must be one of:
  • 0
  • 1
  • 2
  • 5
service   string  optional    

Must not be greater than 100 characters. Example: b

date_from   string  optional    

Must be a valid date. Example: 2026-01-28T22:28:57

date_to   string  optional    

Must be a valid date. Must be a date after or equal to date_from. Example: 2052-02-21

page   integer  optional    

Must be at least 1. Example: 22

per_page   integer  optional    

Must be at least 1. Must not be greater than 100. Example: 7

Initialize wallet funding POST /api/v1/wallet/fund

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/wallet/fund" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"amount\": 95,
    \"provider\": \"monnify\",
    \"email\": \"zbailey@example.net\",
    \"callback_url\": \"https:\\/\\/www.gulgowski.com\\/nihil-accusantium-harum-mollitia-modi-deserunt\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/wallet/fund"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "amount": 95,
    "provider": "monnify",
    "email": "zbailey@example.net",
    "callback_url": "https:\/\/www.gulgowski.com\/nihil-accusantium-harum-mollitia-modi-deserunt"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/wallet/fund';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'amount' => 95,
            'provider' => 'monnify',
            'email' => 'zbailey@example.net',
            'callback_url' => 'https://www.gulgowski.com/nihil-accusantium-harum-mollitia-modi-deserunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/wallet/fund'
payload = {
    "amount": 95,
    "provider": "monnify",
    "email": "zbailey@example.net",
    "callback_url": "https:\/\/www.gulgowski.com\/nihil-accusantium-harum-mollitia-modi-deserunt"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST api/v1/wallet/fund

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

amount   integer     

Must be at least 100. Example: 95

provider   string     

Example: monnify

Must be one of:
  • paystack
  • monnify
email   string     

Must be a valid email address. Example: zbailey@example.net

callback_url   string  optional    

Must be a valid URL. Example: https://www.gulgowski.com/nihil-accusantium-harum-mollitia-modi-deserunt

Get transactions list (alias to wallet/transactions) GET /api/v1/transactions

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/transactions" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"status\": \"2\",
    \"service\": \"b\",
    \"date_from\": \"2026-01-28T22:28:57\",
    \"date_to\": \"2052-02-21\",
    \"page\": 22,
    \"per_page\": 7
}"

const url = new URL(
    "http://localhost:8000/api/v1/transactions"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "status": "2",
    "service": "b",
    "date_from": "2026-01-28T22:28:57",
    "date_to": "2052-02-21",
    "page": 22,
    "per_page": 7
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/transactions';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'status' => '2',
            'service' => 'b',
            'date_from' => '2026-01-28T22:28:57',
            'date_to' => '2052-02-21',
            'page' => 22,
            'per_page' => 7,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/transactions'
payload = {
    "status": "2",
    "service": "b",
    "date_from": "2026-01-28T22:28:57",
    "date_to": "2052-02-21",
    "page": 22,
    "per_page": 7
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/transactions

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

status   integer  optional    

Example: 2

Must be one of:
  • 0
  • 1
  • 2
  • 5
service   string  optional    

Must not be greater than 100 characters. Example: b

date_from   string  optional    

Must be a valid date. Example: 2026-01-28T22:28:57

date_to   string  optional    

Must be a valid date. Must be a date after or equal to date_from. Example: 2052-02-21

page   integer  optional    

Must be at least 1. Example: 22

per_page   integer  optional    

Must be at least 1. Must not be greater than 100. Example: 7

Get transaction by reference with ownership enforcement GET /api/v1/transactions/{transref}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/transactions/architecto" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/transactions/architecto"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/transactions/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/transactions/architecto'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/transactions/{transref}

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

transref   string     

Example: architecto

Get transaction status (lightweight polling endpoint) GET /api/v1/transactions/{transref}/status

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/transactions/architecto/status" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/transactions/architecto/status"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/transactions/architecto/status';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/transactions/architecto/status'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

GET api/v1/transactions/{transref}/status

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

transref   string     

Example: architecto

Purchase Airtime POST /api/v1/services/airtime

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/services/airtime/purchase" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"network\": \"architecto\",
    \"amount\": 22,
    \"phone\": \"82256977571\",
    \"airtime_type\": \"Momo\",
    \"ref\": \"architecto\",
    \"ported_number\": \"true\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/services/airtime/purchase"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "network": "architecto",
    "amount": 22,
    "phone": "82256977571",
    "airtime_type": "Momo",
    "ref": "architecto",
    "ported_number": "true"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/services/airtime/purchase';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'network' => 'architecto',
            'amount' => 22,
            'phone' => '82256977571',
            'airtime_type' => 'Momo',
            'ref' => 'architecto',
            'ported_number' => 'true',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/services/airtime/purchase'
payload = {
    "network": "architecto",
    "amount": 22,
    "phone": "82256977571",
    "airtime_type": "Momo",
    "ref": "architecto",
    "ported_number": "true"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST api/v1/services/airtime/purchase

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

network   string     

Example: architecto

amount   number     

Must be at least 1. Example: 22

phone   string     

Must be 11 digits. Example: 82256977571

airtime_type   string     

Example: Momo

Must be one of:
  • VTU
  • Share And Sell
  • Momo
  • Awoof
ref   string     

Example: architecto

ported_number   string  optional    

Example: true

Must be one of:
  • true
  • false

Purchase Data Bundle POST /api/v1/services/data

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/services/data/purchase" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"network\": \"architecto\",
    \"data_plan\": 16,
    \"phone\": \"82256977571\",
    \"ref\": \"architecto\",
    \"ported_number\": \"true\",
    \"plan\": 16,
    \"mobile_number\": \"82256977571\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/services/data/purchase"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "network": "architecto",
    "data_plan": 16,
    "phone": "82256977571",
    "ref": "architecto",
    "ported_number": "true",
    "plan": 16,
    "mobile_number": "82256977571"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/services/data/purchase';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'network' => 'architecto',
            'data_plan' => 16,
            'phone' => '82256977571',
            'ref' => 'architecto',
            'ported_number' => 'true',
            'plan' => 16,
            'mobile_number' => '82256977571',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/services/data/purchase'
payload = {
    "network": "architecto",
    "data_plan": 16,
    "phone": "82256977571",
    "ref": "architecto",
    "ported_number": "true",
    "plan": 16,
    "mobile_number": "82256977571"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST api/v1/services/data/purchase

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

network   string     

Example: architecto

data_plan   integer     

Example: 16

phone   string     

Must be 11 digits. Example: 82256977571

ref   string     

Example: architecto

ported_number   string  optional    

Example: true

Must be one of:
  • true
  • false
plan   integer  optional    

Example: 16

mobile_number   string  optional    

Must be 11 digits. Example: 82256977571

Verify Electricity Meter POST /api/v1/services/electricity/verify

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/services/electricity/verify" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"meter_number\": \"architecto\",
    \"disco\": \"architecto\",
    \"meter_type\": \"postpaid\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/services/electricity/verify"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "meter_number": "architecto",
    "disco": "architecto",
    "meter_type": "postpaid"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/services/electricity/verify';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'meter_number' => 'architecto',
            'disco' => 'architecto',
            'meter_type' => 'postpaid',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/services/electricity/verify'
payload = {
    "meter_number": "architecto",
    "disco": "architecto",
    "meter_type": "postpaid"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST api/v1/services/electricity/verify

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

meter_number   string     

Example: architecto

disco   string     

Example: architecto

meter_type   string     

Example: postpaid

Must be one of:
  • prepaid
  • postpaid

Purchase Electricity Token POST /api/v1/services/electricity

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/services/electricity/purchase" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"meter_number\": \"architecto\",
    \"disco\": \"architecto\",
    \"meter_type\": \"prepaid\",
    \"amount\": 22,
    \"ref\": \"architecto\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/services/electricity/purchase"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "meter_number": "architecto",
    "disco": "architecto",
    "meter_type": "prepaid",
    "amount": 22,
    "ref": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/services/electricity/purchase';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'meter_number' => 'architecto',
            'disco' => 'architecto',
            'meter_type' => 'prepaid',
            'amount' => 22,
            'ref' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/services/electricity/purchase'
payload = {
    "meter_number": "architecto",
    "disco": "architecto",
    "meter_type": "prepaid",
    "amount": 22,
    "ref": "architecto"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST api/v1/services/electricity/purchase

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

meter_number   string     

Example: architecto

disco   string     

Example: architecto

meter_type   string     

Example: prepaid

Must be one of:
  • prepaid
  • postpaid
amount   number     

Must be at least 1. Example: 22

ref   string     

Example: architecto

Verify Cable TV Smart Card POST /api/v1/services/cable/verify

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/services/cable/verify" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"smartcard_number\": \"architecto\",
    \"provider\": \"startimes\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/services/cable/verify"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "smartcard_number": "architecto",
    "provider": "startimes"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/services/cable/verify';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'smartcard_number' => 'architecto',
            'provider' => 'startimes',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/services/cable/verify'
payload = {
    "smartcard_number": "architecto",
    "provider": "startimes"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST api/v1/services/cable/verify

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

smartcard_number   string     

Example: architecto

provider   string     

Example: startimes

Must be one of:
  • dstv
  • gotv
  • startimes

Purchase Cable TV Subscription POST /api/v1/services/cable

requires authentication

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/services/cable/purchase" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"smartcard_number\": \"architecto\",
    \"provider\": \"startimes\",
    \"package_code\": \"architecto\",
    \"amount\": 22,
    \"ref\": \"architecto\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/services/cable/purchase"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "smartcard_number": "architecto",
    "provider": "startimes",
    "package_code": "architecto",
    "amount": 22,
    "ref": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/services/cable/purchase';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'smartcard_number' => 'architecto',
            'provider' => 'startimes',
            'package_code' => 'architecto',
            'amount' => 22,
            'ref' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/services/cable/purchase'
payload = {
    "smartcard_number": "architecto",
    "provider": "startimes",
    "package_code": "architecto",
    "amount": 22,
    "ref": "architecto"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST api/v1/services/cable/purchase

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

smartcard_number   string     

Example: architecto

provider   string     

Example: startimes

Must be one of:
  • dstv
  • gotv
  • startimes
package_code   string     

Example: architecto

amount   number     

Must be at least 1. Example: 22

ref   string     

Example: architecto

Purchase Exam Pins POST /api/v1/services/exam-pins

requires authentication

Note: Exam pins route to LegacyFallbackProvider which returns PROCESSING status for manual fulfillment by administrators.

Example request:
curl --request POST \
    "http://localhost:8000/api/v1/services/exam-pins/purchase" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"exam_type\": \"waec\",
    \"quantity\": 16,
    \"amount\": 22,
    \"ref\": \"architecto\"
}"

const url = new URL(
    "http://localhost:8000/api/v1/services/exam-pins/purchase"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "exam_type": "waec",
    "quantity": 16,
    "amount": 22,
    "ref": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/services/exam-pins/purchase';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'exam_type' => 'waec',
            'quantity' => 16,
            'amount' => 22,
            'ref' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/services/exam-pins/purchase'
payload = {
    "exam_type": "waec",
    "quantity": 16,
    "amount": 22,
    "ref": "architecto"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "message": "Unauthenticated."
}

Request      

POST api/v1/services/exam-pins/purchase

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

exam_type   string     

Example: waec

Must be one of:
  • waec
  • neco
  • nabteb
quantity   integer     

Must be at least 1. Example: 16

amount   number     

Must be at least 1. Example: 22

ref   string     

Example: architecto

Get all networks GET /api/v1/catalog/networks

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/catalog/networks" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/catalog/networks"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/catalog/networks';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/catalog/networks'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "success",
    "data": [
        {
            "id": 1,
            "name": "MTN",
            "status": "active",
            "service_statuses": {
                "vtu": "active",
                "sme": "active",
                "gifting": "active",
                "corporate": "active",
                "datapin": "active"
            }
        },
        {
            "id": 2,
            "name": "GLO",
            "status": "active",
            "service_statuses": {
                "vtu": "active",
                "sme": "active",
                "gifting": "active",
                "corporate": "active",
                "datapin": "active"
            }
        },
        {
            "id": 3,
            "name": "9MOBILE",
            "status": "active",
            "service_statuses": {
                "vtu": "active",
                "sme": "active",
                "gifting": "active",
                "corporate": "active",
                "datapin": "active"
            }
        },
        {
            "id": 4,
            "name": "AIRTEL",
            "status": "active",
            "service_statuses": {
                "vtu": "active",
                "sme": "active",
                "gifting": "active",
                "corporate": "active",
                "datapin": "active"
            }
        }
    ]
}

Request      

GET api/v1/catalog/networks

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Get data plans GET /api/v1/catalog/data-plans?network={id}&type={type}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/catalog/data-plans" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/catalog/data-plans"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/catalog/data-plans';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/catalog/data-plans'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "success",
    "data": [
        {
            "id": 77,
            "name": "200MB",
            "network_id": 2,
            "network_name": "GLO",
            "type": "Corporate",
            "price": 6700,
            "user_price": 7200,
            "validity_days": 30,
            "plan_id": "325"
        },
        {
            "id": 78,
            "name": "1GB",
            "network_id": 1,
            "network_name": "MTN",
            "type": "SME2",
            "price": 25400,
            "user_price": 25900,
            "validity_days": 30,
            "plan_id": "333"
        },
        {
            "id": 79,
            "name": "2GB",
            "network_id": 1,
            "network_name": "MTN",
            "type": "SME2",
            "price": 50800,
            "user_price": 51500,
            "validity_days": 30,
            "plan_id": "334"
        },
        {
            "id": 80,
            "name": "3GB",
            "network_id": 1,
            "network_name": "MTN",
            "type": "SME2",
            "price": 76200,
            "user_price": 76900,
            "validity_days": 30,
            "plan_id": "335"
        },
        {
            "id": 81,
            "name": "500MB",
            "network_id": 1,
            "network_name": "MTN",
            "type": "SME2",
            "price": 12700,
            "user_price": 13000,
            "validity_days": 30,
            "plan_id": "332"
        },
        {
            "id": 82,
            "name": "5GB",
            "network_id": 1,
            "network_name": "MTN",
            "type": "SME2",
            "price": 127000,
            "user_price": 128500,
            "validity_days": 30,
            "plan_id": "336"
        },
        {
            "id": 83,
            "name": "10GB",
            "network_id": 1,
            "network_name": "MTN",
            "type": "SME2",
            "price": 254000,
            "user_price": 256000,
            "validity_days": 30,
            "plan_id": "337"
        },
        {
            "id": 233,
            "name": "200MB",
            "network_id": 2,
            "network_name": "GLO",
            "type": "coporate",
            "price": 8500,
            "user_price": 8500,
            "validity_days": 30,
            "plan_id": "233"
        }
    ]
}

Request      

GET api/v1/catalog/data-plans

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Get all discos (electricity distribution companies) GET /api/v1/catalog/discos

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/catalog/discos" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/catalog/discos"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/catalog/discos';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/catalog/discos'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "success",
    "data": [
        {
            "id": 1,
            "name": "Ikeja Electric",
            "abbreviation": "IE",
            "status": "active"
        },
        {
            "id": 2,
            "name": "Eko Electric",
            "abbreviation": "EKEDC",
            "status": "active"
        },
        {
            "id": 4,
            "name": "Port Harcourt Electric",
            "abbreviation": "PHEDC",
            "status": "active"
        },
        {
            "id": 6,
            "name": "Ibadan Electric",
            "abbreviation": "IBEDC",
            "status": "active"
        },
        {
            "id": 7,
            "name": "Kaduna Electric",
            "abbreviation": "KEDC",
            "status": "active"
        },
        {
            "id": 8,
            "name": "Abuja Electric",
            "abbreviation": "AEDC",
            "status": "active"
        },
        {
            "id": 9,
            "name": "Enugu Electric",
            "abbreviation": "ENUGU",
            "status": "active"
        },
        {
            "id": 10,
            "name": "Benin Electric",
            "abbreviation": "BENIN",
            "status": "active"
        },
        {
            "id": 11,
            "name": "Yola Electric",
            "abbreviation": "YOLA",
            "status": "active"
        }
    ]
}

Request      

GET api/v1/catalog/discos

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Get all cable providers GET /api/v1/catalog/cable-providers

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/catalog/cable-providers" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/catalog/cable-providers"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/catalog/cable-providers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/catalog/cable-providers'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "success",
    "data": [
        {
            "id": 1,
            "name": "GOTV",
            "status": "active"
        },
        {
            "id": 2,
            "name": "DSTV",
            "status": "active"
        },
        {
            "id": 3,
            "name": "STARTIMES",
            "status": "active"
        }
    ]
}

Request      

GET api/v1/catalog/cable-providers

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Get cable plans GET /api/v1/catalog/cable-plans?provider={id}

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/catalog/cable-plans" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/catalog/cable-plans"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/catalog/cable-plans';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/catalog/cable-plans'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "success",
    "data": [
        {
            "id": 1,
            "name": "GOtv Smallie  - Monthly",
            "provider_id": 1,
            "provider_name": "GOTV",
            "price": 135000,
            "user_price": 140000,
            "validity_days": 30,
            "plan_id": "1"
        },
        {
            "id": 2,
            "name": "GOtv Smallie - Quarterly",
            "provider_id": 1,
            "provider_name": "GOTV",
            "price": 350000,
            "user_price": 356000,
            "validity_days": 90,
            "plan_id": "2"
        },
        {
            "id": 3,
            "name": "GOtv Smallie - Yearly",
            "provider_id": 1,
            "provider_name": "GOTV",
            "price": 860000,
            "user_price": 866000,
            "validity_days": 365,
            "plan_id": "3"
        },
        {
            "id": 4,
            "name": "GOtv Jinja",
            "provider_id": 1,
            "provider_name": "GOTV",
            "price": 270000,
            "user_price": 275000,
            "validity_days": 30,
            "plan_id": "4"
        },
        {
            "id": 5,
            "name": "GOtv Jolli",
            "provider_id": 1,
            "provider_name": "GOTV",
            "price": 395000,
            "user_price": 397000,
            "validity_days": 30,
            "plan_id": "5"
        },
        {
            "id": 6,
            "name": "GOtv Max",
            "provider_id": 1,
            "provider_name": "GOTV",
            "price": 570000,
            "user_price": 575000,
            "validity_days": 30,
            "plan_id": "6"
        },
        {
            "id": 7,
            "name": "GOtv Supa",
            "provider_id": 1,
            "provider_name": "GOTV",
            "price": 760000,
            "user_price": 765000,
            "validity_days": 30,
            "plan_id": "7"
        },
        {
            "id": 8,
            "name": "GOtv Super Plus",
            "provider_id": 1,
            "provider_name": "GOTV",
            "price": 1255000,
            "user_price": 1259000,
            "validity_days": 30,
            "plan_id": "8"
        },
        {
            "id": 9,
            "name": "DStv Padi",
            "provider_id": 2,
            "provider_name": "DSTV",
            "price": 296000,
            "user_price": 300000,
            "validity_days": 30,
            "plan_id": "9"
        },
        {
            "id": 10,
            "name": "DStv Yanga",
            "provider_id": 2,
            "provider_name": "DSTV",
            "price": 420000,
            "user_price": 425000,
            "validity_days": 30,
            "plan_id": "10"
        },
        {
            "id": 11,
            "name": "DStv Confam",
            "provider_id": 2,
            "provider_name": "DSTV",
            "price": 740000,
            "user_price": 745000,
            "validity_days": 30,
            "plan_id": "11"
        },
        {
            "id": 12,
            "name": "DStv Asia",
            "provider_id": 2,
            "provider_name": "DSTV",
            "price": 995000,
            "user_price": 999000,
            "validity_days": 30,
            "plan_id": "12"
        },
        {
            "id": 13,
            "name": "DStv Compact",
            "provider_id": 2,
            "provider_name": "DSTV",
            "price": 1260000,
            "user_price": 1270000,
            "validity_days": 30,
            "plan_id": "13"
        },
        {
            "id": 14,
            "name": "DStv Premium",
            "provider_id": 2,
            "provider_name": "DSTV",
            "price": 2950000,
            "user_price": 2955000,
            "validity_days": 30,
            "plan_id": "14"
        },
        {
            "id": 15,
            "name": "Nova - 1 Day",
            "provider_id": 3,
            "provider_name": "STARTIMES",
            "price": 16000,
            "user_price": 18000,
            "validity_days": 1,
            "plan_id": "15"
        },
        {
            "id": 16,
            "name": "Basic - 1 Day",
            "provider_id": 3,
            "provider_name": "STARTIMES",
            "price": 31000,
            "user_price": 32000,
            "validity_days": 1,
            "plan_id": "16"
        },
        {
            "id": 17,
            "name": "Classic - 1 Day",
            "provider_id": 3,
            "provider_name": "STARTIMES",
            "price": 43000,
            "user_price": 45000,
            "validity_days": 1,
            "plan_id": "17"
        },
        {
            "id": 18,
            "name": "Super - 1 Day",
            "provider_id": 3,
            "provider_name": "STARTIMES",
            "price": 62000,
            "user_price": 65000,
            "validity_days": 1,
            "plan_id": "18"
        },
        {
            "id": 19,
            "name": "Nova - 1 Week",
            "provider_id": 3,
            "provider_name": "STARTIMES",
            "price": 65000,
            "user_price": 70000,
            "validity_days": 7,
            "plan_id": "19"
        },
        {
            "id": 20,
            "name": "Basic - 1 Week",
            "provider_id": 3,
            "provider_name": "STARTIMES",
            "price": 985105000,
            "user_price": 110000,
            "validity_days": 8,
            "plan_id": "20"
        },
        {
            "id": 21,
            "name": "Smart - 1 Week",
            "provider_id": 3,
            "provider_name": "STARTIMES",
            "price": 135000,
            "user_price": 140000,
            "validity_days": 8,
            "plan_id": "21"
        },
        {
            "id": 22,
            "name": "Classic - 1 Week",
            "provider_id": 3,
            "provider_name": "STARTIMES",
            "price": 155000,
            "user_price": 160000,
            "validity_days": 8,
            "plan_id": "22"
        }
    ]
}

Request      

GET api/v1/catalog/cable-plans

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Get all exam types GET /api/v1/catalog/exam-types

requires authentication

Example request:
curl --request GET \
    --get "http://localhost:8000/api/v1/catalog/exam-types" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "http://localhost:8000/api/v1/catalog/exam-types"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'http://localhost:8000/api/v1/catalog/exam-types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'http://localhost:8000/api/v1/catalog/exam-types'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "status": "success",
    "data": [
        {
            "id": 1,
            "name": "WAEC",
            "price": 350000,
            "status": "active"
        },
        {
            "id": 2,
            "name": "NECO",
            "price": 85000,
            "status": "active"
        },
        {
            "id": 3,
            "name": "NABTEB",
            "price": 95000,
            "status": "active"
        }
    ]
}

Request      

GET api/v1/catalog/exam-types

Headers

Authorization        

Example: Bearer {YOUR_AUTH_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json