Integration Guide

const res = await fetch('https://api.pay.kyc.rip/invoice/create', {
  method: 'POST',
  headers: {
    'X-Merchant-Key': 'mk_your-key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    amount: 25.00,
    description: 'Order #1234',
    order_id: 'ORD-1234',
    expiry_minutes: 30,
  }),
});
const invoice = await res.json();
console.log(invoice.payment_url);

import requests

resp = requests.post(
    "https://api.pay.kyc.rip/invoice/create",
    headers={"X-Merchant-Key": "mk_your-key"},
    json={
        "amount": 25.00,
        "description": "Order #1234",
        "order_id": "ORD-1234",
        "expiry_minutes": 30,
    },
)
invoice = resp.json()
print(invoice["payment_url"])

$ch = curl_init('https://api.pay.kyc.rip/invoice/create');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'X-Merchant-Key: mk_your-key',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'amount'        => 25.00,
        'description'   => 'Order #1234',
        'order_id'      => 'ORD-1234',
        'expiry_minutes' => 30,
    ]),
]);
$invoice = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $invoice['payment_url'];

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]any{
        "amount":         25.00,
        "description":    "Order #1234",
        "order_id":       "ORD-1234",
        "expiry_minutes": 30,
    })
    req, _ := http.NewRequest("POST",
        "https://api.pay.kyc.rip/invoice/create",
        bytes.NewReader(body))
    req.Header.Set("X-Merchant-Key", "mk_your-key")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    var invoice map[string]any
    json.NewDecoder(resp.Body).Decode(&invoice)
    fmt.Println(invoice["payment_url"])
}

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Merchant-Key", "mk_your-key");

var payload = JsonSerializer.Serialize(new {
    amount = 25.00,
    description = "Order #1234",
    order_id = "ORD-1234",
    expiry_minutes = 30
});
var content = new StringContent(payload, Encoding.UTF8, "application/json");

var res = await client.PostAsync("https://api.pay.kyc.rip/invoice/create", content);
var invoice = JsonSerializer.Deserialize<JsonElement>(await res.Content.ReadAsStringAsync());
Console.WriteLine(invoice.GetProperty("payment_url"));

import java.net.http.*;
import java.net.URI;

var body = """
    {"amount":25.00,"description":"Order #1234",
     "order_id":"ORD-1234","expiry_minutes":30}
    """;
var req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.pay.kyc.rip/invoice/create"))
    .header("X-Merchant-Key", "mk_your-key")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();

var res = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

const crypto = require('crypto');

function verifyWebhook(rawBody, signature, secret) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signature)
  );
}

// Express example
app.post('/webhook', express.raw({type: 'application/json'}), (req, res) => {
  const sig = req.headers['x-webhook-signature'];
  if (!verifyWebhook(req.body, sig, WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }
  const event = JSON.parse(req.body);
  // process event...
  res.sendStatus(200);
});

import hmac, hashlib

def verify_webhook(raw_body: bytes, signature: str, secret: str) -> bool:
    expected = hmac.new(
        secret.encode(), raw_body, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

# Flask example
@app.route("/webhook", methods=["POST"])
def webhook():
    sig = request.headers.get("X-Webhook-Signature", "")
    if not verify_webhook(request.data, sig, WEBHOOK_SECRET):
        return "Invalid signature", 401
    event = request.get_json()
    # process event...
    return "OK", 200

$rawBody   = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? '';
$secret    = 'your_webhook_secret';

$expected = hash_hmac('sha256', $rawBody, $secret);

if (!hash_equals($expected, $signature)) {
    http_response_code(401);
    die('Invalid signature');
}

$event = json_decode($rawBody, true);
// process $event...
http_response_code(200);
echo 'OK';

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "io"
    "net/http"
)

func verifyWebhook(body []byte, sig, secret string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(body)
    expected := hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(expected), []byte(sig))
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    body, _ := io.ReadAll(r.Body)
    sig := r.Header.Get("X-Webhook-Signature")
    if !verifyWebhook(body, sig, secret) {
        http.Error(w, "Invalid signature", 401)
        return
    }
    // process body...
    w.WriteHeader(200)
}

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

bool VerifyWebhook(string rawBody, string signature, string secret) {
    using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
    var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(rawBody));
    var expected = Convert.ToHexString(hash).ToLowerInvariant();
    return CryptographicOperations.FixedTimeEquals(
        Encoding.UTF8.GetBytes(expected),
        Encoding.UTF8.GetBytes(signature)
    );
}

// ASP.NET Core minimal API example
app.MapPost("/webhook", async (HttpContext ctx) => {
    using var reader = new StreamReader(ctx.Request.Body);
    var body = await reader.ReadToEndAsync();
    var sig = ctx.Request.Headers["X-Webhook-Signature"].ToString();
    if (!VerifyWebhook(body, sig, WEBHOOK_SECRET))
        return Results.StatusCode(401);
    // process body...
    return Results.Ok();
});

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.MessageDigest;

boolean verifyWebhook(String rawBody, String signature, String secret)
        throws Exception {
    var mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(secret.getBytes(), "HmacSHA256"));
    var hash = mac.doFinal(rawBody.getBytes());
    var expected = HexFormat.of().formatHex(hash);
    return MessageDigest.isEqual(
        expected.getBytes(), signature.getBytes()
    );
}

// Spring Boot example
@PostMapping("/webhook")
public ResponseEntity<String> webhook(
        @RequestBody String body,
        @RequestHeader("X-Webhook-Signature") String sig) throws Exception {
    if (!verifyWebhook(body, sig, WEBHOOK_SECRET))
        return ResponseEntity.status(401).body("Invalid signature");
    // process body...
    return ResponseEntity.ok("OK");
}

const res = await fetch(
  'https://api.pay.kyc.rip/invoice/by-order/ORD-1234',
  { headers: { 'X-Merchant-Key': 'mk_your-key' } }
);
const invoice = await res.json();

if (invoice.status === 'confirmed') {
  // fulfill the order
}

resp = requests.get(
    "https://api.pay.kyc.rip/invoice/by-order/ORD-1234",
    headers={"X-Merchant-Key": "mk_your-key"},
)
invoice = resp.json()

if invoice["status"] == "confirmed":
    # fulfill the order
    pass

$ch = curl_init('https://api.pay.kyc.rip/invoice/by-order/ORD-1234');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['X-Merchant-Key: mk_your-key'],
]);
$invoice = json_decode(curl_exec($ch), true);
curl_close($ch);

if ($invoice['status'] === 'confirmed') {
    // fulfill the order
}

req, _ := http.NewRequest("GET",
    "https://api.pay.kyc.rip/invoice/by-order/ORD-1234", nil)
req.Header.Set("X-Merchant-Key", "mk_your-key")

resp, _ := http.DefaultClient.Do(req)
var invoice map[string]any
json.NewDecoder(resp.Body).Decode(&invoice)

if invoice["status"] == "confirmed" {
    // fulfill the order
}

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Merchant-Key", "mk_your-key");

var res = await client.GetAsync(
    "https://api.pay.kyc.rip/invoice/by-order/ORD-1234");
var json = await res.Content.ReadAsStringAsync();
var invoice = JsonSerializer.Deserialize<JsonElement>(json);

if (invoice.GetProperty("status").GetString() == "confirmed") {
    // fulfill the order
}

var req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.pay.kyc.rip/invoice/by-order/ORD-1234"))
    .header("X-Merchant-Key", "mk_your-key")
    .GET().build();

var res = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());

// Parse with org.json or Jackson
var invoice = new org.json.JSONObject(res.body());
if (invoice.getString("status").equals("confirmed")) {
    // fulfill the order
}

const res = await fetch('https://api.pay.kyc.rip/payout', {
  method: 'POST',
  headers: {
    'X-Merchant-Key': 'mk_your-key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    payouts: [
      { address: 'TXyz...', amount: 100.00, chain: 'tron', token: 'usdt', order_id: 'WD-567', memo: 'Withdrawal #567' },
    ],
  }),
});
const data = await res.json();
console.log(data.accepted, data.total_amount);

const res = await fetch('https://api.pay.kyc.rip/payout', {
  method: 'POST',
  headers: {
    'X-Merchant-Key': 'mk_your-key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    payouts: [
      { address: '0xABC...', amount: 200, chain: 'eth', token: 'usdc', order_id: 'INV-1001' },
      { address: 'TXyz...', amount: 150, chain: 'tron', token: 'usdt', order_id: 'INV-1002' },
    ],
  }),
});