KriptoGo API Documentation

curl -X POST https://kriptogo.com/api/create-invoice \
  -H "Content-Type: application/json" \
  -d '{"apiKey":"YOUR_API_KEY","amount":49.90,"callbackUrl":"https://yoursite.com/kriptogo-webhook"}'

{
  "invoice_id": "7c2f1a90-4d3e-4b1c-9a55-0f8e6d2b1c34",
  "address": "TQ5nX8w2fVv3kM1pR7bYc9dLzA4eH6uJt2",
  "amount": 49.9,
  "network": "TRON",
  "status": "PENDING",
  "checkout_url": "https://kriptogo.com/checkout.html?id=7c2f1a90-..."
}

KRIPTOGO_API_KEY=pk_...
KRIPTOGO_SECRET_KEY=...
KRIPTOGO_BASE_URL=https://kriptogo.com

const res = await fetch('https://kriptogo.com/api/create-invoice', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    apiKey: process.env.KRIPTOGO_API_KEY,
    amount: 49.90,
    callbackUrl: 'https://yoursite.com/kriptogo-webhook'
  })
});
const invoice = await res.json();
// redirect to invoice.checkout_url

<?php
$body = json_encode([
  'apiKey' => getenv('KRIPTOGO_API_KEY'),
  'amount' => 49.90,
  'callbackUrl' => 'https://yoursite.com/kriptogo-webhook',
]);

$ch = curl_init('https://kriptogo.com/api/create-invoice');
curl_setopt_array($ch, [
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => $body,
  CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
  CURLOPT_RETURNTRANSFER => true,
]);
$invoice = json_decode(curl_exec($ch), true);
curl_close($ch);

header('Location: ' . $invoice['checkout_url']);

import os, requests

r = requests.post(
    "https://kriptogo.com/api/create-invoice",
    json={
        "apiKey": os.environ["KRIPTOGO_API_KEY"],
        "amount": 49.90,
        "callbackUrl": "https://yoursite.com/kriptogo-webhook",
    },
    timeout=15,
)
invoice = r.json()
# redirect to invoice["checkout_url"]

{
  "id": "7c2f1a90-4d3e-4b1c-9a55-0f8e6d2b1c34",
  "amount": 49.9,
  "address": "TQ5nX8w2fVv3kM1pR7bYc9dLzA4eH6uJt2",
  "currency": "USDT",
  "status": "PAID",
  "txHash": "9f1c...e3a",
  "paidAmount": 49.9,
  "expiresAt": "2026-09-05T10:34:11.000Z",
  "createdAt": "2026-09-05T10:24:11.000Z",
  "trxPrice": 0.331732,
  "trxAmount": 150.42
}

{
  "event": "payment.confirmed",
  "invoice_id": "7c2f1a90-4d3e-4b1c-9a55-0f8e6d2b1c34",
  "amount": "49.9",
  "paid_amount": "49.9",
  "currency": "USDT",
  "address": "TQ5nX8w2fVv3kM1pR7bYc9dLzA4eH6uJt2",
  "tx_hash": "9f1c...e3a",
  "status": "PAID",
  "timestamp": "2026-09-05T10:31:02.415Z"
}

const express = require('express');
const crypto  = require('crypto');
const app = express();

// Keep the raw body; the signature is computed over it
app.use('/kriptogo-webhook', express.json({
  verify: (req, res, buf) => { req.rawBody = buf.toString('utf8'); }
}));

app.post('/kriptogo-webhook', (req, res) => {
  const expected = crypto
    .createHmac('sha256', process.env.KRIPTOGO_SECRET_KEY)
    .update(req.rawBody)
    .digest('hex');

  const received = req.get('X-Kriptogo-Signature') || '';
  const ok = received.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(received), Buffer.from(expected));

  if (!ok) return res.status(401).send('invalid signature');

  const { invoice_id, status, amount, tx_hash } = req.body;
  if (status === 'PAID') {
    // Confirm the order here. Ignore a repeated invoice_id.
  }
  res.sendStatus(200);
});

<?php
$raw = file_get_contents('php://input');
$received = $_SERVER['HTTP_X_KRIPTOGO_SIGNATURE'] ?? '';
$expected = hash_hmac('sha256', $raw, getenv('KRIPTOGO_SECRET_KEY'));

if (!hash_equals($expected, $received)) {
    http_response_code(401);
    exit('invalid signature');
}

$data = json_decode($raw, true);
if (($data['status'] ?? '') === 'PAID') {
    // Confirm the order: $data['invoice_id'], $data['amount'], $data['tx_hash']
}
http_response_code(200);
echo 'ok';

import hmac, hashlib, os
from flask import Flask, request

app = Flask(__name__)

@app.post("/kriptogo-webhook")
def webhook():
    raw = request.get_data()
    expected = hmac.new(
        os.environ["KRIPTOGO_SECRET_KEY"].encode(), raw, hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected, request.headers.get("X-Kriptogo-Signature", "")):
        return "invalid signature", 401

    data = request.get_json()
    if data.get("status") == "PAID":
        pass  # Confirm the order
    return "ok", 200

const express = require('express');
const crypto  = require('crypto');
const app = express();

const BASE   = 'https://kriptogo.com';
const KEY    = process.env.KRIPTOGO_API_KEY;
const SECRET = process.env.KRIPTOGO_SECRET_KEY;

// 1) Start a payment
app.post('/start-payment', express.json(), async (req, res) => {
  const { orderId, amount } = req.body;

  const r = await fetch(BASE + '/api/create-invoice', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      apiKey: KEY,
      amount: Number(amount),
      callbackUrl: 'https://yoursite.com/kriptogo-webhook'
    })
  });

  const inv = await r.json();
  if (!r.ok) return res.status(400).json({ error: inv.error });

  // store the invoice_id -> orderId mapping in your database
  await db.orders.update(orderId, { invoiceId: inv.invoice_id, status: 'awaiting_payment' });

  res.json({ checkoutUrl: inv.checkout_url });
});

// 2) Payment notification
app.use('/kriptogo-webhook', express.json({
  verify: (req, _res, buf) => { req.rawBody = buf.toString('utf8'); }
}));

app.post('/kriptogo-webhook', async (req, res) => {
  const expected = crypto.createHmac('sha256', SECRET).update(req.rawBody).digest('hex');
  const got = req.get('X-Kriptogo-Signature') || '';
  if (got !== expected) return res.status(401).send('bad signature');

  res.sendStatus(200); // Respond first

  const { invoice_id, status, amount, tx_hash } = req.body;
  if (status !== 'PAID') return;

  const order = await db.orders.findByInvoice(invoice_id);
  if (!order || order.status === 'paid') return; // Ignore a repeated notification

  await db.orders.update(order.id, { status: 'paid', txHash: tx_hash, paidAmount: amount });
  // Deliver the product, send a confirmation email...
});

app.listen(3000);

<?php
// Read the cart total, create the invoice, send the customer to the checkout page
$amount = (float) $_POST['amount'];

$ch = curl_init('https://kriptogo.com/api/create-invoice');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_POSTFIELDS     => json_encode([
        'apiKey'      => getenv('KRIPTOGO_API_KEY'),
        'amount'      => $amount,
        'callbackUrl' => 'https://yoursite.com/kriptogo-webhook.php',
    ]),
    CURLOPT_TIMEOUT        => 15,
]);

$invoice = json_decode(curl_exec($ch), true);
curl_close($ch);

if (empty($invoice['checkout_url'])) {
    die('Could not create invoice: ' . ($invoice['error'] ?? 'unknown error'));
}

// match invoice_id with your order, then redirect
$_SESSION['invoice_id'] = $invoice['invoice_id'];
header('Location: ' . $invoice['checkout_url']);

import os, hmac, hashlib, requests
from flask import Flask, request, jsonify, redirect

app = Flask(__name__)
BASE = "https://kriptogo.com"

@app.post("/start-payment")
def start_payment():
    amount = float(request.form["amount"])
    r = requests.post(f"{BASE}/api/create-invoice", json={
        "apiKey": os.environ["KRIPTOGO_API_KEY"],
        "amount": amount,
        "callbackUrl": "https://yoursite.com/kriptogo-webhook",
    }, timeout=15)

    inv = r.json()
    if not r.ok:
        return jsonify(error=inv.get("error")), 400

    # match inv["invoice_id"] with your order
    return redirect(inv["checkout_url"])

@app.post("/kriptogo-webhook")
def webhook():
    raw = request.get_data()
    expected = hmac.new(os.environ["KRIPTOGO_SECRET_KEY"].encode(), raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(expected, request.headers.get("X-Kriptogo-Signature", "")):
        return "bad signature", 401

    data = request.get_json()
    if data.get("status") == "PAID":
        pass  # Confirm the order (ignore a repeated invoice_id)
    return "ok", 200

<button id="payBtn">Pay with crypto (49.90 USDT)</button>

<script>
document.getElementById('payBtn').onclick = async () => {
  const r = await fetch('/start-payment', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ orderId: 'ORD-1042', amount: 49.90 })
  });
  const d = await r.json();
  if (d.checkoutUrl) window.location.href = d.checkoutUrl;
};
</script>