The WcPay high risk payment gateway API is made for sites with their own checkout. You built it yourself, so no plugin will save you. WcPay drops into any custom site — PHP, Node.js, Python, Go — and pays you in USDT within minutes, with no merchant account and no chargebacks.
// The whole integration. $payment = $wcpay->createPayment([ 'amount' => 49.90, 'currency' => 'USD', 'provider' => 'revolut', 'email' => $customer->email, 'callback' => 'https://example.com/cb.php?o=42', ]); header('Location: ' . $payment['redirect_url']);
Every guide about integrating a high risk payment gateway API assumes you run WooCommerce, Shopify or PrestaShop. If you built your own checkout — a Laravel application, an Express API, a Django back office, a plain PHP site a developer wrote for you five years ago — none of that applies. You are handed a raw API, a page of endpoints, and left to work out the rest yourself.
That is exactly where a high risk payment gateway API stops being a technical question and becomes a business one. The endpoints are the easy part; anyone can read a list of parameters. What takes three days, and then breaks quietly in production two weeks later, is everything the documentation does not mention. This page explains what that is, why it costs more than the licence, and what the WcPay Developer Kit hands you instead.
Two walls stand between a custom site and a working high risk payment gateway API, one after the other. Most people only see the first.
Supplements, vapes, IPTV, VPN, adult, gaming top-ups, replica goods, forex education: an underwriter files your category under prohibited and the account closes, usually without warning and usually right after volume grows. A rolling reserve of 5 % to 10 % held for 180 days is standard, and every chargeback costs $15 to $40 before you have argued anything.
The alternatives all ship as a WooCommerce plugin or a PrestaShop module. Your site is not either of those. You get a page of endpoints and a sentence that says "integrate it", which is where the real work starts — and where a weekend becomes three days, then a month of chasing payments that never confirmed.
A high risk payment gateway API that settles in stablecoin removes the first wall entirely: there is no merchant account to underwrite, so there is nothing to terminate, nothing to reserve and no dispute window to lose. The second wall is what this kit removes.
It is not a document. The WcPay high risk payment gateway API kit is working, tested code: a PHP SDK and a Node.js SDK with no dependencies, a callback handler that already solves the hard parts, a licence client, four commented examples, two offline test suites, and a complete reference store that runs on your machine in thirty seconds without a key.
The distinction matters more than it sounds. Reading the endpoints of a high risk payment gateway API takes an afternoon. Shipping an integration that still works ninety days later takes considerably longer, because the failures do not announce themselves. A customer pays, sees a thank-you page, and your order stays unpaid. Nothing threw an error. Nothing appeared in a log. You find out when the customer emails you.
A payment through the high risk payment gateway API takes four steps on the way out and one on the way back. Your code is involved in exactly two of them.
Note what your server never touches: a card number. Card details are entered on the provider's hosted page, which keeps your PCI scope at the lowest possible level. Note also what cannot happen: a reversal. A settled stablecoin transfer is final, which is why a high risk payment gateway API built this way has no chargeback fees, no representment deadlines and no monitoring programme to fall into.
Every hand-rolled high risk payment gateway API integration hits the same four. None of them throw an error. Three of them cost you money directly.
Exchange rates move between the click and the settlement, and the provider's fee comes out in between. The received amount is almost never the expected amount.
Providers resend the same confirmation. It is normal behaviour, and it is not mentioned anywhere you would think to look.
Several providers silently reject a confirmation URL past a certain length. This is the expensive one, because absolutely nothing fails visibly.
The receiving address arrives already URL-encoded. Passing it through an encode function
once more turns %2F into %252F.
Put a number on it. A competent developer costs somewhere between $40 and $90 an hour. Three days to build the integration, plus the two days you will spend finding trap number three after it has already cost you a fortnight of unconfirmed orders, lands between $1,600 and $3,600 of work — before the lost revenue. The kit starts at $399.99, and the traps are already closed and covered by tests.
Both call the same high risk payment gateway API and create one payment. One of them also handles the four traps above.
// Convert. Cache it yourself, or pay // 25 API calls per page render. $r = json_decode(file_get_contents( $api.'/control/convert.php?from=EUR&value=1')); $usd = 49.90 * $r->exchange_rate; // Minimums? Fetch and filter them yourself. // Callback too long? Nothing warns you. $cb = 'https://site.com/cb.php?o=42'; $w = json_decode(file_get_contents( $api.'/control/wallet.php?address='.$wallet .'&callback='.urlencode($cb))); // Trap 4 lives here. http_build_query // would double-encode address_in. $url = $api.'/process-payment.php?address=' . $w->address_in . '&amount=49.90&...'; // Then: store the expected amount, // write the callback, compare with a // tolerance, guard against replays, // return exactly *ok* and nothing else.
$payment = $wcpay->createPayment([ 'amount' => 49.90, 'currency' => 'EUR', 'provider' => 'revolut', 'email' => $customer->email, 'callback' => 'https://site.com/cb.php?o=42', ]); // Conversion cached, minimum checked, // callback length validated, address // assembled correctly. All of it. $order->save([ 'token' => $payment['token'], 'expected' => $payment['expected_usd'], ]); header('Location: '.$payment['redirect_url']); // And the confirmation, in full: $r = (new Callback())->handle($_GET, $lookup); echo $r['reply'];
Same result on the happy path. Very different results on the other ones.
One ZIP, 40 files, no build step, no dependency to install — the whole high risk payment gateway API kit.
php -S localhost:8000 in the reference store and you have a working high risk
payment gateway API shop in sandbox mode. No key, no network. Simulate a full payment, a partial one and an underpayment,
and watch the order change state.
Both SDKs ship with a test suite that runs without touching the network. They cover the underpayment, the replay, the unknown token and the method below its minimum — so you can refactor without crossing your fingers.
The network layer is injectable. Point it at your own fake and your test suite runs offline in milliseconds, with no API key and no rate limit — in your CI pipeline included.
Two SDKs cover most of the work. Everything else needs only an HTTPS request, and the documentation gives you the raw calls.
The PHP SDK has no dependency and loads with a single require, so it works on
shared hosting where Composer is not available. The Node SDK uses nothing but the
built-in
Fetch API, so there is no package to audit and nothing to keep up to date. If your stack is not listed, the two SDKs are short enough to read in one sitting
and port in an afternoon — and the documentation gives you the raw endpoints so you never
have to guess.
One high risk payment gateway API, every rail. Switch a method on by changing one string.
Those minimums are the providers' own, and the kit enforces them for you: a method whose minimum sits above the cart total is never offered. A customer with a $30 basket sees Stripe, Revolut and Klarna; a customer with a $150 basket also sees iDEAL, UPI and Interac. Nobody is shown an option that would reject them on the next screen, which is where a large share of abandoned baskets comes from.
Between them these rails cover Visa, Mastercard, Apple Pay, Google Pay, SEPA, buy-now-pay-later, Canadian Interac, Indian UPI, Dutch iDEAL and the major wallets. Most sites enable three or four; the other twenty-one are there the day you open a new market.
Different starting points, same conclusion: the platform plugin does not exist, and the endpoints alone are not enough.
A subscription product with its own billing logic. No cart, no catalogue, nothing a e-commerce plugin understands — just an account that needs to be charged. The high risk payment gateway API slots in beside your existing billing code rather than replacing it.
Each client has a different stack and the same problem. One Agency licence covers ten production domains, so the integration you write once becomes a service you sell repeatedly — at a cost of $90 per site.
A working store, real customers, and a category every acquirer refuses. The site already exists and works; only the payment side is missing. A high risk payment gateway API is the shortest path back to taking orders.
Revenue has to be split between several parties on every sale. The payout-splitting endpoints divide a single payment across up to nineteen addresses, settled on-chain, with no reconciliation work on your side.
What these four have in common is not the product they sell. It is that a bank decided their category was not worth its risk budget, and that no ready-made module fits the way their site is built. A high risk payment gateway API answers both at once.
The problem, the payment path, the six lines of code, the four traps and the pricing of the high risk payment gateway API kit — all in one short video.
Settlement speed is not a detail of a high risk payment gateway API. It is usually the real constraint on how fast you can grow.
| WcPay API | Stripe / PayPal | High-risk acquirer | |
|---|---|---|---|
| Approval | Instant | Days, then reviewed | 2–6 weeks |
| KYC documents | None | Full file | Extensive file |
| Company required | No | Usually | Always |
| High-risk categories | Accepted | Prohibited | Accepted, at a price |
| Settlement | Minutes | T+2 to T+7 | T+7 to T+14 |
| Rolling reserve | None | Possible | 5–10 % for 180 days |
| Chargebacks | Impossible | $15–$25 each | $25–$40 each |
| Integration | SDK + reference store | SDK | Raw endpoints |
| Payment methods | 25 | Cards + wallets | Cards |
The honest comparison: a traditional processor is cheaper per transaction and handles refunds gracefully. If your category is welcome at Stripe, stay at Stripe. A high risk payment gateway API exists for the sites that are not welcome — and for those, the comparison is not against Stripe's fees but against taking no payments at all.
No subscription, no revenue share, no percentage on your sales — an API partner fee of approximately 4.5 % applies at the provider level. Source code included, yours to modify.
For your own site, or a single client project.
No renewal, ever
For a studio shipping payment integrations for clients.
Pays back on the second client site
For platforms, resellers and anyone deploying at scale.
One payment, every project
Running WooCommerce, PrestaShop, OpenCart or WHMCS instead? Those have ready-made modules. Contact us for the multi-platform bundle. Rates are detailed on our processing fees page.
Yes, or you need one for an hour. The kit assumes you can edit a file and run a command. If you use WooCommerce, PrestaShop, OpenCart or WHMCS, take the ready-made module for your platform instead — it installs without writing any code.
The high risk payment gateway API ships complete SDKs for PHP 7.2 to 8.x and Node.js 18+, with no dependencies. Everything else — Python, Go, Ruby, Java, .NET — works through the documented REST calls, which need nothing more than an HTTPS request. The two SDKs are short enough to read in one sitting if you want to port one.
Yes. The reference store runs in sandbox mode with one command, no licence key and no network: you see the full tunnel, simulate a complete payment, a partial one and an underpayment, and watch each order change state. It is the fastest way to understand what the high risk payment gateway API does before touching your own code.
No. On a high risk payment gateway API they pay with a card, Apple Pay, Google Pay, Revolut, iDEAL, Klarna or their local rail, exactly as anywhere else. The stablecoin conversion happens on the provider's side and is invisible to them. They never see a wallet address.
Within minutes of the payment clearing. No settlement cycle, no minimum payout amount and no rolling reserve. Funds go straight to the wallet address you configured.
Neither. No LLC, no trade register extract, no identity documents, no proof of address. Individuals and sole traders are accepted on the same terms as registered companies.
Not through the API, and this is the honest trade-off for zero chargebacks: a settled stablecoin transfer is final in both directions. Refunds are handled off-platform, by sending funds back yourself or issuing credit. Decide how you will handle that before you go live, not after the first request.
The callback handler compares what arrived against what you stored when the payment was created. Below your tolerance band, it returns an underpaid status with the exact shortfall and the transaction reference, and leaves the order unpaid. What you do next is your decision; the kit never ships an order on a payment that did not arrive.
The number of production domains in your plan. You get the full source and may modify it freely for your own sites or your clients' sites. You may not redistribute, resell or publish the kit itself. Development and staging environments do not count against your domain limit.
No. Every plan is a single payment with updates and support included. The only ongoing cost is the API partner fee of approximately 4.5 %, applied at the provider level on each transaction — not by us, and not on top of your licence.
Download the high risk payment gateway API kit, run the reference store, copy six lines into your checkout. No underwriting file, no merchant account, no chargebacks, and no waiting for settlement.