Error Codes
Every error code the ProphetX SDK can return — what causes it, whether it's retryable, and what your code should do.
Errors reach your code through three separate layers. Knowing which layer an error comes from tells you where to handle it.
| Layer | How you receive it | What it covers |
|---|---|---|
| Embed flow errors | onError(code, message) on a flow, on('error') / useEvents({ onError }), or the PROPHETX_ERROR postMessage | Session problems at open, failed deposits and withdrawals, location re-checks, embed crashes. The codes are the embed's own. |
| SDK client errors | A rejected promise from auth.login() or the wallet client, or the SDK's error event | Your app talking to ProphetX through the SDK's built-in auth and wallet modules, and session refresh failures. |
| REST API errors | The HTTP response body { "code": "...", "error": "..." } | Only if your backend calls the ProphetX REST API directly. The SDK and the embed never forward these; at most, a provider's reason appears inside an embed error's message. |
Some outcomes are not errors and have their own callbacks: onGeofenceBlocked (location blocked when the flow opens), onKycFailed (document verification rejected) and onOneClickFailed / onOneClickDeclined (1-Click Signup).
The
messageis for your logs, not for the user. It can be raw transport text (for exampleRequest failed with status code 400: POST https://…) or a provider's own wording, and the embed has already shown the user a translated error screen. Branch oncode, which is stable; never match onmessage.
Don't close the modal on onError. Most errors leave the embed on its own error screen, often with Try again. The modal closes when the user taps Close there, which fires onCancel. The tables below say what the embed shows for each code.
Embed error shape
The sections from Session errors through Other embed errors are embed flow errors. Each one arrives as:
onError: (code: string, message: string) => voidWith the low-level postMessage protocol, the same error arrives as:
{
"type": "PROPHETX_ERROR",
"payload": {
"code": "DEPOSIT_FAILED",
"message": "Request failed with status code 400: POST https://…"
}
}Session errors
These fire when the flow opens and the embed can't establish a valid session. They point at your token endpoint or origin setup, not at anything the user can fix.
| Code | Detected by | Retry in place? | Cause |
|---|---|---|---|
SESSION_EXPIRED | The embed's token check, or the server | No — reopen | The token's exp was already in the past when the flow opened |
SESSION_INVALID | The embed's token check, or the server | No | Malformed JWT, bad signature, wrong issuer, or any other rejection by GET /embed/v1/token/validate |
ORIGIN_UNAUTHORIZED | The embed (no HTTP request) | No | Your page's origin isn't on the allowlist for this environment |
The embed accepts only the first PROPHETX_SESSION it receives, so none of these can be fixed by sending another token to the same iframe.
SESSION_EXPIRED
SESSION_EXPIREDEmbed tokens are short-lived (10 minutes by default). This code means the token was already expired when the flow opened — for example, a token minted long before the user tapped Deposit.
What to do: Close the flow and open it again with a fresh token. Mint the token right before you open the flow.
A token that expires while the flow is open is handled differently: the embed asks for a new one (PROPHETX_SESSION_EXPIRED), and the SDK calls your onSessionExpired handler, or the auth module's getCredentials, to get it. If that handler returns null, throws, or takes longer than 10 seconds, the embed shows its session-expired screen and sends nothing further — onError does not fire. A handler that throws is reported on the SDK's error event as SESSION_REFRESH_FAILED (see SDK client errors).
<ProphetXProvider
environment="sandbox"
token={token}
onSessionExpired={async () => {
const res = await fetch("/api/prophetx-token");
const { token } = await res.json();
setToken(token);
return token; // within 10 seconds, or the flow stops
}}
>
<App />
</ProphetXProvider>SESSION_INVALID
SESSION_INVALIDThe token failed validation — either client-side (malformed JWT, missing claims) or server-side (bad signature, unrecognized issuer). GET /embed/v1/token/validate returns a bare 401 with no response body in this case, so the specific cause isn't returned over the wire — investigate from your side.
What to do: Do not retry with the same token. ProphetX signs embed tokens, not you: your backend gets one from GET /private/v1/tokens (see Embedded UI). So check how the token reaches the SDK:
- Pass the token exactly as
GET /private/v1/tokensreturned it. Don't decode, re-sign or edit it. - Mint it with the right partner credentials for the environment you're pointing the SDK at. A sandbox token is rejected by production, and the reverse.
- Mint it for the user who is opening the flow.
ORIGIN_UNAUTHORIZED
ORIGIN_UNAUTHORIZEDThe embed checks your page's origin against the allowlist ProphetX configures for each environment. The check runs in the embed, after the token itself has been validated, so an expired token reports SESSION_EXPIRED first.
What to do: Register your origin with ProphetX. This is a one-time setup per domain. If you're seeing this in development, make sure your localhost origin (including port) is registered. See Deposits and Withdrawals — Before you begin.
User prerequisite and permission errors
The embed validates the user's session via GET /embed/v1/token/validate, which returns the same gates and permissions objects available on the embed token itself:
{
"expiration": "2026-06-15T16:30:00Z",
"isvId": "80c7cadf-22e4-4752-b821-ef3e2c8f6cb4",
"userId": "4874c17c-d991-496e-b29c-c7bdba87698d",
"gates": {
"kyc": { "completed": true, "description": "Passed KYC" },
"terms": { "completed": true, "description": "Accepted terms and conditions" },
"email-verify": { "completed": true, "description": "Email address verified" },
"phone-verify": { "completed": true, "description": "Phone number verified" },
"not-suspended": { "completed": true, "description": "Account is not suspended" }
},
"permissions": {
"market-order": { "granted": true, "description": "Submit market orders" },
"parlay": { "granted": true, "description": "Submit parlay orders" },
"deposit-aeropay": { "granted": true, "description": "Deposit via AeroPay" },
"withdraw-aeropay": { "granted": true, "description": "Withdraw via AeroPay" },
"deposit-pnm-card": { "granted": true, "description": "Deposit by debit card" },
"deposit-pnm-apple-pay": { "granted": true, "description": "Deposit by Apple Pay" },
"deposit-pnm-google-pay": { "granted": true, "description": "Deposit by Google Pay" },
"deposit-pnm-cash-at-retail": { "granted": true, "description": "Deposit by cash at retail" },
"withdraw-pnm-card": { "granted": true, "description": "Withdraw to a debit card" },
"deposit-zerohash": { "granted": false, "denyReason": "Blocked in NY", "description": "Deposit via ZeroHash" },
"withdraw-zerohash": { "granted": false, "denyReason": "Blocked in NY", "description": "Withdraw via ZeroHash" }
}
}There are five gates: kyc, terms, email-verify, phone-verify, not-suspended. Geofencing is handled separately from this gate list — see GEOFENCE_BLOCKED below.
The embed builds its list of payment methods from permissions: it shows a method only when its deposit-… or withdraw-… permission is granted, plus Wire Transfer, which is always shown.
KYC is not a special case. Unlike a previous version of this page,
gates.kyc.completedis not alwaystruejust because the user has a session token —kycis one of the required gates for every deposit and withdraw permission, exactly liketermsornot-suspended. There is no separate withdrawal-only KYC gate; the mechanism below covers deposits and withdrawals identically.
When a required gate is unmet, the SDK reports no error. The backend marks the affected payment permissions granted: false, so the deposit or withdraw screen opens with only the methods still granted — often just Wire Transfer. onError doesn't fire, and there's no pending_gates list in the SDK.
If you call the REST API directly, the same condition comes back as 403 PERMISSION_DENIED with a pending_gates array. The SDK and the embed never pass that code on.
So check gates and permissions from the validate response (or the token payload) before opening a deposit or withdraw flow, and route the user first:
| Unmet gate | Route the user to |
|---|---|
kyc | useKyc/useIdUpload (document verification) — a session token means the user already exists, so a missing kyc gate means re-verification after an earlier FAILURE, not new-user signup. See Identity Verification. |
terms | The /tandc route — see Terms flow. |
email-verify | No embedded flow today — verification is handled by your registration system or an out-of-band email link |
phone-verify | No embedded flow today — handle via your own OTP UI |
not-suspended | Not user-resolvable — the account is suspended; direct the user to support |
import { useDeposit, useIdUpload } from "@prophetx/sdk-react";
function DepositButton({ gates }) {
const { open: openDeposit } = useDeposit();
const { open: openIdUpload } = useIdUpload(); // or useKyc — same flow
const start = () => {
// gates: from your backend's GET /embed/v1/token/validate call
if (!gates.terms.completed) return openTerms({ onAccepted: () => openDeposit() });
if (!gates.kyc.completed) return openIdUpload({ onKycSuccess: () => openDeposit() });
openDeposit();
};
return <button onClick={start}>Deposit</button>;
}openTerms stands for your own handler that shows the /tandc route.
Provider-specific denials. A granted: false permission with a denyReason (e.g. deposit-zerohash blocked in NY) works the same way: the embed leaves that method off the list and fires no error. If every method you care about is denied, tell the user why using the denyReason from your validate call.
KYC_REQUIRED on withdraw, and a second GEOFENCE_BLOCKED channel
KYC_REQUIRED on withdraw, and a second GEOFENCE_BLOCKED channelKYC_REQUIRED (Online Bank withdrawals only). The embed handles this code, but the ProphetX backend doesn't send it today. A user without a completed kyc gate isn't granted withdraw-aeropay, so Online Bank never appears in their withdrawal list (see above). A request that gets through anyway is refused by the gateway with 403 PERMISSION_DENIED, not KYC_REQUIRED.
If the embed ever receives 403 { "code": "KYC_REQUIRED" } on an AeroPay withdrawal, it shows a "Verification required" screen with a Close button and sends onError("KYC_REQUIRED", message). It can't be retried inside the flow: open useKyc/useIdUpload (this user already exists, so it's re-verification, not signup), then let the user try again once verified. Keeping a KYC_REQUIRED case in your handler is harmless; check the kyc gate before you open a flow and don't rely on this code.
GEOFENCE_BLOCKED. The location check runs twice, and each run reports through a different channel:
- When the flow opens:
onGeofenceBlocked(stateCode, reason)/PROPHETX_GEOFENCE_BLOCKED, if the user's token says their location check didn't pass. Both arguments are currently always'unknown'; show your own message. - Just before a deposit or withdrawal is submitted:
onError("GEOFENCE_BLOCKED", message). The embed re-validates the session here and fails closed, so this also fires when the session can't be re-validated — for example, the token expired while the user sat on the form. Reopen the flow with a fresh token before showing location messaging. The embed shows "Location not permitted" with a Close button, andonCancelfollows when the user closes it.
There is no VPN detection; location comes from the token your backend mints.
Deposit and withdrawal provider errors
These are the codes the deposit and withdraw flows send through onError. The embed ships flows for AeroPay (Online Bank, deposit and withdraw), ZeroHash (Crypto, deposit only), and PayNearMe (Debit Card, Apple Pay, Google Pay and Cash at Retail deposits; withdrawal to a debit card already used for a deposit). There is no Trustly integration.
"What the embed shows" tells you whether the user can retry inside the modal. Where it offers Try again, don't close the modal yourself.
Deposit
| Code | Cause | What the embed shows | What to do |
|---|---|---|---|
DEPOSIT_FAILED | Generic refusal by the deposit API. For Online Bank, message carries the backend's reason | Error screen with Try again (or Go back, when AeroPay has blocked the user) | Log it |
DEPOSIT_UNCONFIRMED | The submit's answer was lost and the deposit was never confirmed. It may still have gone through | "Check your balance" screen with Try again | Refresh the balance before the user retries |
DEPOSIT_NOT_COMPLETED | The deposit was submitted but settlement failed or was cancelled | "Payment unavailable" with the reference, Close only | Log the transaction ID |
DEPOSIT_WALLET_WRITE_FAILED | The provider took the money but the ProphetX wallet wasn't credited | Error screen with Try again | Don't let the user retry; send the transaction ID to ProphetX support to reconcile |
PROVIDER_LOAD_FAILED / PROVIDER_UNAVAILABLE | The selected provider's widget didn't load, or the provider isn't available right now | "Payment unavailable", Close only | Let the user try a different method |
PAYNEARME_DEPOSIT_FAILED | A debit card, Apple Pay, Google Pay or cash deposit failed: the session didn't open, PayNearMe declined it or errored, or the session expired. message is PayNearMe deposit failed (<PayNearMe code>) | PayNearMe's own failure screen, with Try again where retrying can help | Log the code inside message |
ZEROHASH_LOAD_FAILED | The ZeroHash widget didn't load (often transient) | Error screen with Try again | Log it |
ZEROHASH_PROVIDER_ERROR | ZeroHash reported a failure while funding | "Payment unavailable", Close only | Log it |
ZEROHASH_DENIED / ZEROHASH_RESTRICTED | ZeroHash refused the user | Its own explanation, Close only | Don't offer crypto again for this user |
ZEROHASH_DETAILS_REQUIRED | The user's ProphetX record lacks the email or phone ZeroHash needs | Its own explanation, Close only | Have the user complete their profile, then retry |
ZEROHASH_NOT_APPROVED | ZeroHash hasn't approved the user yet | Its own explanation, Close only | Retry later |
ZEROHASH_KYC_PENDING | ZeroHash's identity check was still undecided when the embed stopped waiting | Error screen with Try again | Retry later |
ZEROHASH_DEPOSIT_CONFLICT | The same transaction ID was already recorded with a different amount, after ZeroHash moved the money | Error screen with Try again | Don't retry; send the transaction ID to ProphetX support |
GEOFENCE_BLOCKED | The pre-submit location re-check failed, or the session couldn't be re-validated | "Location not permitted", Close only (onCancel follows) | Reopen with a fresh token — see above |
Cash at Retail and Wire Transfer never send onSuccess: the user leaves with a barcode or instructions, and the flow ends with onCancel.
Withdrawal
| Code | Cause | What the embed shows | What to do |
|---|---|---|---|
WITHDRAWAL_FAILED | Generic refusal by the withdrawal API. For Online Bank, message carries the backend's reason | Error screen with Try again (or Go back, when AeroPay has blocked the user) | Log it |
WITHDRAWAL_UNCONFIRMED | The submit's answer was lost and the withdrawal was never confirmed. Also sent for a PayNearMe withdrawal that couldn't be confirmed | "Check your balance" screen with Try again | Refresh the balance before the user retries |
WITHDRAWAL_NOT_COMPLETED | The withdrawal was submitted but settlement failed or was cancelled | Error screen with the reference and Try again | Log the transaction ID |
WITHDRAWAL_WALLET_WRITE_FAILED | The payout went out but the ProphetX wallet wasn't debited | Error screen with Try again | Don't let the user retry; send the transaction ID to ProphetX support |
PAYNEARME_WITHDRAWAL_FAILED | A withdrawal to a debit card failed. message is PayNearMe withdrawal failed (<PayNearMe code>) | PayNearMe's own failure screen, with Try again where retrying can help | Log the code inside message |
KYC_REQUIRED | Online Bank only: the user's identity isn't verified. Not sent by the backend today — see above | "Verification required", Close only | Open useKyc/useIdUpload, then let them retry |
PROVIDER_ERROR / ZEROHASH_PROVIDER_ERROR | A provider widget inside the withdraw flow reported an error | Error screen with Try again | Log it |
GEOFENCE_BLOCKED | The pre-submit location re-check failed, or the session couldn't be re-validated | "Location not permitted", Close only (onCancel follows) | Reopen with a fresh token |
A user with less than $1 available can't start a withdrawal: the embed tells them and the flow ends with onCancel, not an error.
Other embed errors
| Code | Cause | What to do |
|---|---|---|
UNCAUGHT_ERROR | An unexpected runtime error inside the embed, caught by its error boundary. message is the raw error text | Log it. The embed offers a retry. If it persists, send the details to ProphetX support |
ROUTE_NOT_FOUND | The iframe URL doesn't match any embed route (only possible when you build the URL yourself). message names the path; PROPHETX_READY never follows | Fix the URL |
SDK client errors
These come from the SDK's own modules, not from a flow.
auth.login()
auth.login()login() rejects with a ProphetXAuthError ({ type: 'AUTH_ERROR', code, message, status? }), and the auth state moves to error:
| Code | When |
|---|---|
INVALID_CREDENTIALS | The login endpoint returned 401 |
SERVER_ERROR | Any other failed request — including timeouts and lost connections |
NETWORK_ERROR | The login couldn't be processed at all (for example, the returned token couldn't be read) |
TIMEOUT exists in the ProphetXAuthError type, but login() reports timeouts as SERVER_ERROR today. Don't rely on it.
Wallet
wallet.getBalance() (and useWallet().error) rejects with a ProphetXApiError: { type: 'API_ERROR', code, message, status }.
code | status | When |
|---|---|---|
TIMEOUT | 0 | No response within 15 seconds |
NETWORK_ERROR | 0 | The request couldn't reach the API (offline, DNS, CORS) |
The backend's code, or HTTP_<status> | The HTTP status | The API answered with an error |
SESSION_REFRESH_FAILED
SESSION_REFRESH_FAILEDYour onSessionExpired handler threw while the embed was waiting for a new token. The SDK reports it on its error event — sdk.on('error', …) or useEvents({ onError }) — with { code: 'SESSION_REFRESH_FAILED', message }, not on the flow's onError. The embed then shows its session-expired screen; reopen the flow with a fresh token.
REST API codes (direct API callers)
These codes appear in REST response bodies ({ "code": "...", "error": "..." }) when your backend calls ProphetX payment endpoints directly. The SDK never passes them to onError. If you only use the SDK, an Online Bank refusal reaches you as DEPOSIT_FAILED / WITHDRAWAL_FAILED with the backend's sentence in message, and a PayNearMe failure as PAYNEARME_*_FAILED with the PayNearMe code inside message.
| Code | Provider | Retryable | Cause |
|---|---|---|---|
PERMISSION_DENIED | Any | No | A required gate is unmet; the body names them in pending_gates — see User prerequisite and permission errors |
amount_mismatch | All | No | The amount for this transactionId doesn't match a prior request — mint a new transactionId and resubmit |
insufficient_funds | All | No | Wallet balance is too low for the requested withdrawal |
aeropay_rejected | AeroPay | Yes | AeroPay rejected the deposit or withdrawal request |
user_unconfirmed | AeroPay | No | The user hasn't completed AeroPay's SMS MFA confirmation yet — see Embedded UI |
link_failed | AeroPay | Yes | Bank-linking via Aerosync failed |
mfa_rejected | AeroPay | Yes | The SMS MFA code was rejected. The code is a real SMS sent to the user's phoneNumber, even in sandbox; in sandbox only, 000000 is always accepted |
invalid_amount | PayNearMe, ZeroHash | No | Amount is not a positive decimal with at most 2 places |
participant_unconfirmed | ZeroHash | No | The user hasn't completed ZeroHash participant onboarding yet |
missing_user_profile | AeroPay, ZeroHash | No | No provider profile exists yet for this user — trigger the provider's onboarding step |
PayNearMe codes are listed below. This is a representative list, not exhaustive — see each provider's section in Embedded UI for the full picture.
Errors raised inside the Aerosync bank-linking widget (for example INSTITUTION_ERROR / AC-148) are shown inside the widget and never sent to your page. They originate on AeroPay's side after ProphetX has issued a valid widget session, and usually track an AeroPay incident — retry, and report the user id and timestamp to ProphetX if it persists.
PayNearMe codes
These are every code the PayNearMe endpoints (/embed/v1/payment/pnm/*) return. Branch on code, not on the error text.
| Code | Status | Cause | What to do |
|---|---|---|---|
pnm_rejected, pnm_find_orders_failed, pnm_smart_token_failed | 502 | Deposit: PayNearMe couldn't create or open the order | Retrying the same request is safe |
tenant_unavailable | 503 | Payments aren't available right now | Retry later |
invalid_amount | 400 | Amount isn't a positive decimal with at most 2 places | Ask for the amount again |
payment_method_identifier_required | 400 | No card was chosen for the withdrawal | Ask the user to pick a card |
user_suspended | 400 | The account is suspended and can't withdraw | Route the user to support |
user_profile_incomplete | 400 | A required profile field (name, date of birth, street, city, state, ZIP) is missing | Have the user complete their profile, then retry |
user_profile_unsupported_country | 400 | PayNearMe payouts are US-only | Final for this user; hide the withdraw option |
pnm_push_user_rejected, pnm_push_order_rejected | 400 | PayNearMe refused the recipient or the payout setup; error has PayNearMe's reason | Route the user to support |
withdrawal_already_pending | 409 | Another withdrawal is waiting for review | Wait for it to finish |
amount_mismatch, payment_method_identifier_mismatch | 409 | This transactionId was already used with a different amount or card | Mint a new transactionId |
withdrawal_settled | 409 | This transactionId was already paid out, rejected or declined | Mint a new transactionId |
payout_method_not_deposited | 422 | The card isn't one this user has deposited with | Ask for another card |
wallet_withdraw_failed | 422 | The amount couldn't be held: low balance, over the withdrawal limit, or suspended. Nothing was held | Show the reason; don't retry as is |
pnm_push_order_failed | 502 | PayNearMe couldn't set up the payout. Nothing was held | Retry with a new transactionId |
pnm_find_payment_methods_failed | 502 | GET .../withdraw/methods: PayNearMe couldn't list the payout methods | Retrying is safe |
ops_approval_required | 403 | Returned by the deprecated POST .../withdraw/{transactionId}/execute | Don't call it; see below |
There is no execute step. A PayNearMe withdrawal is complete from your side once POST /embed/v1/payment/pnm/withdraw succeeds: ProphetX holds the amount, and the payout is sent when ProphetX operations approves it. The old execute endpoint is deprecated and always answers 403 ops_approval_required. This is the same whether the user withdraws in the embed or your backend calls the API.
Complete error handling example
One handler for the deposit and withdraw flows:
import { useCallback } from "react";
import { useIdUpload } from "@prophetx/sdk-react";
function useFlowErrorHandler() {
const { open: openIdUpload } = useIdUpload(); // or useKyc — same flow
return useCallback((code, message) => {
// Always log: the message is for you, not the user
analytics.track("flow_error", { code, message });
switch (code) {
// The session can't be fixed in this iframe: start over
case "SESSION_EXPIRED":
case "GEOFENCE_BLOCKED":
reopenWithFreshToken();
break;
case "SESSION_INVALID":
case "ORIGIN_UNAUTHORIZED":
showContactSupport();
break;
// Online Bank withdrawal refused until the user re-verifies
case "KYC_REQUIRED":
openIdUpload({ onKycSuccess: () => showRetryPrompt() });
break;
// The outcome is unknown: show the latest balance
case "DEPOSIT_UNCONFIRMED":
case "WITHDRAWAL_UNCONFIRMED":
refreshBalance();
break;
// Money moved but the wallet didn't update: needs support
case "DEPOSIT_WALLET_WRITE_FAILED":
case "WITHDRAWAL_WALLET_WRITE_FAILED":
case "ZEROHASH_DEPOSIT_CONFLICT":
refreshBalance();
flagForSupport(code);
break;
// Everything else: the embed shows its own error or retry screen
default:
break;
}
}, [openIdUpload]);
}
// reopenWithFreshToken(), showContactSupport(), showRetryPrompt(),
// refreshBalance() and flagForSupport() are your own functions.
// Unmet gates produce no error: check them before opening a flow (see above).Quick reference
Every code the SDK can send to onError, plus the SDK client codes.
| Code | Layer | Flow | Summary |
|---|---|---|---|
SESSION_EXPIRED | Embed | All | Token already expired at open — reopen with a fresh token |
SESSION_INVALID | Embed | All | Bad or rejected JWT — pass the /private/v1/tokens token unchanged |
ORIGIN_UNAUTHORIZED | Embed | All | Origin not on the allowlist — contact ProphetX |
GEOFENCE_BLOCKED | Embed | Deposit, withdraw | Pre-submit location re-check failed (or the session couldn't be re-validated) |
DEPOSIT_FAILED | Embed | Deposit | Generic refusal; embed offers Try again |
DEPOSIT_UNCONFIRMED | Embed | Deposit | Outcome unknown — refresh the balance |
DEPOSIT_NOT_COMPLETED | Embed | Deposit | Settlement failed or was cancelled |
DEPOSIT_WALLET_WRITE_FAILED | Embed | Deposit | Money moved, wallet not credited — support |
PROVIDER_LOAD_FAILED / PROVIDER_UNAVAILABLE | Embed | Deposit | Provider unavailable — try another method |
PAYNEARME_DEPOSIT_FAILED | Embed | Deposit | PayNearMe failure; code inside message |
ZEROHASH_* (8 codes) | Embed | Deposit | Crypto deposit failures — see the deposit table |
WITHDRAWAL_FAILED | Embed | Withdraw | Generic refusal; embed offers Try again |
WITHDRAWAL_UNCONFIRMED | Embed | Withdraw | Outcome unknown — refresh the balance |
WITHDRAWAL_NOT_COMPLETED | Embed | Withdraw | Settlement failed or was cancelled |
WITHDRAWAL_WALLET_WRITE_FAILED | Embed | Withdraw | Payout sent, wallet not debited — support |
PAYNEARME_WITHDRAWAL_FAILED | Embed | Withdraw | PayNearMe failure; code inside message |
KYC_REQUIRED | Embed | Withdraw (Online Bank) | Identity not verified — open ID Upload. Not sent today |
PROVIDER_ERROR | Embed | Withdraw | Provider widget error |
UNCAUGHT_ERROR | Embed | All | Embed crashed — log and retry |
ROUTE_NOT_FOUND | Embed | — | Bad iframe URL |
INVALID_CREDENTIALS / SERVER_ERROR / NETWORK_ERROR | SDK client | auth.login() | Login failed |
TIMEOUT / NETWORK_ERROR / backend code | SDK client | Wallet | Balance request failed |
SESSION_REFRESH_FAILED | SDK client | error event | Your onSessionExpired handler threw |
Updated 11 days ago
