API Documentation.

┌ YOUR SERVER ───────────────────────────────────────────────────────────────┐
│ 1. GET api.risksless.com/control/wallet.php?address={your wallet}&callback={url}
│    → { "address_in": "…" }        # a fresh tracking address for THIS order
│    Persist address_in with the order.
│
│ 2. Redirect the customer to
│    checkout.risksless.com/pay.php?address={address_in}&amount=99.00&currency=USD&email=…
└────────────────────────────────────────────────────────────────────────────┘
┌ CUSTOMER ──────────────────────────────────────────────────────────────────┐
│ 3. Pays with Visa / Mastercard / Amex / Apple Pay / Google Pay / SEPA / UPI…
│    on the hosted page. The provider settles USDC to address_in, which
│    forwards it on-chain to your wallet.
└────────────────────────────────────────────────────────────────────────────┘
┌ RISKSLESS → YOUR SERVER ───────────────────────────────────────────────────┐
│ 4. GET {your callback url}&address_in=…&value_coin=96.53&coin=usdc&txid_out=0x…
│    Verify, mark the order paid, reply 200 "OK".
└────────────────────────────────────────────────────────────────────────────┘

• One address_in per order. Every call to wallet.php mints a new tracking address. Call it once when the order is created, store the result, and never reuse an address_in for a second order — the callback is how you know which order was paid.
• Steps 1 and 4 are server-side; step 2 is a browser redirect. Step 1 also works from the browser (the API sends CORS headers — the Payment Link Generator does it that way), but the callback must hit a public HTTPS URL you control.
• The callback is the source of truth. The customer returning to your site is not proof of payment. Only mark an order paid from the callback (or from the on-chain transfer to your wallet).
• You receive slightly less than amount. Provider fees are deducted before settlement, so value_coin in the callback is normally a little below the charged amount. Compare with a tolerance — see Callbacks.

Step 1 — Generate a tracking address

GEThttps://api.risksless.com/control/wallet.php
  ?address=0xYourPolygonWalletAddress
  &callback=https%3A%2F%2Fyoursite.com%2Fwebhook%3Forder%3D42%26token%3Dk3Jd9s

Response

{
  "address_in": "0x8f2a91c84e3d…",          # tracking address — use this as `address` in step 2
  "polygon_address_in": "0x8f2a91c84e3d…",  # plain Polygon form of the tracking address (for receipts / explorer lookups)
  "callback_url": "https://yoursite.com/webhook?order=42&token=k3Jd9s",
  "ipn_token": "…"                          # reserved; safe to ignore
}

Step 2 — Redirect the customer to checkout

Two checkout pages exist on checkout.risksless.com. /pay.php is the hosted multi-provider page: it geo-detects the customer and lets them pick the best provider for their country. /process-payment.php skips the picker and opens one named provider directly. Use /pay.php unless you have a reason not to.

Option A — Hosted checkout (recommended)

GEThttps://checkout.risksless.com/pay.php
  ?address=0x8f2a91c84e3d…           # address_in from step 1, embedded RAW (see warning below)
  &amount=99.00
  &currency=USD
  &email=customer%40example.com
  &logo=https%3A%2F%2Fyoursite.com%2Flogo.png  # optional branding, see table

Option B — Direct to one provider

GEThttps://checkout.risksless.com/process-payment.php
  ?address=0x8f2a91c84e3d…
  &amount=99.00
  &provider=stripe
  &currency=USD
  &email=customer%40example.com

Provider ids, currency locks and minimums

/control/provider-status/ is authoritative for what is active right now and for the minimum amount. The table below lists every id the platform knows, plus the locks and minimums that the official plugins enforce before redirecting, so you can validate on your side and show a helpful error instead of a failed checkout.

Each minimum is in the provider's own currency, exactly as minimum_amount / minimum_currency report it. Where this table shows a value the official plugins enforce, the live value from provider-status still wins if it differs. When a provider is missing from provider-status or has a status other than active, do not route to it — fall back to hosted, which is a client-side choice and never appears in that response.

Code examples

JavaScript (browser or Node 18+)

// 1. Mint the tracking address (works client-side thanks to CORS, but do it
//    server-side if you need to trust the amount).
const wallet   = '0xYourPolygonWallet';
const callback = encodeURIComponent('https://yoursite.com/webhook?order=42&token=k3Jd9s');
const res = await fetch(
  `https://api.risksless.com/control/wallet.php?address=${wallet}&callback=${callback}`
);
const { address_in } = await res.json();
if (!address_in) throw new Error('wallet.php returned no address_in');
// persist (orderId, address_in) here

// 2. Redirect — address_in RAW, everything else encoded.
const amount = (99).toFixed(2);   // "99.00"
const email  = encodeURIComponent('customer@example.com');
window.location.href =
  `https://checkout.risksless.com/pay.php?address=${address_in}` +
  `&amount=${amount}&currency=USD&email=${email}`;

Python (requests)

import requests
from urllib.parse import quote

WALLET   = "0xYourPolygonWallet"
callback = "https://yoursite.com/webhook?order=42&token=k3Jd9s"

r = requests.get(
    "https://api.risksless.com/control/wallet.php",
    params={"address": WALLET, "callback": callback},  # requests encodes these once — correct
    timeout=15,
)
address_in = r.json()["address_in"]

# Concatenate: address_in raw, email encoded.
checkout_url = (
    "https://checkout.risksless.com/pay.php"
    f"?address={address_in}&amount={99:.2f}&currency=USD"
    f"&email={quote('customer@example.com')}"
)
# redirect the customer to checkout_url

cURL

# --data-urlencode encodes the callback exactly once
curl -G "https://api.risksless.com/control/wallet.php" \
  --data-urlencode "address=0xYourPolygonWallet" \
  --data-urlencode "callback=https://yoursite.com/webhook?order=42&token=k3Jd9s"

# → {"address_in":"0x8f2a…","polygon_address_in":"0x8f2a…","callback_url":"https://yoursite.com/webhook?order=42&token=k3Jd9s","ipn_token":"…"}

# Then send the customer to:
# https://checkout.risksless.com/pay.php?address=0x8f2a…&amount=99.00&currency=USD&email=customer%40example.com

PHP developers: use the single-file PHP SDK, which wraps both steps and the callback verification.

GEThttps://api.risksless.com/control/provider-status/
# Response
{
  "providers": [
    { "id": "stripe",     "provider_name": "Stripe",     "status": "active",   "minimum_amount": 2,    "minimum_currency": "USD" },
    { "id": "paypal",     "provider_name": "PayPal",     "status": "active",   "minimum_amount": 5,    "minimum_currency": "USD" },
    { "id": "revolut",    "provider_name": "Revolut",    "status": "active",   "minimum_amount": 6,    "minimum_currency": "EUR" },
    { "id": "upi",        "provider_name": "UPI",        "status": "active",   "minimum_amount": 1600, "minimum_currency": "INR" },
    { "id": "alchemypay", "provider_name": "Alchemy Pay", "status": "unstable", "minimum_amount": …,    "minimum_currency": "USD" },  # not "active" → do not route to it
    …
  ]
}

The Payment Link Generator uses this exact response to build its dropdown: it keeps only status === "active", shows each provider_name with its minimum_amount, and refuses to build a link below the minimum. When you display the minimum, print it with minimum_currency rather than assuming dollars. Note that hosted is not an entry in this response — it is a client-side option that always exists (it is the multi-provider /pay.php page), which is why the generator can fall back to it when this request fails. Do the same.

GEThttps://api.risksless.com/control/convert.php
  ?from=eur          # source currency, lower-case ISO code
  &value=99.00       # amount in that currency
# Response (99.00 EUR)
{ "status": "success", "value_coin": "112.42", "exchange_rate": "1.13554" }

• When to call it. At order creation (store the USD value as expected_usd alongside address_in), or at callback time. Calling it at order creation is better — the rate you charged is the rate you verify against.
• USD orders don't need it. If currency is USD, expected_usd is just the amount.
• If value_coin is missing or status is not success, the currency is not supported for conversion. Use USD, or one of EUR / CAD / INR, for that order.
• Use the exact parameter names from and value. A request with a wrong or missing parameter name is answered with a 302 redirect to the site's error page rather than a JSON error — see Troubleshooting.

Payload

# Your own query parameters come first, exactly as you passed them:
GET https://yoursite.com/webhook?order=42&token=k3Jd9s
  &address_in=0x8f2a91c84e3d…    # the tracking address that was paid
  &value_coin=96.53            # amount forwarded, in units of `coin` (net of provider fees)
  &coin=usdc                   # what was delivered — see the coin table
  &txid_in=0x9af2c1…           # provider → address_in
  &txid_out=0xbc77d2…          # address_in → your wallet (the payout tx; show it on receipts)
  &confirmations=3

Which coin can arrive

Payouts default to USDC on Polygon, but depending on the provider a payout may be delivered as USDT, POL (Polygon native), ETH or BNB — the same self-custodial wallet address receives all of them. Your callback handler must handle coin:

Verifying the amount

Because value_coin is net of fees, an exact comparison against the order total will reject every legitimate payment. All official plugins use a tolerance threshold: accept when value_usd ≥ threshold × expected_usd. The plugins default to 0.60 (accept ≥ 60%), which tolerates the highest provider fees while still catching a customer who edited the amount on the checkout page. Tighten it (0.90) if all your traffic goes through low-fee providers.

// Node / Express — full callback handler
app.get('/webhook', async (req, res) => {
  const { order, token, address_in, value_coin, coin, txid_out } = req.query;

  const o = await db.orders.findOne({ id: order });
  if (!o || o.callback_token !== token)      return res.status(403).send('bad token');
  if (o.address_in !== address_in)          return res.status(400).send('wrong address_in');
  if (o.status === 'paid')                  return res.send('OK');   // idempotent

  // value_coin → USD
  let valueUsd = parseFloat(value_coin);
  if (['polygon_pol', 'eth', 'bep20_bnb'].includes(coin)) {
    const info = await fetch(`https://api.risksless.com/crypto/${coin.replace('_', '/')}/info.php`).then(r => r.json());
    valueUsd = valueUsd * parseFloat(info.prices.USD);
  }

  // o.expected_usd was stored at order creation (via /control/convert.php for non-USD)
  if (valueUsd < 0.6 * o.expected_usd) {
    await db.orders.update(o.id, { status: 'failed', note: `underpaid ${valueUsd} / ${o.expected_usd}` });
    return res.status(200).send('underpaid');  // 200: we handled it, don't retry
  }

  await db.orders.update(o.id, { status: 'paid', txid: txid_out, paid_usd: valueUsd });
  res.status(200).send('OK');
});

Securing the callback

The callback is an unauthenticated GET. Anyone who learns the URL can request it, so never mark an order paid on the strength of the URL alone. Do all of the following — it is what the official plugins do:

• Put an unguessable per-order token in the callback URL when you call wallet.php (a random 32-char string, or an HMAC of the order ID keyed with a secret). Reject callbacks whose token does not match the stored one. The WHMCS module uses sig=HMAC-SHA256(invoice_id); the WooCommerce plugin uses a WordPress nonce stored on the order.
• Check address_in equals the one you stored for that order in step 1 (compare polygon_address_in on white-label deployments).
• Check the amount with the tolerance rule above.
• Be idempotent. The same settlement can be delivered more than once (retries). If the order is already paid, return 200 and do nothing.
• Optionally verify on-chain. txid_out is a public Polygon transaction to your wallet; you can confirm it on Polygonscan or via any RPC before releasing high-value goods.

Responding

• Return an HTTP 2xx within 10 seconds. Any body is fine — the plugins return OK. A non-2xx or a timeout causes the callback to be retried, so do slow work (emails, fulfilment) after responding or in a queue.
• Return 2xx even for a payment you reject as underpaid — you have handled it, and a retry will not change the outcome. Log it for manual review.
• The URL must be reachable from the public internet over HTTPS. localhost, private IPs and URLs behind HTTP auth will never receive a callback. Use a tunnel (ngrok, Cloudflare Tunnel) during development.

Mint a receiving address

GEThttps://api.risksless.com/crypto/polygon/usdc/wallet.php
  ?address=0xYourDestinationWallet     # a wallet on the SAME network as the ticker
  &callback=https%3A%2F%2Fyoursite.com%2Fwebhook%3Forder%3D42%26token%3Dk3Jd9s
# Response
{
  "address_in": "0x8f2a91c84e3d…",   # show this to the customer (and a QR — below)
  "callback_url": "https://yoursite.com/webhook?order=42&token=k3Jd9s"
}

The customer sends the coin to address_in. When it confirms, the funds are forwarded to the destination wallet you passed as address and your callback is requested with the same payload as a card payment (value_coin is in units of the ticker's coin, coin names it).

Convert fiat to coin amount

GEThttps://api.risksless.com/crypto/polygon/usdc/convert.php
  ?from=USD
  &value=99.00
# Response — how much of the coin equals 99.00 USD right now
{ "value_coin": "99.00", "coin": "usdc" }

Use it to tell the customer exactly how much to send. Note the difference from /control/convert.php: that one returns a USD value, this one returns a coin amount.

Render a QR code for the receiving address

GEThttps://api.risksless.com/crypto/polygon/usdc/qrcode.php?address=0x8f2a91c84e3d…
# Response — qr_code is a base64 PNG
{ "status": "success", "qr_code": "iVBORw0KGgoAAAANS…" }

<!-- inline it directly -->
<img src="data:image/png;base64,{qr_code}" alt="Pay">

Ticker info, minimum and live price

GEThttps://api.risksless.com/crypto/polygon/usdc/info.php
# Response (abridged)
{
  "coin": "USD Coin (Native)",      # display name of the coin (the key is `coin`, not `name`)
  "minimum": 0.665,                 # number — smallest amount that will be forwarded
  "prices": { "USD": "1.00", … }   # live price per 1 coin — used to value native-coin payouts
}

Supported tickers

Tickers are path segments. The wallet address you pass must be valid on that network.

Always read minimum from info.php at runtime rather than hard-coding it. Try the flow interactively with the crypto wallet generator, which calls these four endpoints in the browser.

Download risksless-php-sdk.zip, drop Risksless.php into your project, and require_once it. Requires PHP 7.2+ and the curl extension. The zip also contains example.php, a working pay + callback endpoint in one file.

Server-side: create a payment

// Persist $payment['address_in'] alongside your order, then redirect.
require_once __DIR__ . '/Risksless.php';

$r = new Risksless('0xYourPolygonWallet');
$payment = $r->createPayment([
    'order_id'     => 'INV-1042',               // appended to callback_url as ?order=INV-1042
    'amount'       => 99.00,
    'currency'     => 'USD',
    'email'        => 'customer@example.com',
    'callback_url' => 'https://yoursite.com/risksless-cb.php?token=k3Jd9s',
    // 'provider' => 'stripe',  // optional; default is the hosted picker
]);

// $payment = [ 'redirect_url' => …, 'address_in' => …, 'polygon_address_in' => …, 'callback_url' => … ]
header('Location: ' . $payment['redirect_url']);
exit;

Callback endpoint: verify settlement

// risksless-cb.php — the URL you passed as callback_url above.
require_once __DIR__ . '/Risksless.php';

// 1. Authenticate the request with the token you put in callback_url.
if (!hash_equals('k3Jd9s', $_GET['token'] ?? '')) { http_response_code(403); exit; }

// 2. Load the order by $_GET['order'] and its expected total, then verify.
$r = new Risksless('0xYourPolygonWallet');
$result = $r->verifyCallback($_GET, [
    'expected_amount'   => 99.00,
    'expected_currency' => 'USD',     // non-USD is converted via /control/convert.php for you
]);

if ($result['ok']) {
    // Mark the order paid; $result['txid_out'] is the on-chain payout tx.
    echo 'OK';
} else {
    // $result['reason'] is 'underpaid' or 'missing_value_coin';
    // $result['value_coin'] and $result['expected_usd'] tell you by how much.
    echo $result['reason'];
}

Default settlement threshold is 60% — pass a second argument to the constructor (new Risksless($wallet, 0.95)) to require ≥ 95% of expected before accepting. $r->listProviders() returns the /control/provider-status/ list if you want to render your own picker. Supported provider values: hosted (default), revolut, stripe, paypal, rampnetwork, transak, moonpay, banxa, utorg, transfi, sardine, topper, bitnovo, robinhood, upi, interac, simplex, binance, customprovider.

Ready-made modules for WooCommerce, WHMCS, OpenCart, PrestaShop and HOSTINPL are on the modules page.

• What it produces is exactly the /pay.php (or /process-payment.php) URL described above, with a fresh address_in minted for that link. One link = one payment; generate a new link for each invoice.
• Its callback is a throw-away tracker URL, so no server is needed. You confirm payment by watching your wallet on the tracker / block explorer.
• Pre-fill from a URL. You can deep-link into the generator from your own pricing page or CRM:

https://risksless.com/payment-link/
  ?wallet=0xYourPolygonWallet
  &amount=99
  &email=customer%40example.com
  &auto=1       # optional: generate immediately and redirect the visitor straight to checkout

With auto=1 the page mints the tracking address and forwards the visitor to the hosted checkout without a click — a zero-backend "Buy now" button. Without it the form is pre-filled and the visitor presses Generate.

Need a hand?

Work through the troubleshooting table first — it resolves most integration questions in minutes. If you are still blocked, include your address_in and checkout URL when you reach out.