VerifyNG API

// VerifyNG HMAC signing — PHP

function buildHmacHeaders(string $clientKey, string $apiSecret,
string $method, string $path, string $body): array {

$timestamp     = time();
$bodyHash      = hash('sha256', $body);
$signingString = implode('|', [
$clientKey, $timestamp,
strtoupper($method),
'/api/v1' . $path,
$bodyHash,
]);

$signature = hash_hmac('sha256', $signingString, $apiSecret);

return [
'X-Client-Key'  => $clientKey,
'X-Timestamp'   => $timestamp,
'X-Signature'   => $signature,
'Content-Type'  => 'application/json',
'Accept'        => 'application/json',
];
}

// Step 1: Get JWT token
$body    = '{}';
$headers = buildHmacHeaders($clientKey, $apiSecret, 'POST', '/auth/token', $body);

$response = Http::withHeaders($headers)
->withBody($body, 'application/json')
->post('https://api.verifyn.ng/api/v1/auth/token');

$jwt = $response->json('data.access_token');

// Step 2: Verify a NIN
$payload = json_encode([
'checks'     => ['nin'],
'nin'        => '12345678901',
'first_name' => 'Adaeze',
'last_name'  => 'Okonkwo',
]);

$headers = buildHmacHeaders($clientKey, $apiSecret, 'POST', '/verify', $payload);
$headers['Authorization'] = "Bearer {$jwt}";

$result = Http::withHeaders($headers)
->withBody($payload, 'application/json')
->post('https://api.verifyn.ng/api/v1/verify')
->json('data');

if ($result['outcome'] === 'approved') {
// User identity verified ✅
}

// VerifyNG HMAC signing — Node.js
const crypto = require('crypto');
const axios  = require('axios');

function buildHmacHeaders(clientKey, apiSecret, method, path, body) {
const timestamp     = Math.floor(Date.now() / 1000);
const bodyHash      = crypto.createHash('sha256').update(body).digest('hex');
const signingString = [clientKey, timestamp, method.toUpperCase(),
            `/api/v1${path}`, bodyHash].join('|');
const signature     = crypto.createHmac('sha256', apiSecret)
            .update(signingString).digest('hex');

return { 'X-Client-Key': clientKey,
'X-Timestamp':  timestamp,
'X-Signature':  signature,
'Content-Type': 'application/json',
'Accept':        'application/json' };
}

async function verifyNIN(nin, firstName, lastName) {
// Get JWT
const tokenRes = await axios.post(
'https://api.verifyn.ng/api/v1/auth/token',
{}, { headers: buildHmacHeaders(CLIENT_KEY, API_SECRET, 'POST', '/auth/token', '{}') }
);
const jwt = tokenRes.data.data.access_token;

// Verify NIN
const body = JSON.stringify({ checks: ['nin'], nin, first_name: firstName, last_name: lastName });
const headers = { ...buildHmacHeaders(CLIENT_KEY, API_SECRET, 'POST', '/verify', body),
  Authorization: `Bearer ${jwt}` };

const res = await axios.post('https://api.verifyn.ng/api/v1/verify', JSON.parse(body), { headers });
return res.data.data;
}

# VerifyNG HMAC signing — Python
import hmac, hashlib, time, json, requests

def build_hmac_headers(client_key, api_secret, method, path, body):
timestamp      = int(time.time())
body_hash      = hashlib.sha256(body.encode()).hexdigest()
signing_string = "|".join([client_key, str(timestamp),
     method.upper(), f"/api/v1{path}", body_hash])
signature      = hmac.new(api_secret.encode(), signing_string.encode(),
          hashlib.sha256).hexdigest()
return { "X-Client-Key": client_key, "X-Timestamp": str(timestamp),
"X-Signature": signature, "Content-Type": "application/json",
"Accept": "application/json" }

# Get JWT
headers = build_hmac_headers(CLIENT_KEY, API_SECRET, "POST", "/auth/token", "{}")
jwt = requests.post("https://api.verifyn.ng/api/v1/auth/token",
data="{}", headers=headers).json()["data"]["access_token"]

# Verify NIN
payload = json.dumps({"checks": ["nin"], "nin": "12345678901",
   "first_name": "Adaeze", "last_name": "Okonkwo"})
headers = build_hmac_headers(CLIENT_KEY, API_SECRET, "POST", "/verify", payload)
headers["Authorization"] = f"Bearer {jwt}"
result = requests.post("https://api.verifyn.ng/api/v1/verify",
   data=payload, headers=headers).json()["data"]

# Step 1 — Get JWT (replace values with your credentials)
# First compute the signature (see signing string docs)

curl -X POST https://api.verifyn.ng/api/v1/auth/token \
-H "X-Client-Key: ck_live_xxxx" \
-H "X-Timestamp: 1783440000" \
-H "X-Signature: your_hmac_signature" \
-H "Content-Type: application/json" \
-d '{}'

# Response:
{
"success": true,
"data": {
"access_token": "eyJhbGci...",
"expires_in": 3600
}
}

# Step 2 — Verify a NIN
curl -X POST https://api.verifyn.ng/api/v1/verify \
-H "X-Client-Key: ck_live_xxxx" \
-H "X-Timestamp: 1783440001" \
-H "X-Signature: new_hmac_for_this_body" \
-H "Authorization: Bearer eyJhbGci..." \
-H "Content-Type: application/json" \
-d '{"checks":["nin"],"nin":"12345678901","first_name":"Adaeze","last_name":"Okonkwo"}'

// VerifyNG HMAC signing — Go
package main

import (
"crypto/hmac"; "crypto/sha256"; "encoding/hex"
"fmt"; "strings"; "time"; "bytes"; "net/http"
)

func buildHmacHeaders(clientKey, apiSecret, method, path, body string) map[string]string {
timestamp  := fmt.Sprintf("%d", time.Now().Unix())
h          := sha256.Sum256([]byte(body))
bodyHash   := hex.EncodeToString(h[:])
signing    := strings.Join([]string{clientKey, timestamp,
 strings.ToUpper(method), "/api/v1"+path, bodyHash}, "|")

mac := hmac.New(sha256.New, []byte(apiSecret))
mac.Write([]byte(signing))
sig := hex.EncodeToString(mac.Sum(nil))

return map[string]string{
"X-Client-Key": clientKey, "X-Timestamp":  timestamp,
"X-Signature":  sig,         "Content-Type": "application/json",
}
}