API Documentation

curl -X POST https://taskbazi.xyz/api/v1/payouts \
  -H "Content-Type: application/json" \
  -H "x-api-key: nvx_pk_live_your_key" \
  -H "x-merchant-id: your_merchant_id" \
  -H "x-signature: calculated_hmac_signature" \
  -H "x-timestamp: 1785089201" \
  -H "x-nonce: random_uuid_string" \
  -d '{
    "client_reference_id": "unique_ref_101",
    "amount": 1500.00,
    "bank_name": "HDFC Bank",
    "bank_account_number": "5010022334455",
    "bank_ifsc": "HDFC0001245",
    "bank_holder_name": "John Doe"
  }'

<?php
$apiKey = 'nvx_pk_live_your_key';
$secretKey = 'nvx_sk_live_your_secret';
$merchantId = 'your_merchant_id';
$timestamp = time();
$nonce = bin2hex(random_bytes(16));

$body = json_encode([
    'client_reference_id' => 'unique_ref_101',
    'amount' => 1500.00,
    'bank_name' => 'HDFC Bank',
    'bank_account_number' => '5010022334455',
    'bank_ifsc' => 'HDFC0001245',
    'bank_holder_name' => 'John Doe'
]);

$stringToSign = $timestamp . '.' . $nonce . '.' . $body;
$signature = hash_hmac('sha256', $stringToSign, $secretKey);
// Send POST request with x-api-key, x-signature, x-timestamp, x-nonce, x-merchant-id headers
?>

const crypto = require('crypto');
const axios = require('axios');

const apiKey = 'nvx_pk_live_your_key';
const secretKey = 'nvx_sk_live_your_secret';
const merchantId = 'your_merchant_id';
const timestamp = Math.floor(Date.now() / 1000).toString();
const nonce = crypto.randomUUID();

const payload = {
  client_reference_id: "unique_ref_101",
  amount: 1500.00,
  bank_name: "HDFC Bank",
  bank_account_number: "5010022334455",
  bank_ifsc: "HDFC0001245",
  bank_holder_name: "John Doe"
};

const bodyString = JSON.stringify(payload);
const signature = crypto
  .createHmac('sha256', secretKey)
  .update(`${timestamp}.${nonce}.${bodyString}`)
  .digest('hex');

import time, uuid, hmac, hashlib, json, requests

api_key = 'nvx_pk_live_your_key'
secret_key = 'nvx_sk_live_your_secret'
merchant_id = 'your_merchant_id'
timestamp = str(int(time.time()))
nonce = str(uuid.uuid4())

payload = {
    "client_reference_id": "unique_ref_101",
    "amount": 1500.00,
    "bank_name": "HDFC Bank",
    "bank_account_number": "5010022334455",
    "bank_ifsc": "HDFC0001245",
    "bank_holder_name": "John Doe"
}

body_str = json.dumps(payload, separators=(',', ':'))
string_to_sign = f"{timestamp}.{nonce}.{body_str}"
signature = hmac.new(secret_key.encode(), string_to_sign.encode(), hashlib.sha256).hexdigest()

#include <iostream>
#include <sstream>
#include <iomanip>
#include <openssl/hmac.h>
#include <cpr/cpr.h>

std::string compute_hmac(const std::string& key, const std::string& msg) {
    unsigned char hash[32];
    unsigned int len = 32;
    HMAC(EVP_sha256(), key.c_str(), key.length(), (unsigned char*)msg.c_str(), msg.length(), hash, &len);
    std::stringstream ss;
    for(int i = 0; i < 32; i++) {
        ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    }
    return ss.str();
}

package main
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"time"
)

func main() {
	secret := "nvx_sk_live_your_secret"
	timestamp := fmt.Sprintf("%d", time.Now().Unix())
	nonce := "uuid_or_random_hash"
	body := `{"client_reference_id":"unique_ref_101","amount":1500.00}`

	h := hmac.New(sha256.New, []byte(secret))
	h.Write([]byte(timestamp + "." + nonce + "." + body))
	signature := hex.EncodeToString(h.Sum(nil))
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import okhttp3.*;

public class NovexaPay {
    public static String calculateHMAC(String data, String key) throws Exception {
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), "HmacSHA256");
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(secretKeySpec);
        byte[] rawHmac = mac.doFinal(data.getBytes());
        return hex(rawHmac);
    }
}

using System;
using System.Security.Cryptography;
using System.Text;
using RestSharp;

public class NovexaPay {
    public static string CreateHMAC(string message, string secret) {
        byte[] keyByte = Encoding.UTF8.GetBytes(secret);
        byte[] messageBytes = Encoding.UTF8.GetBytes(message);
        using (var hmacsha256 = new HMACSHA256(keyByte)) {
            byte[] hashmessage = hmacsha256.ComputeHash(messageBytes);
            return BitConverter.ToString(hashmessage).Replace("-", "").ToLower();
        }
    }
}

require 'openssl'
require 'net/http'
require 'json'
require 'securerandom'

secret = "nvx_sk_live_your_secret"
timestamp = Time.now.to_i.to_s
nonce = SecureRandom.uuid
body = { client_reference_id: "unique_ref_101", amount: 1500.00 }.to_json

string_to_sign = "#{timestamp}.#{nonce}.#{body}"
signature = OpenSSL::HMAC.hexdigest('SHA256', secret, string_to_sign)

import Foundation
import CryptoKit

let secret = "nvx_sk_live_your_secret"
let timestamp = String(Int(Date().timeIntervalSince1970))
let nonce = UUID().uuidString
let body = "{\"client_reference_id\":\"unique_ref_101\",\"amount\":1500.00}"

let key = SymmetricKey(data: secret.data(using: .utf8)!)
let code = HMAC<SHA256>.authenticationCode(for: (timestamp + "." + nonce + "." + body).data(using: .utf8)!, using: key)