Crypto payment infrastructure

Private crypto payments for platforms that move millions.

Cryptogon is the private payment layer for high-volume platforms. Take deposits and send payouts in stablecoins and major cryptocurrencies, quote in your customers’ own currency, and hear about every payment within seconds.

  • USDTTether USD
  • USDCUSD Coin
  • ETHEther
  • BNBBNB
  • TRXTRON
  • BTCBitcoin
  • SOLSolana
  • LTCLitecoin
  • DOGEDogecoin
  • TONToncoin
  • XRPXRP
  • POLPOL
  • AVAXAvalanche
  • BCHBitcoin Cash
  • DAIDai
from on-chain payment to your webhook, before network finality
<5s
private keys on any internet-facing machine
0
of automatic, signed webhook retries
24h
trackers, cookies or third-party scripts
0

Why Cryptogon

Cryptogon is built for platforms that move serious volume and cannot afford to leak a single detail. Signing keys stay offline, every movement is booked twice in the ledger, and nothing about you or your customers is shared.

Platform

Everything you need to take crypto in and send it out

Checkout, payouts, quotes, webhooks and settlement, delivered as one product behind one API.

Hosted checkout

A fast, mobile-first payment page. Your customer picks coin and network, scans a QR and watches the payment confirm live.

Automated payouts

Withdrawals you approve are signed and sent automatically. Rules hold only what genuinely needs a second look.

Local-currency quotes

Price in your customers’ currency. The rate is locked while they pay.

Real-time webhooks

Signed events the moment a payment is detected, confirmed or sent.

Free top-ups

Fund your payout balance from your own top-up address. No fee, no paperwork.

Underpaid, overpaid or late

Underpaid, overpaid, late, or sent on the wrong EVM network: every transfer is recorded and resolvable. Nothing silently disappears.

Settle on demand

Move your net balance to your own wallet whenever you choose.

How it works

How a payment moves through Cryptogon

It starts with one API call. We handle the chain, the checkout and the bookkeeping.

  1. Create

    Your platform makes one signed API call and gets back a hosted payment link and a permanent deposit address for that customer.

    POST /v1/deposits
    {
      "merchant_reference": "order-1001",
      "network": "tron",
      "asset": "USDT",
      "amount": "250.00"
    }
    
    ← 201 Created
    {
      "status": "pending",
      "checkout_url": "https://cryptogon.app/p/…"
    }
  2. Pay

    Your customer chooses coin and network on the hosted page and pays from any wallet. The rate stays locked while they pay.

  3. Confirm

    We watch the chain and credit only on network finality, so reorganisations and dropped transactions never touch your balance.

    {
      "type": "deposit.confirmed",
      "resource_version": 2,
      "data": {
        "status": "confirmed",
        "asset": "USDT",
        "amount": "250.00",
        "transfer": { "variance": "exact" }
      }
    }
  4. Settle

    A signed webhook reaches you within seconds. Payouts run on rules, and you settle to your own wallet on demand.

    POST https://your-platform.example/hooks
    X-Cryptogon-Event-Id: 0b8f5a52-2d1c-4c47…
    X-Cryptogon-Signature: v1=5f2c9e81d0…
    
    ← 200 OK · 143 ms

Coverage

Supported coins and networks

Stablecoins first, majors next. Your customer picks coin and network on the checkout, and you receive exactly what they sent: no forced conversion, no hidden spread.

5 assets live on 3 networks today · 26 assets across 13 networks on the roadmap

  • Live

    USDT

    Tether USD

    TRC20BEP20ERC20SolanaTON

  • Live

    USDC

    USD Coin

    BEP20ERC20SolanaPolygon

  • Live

    ETH

    Ether

    ERC20

  • Live

    BNB

    BNB

    BEP20

  • Live

    TRX

    TRON

    TRC20

  • Rolling out

    BTC

    Bitcoin

    Bitcoin

  • Rolling out

    SOL

    Solana

    Solana

  • Rolling out

    LTC

    Litecoin

    Litecoin

  • Rolling out

    DOGE

    Dogecoin

    Dogecoin

  • Rolling out

    TON

    Toncoin

    TON

  • Rolling out

    XRP

    XRP

    XRPL

  • Rolling out

    POL

    POL

    Polygon

  • Rolling out

    AVAX

    Avalanche

    Avalanche

  • Rolling out

    BCH

    Bitcoin Cash

    BCH

  • Rolling out

    DAI

    Dai

    ERC20

  • EOS
  • LINK
  • UNI
  • SHIB
  • APE
  • SAND
  • CRO
  • BONK
  • WIF
  • PUMP
  • TRUMP

Priced in their currency

Show amounts in your customers’ own currency: US dollars, euros, Turkish lira, Brazilian real and many more. We convert at a locked rate built from several exchange prices.

Dashboard

A dashboard built for finance teams

Balances, payments, payouts, settlements and team access in one fast interface.

  • Live overview

    Deposits, payouts and net balance by asset and network, as they happen.

  • Full history

    Every payment and payout per customer, with filters and CSV export.

  • Webhook log

    See every delivery and resend any event in one click.

  • Scoped API keys

    Read, deposit and payout scopes; payout keys locked to your IP addresses.

  • Team roles

    Admin, finance and support roles, with two-factor sign-in for everyone.

  • Settlements

    Withdraw your net balance to your own registered wallet.

White-label

Your brand on the checkout

Customers stay inside your experience. Choose the colours, logo, background, typeface and footer, and the checkout follows your brand instead of ours.

  • Palette and logo

    Your colours, logo and icon. Text contrast is enforced automatically, so every theme stays readable.

  • Type and background

    Pick from a curated set of self-hosted typefaces and set your own background.

  • Safety stays on

    The address check and our domain line always remain, so look-alike pages can’t borrow your brand.

Theme 1 of 5: Nova

Drag, swipe or use the arrows

Security

Five layers between the internet and your funds

Each layer assumes the one before it can fail. Keys stay offline, money moves only by rule, and every movement is recorded twice.

  • Keys never touch the internet

    Signing happens on an isolated machine that accepts no inbound connections. Nothing that faces the internet ever sees a private key.

  • Cold by default

    Hot wallets hold only what near-term payouts need. Everything else sweeps to cold storage automatically.

  • A ledger that can’t be edited

    Balances are never typed in. Every movement is a double-entry journal record, reconciled against the chain every day.

  • Credit only on finality

    Deposits credit only on network finality. Reorganisations and dropped transactions never reach your balance.

  • One switch to halt payouts

    Halt every payout, a single network or a single merchant in one action, without losing a single request.

  • Signed and audited

    HMAC-signed requests, idempotency keys, signed webhooks, mandatory two-factor sign-in and an append-only audit trail.

Privacy

Nothing shared, nothing tracked

Privacy is built into how Cryptogon works. We guarantee that nothing is shared, nothing is tracked and nothing is linked back to you or your customers.

Our privacy guarantee

private by design
100%
bytes of your data shared or sold
0
trackers, pixels, cookies or visitor logs
0
  • Zero data sharing

    No data brokers, no ad networks, no “partner insights”. Your volumes and your customers are never shared, sold or rented.

  • Zero tracking

    No analytics, pixels, fingerprinting, session recording or cookies, on this site and on the checkout. Visits to this site aren’t logged at all.

  • A console off the public internet

    Our operations console isn’t on the public internet: it’s reachable only through a private, encrypted layer, and monitoring runs entirely on our own infrastructure.

  • Addresses tied to no identity

    Every customer gets their own deposit address from keys that never touch the internet. No address is ever tied to a name, email, phone or document.

  • Only what a payment needs

    We never ask for your customers’ names, emails or documents. An opaque reference is all we need, and it never appears in an address or a log line.

  • No IP next to an address

    Checkout logs keep only masked tokens and are deleted after 30 days. An IP address is never stored next to a wallet address.

  • No public client list

    No public client list, no logos, no case studies, no per-merchant subdomains that would show up in public certificate logs.

  • We never send email

    We never send email and keep no public inbox or contact form. Any message in our name is phishing; access is handed over in person.

What we store about a payment

Customer name
Not collected
Email address
Not collected
Documents
Not collected
IP address
Not stored
Reference
c_7f3a…e91
Amount
250.00 USDT
Network
Tron (TRC20)

Pricing

Published rates, no conversion fees

One rate on deposits, network costs passed through at cost on payouts, and no margin hidden in conversion.

  • Deposits

    from0.5%

    per confirmed payment

    Volume pricing for larger platforms.

  • Payouts

    from0.25%

    per payout

    Plus the network fee, shown before you send.

  • Top-ups

    Free

    always

    Fund your payout balance at no cost.

  • Setup and monthly

    Free

    no minimums

    No setup fee and no monthly fee.

How we compare

How we compareCryptogonTypical gateway
Processing feefrom 0.5%0.5%–1%
Conversion feeNone, you keep the coin0.5%–1% where charged
White-label checkoutAvailableUsually enterprise-only or extra
Payout balance top-upsFreeVaries
Trackers on checkoutNoneVaries
Fees on $1,000,000 of deposits
  • Cryptogon$5,000
  • Most common published rate$10,000
  • Entry-level rates, up to$30,000

Deposit fee only, at published rates. Network fees excluded.

Typical figures summarise the publicly listed prices of major crypto payment processors as of October 2026. Your rate depends on volume and asset mix.

Volume rates are agreed personally during onboarding.

Developers

A REST API, signed webhooks and a full sandbox

Versioned endpoints, signed events and a complete test-network sandbox. Our engineers work with you from the first request to go-live.

  • Versioned and stable

    /v1 stays backward compatible. Breaking changes only ever ship as a new version.

  • Signed requests

    HMAC-SHA256 signatures with timestamps, idempotency keys on every money-moving call, scoped keys with IP allowlists.

  • Reliable webhooks

    Signed, de-duplicated by event ID, retried with back-off for 24 hours and re-sendable from the dashboard.

  • Sandbox on test networks

    Run the complete flow on test networks before a single real coin moves.

  • Platform connectors

    Ready-made connectors for leading platform back-offices, or plug in directly through the API.

  • Direct engineering support

    Direct access to the people who built the system, from sandbox to go-live.

Create a paymentSimplified example

cURL

BODY='{"merchant_reference":"order-1001","network":"tron","asset":"USDT","amount":"250.00"}'
TS=$(date +%s)
HASH=$(printf '%s' "$BODY" | sha256sum | cut -d' ' -f1)
SIG=$(printf '%s\nPOST\n/v1/deposits\n%s' "$TS" "$HASH" \
  | openssl dgst -sha256 -hmac "$CRYPTOGON_SECRET" | cut -d' ' -f2)

curl "$CRYPTOGON_API/v1/deposits" \
  -H "X-Cryptogon-Key: $CRYPTOGON_KEY" \
  -H "X-Cryptogon-Timestamp: $TS" \
  -H "X-Cryptogon-Signature: v1=$SIG" \
  -H "Idempotency-Key: order-1001" \
  -H "Content-Type: application/json" \
  -d "$BODY"

Node.js

import { createHash, createHmac } from 'node:crypto';

const body = JSON.stringify({
  merchant_reference: 'order-1001',
  network: 'tron',
  asset: 'USDT',
  amount: '250.00',
});
const ts = String(Math.floor(Date.now() / 1000));
const digest = createHash('sha256').update(body).digest('hex');
const sig = createHmac('sha256', process.env.CRYPTOGON_SECRET)
  .update([ts, 'POST', '/v1/deposits', digest].join('\n'))
  .digest('hex');

const res = await fetch(`${process.env.CRYPTOGON_API}/v1/deposits`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Idempotency-Key': 'order-1001',
    'X-Cryptogon-Key': process.env.CRYPTOGON_KEY,
    'X-Cryptogon-Timestamp': ts,
    'X-Cryptogon-Signature': `v1=${sig}`,
  },
  body,
});
const { checkout_url } = await res.json(); // send your customer here

Python

import hashlib, hmac, json, os, time, requests

body = json.dumps({
    "merchant_reference": "order-1001",
    "network": "tron",
    "asset": "USDT",
    "amount": "250.00",
}, separators=(",", ":"))
ts = str(int(time.time()))
digest = hashlib.sha256(body.encode()).hexdigest()
text = "\n".join([ts, "POST", "/v1/deposits", digest])
secret = os.environ["CRYPTOGON_SECRET"].encode()
sig = hmac.new(secret, text.encode(), hashlib.sha256).hexdigest()

res = requests.post(os.environ["CRYPTOGON_API"] + "/v1/deposits", data=body, headers={
    "Content-Type": "application/json",
    "Idempotency-Key": "order-1001",
    "X-Cryptogon-Key": os.environ["CRYPTOGON_KEY"],
    "X-Cryptogon-Timestamp": ts,
    "X-Cryptogon-Signature": "v1=" + sig,
})
checkout_url = res.json()["checkout_url"]  # send your customer here

PHP

$body = json_encode([
    'merchant_reference' => 'order-1001',
    'network' => 'tron',
    'asset' => 'USDT',
    'amount' => '250.00',
]);
$ts = (string) time();
$text = implode("\n", [$ts, 'POST', '/v1/deposits', hash('sha256', $body)]);
$sig = hash_hmac('sha256', $text, getenv('CRYPTOGON_SECRET'));

$ch = curl_init(getenv('CRYPTOGON_API') . '/v1/deposits');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $body,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Content-Type: application/json',
        'Idempotency-Key: order-1001',
        'X-Cryptogon-Key: ' . getenv('CRYPTOGON_KEY'),
        "X-Cryptogon-Timestamp: $ts",
        "X-Cryptogon-Signature: v1=$sig",
    ],
]);
$checkoutUrl = json_decode(curl_exec($ch), true)['checkout_url'];
Verify a webhookNode.js
import { createHmac, timingSafeEqual } from 'node:crypto';

export function verifyWebhook(secret, headers, rawBody) {
  const ts = headers['x-cryptogon-timestamp'];
  if (Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;
  const sig = createHmac('sha256', secret).update(`${ts}.${rawBody}`).digest('hex');
  const expected = Buffer.from(`v1=${sig}`);
  const given = Buffer.from(String(headers['x-cryptogon-signature']));
  return given.length === expected.length && timingSafeEqual(given, expected);
}

Sandbox keys are shared during onboarding. Read the API documentation

FAQ

Frequently asked questions

Which coins and networks do you support?

USDT and USDC on Tron, BNB Smart Chain and Ethereum, plus TRX, BNB and ETH, are live today. Bitcoin, Litecoin, Dogecoin and Solana come next, followed by the rest of our list: 26 assets across 13 networks in total.

Can my customers see prices in their own currency?

Yes. You can quote in your customers’ local currency and we convert at a rate built from several exchange prices. The rate is locked for the customer while they pay.

How fast will I know about a payment?

We notify you within seconds of a payment appearing on-chain, and again the moment it reaches network finality. Finality depends on the network: from seconds on BNB Smart Chain to a few minutes on Ethereum.

What happens if a customer pays the wrong amount?

Every transfer is recorded. Underpayments are credited and flagged, overpayments are credited in full, and late payments are never lost. Tokens sent on the wrong EVM network can be recovered.

Where are the funds held?

Payments credit your merchant balance, recorded in a double-entry ledger. Hot wallets hold only what near-term payouts need, the rest sits in cold storage, and you can settle your net balance to your own wallet at any time.

What data do you collect about my customers?

Only what a payment needs: an opaque customer reference, amounts, addresses and transaction hashes. We never ask for names, email addresses or documents, and we never share or sell data.

Can the checkout carry my own brand?

Yes. White-label lets you set the palette, logo, background, typeface and footer. Anti-phishing elements always stay visible to protect your customers.

How long does integration take?

A basic integration is one API call and one webhook endpoint. You build against our test-network sandbox, and our engineers support you until you go live.

How do I get started?

Access is by invitation only. There is no public sign-up, contact form or inbox: new merchants join through a trusted introduction, and every onboarding is handled personally.

Access is by invitation only

Cryptogon has no public sign-up, no contact form and no inbox. Fewer open doors leave nothing to phish and nothing to probe. New merchants join through a trusted introduction, and every onboarding is handled personally.

Introduced to us? Your introducer connects you directly.