# Set your Bearer token
TOKEN="your_jwt_bearer_token_here"

curl -X POST https://kyc.sbx.moduluslabs.io/v2/onboard/signup \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "contact": {
      "email": "john.doe@example.com",
      "phone": "09171234567"
    },
    "user": {
      "firstName": "John",
      "middleName": "Michael",
      "lastName": "Doe",
      "username": "john.doe",
      "password": "SecurePass123!",
      "pin": "1234"
    }
  }'

const axios = require('axios');

const BEARER_TOKEN = process.env.BEARER_TOKEN; // Your JWT Bearer token

async function createAccount() {
  const accountData = {
    contact: {
      email: 'john.doe@example.com',
      phone: '09171234567'
    },
    user: {
      firstName: 'John',
      middleName: 'Michael',
      lastName: 'Doe',
      username: 'john.doe',
      password: 'SecurePass123!',
      pin: '1234'
    }
  };

  try {
    const response = await axios.post(
      'https://kyc.sbx.moduluslabs.io/v2/onboard/signup',
      accountData,
      {
        headers: {
          'Authorization': `Bearer ${BEARER_TOKEN}`,
          'Content-Type': 'application/json'
        }
      }
    );

    console.log(' Account created successfully');
    console.log('Account ID:', response.data.id);
    return response.data;

  } catch (error) {
    if (error.response?.status === 401) {
      console.error('  Unauthorized. Check your Bearer token.');
    } else if (error.response?.status === 429) {
      console.error('  Rate limit exceeded. Please wait before retrying.');
    } else {
      console.error(' Account creation failed:', error.response?.data || error.message);
    }
    throw error;
  }
}

createAccount();

import os
import requests

BEARER_TOKEN = os.getenv('BEARER_TOKEN')  # Your JWT Bearer token

def create_account():
    """Create a new user account"""
    account_data = {
        'contact': {
            'email': 'john.doe@example.com',
            'phone': '09171234567'
        },
        'user': {
            'firstName': 'John',
            'middleName': 'Michael',
            'lastName': 'Doe',
            'username': 'john.doe',
            'password': 'SecurePass123!',
            'pin': '1234'
        }
    }

    try:
        response = requests.post(
            'https://kyc.sbx.moduluslabs.io/v2/onboard/signup',
            json=account_data,
            headers={
                'Authorization': f'Bearer {BEARER_TOKEN}',
                'Content-Type': 'application/json'
            }
        )

        response.raise_for_status()
        print(' Account created successfully')
        print(f"Account ID: {response.json()['id']}")
        return response.json()

    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 401:
            print('  Unauthorized. Check your Bearer token.')
        elif e.response.status_code == 429:
            print('  Rate limit exceeded. Please wait before retrying.')
        else:
            print(f' Account creation failed: {e.response.text}')
        raise

if __name__ == '__main__':
    create_account()

<?php
require 'vendor/autoload.php'; // composer require guzzlehttp/guzzle

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

$bearerToken = getenv('BEARER_TOKEN'); // Your JWT Bearer token

/**
 * Create a new user account
 */
function createAccount() {
    global $bearerToken;

    $accountData = [
        'contact' => [
            'email' => 'john.doe@example.com',
            'phone' => '09171234567'
        ],
        'user' => [
            'firstName' => 'John',
            'middleName' => 'Michael',
            'lastName' => 'Doe',
            'username' => 'john.doe',
            'password' => 'SecurePass123!',
            'pin' => '1234'
        ]
    ];

    try {
        $client = new Client();
        $response = $client->post('https://kyc.sbx.moduluslabs.io/v2/onboard/signup', [
            'headers' => [
                'Authorization' => 'Bearer ' . $bearerToken,
                'Content-Type' => 'application/json'
            ],
            'json' => $accountData
        ]);

        $body = json_decode($response->getBody(), true);
        echo " Account created successfully\n";
        echo "Account ID: " . $body['id'] . "\n";
        return $body;

    } catch (RequestException $e) {
        if ($e->hasResponse()) {
            $statusCode = $e->getResponse()->getStatusCode();
            if ($statusCode === 401) {
                echo "  Unauthorized. Check your Bearer token.\n";
            } elseif ($statusCode === 429) {
                echo "  Rate limit exceeded. Please wait before retrying.\n";
            } else {
                echo " Account creation failed: " . $e->getMessage() . "\n";
                echo $e->getResponse()->getBody() . "\n";
            }
        } else {
            echo " Account creation failed: " . $e->getMessage() . "\n";
        }
        throw $e;
    }
}

createAccount();
?>

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

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class CreateAccount {
    private static final String BEARER_TOKEN = System.getenv("BEARER_TOKEN"); // Your JWT Bearer token
    private static final String API_URL = "https://kyc.sbx.moduluslabs.io/v2/onboard/signup";
    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

    /**
     * Create a new user account
     */
    public static void createAccount() throws IOException {
        // Create account data
        Map<String, Object> accountData = new HashMap<>();

        Map<String, String> contact = new HashMap<>();
        contact.put("email", "john.doe@example.com");
        contact.put("phone", "09171234567");
        accountData.put("contact", contact);

        Map<String, String> user = new HashMap<>();
        user.put("firstName", "John");
        user.put("middleName", "Michael");
        user.put("lastName", "Doe");
        user.put("username", "john.doe");
        user.put("password", "SecurePass123!");
        user.put("pin", "1234");
        accountData.put("user", user);

        // Send request
        Gson gson = new Gson();
        String json = gson.toJson(accountData);

        OkHttpClient client = new OkHttpClient();
        RequestBody body = RequestBody.create(json, JSON);
        Request request = new Request.Builder()
                .url(API_URL)
                .header("Authorization", "Bearer " + BEARER_TOKEN)
                .post(body)
                .build();

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

            if (response.isSuccessful()) {
                System.out.println(" Account created successfully");
                System.out.println("Response: " + responseBody);
            } else if (response.code() == 401) {
                System.out.println("  Unauthorized. Check your Bearer token.");
            } else if (response.code() == 429) {
                System.out.println("  Rate limit exceeded. Please wait before retrying.");
            } else {
                System.out.println(" Account creation failed: HTTP " + response.code());
                System.out.println("Details: " + responseBody);
            }
        }
    }

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

package main

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

const apiURL = "https://kyc.sbx.moduluslabs.io/v2/onboard/signup"

// createAccount creates a new user account
func createAccount() error {
	bearerToken := os.Getenv("BEARER_TOKEN") // Your JWT Bearer token

	accountData := map[string]interface{}{
		"contact": map[string]string{
			"email": "john.doe@example.com",
			"phone": "09171234567",
		},
		"user": map[string]string{
			"firstName":  "John",
			"middleName": "Michael",
			"lastName":   "Doe",
			"username":   "john.doe",
			"password":   "SecurePass123!",
			"pin":        "1234",
		},
	}

	jsonData, err := json.Marshal(accountData)
	if err != nil {
		return fmt.Errorf("failed to marshal data: %w", err)
	}

	req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonData))
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}

	req.Header.Set("Authorization", "Bearer "+bearerToken)
	req.Header.Set("Content-Type", "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 result map[string]interface{}
		if err := json.Unmarshal(body, &result); err != nil {
			return fmt.Errorf("failed to parse response: %w", err)
		}

		fmt.Println(" Account created successfully")
		fmt.Printf("Account ID: %.0f\n", result["id"])
		return nil
	} else if resp.StatusCode == http.StatusUnauthorized {
		fmt.Println("  Unauthorized. Check your Bearer token.")
		return fmt.Errorf("unauthorized")
	} else if resp.StatusCode == http.StatusTooManyRequests {
		fmt.Println("  Rate limit exceeded. Please wait before retrying.")
		return fmt.Errorf("rate limit exceeded")
	}

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

func main() {
	if err := createAccount(); 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;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        await CreateAccount();
    }

    static async Task CreateAccount()
    {
        // Get Bearer token from environment variable
        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();

            // Set Bearer token authorization
            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Bearer", bearerToken);

            // Prepare account data
            var accountData = new
            {
                contact = new
                {
                    email = "john.doe@example.com",
                    phone = "09171234567"
                },
                user = new
                {
                    firstName = "John",
                    middleName = "Michael",
                    lastName = "Doe",
                    username = "john.doe",
                    password = "SecurePass123!",
                    pin = "1234"
                }
            };

            var content = new StringContent(
                JsonSerializer.Serialize(accountData),
                Encoding.UTF8,
                "application/json"
            );

            // Send POST request
            var response = await client.PostAsync(
                "https://kyc.sbx.moduluslabs.io/v2/onboard/signup",
                content
            );

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

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

                Console.WriteLine(" Account created successfully");
                Console.WriteLine($"Account ID: {result.Id}");
            }
            else if ((int)response.StatusCode == 401)
            {
                Console.WriteLine("  Unauthorized. Check your Bearer token.");
            }
            else if ((int)response.StatusCode == 429)
            {
                Console.WriteLine("  Rate limit exceeded. Please wait before retrying.");
            }
            else
            {
                Console.WriteLine($" Account creation 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}");
        }
    }
}

// Response model
public class CreateAccountResponse
{
    public int Id { get; set; }
}

{
  "id": 12345
}

{
  "statusCode": 400,
  "message": "user.password must have at least 1 uppercase and lowercase character, a number, and special character.",
  "error": "Bad Request"
}

{
  "statusCode": 401,
  "message": "Unauthorized",
  "error": "Unauthorized"
}

{
  "statusCode": 429,
  "message": "ThrottlerException: Too Many Requests",
  "error": "Too Many Requests"
}

{
  "statusCode": 500,
  "message": "Internal server error",
  "error": "Internal Server Error"
}