Every market on the rail, both ways.
Scroll to tour the regions. Each market takes pay-ins and sends pay-outs on the same local rail, against one balance.
Local rails, European bank payments and stablecoin settlement for iGaming, betting and sportsbook operators, with pay-out on the same local rail as the pay-in. One counterparty, one integration, one balance.
Scroll to tour the regions. Each market takes pay-ins and sends pay-outs on the same local rail, against one balance.
20 local markets and 9 European bank-payment markets, each paying in and paying out on the same rail, settling to one balance with USDT and USDC available.
Methods, limits, currency ranges and settlement terms are confirmed per corridor in writing before launch. The full rate card is issued on request. Flags: flag-icons, MIT licence.
Wallets, QR schemes and bank rails as depositors know them at home, across 20 markets, with European bank payments and stablecoin settlement on the same balance. Hover a row to pause it and see each market.
Logos are trade marks of their owners, shown to identify the payment methods available; no endorsement is implied. Methods without a usable official logo file are shown by name. Nequi logo: Nequi, CC BY-SA 4.0. Maya logo: Maya Bank, Inc., CC BY 4.0. WavePay logo: Wave Money, CC BY-SA 4.0. All via Wikimedia Commons; sources and licences in LOGOS.md.
For a high-risk operator, stablecoin is not a novelty rail. It is how treasury copes with many collection currencies and a correspondent-banking system that does not want the business.
Stablecoin settlement can take out the correspondent-banking leg, the FX spread on each repatriation and the float between a local pay-out and a usable balance: the three costs that quietly eat a high-risk operator's margin.
A depositor pays at your checkout over a local rail, open banking or stablecoin, and the money lands on one balance. When they withdraw, the pay-out goes back over the same rail, from the same balance. Most gateways take the deposit and leave the withdrawal to someone else.
Withdrawals go back over the same local rail the deposit came in on, from the same balance.
Collected pay-ins are calculated into your settlement balance every 30 minutes; settlements and withdrawals are recorded in the console.
Take settlement in USDT or USDC against the same balance, alongside local fiat and European bank payments.
The API starts the payment directly from the depositor's bank account into yours. No card network in the path means no interchange, no issuer decline wall and no chargeback mechanism for friendly fraud to exploit.
97% and 89% are partner-reported figures for the European open banking rail only. They do not describe any other rail.
Payee Global is also a white-label payments reseller. Payment companies, platforms and agencies put their own brand on the rails, the back office and the checkout, and sell to their merchants as their own product. One integration gives your merchants every solution we run: local rails in 20 markets, European bank payments and stablecoin settlement. We run the platform behind it and stay out of sight.
Your logo, colours and name across the admin back office, the merchant console and the hosted checkout page your merchants' customers see.
The back office and the merchant console run on a domain you choose, such as console.yourbrand.com, not on ours.
Run merchants, transactions, pay-outs, settlements, provider accounts and risk rules from one back office, with roles and permissions for your team.
Open merchant accounts, set their limits and risk rules and issue their API keys. Merchants integrate the API or send customers to the hosted checkout.
Collected pay-ins are calculated into settlement balances every 30 minutes, and settlements and withdrawals are recorded where you and your merchants can see them.
Five steps, delivered in 10 days from kickoff. Kickoff follows the review of your business and signed terms.
Tell us your company, the markets you need, your expected volume band and your use case. Apply for several markets at once.
We review your business, its ownership and the corridors you asked for, and agree terms in writing.
We set up your brand, your domain and your admin back office, with your team's roles.
You open merchant accounts. Merchants integrate the API or use the hosted checkout.
You run merchants, pay-outs and settlement from your back office. We run the rails.
Routing, settlement, webhooks, provider management and reporting, run from the admin back office and the merchant console.
Pay-ins are routed across your provider accounts by configured rules, round robin or percentage split.
Collected pay-ins are calculated into your settlement balance every 30 minutes, with settlements and withdrawals recorded in the console.
Pay-in and pay-out results are posted to your webhook URL and retried up to three more times. Confirm each with a status call.
Add, edit and activate provider connectors and accounts from the back office, and set their limits.
Totals, success and failure counts, balances and last-hour reports, calculated when the page loads.
Operators run merchants, transactions, pay-outs, settlements, providers and risk rules from one back office.
Merchants see pay-ins, pay-outs, settlements, API keys, webhooks and IP allow-list settings in one place.
A hosted page with a QR code, UPI app buttons and a countdown.
Create a pay-in, check it, send a pay-out, check it, read your balance. Results arrive by webhook; the docs say plainly where the API is still rough.
api.payeeglobal.com, with your API key as a Bearer token on every call.
Pay-in and pay-out fields travel AES-256-CBC encrypted under your secret hash.
Confirm each webhook with a status call before you act on it.
Most answers use HTTP 200. Read status in the body; only authentication failures use 401.
curl -sS -X POST 'https://api.payeeglobal.com/v2/upi/status' \
-H 'Authorization: Bearer <API_KEY>' \
-H 'Content-Type: application/json' \
-d '{"merchant_order_id":"<merchant_order_id>"}'// Node 18 or later. No dependencies.
const res = await fetch('https://api.payeeglobal.com/v2/upi/status', {
method: 'POST',
headers: { Authorization: 'Bearer <API_KEY>', 'Content-Type': 'application/json' },
body: JSON.stringify({ merchant_order_id: '<merchant_order_id>' }),
});
const data = await res.json();
// Read data.status: success, failed, authenticate (still waiting), notfound, validation_error.
console.log(res.status, data);# Python 3.9 or later: pip install requests
import requests
res = requests.post(
"https://api.payeeglobal.com/v2/upi/status",
headers={"Authorization": "Bearer <API_KEY>"},
json={"merchant_order_id": "<merchant_order_id>"},
timeout=30,
)
# Read data.status: success, failed, authenticate (still waiting), notfound, validation_error.
print(res.status_code, res.json())// Go 1.20 or later. Standard library only.
package main
import (
"fmt"
"io"
"net/http"
"strings"
)
func main() {
req, _ := http.NewRequest("POST", "https://api.payeeglobal.com/v2/upi/status", strings.NewReader(`{"merchant_order_id":"<merchant_order_id>"}`))
req.Header.Set("Authorization", "Bearer <API_KEY>")
req.Header.Set("Content-Type", "application/json")
res, err := http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
defer res.Body.Close()
out, _ := io.ReadAll(res.Body)
// Read data.status: success, failed, authenticate (still waiting), notfound, validation_error.
fmt.Println(res.StatusCode, string(out))
}<?php
// PHP 7.4 or later with the curl extension.
$ch = curl_init('https://api.payeeglobal.com/v2/upi/status');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTPHEADER => ['Authorization: Bearer <API_KEY>', 'Content-Type: application/json'],
CURLOPT_POSTFIELDS => json_encode(['merchant_order_id' => '<merchant_order_id>']),
]);
$data = json_decode(curl_exec($ch), true);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
// Read data.status: success, failed, authenticate (still waiting), notfound, validation_error.
echo $httpCode, ' ', json_encode($data), PHP_EOL;{
"status": "success",
"merchant_order_id": "ORDER-10001",
"transaction_id": "T4K2Q9ZB1790000000000",
"amount": "100.00",
"utr": "000000000000"
}Dashboard, merchants, transactions, pay-outs, routing, settlement and branding. Drag the ring, or open the clickable demo with sample data.







Adding a market later is a configuration change, not a new build.
Operating entity verified, each URL reviewed and approved one by one. High-risk categories are the expected case, not an escalation.
Pay-in, pay-out and settlement accounts opened; API key, secret hash and console access issued.
Integrate the documented API or use the hosted checkout. Your developers work from the same docs we publish.
Small real transactions on each enabled corridor, then production traffic.
iGaming, betting, sportsbook and forex are the categories this gateway is built for. Fraud-type merchants are refused outright and terminated on discovery, so your funds are not pooled behind someone else's book.
Every app and URL is reviewed one by one before it takes traffic. If you are an aggregator, the same standard applies to your merchants.
Reserve, settlement cycle, limits and dispute handling are agreed in writing before the first transaction. No mid-season re-pricing.
How a disputed order is evidenced, held and released is part of the terms you sign, not a policy we change later.
Fraud-type merchants are refused, and terminated with funds frozen on discovery. That standard is what keeps the rails open for everyone on them.
Six controls, in the merchant console and the admin back office.
Each merchant gets an API key and an encryption key. The API key can be reset from the console at any time.
Merchants turn on two-factor sign-in with an authenticator app or an emailed code.
Back-office users get roles and permissions; merchants add sub-users with their own permissions.
Merchants restrict API calls to their own server addresses. Anything else is refused.
Block lists for email, UPI ID and user, with per-transaction and daily amount limits per account.
Pay-in and pay-out request fields are encrypted with AES-256-CBC under a key held by the merchant.
Tell us the markets where deposits fail or withdrawals stall. We come back with the corridors we can run for you, the settlement terms and the commercials, before you sign anything.
Reselling payments under your own brand? Request a white label.