# Set your Bearer token and reference number
TOKEN="your_jwt_bearer_token_here"
REF_NO="550e8400-e29b-41d4-a716-446655440000"

curl -X GET "https://kyc.sbx.moduluslabs.io/v2/onboard/$REF_NO/status" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/json"

const axios = require('axios');

const BEARER_TOKEN = process.env.BEARER_TOKEN;
const REFERENCE_NUMBER = '550e8400-e29b-41d4-a716-446655440000';

async function getOnboardingStatus(refNo) {
  try {
    const response = await axios.get(
      `https://kyc.sbx.moduluslabs.io/v2/onboard/${refNo}/status`,
      {
        headers: {
          'Authorization': `Bearer ${BEARER_TOKEN}`,
          'Accept': 'application/json'
        }
      }
    );

    const { onboardingStatus, merchantName, declinedReason } = response.data;

    console.log(' Status retrieved successfully');
    console.log(`Merchant: ${merchantName}`);
    console.log(`Status: ${onboardingStatus}`);

    if (onboardingStatus === 'APPROVED') {
      console.log(' Onboarding approved!');
    } else if (onboardingStatus === 'DECLINED') {
      console.log(`  Declined: ${declinedReason}`);
    } else if (onboardingStatus === 'PENDING') {
      console.log(' Awaiting re-approval...');
    } else {
      console.log(' Awaiting initial approval...');
    }

    return response.data;

  } catch (error) {
    if (error.response?.status === 401) {
      console.error('  Unauthorized. Check your Bearer token.');
    } else if (error.response?.status === 400) {
      console.error('  Bad Request:', error.response.data.message);
    } else {
      console.error(' Request failed:', error.response?.data || error.message);
    }
    throw error;
  }
}

// Usage
getOnboardingStatus(REFERENCE_NUMBER);

import os
import requests

BEARER_TOKEN = os.getenv('BEARER_TOKEN')
REFERENCE_NUMBER = '550e8400-e29b-41d4-a716-446655440000'

def get_onboarding_status(ref_no):
    """Get onboarding status by reference number"""
    try:
        response = requests.get(
            f'https://kyc.sbx.moduluslabs.io/v2/onboard/{ref_no}/status',
            headers={
                'Authorization': f'Bearer {BEARER_TOKEN}',
                'Accept': 'application/json'
            }
        )

        response.raise_for_status()
        data = response.json()

        status = data['onboardingStatus']
        merchant_name = data['merchantName']
        declined_reason = data.get('declinedReason')

        print(' Status retrieved successfully')
        print(f"Merchant: {merchant_name}")
        print(f"Status: {status}")

        if status == 'APPROVED':
            print(' Onboarding approved!')
        elif status == 'DECLINED':
            print(f"  Declined: {declined_reason}")
        elif status == 'PENDING':
            print(' Awaiting re-approval...')
        else:
            print(' Awaiting initial approval...')

        return data

    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 401:
            print('  Unauthorized. Check your Bearer token.')
        elif e.response.status_code == 400:
            print(f"  Bad Request: {e.response.json().get('message')}")
        else:
            print(f' Request failed: {e.response.text}')
        raise

if __name__ == '__main__':
    get_onboarding_status(REFERENCE_NUMBER)

<?php
require 'vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;

$bearerToken = getenv('BEARER_TOKEN');
$referenceNumber = '550e8400-e29b-41d4-a716-446655440000';

function getOnboardingStatus($refNo) {
    global $bearerToken;

    try {
        $client = new Client();
        $response = $client->get(
            "https://kyc.sbx.moduluslabs.io/v2/onboard/$refNo/status",
            [
                'headers' => [
                    'Authorization' => 'Bearer ' . $bearerToken,
                    'Accept' => 'application/json'
                ]
            ]
        );

        $data = json_decode($response->getBody(), true);

        $status = $data['onboardingStatus'];
        $merchantName = $data['merchantName'];
        $declinedReason = $data['declinedReason'] ?? null;

        echo " Status retrieved successfully\n";
        echo "Merchant: $merchantName\n";
        echo "Status: $status\n";

        if ($status === 'APPROVED') {
            echo " Onboarding approved!\n";
        } elseif ($status === 'DECLINED') {
            echo "  Declined: $declinedReason\n";
        } elseif ($status === 'PENDING') {
            echo " Awaiting re-approval...\n";
        } else {
            echo " Awaiting initial approval...\n";
        }

        return $data;

    } catch (RequestException $e) {
        if ($e->hasResponse()) {
            $statusCode = $e->getResponse()->getStatusCode();
            if ($statusCode === 401) {
                echo "  Unauthorized. Check your Bearer token.\n";
            } elseif ($statusCode === 400) {
                $body = json_decode($e->getResponse()->getBody(), true);
                echo "  Bad Request: " . $body['message'] . "\n";
            } else {
                echo " Request failed: " . $e->getMessage() . "\n";
                echo $e->getResponse()->getBody() . "\n";
            }
        } else {
            echo " Request failed: " . $e->getMessage() . "\n";
        }
        throw $e;
    }
}

getOnboardingStatus($referenceNumber);
?>

import com.google.gson.Gson;
import okhttp3.*;

import java.io.IOException;

public class GetOnboardingStatus {
    private static final String BEARER_TOKEN = System.getenv("BEARER_TOKEN");
    private static final String REFERENCE_NUMBER = "550e8400-e29b-41d4-a716-446655440000";
    private static final String API_URL = "https://kyc.sbx.moduluslabs.io/v2/onboard/";

    public static void getOnboardingStatus(String refNo) throws IOException {
        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder()
                .url(API_URL + refNo + "/status")
                .header("Authorization", "Bearer " + BEARER_TOKEN)
                .header("Accept", "application/json")
                .get()
                .build();

        try (Response response = client.newCall(request).execute()) {
            String responseBody = response.body().string();

            if (response.isSuccessful()) {
                Gson gson = new Gson();
                StatusResponse data = gson.fromJson(responseBody, StatusResponse.class);

                System.out.println(" Status retrieved successfully");
                System.out.println("Merchant: " + data.merchantName);
                System.out.println("Status: " + data.onboardingStatus);

                switch (data.onboardingStatus) {
                    case "APPROVED":
                        System.out.println(" Onboarding approved!");
                        break;
                    case "DECLINED":
                        System.out.println("  Declined: " + data.declinedReason);
                        break;
                    case "PENDING":
                        System.out.println(" Awaiting re-approval...");
                        break;
                    default:
                        System.out.println(" Awaiting initial approval...");
                }
            } else if (response.code() == 401) {
                System.out.println("  Unauthorized. Check your Bearer token.");
            } else if (response.code() == 400) {
                System.out.println("  Bad Request: " + responseBody);
            } else {
                System.out.println(" Request failed: HTTP " + response.code());
                System.out.println("Details: " + responseBody);
            }
        }
    }

    public static void main(String[] args) {
        try {
            getOnboardingStatus(REFERENCE_NUMBER);
        } catch (IOException e) {
            System.err.println(" Error: " + e.getMessage());
            e.printStackTrace();
        }
    }

    static class StatusResponse {
        String onboardingStatus;
        String onboardingReferenceNumber;
        String merchantName;
        String dateCreated;
        String dateUpdated;
        String declinedReason;
    }
}

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

const (
	apiURL          = "https://kyc.sbx.moduluslabs.io/v2/onboard/"
	referenceNumber = "550e8400-e29b-41d4-a716-446655440000"
)

type StatusResponse struct {
	OnboardingStatus          string  `json:"onboardingStatus"`
	OnboardingReferenceNumber string  `json:"onboardingReferenceNumber"`
	MerchantName              string  `json:"merchantName"`
	DateCreated               string  `json:"dateCreated"`
	DateUpdated               *string `json:"dateUpdated"`
	DeclinedReason            *string `json:"declinedReason"`
}

func getOnboardingStatus(refNo string) error {
	bearerToken := os.Getenv("BEARER_TOKEN")

	req, err := http.NewRequest("GET", apiURL+refNo+"/status", nil)
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}

	req.Header.Set("Authorization", "Bearer "+bearerToken)
	req.Header.Set("Accept", "application/json")

	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return fmt.Errorf("failed to read response: %w", err)
	}

	if resp.StatusCode == http.StatusOK {
		var data StatusResponse
		if err := json.Unmarshal(body, &data); err != nil {
			return fmt.Errorf("failed to parse response: %w", err)
		}

		fmt.Println(" Status retrieved successfully")
		fmt.Printf("Merchant: %s\n", data.MerchantName)
		fmt.Printf("Status: %s\n", data.OnboardingStatus)

		switch data.OnboardingStatus {
		case "APPROVED":
			fmt.Println(" Onboarding approved!")
		case "DECLINED":
			if data.DeclinedReason != nil {
				fmt.Printf("  Declined: %s\n", *data.DeclinedReason)
			}
		case "PENDING":
			fmt.Println(" Awaiting re-approval...")
		default:
			fmt.Println(" Awaiting initial approval...")
		}

		return nil
	} else if resp.StatusCode == http.StatusUnauthorized {
		fmt.Println("  Unauthorized. Check your Bearer token.")
		return fmt.Errorf("unauthorized")
	} else if resp.StatusCode == http.StatusBadRequest {
		fmt.Printf("  Bad Request: %s\n", string(body))
		return fmt.Errorf("bad request")
	}

	fmt.Printf(" Request failed: HTTP %d\n", resp.StatusCode)
	fmt.Printf("Details: %s\n", string(body))
	return fmt.Errorf("request failed with status %d", resp.StatusCode)
}

func main() {
	if err := getOnboardingStatus(referenceNumber); err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}
}

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        await GetOnboardingStatus("550e8400-e29b-41d4-a716-446655440000");
    }

    static async Task GetOnboardingStatus(string refNo)
    {
        var bearerToken = Environment.GetEnvironmentVariable("BEARER_TOKEN");

        if (string.IsNullOrEmpty(bearerToken))
        {
            Console.WriteLine(" Error: BEARER_TOKEN environment variable not set");
            return;
        }

        try
        {
            using var client = new HttpClient();
            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Bearer", bearerToken);
            client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));

            var response = await client.GetAsync(
                $"https://kyc.sbx.moduluslabs.io/v2/onboard/{refNo}/status"
            );

            var responseBody = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode)
            {
                var data = JsonSerializer.Deserialize<StatusResponse>(
                    responseBody,
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
                );

                Console.WriteLine(" Status retrieved successfully");
                Console.WriteLine($"Merchant: {data.MerchantName}");
                Console.WriteLine($"Status: {data.OnboardingStatus}");

                switch (data.OnboardingStatus)
                {
                    case "APPROVED":
                        Console.WriteLine(" Onboarding approved!");
                        break;
                    case "DECLINED":
                        Console.WriteLine($"  Declined: {data.DeclinedReason}");
                        break;
                    case "PENDING":
                        Console.WriteLine(" Awaiting re-approval...");
                        break;
                    default:
                        Console.WriteLine(" Awaiting initial approval...");
                        break;
                }
            }
            else if ((int)response.StatusCode == 401)
            {
                Console.WriteLine("  Unauthorized. Check your Bearer token.");
            }
            else if ((int)response.StatusCode == 400)
            {
                Console.WriteLine($"  Bad Request: {responseBody}");
            }
            else
            {
                Console.WriteLine($" Request failed: HTTP {(int)response.StatusCode}");
                Console.WriteLine($"Details: {responseBody}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($" Request failed: {e.Message}");
        }
        catch (Exception e)
        {
            Console.WriteLine($" Error: {e.Message}");
        }
    }
}

public class StatusResponse
{
    public string OnboardingStatus { get; set; }
    public string OnboardingReferenceNumber { get; set; }
    public string MerchantName { get; set; }
    public string DateCreated { get; set; }
    public string DateUpdated { get; set; }
    public string DeclinedReason { get; set; }
}