FAQ

Questions, answered.

Everything you need to know about U.CASH, the apps, and the network. Still stuck? Get in touch.

What is the 402 Online Protocol?

The 402 Online Protocol turns the familiar HTTP 402 'payment required' status into a real pay-to-access mechanism. AI agents and other HTTP clients fetch a priced resource, receive a 402 with payment details, pay on-chain, and retry with proof. It is open and documented at https://402.onl. U.CASH Pay is built on it, so agents are first-class participants. Open →

What is the /payment/ operator console used for?

The /payment/ surface (payment/admin.php) is the operator console for configuring payment methods, monitoring transactions, managing checkouts, and setting platform-wide fees and exchange-rate providers. It is a distinct product surface from the merchant app (admin.php). It stays a fully isolated identity with its own UXC_LOGIN cookie and never trusts consumer SSO, so a compromised consumer session cannot pivot to it. Open →

What is the reseller console and how is it reached?

The reseller console is a brand-owner dashboard rendered at payment/admin.php on the branded domain (e.g. https://pay.bitcoin.ws/payment/admin.php). It activates when the request host differs from the platform host: pay.bitcoin.ws shows the reseller console, pay.u.cash shows the operator console. It queries the tenant database via the domain-rewrite cookie handoff. A logged-out visitor sees the cloud login box; only a valid UXC_LOGIN cookie shows the dashboard. Open →

What are the three admin tiers on U.CASH Pay and what can each do?

U.CASH Pay has three tiers. The Super admin (cloud/super.php) is the platform owner and can adjust any balance, edit platform config, and oversee every merchant. The Payment admin (payment/admin.php) is the operator console that configures payment methods, fees, exchange-rate providers, and monitors transactions across the platform. The Master merchant (admin.php) is a single merchant account that creates checkouts, sets wallets, and accepts payments. A white-label merchant sits under a branded domain (e.g. pay.bitcoin.ws/admin.php) and is a brand-scoped clone of the master merchant. Open →

What is the agents.u.cash x402 integration?

agents.u.cash makes AI agents first-class merchants via the unified HTTP-402 (x402) protocol spanning crypto and fiat. It is strictly non-custodial: every payment goes direct buyer-to-seller (the seller's own wallet), and the platform only verifies, detects on-chain, and notifies. The same account is buyer and seller. The x402 / exact rail uses USDC on Base via EIP-3009 transferWithAuthorization, so a buyer signs an off-chain authorization and the platform settles gasless. An off-the-shelf x402 client pays without changes via the /r/ door and facilitator endpoints. Open →

Does U.CASH Pay have a REST API?

Yes. The API surface spans payment/api.php (transaction operations), cloud/api.php (cron and platform actions), and payment/ajax.php. Authenticate with your API key in the Authorization: Bearer header or as api-key in the query string. Typical endpoints include get-transaction, create-transaction, create-credit-checkout, and the cron endpoint. The agents.u.cash surface adds a dedicated agent REST API at /v1 that agents use instead of the legacy RPC. Open →

What is the UCP REST surface on U.CASH Pay?

UCP (Universal Checkout Protocol) is the public, agent-discoverable REST surface served from ucp.php and routed from /.well-known/ucp, /catalog.json, and /catalog.txt. It exposes POST checkout-sessions (create a checkout session), GET catalog (list a merchant's priced resources as schema.org Product JSON-LD), and GET orders. It is rate-limited per IP and rejects oversized bodies. The business context is resolved from the merchant custom domain or a ?cloud=<merchant-token> parameter. No auth is required for discovery. Open →

What is captured in the audit log?

The tenant audit log (uxc_audit_log) records who did what, when. Each row has the actor (the staff email, or the owner email), an action string (e.g. pos-terminal-add, pos-save-setting), a target_type, a target_id, a bounded summary, and a timestamp. The table is lazy-created on first use per request. Only roles carrying audit.view (auditor plus the management chain) can see the log. It is indexed on actor and ts for fast lookup.

How does prepaid credit billing work?

U.CASH Pay uses a prepaid credit model. You add funds (Add Funds) via a create-credit-checkout, which produces an encrypted payment link; once paid, the webhook credits your credit_balance standalone settings row. Platform fees, staff seats, POS terminals, and custom-domain monthly billing are debited from this balance. The credit balance is read from the tenant settings table and written by the webhook increment. Fee charges are recorded in the fee_history table with the amount, percentage, transaction, currency, and date. Open →

What does the customer see at checkout?

The buyer opens your link and sees the product title, amount, and a grid of accepted coins grouped by network (Ethereum, Base, Solana, TRON, native, etc.). They pick a coin; the page shows the receive address, a QR code, the exact crypto amount, and a countdown timer. If they have MetaMask/TronLink/Phantom connected, a one-tap wallet button and their balance appear. The page polls the chain and updates to a confirmation screen when the payment lands. See https://pay.u.cash/about. Open →

What are Converters?

Converters are retail merchants who use U.CASH Pay to move cash<->crypto for their customers, using the Payout Info Request and payment-link features. It is the human/retail fiat<->crypto on/off-ramp: a customer brings cash, the converter sends crypto (or vice versa), and the platform tracks the request. This is distinct from swap.u.cash, which is on-chain crypto<->crypto token swaps.

How and when do I get paid?

Immediately in principle: the buyer pays your wallet directly on-chain. A sale is marked settled once the payment reaches the required number of confirmations for that coin. There is no payout queue and no withdrawal to wait for, because the money was never anywhere but your wallet. Open →

Is U.CASH Pay a money transmitter?

No. Because the platform never holds customer funds (payments go direct buyer to seller), it is not a money transmitter or a custodian. It is payment infrastructure. As with any payments integration, you remain responsible for your own regulatory compliance in your jurisdiction. Open →

What does non-custodial mean for U.CASH Pay?

Non-custodial means U.CASH Pay never holds your funds or your keys. A payment travels direct from the buyer's wallet to your own wallet on the blockchain. The platform only reads the chain to confirm the payment happened and then notifies you. Because no custodial account exists, there is nothing to lose, freeze, or be robbed of. Open →

What is a Payout Info Request?

A Payout Info Request is a merchant-mediated fiat<->crypto / OTC flow. You request a payee's crypto wallet address (or PayPal/fiat email) via a no-login, token-authenticated form. They submit it; you complete the cash or crypto leg in person (off-platform) and click Mark as Sent. It is pay.u.cash's built-in over-the-counter desk for moving cash to crypto and back through a human converter.

How does pos.u.cash integrate with pay.u.cash?

pos.u.cash is administered from pay.u.cash in-process. pay.u.cash loads pos.u.cash's apps/pos/functions.php and provides a POS management panel where you add and remove registers, assign staff who can operate them, and save POS settings. The tenant token is embedded in a register's public display_token so a customer-facing browser resolves the tenant without the merchant SSO cookie. POS staff (tellers) are sealed to pos.u.cash. Open →

Is there a reseller or white-label program?

Yes. U.CASH Pay is multi-tenant by design: host many merchants under one install with MySQL-enforced isolation, branded domains, a reseller login, and a reseller console dashboard. A reseller can run a branded instance (e.g. pay.bitcoin.ws) with its own domain, coin restrictions, and per-merchant stats. Contact U.CASH about reseller onboarding. Open →

Is there a JavaScript / npm SDK for U.CASH Pay?

Yes. The agents-u-cash SDK is published on npm (npm install agents-u-cash) for the agents.u.cash 402 Online Protocol API. The @ucash/ucash-cli package provides a CLI. Additional UdotCASH SDK packages cover language-specific clients (Go, Rust, Elixir, Java, Maven, and more) that build and publish against the U.CASH Pay API. See the awesome-ucash catalog on GitHub for the full list. Open →

Is there a Python SDK, and what does it cover?

Yes. agents-u-cash is a zero-dependency Python client (pip install agents-u-cash) for the agents.u.cash 402 Online Protocol API. It uses only the standard library (urllib), supports Python 3.7+, and covers both sides of the network: selling (manage resources, watch settlements) and buying (fetch a 402 door, pay, and settle via on-chain detection or by submitting the tx hash). The single-file module agents_u_cash.py can be copied with no dependencies. Open →

Can I use U.CASH Pay to sell on my website or online store?

Yes. Three ways: embed a Pay button on any site (one script tag), integrate the REST API or WHMCS/Shopify module into your existing store, or use the built-in Shop storefront as a hosted online store with products, discount codes, and digital license-key delivery. All are non-custodial; funds settle direct to your wallet. Open →

Does U.CASH Pay have a storefront / shop page?

Yes. The Shop Page is a Shopify-style storefront: pick from 16 layouts, configure a hero, nav, content sections, footer columns, social links, announcement bar, and custom pages. Products are checkouts with extra fields (badge, category, compare-at price, CTA label). Discount codes, license keys (for digital goods), and per-product imagery are supported. It renders at `/shop.php` or your custom domain.

Is staff activity recorded in the audit log?

Yes. uxc_audit(action, target_type, target_id, summary) appends a per-user action to the tenant audit log (the uxc_audit_log table), recording the actor (staff email or owner), the action, the target, and a timestamp. Only roles that carry audit.view (auditor plus the management chain) can see the log. POS actions like adding or removing a terminal and saving a setting are audited, as are staff changes.

How does delegated staff management work?

Staff management is hierarchy-scoped via uxc_can_manage(target_id). The owner can manage everyone. A master-admin can manage everyone. An admin can manage anyone below admin rank. Supervisor through officer can manage only staff within their reports-to subtree whose rank is lower than their own. Each role has a numeric rank (teller=2 up to master-admin=10), and managers cannot touch staff at the same or higher rank. All checks are same-tenant only.

Which staff roles are sealed to pos.u.cash only?

Teller roles are sealed to pos.u.cash only and cannot use the pay.u.cash admin. The admin bootstrap bounces them to pos. The teller is the cashier or server who operates a register. Everyone else, including the clerk who does back-office payment links, uses the pay.u.cash admin. POS staff (tellers) are billed separately via the teller seat price and are intentionally unaffected by the POS terminal-seat paygate.

How do staff seats and roles work under a merchant?

Each merchant owner can add staff on the cloud tenant_users table. Every staff row has a role, and uxc_can(permission) is the single permission gate. The owner is god (no staff row). Built-in roles expand from a canonical permission set; a 'custom' role reads its stored subset. The ladder is cumulative, so each higher role adds permissions. The standard built-ins include teller, clerk, lead, supervisor, manager, director, officer, admin, and master-admin on the management chain, plus the specialists accountant, auditor, and designer. Open →

What can each staff role do?

Teller is POS-only (pos.operate). Clerk creates payment links and views transactions and checkouts. Lead adds refunds and POS operate. Supervisor adds checkout editing and user management (it does NOT carry settings, processors, design, payouts, or financials). Manager adds settings, processors, design, payouts, financials, and broader user management. Director, Officer, Admin, and Master-admin add progressively more (payment methods, wallets, audit view, full user management). Accountant handles financials and transactions. Auditor is read-only across financials, transactions, checkouts, audit, and landers. Designer edits design and views checkouts and landers.

What is the difference between pay.u.cash and swap.u.cash?

pay.u.cash is for accepting payments (merchant checkout, invoices, storefront, converter cash<->crypto). swap.u.cash is a non-custodial DEX aggregator for on-chain crypto<->crypto token swaps (EVM DEXs/cross-chain bridges, 18+ EVM chains, plus instant-exchange). They are separate products: pay moves money for goods/services; swap converts one token to another. Open →

What is the Flat Fee feature and how does it differ from the Checkout Flat Fee?

Flat Fee (payment-fee-flat, $40 tier) adds a flat fee to every transaction. Checkout Flat Fee (checkout-flat-fee, $45 tier) overrides the fee per individual checkout, so you can set a different flat amount on a specific checkout. Both are premium toggles: when toggled off they revert to zero (no flat fee applied). The default platform percentage fee applies regardless. Open →

What is UCASH on U.CASH Pay?

UCASH is the U.CASH network token. On pay.u.cash you can buy UCASH (loaded 1:1 to your UCASH points balance) and hold UCASH to unlock a platform-fee discount that scales with your holding (verified via a MetaMask wallet signature). UCASH is also a receivable coin for checkouts. UCASH points are separate from your fee credit balance. Open →

How does the UCASH holding discount work?

Verify a UCASH wallet holding and your platform fee drops further on top of your volume tier. The discount scales with how much UCASH you hold, applied automatically. Combine it with the volume tiers and the funding-tier unlocks and the effective fee can fall well below the headline rate. Check your current tier in your Account area. Open →

What is U.CASH Pay?

U.CASH Pay (pay.u.cash) is a non-custodial crypto payment platform. You connect your own wallets and nodes, and buyers pay you direct on-chain. The platform reads the blockchain to detect each payment, marks it settled at the required confirmations, fires a webhook to your store, and shows it in your dashboard. It never holds your funds or your private keys, so it is payment infrastructure, not a money transmitter. See https://pay.u.cash/about. Open →

What is white-label on U.CASH Pay?

White-label turns U.CASH Pay into a reseller platform. Each merchant is scoped by platform_domain (the host they registered on), so a pay.bitcoin.ws merchant cannot log in on pay.u.cash and vice versa. A white-label merchant under a branded domain is a brand-scoped clone of the master merchant and can diverge per-brand (for example, a BTC-only brand). The reseller (the branded-domain owner) manages their instance from the reseller console at payment/admin.php on the branded domain. Open →

Is two-factor authentication available for operators?

Yes. The /payment/ operator console has self-contained TOTP two-factor authentication (scan a QR with an authenticator app, then enter the 6-digit code to confirm). Enrollment is on the standalone security.php page, gated by the operator login and CSRF-protected. The enabled flag and the secret both live in the tenant settings rows and are read by the login gate. Legacy per-tenant 2FA was retired from the merchant and cloud-login surfaces, but the operator gate was kept and hardened. Open →

Can an agent accept card payments too?

Yes. POST /v1/stripe with your OWN Stripe account keys (secret_key, product_id, webhook_secret, optional publishable_key). The key and product are verified against Stripe before storing, and secrets are never returned in full. Then register the returned webhook_endpoint (subscribe to checkout.session.completed) in your Stripe dashboard. Buyers see a redirect card entry alongside the coin entries in accepts[]. Card payments settle direct to your Stripe account (non-custodial), and the platform fee is debited from your prefunded credit. Open →

How does a buyer pay an agent's 402 resource?

Fetching GET /r/{res_id} returns HTTP 402 with an accepts[] array: one entry per accepted asset, each with a scheme (detect or exact), asset, network, the seller's payTo address, an exact randomized amount, a challengeId (chal_), and an expiresAt. The buyer pays the exact amount to the payTo address, then POST /v1/verify with the challengeId and the on-chain hash (for detect) or the signed authorization (for exact). The platform verifies and settles. The challengeId is public and safe to share; settlement still requires real on-chain payment. Open →

Can an agent accept a custom token not built in?

Yes. POST /v1/custom-tokens with the type (erc-20, bep-20, base-20, polygon-20, arb-20, op-20, avax-20, trc-20, spl, or ton-jetton), a code that does not collide with a built-in coin, the contract address, decimals, and name. Then POST /v1/wallets with the asset code and your address to set where buyers pay. The token is auto-detected on-chain like any built-in coin (the cron scans the contract transfers). GET /v1/custom-tokens lists them; DELETE removes one. Open →

How does an agent start selling on agents.u.cash?

Sign up via POST /v1/signup to get an api_key (works instantly at $0; email is optional). Set your wallet for each coin you accept via POST /v1/wallets (the tenant database is created on this first write). Create a priced resource via POST /v1/resources to get a res_id, then share https://agents.u.cash/r/{res_id}. On payment you receive an HMAC-signed webhook and the settlement appears in GET /v1/settlements. Buyer funds went straight to your wallet. Verifying an email, when provided, is an optional reward of free starter credit. Open →

How do I authenticate to the U.CASH Pay API?

All API requests require an API key. Send it as Authorization: Bearer YOUR_API_KEY, or as the api-key=YOUR_API_KEY query parameter. Obtain your API key from the dashboard under Settings. For multi-store setups, each store has its own api_key in the stores table that resolves to that store's user and tenant. The legacy account-level api_key (users.api_key) is a global webhook key with store_id NULL. Open →

How do I rotate my API key?

Use the rotate-api-key action in the dashboard. It generates a fresh 40-character hex key, updates users.api_key, and returns the new key. Rotating is treated as a credential-changing op: if you have MFA enrolled, you are bounced to a fresh step-up challenge first; users without MFA pass straight through. Old API keys stop working immediately after rotation. Store-level api_keys rotate via the cycle-store-api-key action.

After I edit dashboard JS or CSS, why does my fix not appear?

Cloudflare and browsers cache pay.u.cash static JS and CSS at a ?v=UXC_ASSET_VER query string for several hours. After any JS or CSS edit, bump UXC_ASSET_VER (defined in the root and payment functions.php, which can drift) or CF and browsers keep serving the stale ?v= URL and your fix looks broken. HTML and PHP are uncached (served DYNAMIC). For the separately-minified client.min.js, re-minify with terser after editing client.js or the dashboard keeps the old bugs.

How is a credit top-up created and delivered?

A credit top-up uses create-credit-checkout, which pre-creates a transaction in the payment table and returns an encrypted /id/ link (pay.u.cash/payment/id/<encrypted-id>). The link is encrypted (the id is uxc_encryption of the numeric transaction id) so the price and redirect parameters are never exposed as plaintext query params. When paid, the webhook credits credit_balance because the transaction is found in the payment table. This works for logged-in merchants because the payment functions force the payment-table path on the platform host.

Where can I see the fees I have been charged?

The fee_history table records every fee charge: the user_id, amount, fee_percentage, transaction_amount, transaction_id (which for seat purchases is a seat-slot-<role> label), currency, and date. The dashboard exposes this as the fee history view. Staff seat purchases, POS terminal slot purchases, and per-transaction platform fees all appear here.

Can I customize the branding (logo, colors, CSS)?

Yes. Set your brand name ($5 tier), payment page logo ($15), custom colors ($20), and custom CSS ($25). Dark/light logo variants and a custom favicon are supported. The checkout and shop pages pick up the theme automatically. Open →

How do I cancel a pending transaction?

Use Cancel on the pending transaction. The row is removed and the receive address is released back to the address pool (manual list or HD pool) so it can be reused. Any shop license keys tied to the order are deleted. Completed (C) or underpayment (X) transactions cannot be cancelled this way.

How do I rotate my Cloud token, and what breaks?

Use the rotate-cloud-token action. Because the token is both the users.token column and the cloud/config/<token>.php filename, rotation is race-guarded: it copies the config to a new name, rewrites the UXC_TOKEN constant, flips users.token (with rollback on a miss), then removes the old config. You get a fresh UXC_CLOUD cookie so you stay logged in. Old embeds that carry the old token in cloud= stop resolving immediately, which is the intended remedy for a leaked embed. MFA users get a step-up challenge first.

How do I create a payment link?

In your dashboard go to Create Checkout (or Payment Request). Set a title, price, currency, optional description, redirect URL, and the coins to accept. You get a shareable /checkout/<slug> link plus an opaque encrypted /checkout/<token> link, both hosted on pay.u.cash (or your custom domain). Send the link by email, chat, or invoice; the buyer opens it and pays. Open →

How do I sign up and create my first store?

Go to pay.u.cash and click Sign up free (which goes to the U.CASH portal registration) or 'Sign in with U'. After SSO, the dashboard walks you through connecting wallets per coin, setting branding, and creating your first checkout or shop product. Each new account is an isolated tenant database. Open →

How do I top up my credit balance?

In your Account area, choose Add Funds (credit) or Buy UCASH. This creates an encrypted payment link (`/payment/id/<enc>`) for the amount; you pay it on-chain like any checkout. On confirmation the webhook credits your `credit_balance` (or UCASH points) and counts toward your lifetime funding total that unlocks features. Open →

Can I upload files like CSV or text data?

Yes, in specific areas: - Lander import: CSV bulk import of landing pages (Settings -> Import in pay.u.cash). - Transaction export: download your transactions as CSV or text from the dashboard. - U.CASH Send (send.u.cash): upload a CSV of addresses + amounts for mass distribution. There is no general file upload for graphics or branding - use a logo URL for branding images.

Can I run the checkout on my own domain?

The Custom Domain feature (a $50 lifetime-spend tier unlock) lets a merchant host checkouts on their own domain. You unlock it either by reaching $50 in lifetime Add-Funds top-ups or by holding enough UCASH to qualify for the equivalent tier. Then enter your domain, CNAME it to pay.u.cash, and edge SSL is auto-provisioned. The feature costs $0.50 per month from prepaid credit while in use. You can toggle it on and off, and it auto-suspends if the tier lapses. Open →

Can I turn my custom domain on and off, and what happens if my tier lapses?

Yes. There is an on/off toggle on the custom-domain row. Active means the domain is enabled, the feature is unlocked, a domain is set, and the account is funded. If the tier lapses (for example UCASH holdings drop below the threshold), the domain auto-suspends: it stops routing and stops billing, but the domain text is kept in your settings so toggling back on (after re-qualifying) re-provisions the same domain. The toggle is your intent; tier and credit are automatic gates. Open →

Can I use a custom block explorer or address source?

Yes. The custom explorer integration lets you plug in your own explorer endpoint for address generation and lookup (templated URL with `{N}`/`{N2}` for coin code/name and a JSON path to the address). Useful for long-tail coins or a private explorer. See https://pay.u.cash/docs/custom-explorer.html. Open →

Can I collect custom fields or customer details at checkout?

Yes. Checkout custom fields ($30 tier) let you add extra inputs to the payment page. Required user details ($35 tier) let you make customer info mandatory. Responses are stored on the transaction and visible in your dashboard. Open →

Can I accept my own ERC-20 or custom token?

Yes. Add any token under Custom Tokens in your dashboard: give it a code, name, contract address, network (Ethereum/Base/Polygon/Arbitrum/Optimism/Avalanche/BSC/Solana/Tron/TON/Linea/Mantle/Berachain/Sonic/Unichain/Worldchain/Monad/Plasma/Abstract/HyperEVM/Scroll/Ink), decimals, and the receive wallet you control. Incoming transfers are detected per-chain (Etherscan v2, Blockscout, Snowtrace, or direct RPC for newer chains) and credited like any built-in coin. See https://pay.u.cash/docs/custom-token.html. Open →

How does a customer actually pay an invoice or link?

Open the link, pick a coin, and either scan the QR with a mobile wallet, copy the address and exact amount into your wallet, or tap the MetaMask/TronLink/Phantom button to pay from your browser wallet. Send the exact crypto amount shown. Wait on the page; it polls the chain and switches to a confirmation screen once the payment lands and reaches the required confirmations.

Why does the dashboard sometimes get stuck on a loading spinner, and how is it fixed?

The dashboard loading helper has two spinner classes: uxc-loading (cleared on completion) and uxc-loading-first (cleared only by a nav refresh). If a render throws after the area's loading flag is set but before the finally clears it, the spinner sticks. The fix is to clear area loading in a finally block (or a try/catch) and run a 12-second watchdog. Navigating away and back also clears it because nav() drops both classes.

Can I embed a Pay button on my own website?

Yes. Paste a one-line embed script: `<script src="https://pay.u.cash/embed.js" data-cloud="<token>" data-amount="5.00" data-currency="USD" data-title="My Product" data-redirect="https://shop.com/thanks"></script>`. It renders a styled 'Pay with U.CASH' button; clicking creates the checkout server-side and redirects to the hosted payment page. No CORS, no client-side API calls; works on any site.

Why does the checkout show no payment methods (but works in incognito)?

This is almost always a stale login cookie. Your browser's UXC_CLOUD cookie makes the checkout resolve your own account (which has no receive addresses) instead of the store. Fix it by clearing the site's application data (or the pay.u.cash cookies) and reloading. The platform also has a guard that forces the store token from the URL when present.

How do I host my logo image to get a URL?

To get a direct image URL for your U.CASH Pay logo: 1. Cloudinary (recommended): create a free account at cloudinary.com, upload your image, copy the secure URL. 2. GitHub: push the image to a public repo, then use the raw URL: `https://raw.githubusercontent.com/USER/REPO/main/logo.png` 3. Imgur: upload at imgur.com, right-click the image, copy image address. 4. Your own server: if you have web hosting, upload the image and use its public URL. Paste the URL into Settings -> Branding -> logo-pay in your pay.u.cash admin.

Can I generate an invoice or tax receipt?

Yes. With Invoicing unlocked ($10 funding tier), a completed transaction with billing details can generate a branded PDF tax invoice (invoice-number prefix configurable). The buyer can also enter billing details on the payment page and download the invoice themselves. VAT/Tax calculation is supported with country-code rates and VAT-number validation. Open →

Can an existing merchant become an AI agent operator?

Yes. An existing pay.u.cash merchant can flip its account into an agent operator in place from the dashboard under AI Agents then 'Link an AI agent'. This sets the is_ai_agent flag and mints an api_key if none exists. The same account then works on agents.u.cash as both a seller (get paid to its own wallet) and a buyer (pay for resources). The flag is is_ai_agent, never is_agent (which is the support-agent admin role). Open →

Can merchants sign in with U.CASH SSO (Google)?

Merchant sign-in on pay.u.cash uses SSO through the portal.u.cash identity provider, including the Google way. New identities are created at the portal IdP (portal.u.cash/register), and pay.u.cash is a first-class relying party. True single-logout works: an app logout triggers a front-channel portal op=logout that revokes the IdP session and all central sessions, so no app silently re-signs you in. The operator /payment/ console is intentionally excluded from this SSO network and keeps independent login. Open →

How does the Payout Info Request flow work step by step?

1) You create a Payout Info Request (amount, coin or fiat, note, payee email). 2) The payee gets a no-login link to submit their wallet address (or PayPal email); Web3 names (ENS/UD/FIO) are accepted and resolved. 3) You are notified they submitted. 4) You settle the cash/crypto leg in person, off-platform. 5) You click Mark as Sent, which completes the record and meters the fee.

Which staff can operate a POS register?

Staff whose role carries the pos.operate permission can operate a register: teller, lead, supervisor, and the full management chain up to master-admin. The POS staff list (uxc_pos_staff_list) shows the admin, manager, and teller roles for a tenant. Tellers log in with username and PIN at the POS keypad (email-less staff get a synthesized address).

Where do the funds go? Do I set my own receive wallet?

Funds go direct to your own wallet. You set a receive address per coin under Payment Options (the `address-<code>` fields), or use address generation (BTC xpub, Ethereum node-derived addresses, Gemini generation, or a custom explorer). For cloud merchants, addresses are HD-generated. The platform never holds or moves the payment. Open →

Can I redirect the buyer back to my site after payment?

Yes. Set a redirect URL on the checkout or per-transaction (integrations can stamp it per order). On successful completion the buyer is redirected there. The shop app and embeds both support this.

How do I refund a payment?

Open the transaction in your dashboard and use Refund. The platform reads the original on-chain transaction to find the sender's address and amount, then sends the funds back if you have a refund method enabled: BTC node refunds (btc-node-refunds), Ethereum node refunds (eth-node-refunds), or Coinbase refunds (coinbase-refunds). The amount and sender must match exactly. Refunds are off by default; enable the method in settings.

How do I brand my checkout (brand name, logo, colors)?

Branding settings live in the dashboard under Settings. Brand Name (display your brand instead of U.CASH Pay) unlocks at the $5 lifetime-spend tier. Payment Page Logo unlocks at $15. Colors (custom payment form colors) unlock at $20. Custom CSS (your own CSS for the admin and payment page) unlocks at $25. Each premium field has an on/off toggle so you can disable it without clearing the value; toggled-off fields revert to default (CSS not loaded, default brand name). Open →

How are settings edits gated by staff role?

Each settings key maps to a section permission via uxc_setting_permission. Receive addresses, payment fees, confirmations, and underpayment require payments.methods.edit. Wallet keys, Lightning macaroons, and xpubs require wallets.edit. Processor keys (stripe, paypal, verifone, coinbase, gemini) require payments.processors.edit. Logo, shop colors, theme color, and checkout style require design.edit. Everything else defaults to settings.edit. A staff member without the matching permission cannot save that section.

How do I add a product to my shop?

A product is a checkout with shop fields. In the Shop section, create a checkout and set its price, title, image, category, badge, compare-at price, and CTA label. It appears in the storefront grid (optionally filtered by category section). Buyers click through to the normal checkout flow.

How do I sign in to my merchant account?

Merchant sign-in uses U.CASH SSO (portal.u.cash is the identity provider). Click 'Sign in with U' on pay.u.cash; 'Sign up free' goes to the portal registration. True single-logout: signing out of any U.CASH app revokes the identity-provider session and all central sessions, so no app silently re-signs you in. Open →

Can I create a staff role with a custom permission set?

Yes. A staff role set to 'custom' reads its own stored permission subset instead of a built-in role map. Permissions are stored as a comma-separated list (not JSON, to avoid an escaping trap). Available permission keys include settings.edit, payments.methods.edit, payments.processors.edit, wallets.edit, design.edit, checkouts.edit, checkouts.view, payment-links.create, payouts.create, financials.view, financials.edit, transactions.view, transactions.edit, transactions.refund, transactions.delete, pos.operate, audit.view, and users.manage.

Can I stop addresses from being reused?

Yes. Enable stop-reusing-addresses in settings and each order gets a fresh address from your pool (never a recycled one), improving privacy. Combined with address generation (BTC xpub / Ethereum node), this gives a unique address per payment without manual management.

If my store cloud token leaks, can I rotate it?

Yes. Store tokens are opaque and rotation-proof (`st_...`): rotating a store's cloud token invalidates the old one without breaking already-issued payment links (they reference the store by a stable internal id). Use the cycle/rotate-store-cloud-token action to mint a new token for a store; re-copy it once to your integrations.

The checkout is stuck on 'Confirming your payment'. What do I do?

Usually the platform is fine and the merchant site is still polling. First check the transaction in your dashboard (status C = complete). If it shows complete there, the buyer's page should update within a few polls; refresh it. If the on-chain transaction has fewer than the required confirmations, just wait. If you are the merchant and need to verify crediting, check the transaction status and webhook log.

Can I test on testnets before going live?

Yes. There is a test/staging instance and testnet support so you can run the full flow without real funds. The platform has a demo mode that exempts orders from the expiry timer. See https://pay.u.cash/docs/testnets.html for the testnet configuration. Open →

How do I link a UCASH wallet to unlock the holding tier?

From the dashboard, request a nonce (a short-TTL, HMAC-signed message bound to your account), then sign it with MetaMask using personal_sign. The server ecrecovers the signer, proves you own the address, and links it to your account (one row per wallet; a wallet grants premium to at most one account). The UCASH tier is then resynced from the sum of all linked wallets. The same wallet cannot be re-linked to another account.

Can I upload a logo or image for my store?

U.CASH Pay uses logo URLs, not direct image uploads. Host your logo on an image-hosting service and paste the direct URL into Settings -> Branding -> logo-pay. Free hosting options: - Cloudinary (free tier, best for production) - GitHub (push the image to a public repo, use the raw URL) - Imgur (quick, no account needed for basic use) The URL must point directly to the image file (ending in .png, .jpg, .svg, or .webp). Open →

How do I verify my UCASH holding for the discount?

In your Account area, connect the Ethereum wallet holding your UCASH and sign a message (MetaMask personal_sign; no gas, no transaction). The platform recovers the address from the signature, reads the on-chain UCASH balance, and caches your tier and fee discount (re-checked on each login). One holding tier maps to feature unlocks and a percentage fee discount. Open →

How do webhooks work and how do I verify them?

When a sale settles, U.CASH Pay POSTs a JSON webhook to your store's webhook URL. Each webhook is HMAC-signed with an `X-Webhook-Signature: t=<timestamp>,v1=<hmac>` header (signed with your webhook secret). Verify the HMAC and check the timestamp is within 5 minutes to reject replays. The platform re-verifies the transaction against its own DB before crediting, so amounts/ids in the body are never trusted blindly. See https://pay.u.cash/docs/webhook-signing.md. Open →

Can each store have its own webhook URL and secret?

Yes. Each store in the multi-store table has its own webhook_url and webhook_secret columns, so different stores can deliver to different endpoints with different secrets. The legacy account-level webhook (keyed by the dedicated users.api_key) is still supported with store_id NULL as a global webhook, but the recommended setup is a per-store webhook.

Are U.CASH Pay webhooks signed, and how do I verify them?

Yes. When a payment confirms, U.CASH Pay posts JSON to your Webhook URL with an X-Webhook-Signature header of the form t=<unix-seconds>,v1=<hex-hmac-sha256>. The signature is an HMAC-SHA256 of the string "<t>.<raw-body>" keyed with your Webhook secret (shown in Settings then Webhook). To verify, parse t and v1, reject anything older than 5 minutes, recompute the HMAC over the raw body (not a re-encoded copy), and compare in constant time with hash_equals. Always return HTTP 200 once processed. Open →

How do I test my webhook endpoint from the dashboard?

Use the test-webhook action on a store in the dashboard. It sends a signed POST with a transaction body whose id is 'TEST' and a status of 'C' to the store's webhook_url, using the store's webhook_secret and a fresh event_id prefixed 'test_'. The dashboard reports the HTTP status code and a snippet of the response so you can confirm your endpoint accepts and verifies the signature.

Are passkeys supported for operator login?

Passwordless passkey login is live on the consumer portal (portal.u.cash), and the operator surface keeps independent hardened password login with TOTP as its second factor. The /payment/ operator console is deliberately not coupled to consumer SSO or consumer passkeys, so consumer credential changes do not affect operator access. Operator auth uses HttpOnly, server-set UXC_LOGIN, UXC_CLOUD, and UXC_SUPER cookies with a dedicated logout endpoint. Open →

What is step-up MFA for sensitive operations?

Credential-changing operations like rotating the API key or Cloud token are gated by a step-up challenge. If you have MFA enrolled and your last MFA verification is older than the sensitive-op window, you are bounced to a fresh challenge before the action runs. Users without MFA enrolled pass straight through. The SPA reads a stepup_required response and redirects to the challenge. This protects rotation and other high-impact actions without requiring MFA on every request. Open →

What is address generation and do I need it?

Address generation derives a fresh receive address for each order so payments are easier to tell apart. Options: BTC xpub (derive from your public key), Ethereum node derivation (needs an eth-node-url), Gemini deposit-address generation, or a custom explorer endpoint. Without it, the platform reuses your single address per coin and disambiguates simultaneous payments by giving each a tiny unique amount suffix. Open →

Why is the crypto amount sometimes slightly off-round?

When you use a single shared receive address for a coin (no address generation), the platform adds a tiny randomized suffix to the crypto amount so it can tell two simultaneous payments apart (e.g. 0.0015 instead of 0.0015 BTC). The fiat price you quoted is unaffected; only the on-chain crypto amount carries the disambiguator. Enable address generation to avoid this entirely.

Why is the operator console kept separate from SSO?

The /payment/ operator console is deliberately kept off the consumer single-sign-on (SSO) network. It uses its own host-only UXC_LOGIN cookie (AES-encrypted) plus cloud-token tenant resolution, and never trusts the consumer __Secure-ucash_sid cookie that is shared across the consumer apps. Coupling it to SSO would let any consumer-app session theft or XSS pivot to the operator console, which is the most privileged surface. The operator gate is independent password login with hardened timeouts. Open →

What are the operator session timeouts?

The operator UXC_LOGIN cookie enforces bank-style timeouts: a 30-minute idle (inactivity) window (UXC_LOGIN_IDLE), a 5-minute warning countdown before the idle window ends (UXC_LOGIN_WARN), and a 12-hour absolute session cap (UXC_LOGIN_TTL). A session unused for 30 minutes expires even under the absolute cap. The Super admin cookie is stricter at an 8-hour absolute cap (UXC_SUPER_TTL). Open →

How do I reach the Super admin console and what are its limits?

The Super admin console is at https://pay.u.cash/cloud/super.php. It is gated by the CLOUD_SUPER_EMAIL / CLOUD_SUPER_PASSWORD credentials in the platform config and an HttpOnly, server-set UXC_SUPER cookie. Its absolute session lifetime is stricter than the operator console (8 hours) because it can adjust every balance and edit platform config. It is the only surface that can edit the UCASH-holding premium tier ladder and view all customers, databases, and credit balances platform-wide. Open →

Can an AI agent pay a checkout?

Yes. On the send-payment screen, a 'Pay with your agent' button (gated by the merchant's 'Allow Agent Payments' setting) copies a `/id/?agent=1` link the buyer hands to an AI agent. The agent fetches it and gets a 402 Online Protocol payment manifest, then pays on-chain. AI agents are first-class merchants and buyers on pay.u.cash. See https://pay.u.cash/agents and https://agents.u.cash. Open →

What is the exact relayer for gasless USDC-on-Base settlement?

The exact relayer adds instant, gasless USDC-on-Base settlement. It is ON by default (opt-out): a stock x402 client pays gasless and the seller is billed gas plus a 21 percent margin per settle. POST /v1/exact-relay with enabled:0 or DELETE opts out to verify-only (buyer-pays-gas). GET returns the masked config and funding source. With the relayer on, a buyer signs an EIP-3009 authorization and the platform verifies and settles non-custodially without the buyer needing gas. Open →

Is there a REST API?

Yes. The API (`/api.php`, authenticated with `X-Api-Key` header or `api-key` param) exposes create-transaction, get-transaction, get-checkouts, save-checkout, get-balances, get-exchange-rates, refund, payment-link, validate-license-key, and raw btc/eth curl passthroughs. It returns structured JSON. See https://pay.u.cash/docs/API-DOCUMENTATION.md. Open →

How do agents discover what a merchant sells?

Public discovery docs are published at /.well-known/ucp (a UCP business profile), /catalog.json (schema.org Product JSON-LD for crawlers and LLMs), and /catalog.txt (a plain-text index). These are unauthenticated and let an agent or crawler enumerate a merchant's priced resources. Resolve the merchant context from their custom domain or a ?cloud=<merchant-token> parameter. Open →

What is the difference between an API key and a Cloud token?

An API key (users.api_key or stores.api_key) authenticates API and webhook requests; it is a secret you keep server-side. A Cloud token (users.token, surfaced as a UXC_CLOUD cookie or a cloud= parameter) is the publishable tenant identifier used by embeds and checkout links to resolve the tenant. The Cloud token is also the filename of the cloud/config/<token>.php config file. Because it is publishable, rotating it invalidates old embeds. Store cloud tokens (st_ prefix) are an opaque, rotation-proof variant. Open →

How does the UCASH-holding fee discount work?

Merchants who hold UCASH get a platform-fee discount based on their cached on-chain tier. Each UCASH tier in the ladder (editable by the super admin) carries a fee_discount between 0 and 1. The merchant's resolved discount comes from the highest tier their aggregate linked-wallet balance qualifies for. This discount is applied on top of the spend-tier feature unlocks; holding UCASH can both unlock premium features and reduce your per-transaction fee. Open →

Can customers pay by credit or debit card?

Yes, through your own Stripe, PayPal, or Verifone/2Checkout account. The buyer selects 'Credit or debit card' or 'PayPal', leaves the crypto checkout, and pays in fiat on the processor's page. The card fiat settles in your Stripe/PayPal account (minus their fees); U.CASH Pay then marks the order complete and fires the webhook. This is merchant fiat acceptance, not a consumer buy-crypto ramp. Open →

What is the difference between the cloud token and the API key?

Cloud token (publishable, `st_...` or the encrypted blob) is safe to put in buyer-facing URLs and embeds; it identifies your store to the checkout. API key (40-hex, secret) is a server-side credential for the REST API and must never be exposed in the browser. The checkout only ever reads the cloud token; the API key is used server-to-server.

How does the checkout show confirmation progress?

Once the on-chain transaction is detected, the screen switches to a confirming state showing `confirmations / minimum` (e.g. `2 / 3`) ticking up, with a 'Confirmed' badge when it crosses the threshold. The page polls every few seconds (Lightning every second) via the check-transactions endpoint.

How many confirmations are required?

Each coin has a configurable confirmation count (default 3), set per-coin under confirmations settings or carried by a custom token. A high-value transaction can require more: set a confirmations-increase-threshold (a USD fiat value) and the count multiplies by a percentage once a payment crosses it. A sale settles only once the on-chain transaction reaches the required confirmations.

Why is there a countdown timer on the checkout?

The countdown is the payment window for that order, set by the merchant's refresh-interval (default 30 minutes). When it hits zero the order is marked expired and the address is released back to the pool (so it can be reused for a new order). The timer exists because exchange rates fluctuate and addresses are recycled; it keeps the quoted amount valid.

What happens if my credit balance runs out?

If your balance cannot cover the fee for a sale, the platform blocks the payment with a friendly message ('This payment option is not available right now. Please contact the merchant.') and emails you. The transaction is not created, so the balance never goes negative. Top up to resume. Self-top-up links are exempt.

Does U.CASH Pay need a cron job?

The platform runs a per-minute cron (`uxc_cron`) that re-checks pending transactions for on-chain confirmation and credits any the buyer's browser poll missed. It is invoked via the API `cron` function. This ensures payments are credited even if the buyer closes the page before confirmation.

Can another merchant steal or overwrite my custom domain?

No. The custom_domains map is keyed by host and ownership-guarded. If the host is already in the map owned by a different tenant token, the claim is refused outright before any deprovisioning. Deprovisioning (clearing a domain) is gated on the map entry's decrypted token matching the account's token, so a merchant can only deprovision their own cert. This prevents both hijack (overwriting another tenant's entry) and destructive collisions.

How is SSL provisioned for a custom domain?

Custom-domain SSL uses Cloudflare for SaaS. When you set a domain, U.CASH Pay provisions a custom hostname on the u.cash zone via the Cloudflare API with the fallback origin set to pay.u.cash. Cloudflare issues the edge certificate using its default DCV method. The first 100 hostnames are free on the Cloudflare plan; the merchant is billed $0.50 per month from credit. You must CNAME your domain to pay.u.cash for DCV to succeed. Open →

Does the buyer need an account to pay?

No. The buyer does not need a U.CASH account. They open the payment link, pick a coin, and pay from their own wallet. Only the merchant has an account; the buyer is anonymous to the platform (the merchant can optionally collect customer details via custom fields).

Does U.CASH Pay keep a customer list?

Yes. When a buyer provides an email (at checkout or via custom fields), a customer record is created/updated in your tenant. The dashboard lists customers with their transaction history and (in the shop app) UCASH points. You can search and manage them. Customers belong to your merchant account only.

What does the merchant dashboard show?

The dashboard (admin.php) is the merchant home. It shows transactions, checkouts, balances, payouts, the AI Agents panel, the shop, the point-of-sale panel, landers, settings, staff, the audit log, and analytics. Each section is gated by the viewer's role permissions. If the account is an AI agent operator, the agent dashboard renders in place of the explainer. The dashboard loads via ajax and uses a loading-spinner pattern with a watchdog so a stuck render clears. Open →

How does U.CASH Pay detect an incoming payment?

The platform reads the blockchain via explorer APIs (Etherscan v2, Blockscout, Snowtrace, Tatum, Blockdaemon) and, for newer chains, direct RPC. It scans the receive address for incoming transfers matching the order amount, or follows a wallet-submitted hash. A per-minute cron and the buyer's browser poll both run; the first to confirm the transaction credits the sale and fires the webhook.

Can I offer discount codes?

Yes. In the Shop section create discount codes (percentage or fixed off, optional usage limits). Buyers enter the code at checkout; the platform validates it and applies the discount to the price before computing the crypto amount. Tied to the shop app.

What is the difference between the readable and encrypted checkout link?

Every checkout has two shareable /checkout/ links. The readable one uses the slug or numeric id (e.g. `/checkout/my-product`). The encrypted one is an opaque token (`/checkout/<encryption(id)>`) that hides the id but resolves to the same checkout. Both require the store's `?cloud=` token to load. Access is still gated by the cloud token, just like slug links.

Where do the exchange rates come from?

External-rate cryptos (BTC, ETH, etc.) come from Coinbase as the base feed; fiat cross-rates use Open Exchange Rates (cached hourly, overridable with your own OXR key). Custom tokens can carry a fixed rate or a `rate_url` the platform fetches. UCASH uses the platform's configured price (default $0.0021/UCASH). Rates are crypto-per-unit-of-fiat so the buyer sees the exact on-chain amount for the fiat price.

What happens when a checkout expires?

When the countdown hits zero, the order is marked expired and the receive address is released back to the address pool for reuse. The buyer sees an expired/failed screen and can start a fresh payment (a new address and rate quote). No funds are lost: if the buyer sends crypto after expiry, it still lands in your wallet, but the platform will not auto-match it to the expired order (handle manually).

Where can I see the on-chain transaction in a block explorer?

Each transaction has a TX hash and an explorer link (Etherscan/Snowtrace/Blockscout/etc., depending on the chain). In your dashboard the transaction detail shows a clickable explorer link to the on-chain transaction. The `get-explorer-link` ajax/API action returns it programmatically.

What happens if the buyer's on-chain transaction fails or reverts?

For EVM chains the platform reads the transaction receipt status; a failed/reverted transaction is detected and shown to the buyer as 'No payment' / 'The transaction failed on the blockchain. No funds were taken; please try again.' The row is left pending (not deleted) so the cron can re-check if it genuinely confirms later. Solana failed transactions are also detected.

What are the volume-based fee tiers?

Your fee rate is set by your total processed volume each month and drops automatically: $0-$99.99 = 0.50%, $100-$249.99 = 0.45%, $250-$499.99 = 0.40%, $500-$999.99 = 0.35%, $1,000-$2,499.99 = 0.30%, $2,500-$4,999.99 = 0.25%, $5,000+ = 0.20%. Minimum fee per transaction is $0.01. See https://pay.u.cash/pricing. Open →

How do fees work on U.CASH Pay?

The platform fee is a small percentage of your monthly transaction volume, tiered so it drops as you process more: 0.50% under $100/month down to 0.20% at $5,000+/month. The minimum fee per transaction is $0.01. It is debited from your prepaid credit balance when a sale settles, never taken out of the payment itself. There is no monthly fee, setup fee, per-seat charge, or payout fee. Network/miner fees are paid by the buyer on-chain as usual. See https://pay.u.cash/pricing. Open →

Can I charge a flat fee per transaction?

Yes. Flat Fee ($40 tier) adds a flat amount to every transaction on top of the percentage. Per-checkout fee override ($45 tier) sets a custom percentage and/or flat fee for a single checkout, overriding the global. These are added to the price the buyer pays; the platform fee itself is still debited from your credit balance. Open →

What are the funding tiers and what do they unlock?

Every dollar you load to run your account counts toward a lifetime total that permanently unlocks features: $5 Brand name, $10 Invoicing & tax/VAT, $15 Payment page logo, $20 Custom colors, $25 Custom CSS, $30 Checkout custom fields, $35 Required user details, $40 Flat per-transaction fee, $45 Per-checkout fee override, $50 Custom domain. The money stays as your prepaid balance for fees. See https://pay.u.cash/pricing. Open →

Who pays the network (miner/gas) fee?

The buyer pays the network/miner fee on-chain as usual for their wallet and coin. U.CASH Pay's platform fee is separate (a percentage of volume from your credit balance) and never touches the on-chain payment. The platform shows an estimated network fee on the checkout for transparency. Open →

What is a /payment/id/ link?

A /payment/id/<encrypted> link is the per-order payment page for a single transaction (used by Payment Requests, integrations like the WHMCS module, and credit top-ups). The id is a separate encryption of the transaction reference, not a decryptable cloud token. It shows the buyer the address screen, QR, and countdown for that specific order.

If a buyer clicks Pay twice, do they get charged twice?

No. Integrations can create transactions idempotently (the API/WHMCS module passes `idempotent`), so repeat Pay clicks for the same invoice reuse the existing pending order instead of creating duplicates. A single on-chain hash can also only be credited to at most one checkout (a replay guard blocks resubmitting a known hash against a new order).

What is the difference between a checkout, an invoice, and a payment request?

A checkout is a reusable payment page for a product/price (shown in your storefront or via a link). A payment request is a one-off link for a specific amount to a specific buyer (no product, optionally with an expiry). An invoice is the PDF tax document generated from a completed transaction with billing details. Payout Info Requests are a fourth type (reverse flow, type-4 transactions).

What if the buyer sends crypto just after the timer expired?

The crypto still lands in your wallet (it always does, direct to your address), but the platform will not auto-match it to the expired order. The funds are yours; handle it manually (refund the buyer, or recreate an order and mark it complete). Remind buyers to send within the countdown window.

Is the checkout available in multiple languages?

Yes. The checkout and admin support many languages via translation JSON files (auto-detected from the buyer's browser, or set per-store). You can also add custom translations in `translations.json`. See https://pay.u.cash/docs/languages.html. Open →

Can I sell digital goods with license keys?

Yes. With the Shop app, a checkout can carry a pool of license keys. On a completed payment the buyer is issued a key (and/or a downloads URL), shown on the confirmation screen and emailed. Cancelling the transaction revokes the unclaimed key. Common for software, game codes, and digital downloads.

Does U.CASH Pay support Bitcoin Lightning?

Yes. With a Lightning node connected (`ln-node-active`), buyers can pay a Bitcoin Lightning invoice. The platform creates a Lightning invoice, shows it as a QR, and polls the node; settlement is near-instant once the invoice is settled. This appears as a separate method alongside on-chain Bitcoin. See https://pay.u.cash/docs/lightning-network.html. Open →

How is a new merchant account provisioned?

Sign up is via the cloud registration flow. A new users row is created with an email, hashed password, a 40-character hex token, and an api_key, scoped to the current platform_domain. The tenant database, MySQL user, and config file (cloud/config/<token>.php) are provisioned by uxc_installation, which creates the four core tenant tables (checkouts, customers, settings, transactions). Provisioning is throttled per IP and idempotent (IF NOT EXISTS, race-guarded). For agent accounts the tenant database is created lazily on the first write. Open →

How is each merchant's data isolated?

Each merchant gets an isolated tenant database with its own MySQL user and credentials in cloud/config/<token>.php. The four core tables (checkouts, customers, settings, transactions) live in that database. The cloud (platform) database holds the users, stores, tenant_users, custom_domains, fee_history, and other shared tables. Queries use the right helper: db_* for the cloud connection, uxc_db_* for the tenant connection. Mixing them up queries the wrong database. Open →

Can a checkout accept multiple coins at once?

Yes. A checkout shows every coin you have a receive address for and that is marked active. The buyer picks any of them; the page converts your fiat price to that coin's exact crypto amount at the live rate and proceeds. You can also denominate a checkout in a single crypto if you only want one.

Can I have multiple stores under one account?

A merchant can run several stores under one account. Each store has its own label, api_key, cloud_token, webhook_url, and webhook_secret in the stores table. Stores share the merchant's tenant database but are isolated by store_id filters in queries. A merchant with exactly one store is auto-scoped to it; with zero or multiple stores the account-level context applies unless a store token is used. You create, edit, and delete stores from the dashboard.

How does store-scoped data isolation work?

When a request authenticates with a per-store api_key or a store cloud_token, the store_id is resolved and applied as a filter (uxc_store_id_filter) to store-aware queries, so a store only sees its own transactions, checkouts, and customers. Account-level authentication (the legacy users.api_key) leaves store_id NULL and behaves as a global webhook across all the merchant's stores. Store-scoped cloud tokens are generated for a specific store_id to guarantee the link resolves under the per-store isolation filter.

Do I need to run my own blockchain node?

No. Payment detection works via explorer APIs by default, so no node is required. Running your own BTC node (with xpub) or Ethereum node unlocks extras: address generation, node-based refunds, and (for ENS resolution) your own ETH RPC. Nodes are optional enhancements, not a requirement. See https://pay.u.cash/docs/nodes.html. Open →

Does U.CASH Pay connect to my bank account?

No. There is no crypto-to-bank off-ramp on pay.u.cash. Funds settle to your crypto wallet directly. For consumer buy/sell crypto (an automated MoonPay/Transak-style ramp), use swap.u.cash or buy.u.cash. pay.u.cash's fiat story is merchant card acceptance (Stripe/PayPal) and the human Converter / Payout Info Request flow.

What happens if the buyer sends too much?

An overpayment within tolerance is treated as a normal completion (the buyer simply sent a bit more). The platform credits the sale at the expected amount; the excess remains in your receive wallet as it landed. The buyer is not automatically refunded the difference unless you issue a manual refund.

Can a buyer pay in multiple transactions or partially?

The checkout expects a single payment of the exact amount. Sending less is treated as an underpayment (status X). To pay in parts, the buyer should contact the merchant to split the order into separate links. Sending more (within tolerance) completes normally.

Can a payment request stay open longer than the timer?

Yes. A Payment Request (the no-product link) never expires by default. You can optionally set a per-request expiry: 15 minutes, 1 hour, 24 hours, 7 days, or 30 days. Real-checkout payments (a buyer actively paying) still use the refresh-interval timer, but a standalone request link can stay payable for days.

How are POS registers (terminals) billed?

Each master account gets 1 register included free. Each additional register is a one-time $25 purchase (uxc_pos_terminal_price) from the credit balance. Slots are reusable: removing a register frees the slot, so a remove and re-add never double-charges. Removing a register is refused if it has an active sale. Existing registers are grandfathered so pre-existing terminals are never charged retroactively. Open →

Does the checkout show a QR code?

Yes. Once the buyer picks a coin, the address screen renders a QR code encoding the coin URI (e.g. `bitcoin:address?amount=...` or `ethereum:address?amount=...`) so a mobile wallet can scan and pay the exact amount. A copy-address button and a deep link are beside it.

Does U.CASH Pay screen sanctioned addresses?

The platform includes a lightweight OFAC sanctioned-address screen for receive addresses. It checks your configured receive wallet against Treasury's published sanctioned digital-currency-address list (in `lib/sanctioned-addresses.txt`, refreshed periodically). Because the platform is non-custodial and holds no balances, this is near-free insurance rather than mandatory party-wide screening; no name/email screening is performed.

Which package registries ship U.CASH Pay SDKs?

U.CASH Pay SDKs ship on npm (JavaScript) and PyPI (Python), with additional language SDKs build-ready for Go, Rust, Elixir, Java (Maven Central), and others. The awesome-ucash GitHub repo is the full catalog of 125-plus plugins, SDKs, and integrations. Each UdotCASH repo carries a description, homepage, and standard topics (ucash, crypto-payments, non-custodial, payment-gateway, web3, defi, bitcoin, ethereum, agents, http-402, mcp). Open →

Where are merchant settings stored, and what is the difference between the blob and standalone rows?

The tenant settings table has two unrelated stores. The 'settings' blob row is an encrypted JSON object read by uxc_settings_get(key); it holds merchant-configured keys like receive addresses and is written wholesale by the settings save flow. Standalone rows (one row per name, like credit_balance) are read and written by uxc_settings_db(name, value). The two do not reconcile: writing a standalone row that the blob reader never sees silently returns false. New programmatic settings should use standalone rows, never mutate the encrypted blob.

Are my settings and keys encrypted?

Merchant settings are stored encrypted, and cloud/session tokens use AES-256-GCM. The platform never generates or stores your private keys; you connect wallets and nodes you already control. Settlement webhooks are HMAC-signed so you can verify them, and URL inputs are checked for unsafe redirects. Open →

How does the dashboard decide which nav sections a staff member sees?

uxc_allowed_nav() maps each nav section to a permission and emits only the sections the current role can access: transactions requires transactions.view, checkouts requires checkouts.view, balances and analytics require financials.view, payouts requires payouts.create, point-of-sale requires pos.manage, landers requires landers.view, settings requires settings.edit, staff requires users.manage, and audit requires audit.view. The owner sees everything. The list is also emitted to the browser as window.UXC_NAV.

Can I integrate U.CASH Pay with Shopify?

Yes, U.CASH Pay can be wired into Shopify as a manual/alternative payment method using your store's cloud token and webhook. See the integration guide at https://pay.u.cash/docs/shopify.html for the exact setup (payment provider configuration + webhook signing). Open →

How are staff seats billed?

Each role has a one-time seat price charged from the merchant's prepaid credit balance when no free slot exists for that role: clerk $6, designer $6, lead $8, teller $9, auditor $9, supervisor $10, manager $12, accountant $12, director $13, officer $14, admin $15, master-admin $16, custom $15. Slots are reusable: removing a staff member frees the slot, so a remove and re-add never double-charges. There is no recurring billing, only the one-time purchase recorded in fee_history. Open →

What is a store Cloud token (the st_ prefix), and why is it rotation-proof?

Store cloud tokens are opaque strings prefixed st_ (for example st_<hex>). They live in the stores.cloud_token column and resolve to the store via a direct database lookup, decoupled from the merchant's publishable users.token. Because the lookup is by the opaque string and not the merchant token, rotating the merchant's Cloud token does NOT break existing store embeds or checkout links that use the st_ token. Rotate a store token with cycle-store-cloud-token if a specific store's token leaks.

Which coins and chains does U.CASH Pay support?

Built-in coins include Bitcoin (+ Lightning), Ethereum and ERC-20s, USDT and USDC across their networks, Solana, Tron, XRP, Monero, Litecoin, Bitcoin Cash, Dogecoin, TON, Algorand, Stellar, Tezos, Polkadot, Polygon, Avalanche, BNB, Arbitrum, Optimism, Base, Chainlink, BAT, and UCASH, plus newer L2s (Linea, Mantle, Berachain, Sonic, Unichain, Worldchain, Monad, Plasma, Abstract, HyperEVM, Scroll, Ink). You can also add any custom token (ERC-20 / BEP-20 / Base-20 / Polygon-20 / Arbitrum-20 / OP-20 / Avax-20 / TRC-20 / SPL / TON Jetton style). Card payments run through your own Stripe, PayPal, or Verifone account. Open →

How are merchant accounts isolated from each other?

Each merchant account connects to the database as its own limited MySQL user granted only on its own database, so MySQL itself forbids cross-merchant access. Isolation is database-enforced, not just app-layer. A missed store-token resolution fails closed (no database credentials = no connection). Open →

How do spend tiers unlock premium features?

Premium features unlock in a ladder based on a merchant's lifetime Add-Funds top-ups: Brand Name at $5, Invoicing and Tax at $10, Payment Page Logo at $15, Colors at $20, Custom CSS at $25, Checkout Custom Fields at $30, User Details at $35, Flat Fee at $40, Checkout Flat Fee at $45, and Custom Domain at $50. Each tier unlocks one or more setting ids. Reach the threshold in cumulative top-ups and the feature is unlocked permanently for that path. Open →

Can I unlock premium features by holding UCASH instead of spending?

Yes. There is a second unlock path based on your cached on-chain UCASH holdings. The UCASH tier ladder (editable by the super admin) maps holding balances to tiers, and the top UCASH tier unlocks all spend-tier features. Lower UCASH tiers scale proportionally (a tier halfway up the ladder unlocks about half the spend features). Holding UCASH also grants a platform-fee discount per the tier's fee_discount. You link a wallet by signing a nonce with MetaMask to prove ownership; the tier is resolved from the sum of all linked wallets. Open →

What do the transaction statuses mean?

Pending (P) = created, waiting for an on-chain payment. Completed (C) = the on-chain payment reached the required confirmations and the sale settled. Cancelled/Expired (X for underpayment; expired/cancelled rows are removed) = the order was cancelled, the timer ran out, or (status X) the buyer underpaid beyond the allowed tolerance. Failed/reverted EVM transactions are detected and shown as 'No payment'.

What happens if the buyer sends too little (underpayment)?

If the received amount is less than expected beyond a small tolerance (more than 0.1% difference), the transaction is marked underpaid (status X) rather than completed. The buyer sees an underpayment notice. The merchant can then handle it manually (contact the buyer, refund if a method is enabled, or accept the partial amount). Exact-match or within-tolerance payments complete normally. See https://pay.u.cash/docs/underpayments.html. Open →

Does U.CASH Pay handle VAT or sales tax?

Yes. With the Invoicing tier you can enable VAT/Tax at checkout. The platform calculates tax by country code, validates EU VAT numbers (so B2B EU buyers can be zero-rated), and records the tax line on the transaction and invoice. Configure rates and the VAT-number validation endpoint in settings. See https://pay.u.cash/docs/vat.html. Open →

Can customers pay with MetaMask, TronLink, or Phantom?

Yes. When the buyer has a compatible wallet extension, a one-tap button appears: MetaMask for EVM coins, TronLink for TRX/TRC-20, Phantom for Solana/SPL, and TON Keeper for TON. The button submits the transaction hash to the platform, which then confirms that exact on-chain transaction (instant detection, even before the address scan catches it).

Can buyers or payees use ENS, Unstoppable Domains, or FIO names?

Yes. Wherever a wallet address is taken (receive address config, payout info form, payout to a payee), users can enter a human-readable name: ENS (`*.eth`), Unstoppable Domains (`name.tld`), or FIO (`name@domain`). The platform resolves it to the on-chain address (ENS via its own ETH RPC, UD via the UD API, FIO via public FIO nodes) and validates the result. Unresolved names fall back to the raw value.

What is the 'key' field in the webhook body, and is it safe?

The request body still includes a 'key' field containing the Webhook secret, but it is deprecated. Relying on it is insecure because it places the secret in every request body. Migrate to signature verification (the X-Webhook-Signature header). The 'key' field is kept only to satisfy the entry gate and will be removed in a future release. Open →

How are webhooks protected against replay attacks?

Two mechanisms. First, the signature carries a timestamp (t=) and signatures older than 5 minutes are rejected as stale. Second, every event includes a 32-character hex event_id (also sent in the X-Webhook-Event-Id header) that you must use to deduplicate: the same confirmed transaction may be delivered more than once, so store event_id and treat repeats as no-ops. The static-key fallback was dropped, so signature verification is now required. Open →

Does U.CASH Pay deliver webhooks over HTTPS only?

Yes. U.CASH Pay only delivers to https:// endpoints on public hosts. Plain http:// or internal and private addresses are rejected. Use the raw request body for signature verification, not a re-encoded copy, because re-encoding JSON can change byte order or whitespace and break the signature. Open →

How does the platform know which tenant a branded domain belongs to?

Branded domains are mapped in a settings.custom_domains entry (the value is an encrypted JSON blob of token and user_id). When a request arrives on an unmatched host, the domain-rewrite loader looks up the host in that map, sets the UXC_CLOUD cookie to the resolved tenant token, and requires the tenant config file at cloud/config/<token>.php, which selects the right tenant database. This makes payment/ a single shared docroot that is domain-routed, not a per-brand clone.

Can I restrict which addresses the platform will accept payments to?

Yes. A whitelist setting restricts receive addresses to a known set; if a resolved address is not on the whitelist, the transaction is rejected with `whitelist-invalid` and not created. This is a defense against misconfiguration (e.g. a stale or wrong address) before showing it to a buyer.

Is there a WHMCS payment gateway module?

Yes. The community WHMCS module (`ucashpay-whmcs`) lets a WHMCS store accept crypto via U.CASH Pay. Each gateway instance is configured per-store with a cloud token and webhook secret, includes a 'Test Connection' button, and uses innocuous `inv-<invoiceid>` checkout ids with idempotent order creation. The receiver validates the `X-Webhook-Signature` HMAC and calls `addInvoicePayment` on settlement.

Is there a setup fee or monthly subscription?

No. There is no setup fee, no monthly fee, no per-seat charge, and no payout fee. You only pay the platform fee (a small percentage of monthly volume, debited from a prepaid balance you top up). Top up the balance whenever you like; it is your operating funds, not a subscription. Open →

What is the difference between swap, buy, and convert?

On U.CASH these are three related but distinct things. swap.u.cash is the general exchange: swap any token for any other token across many chains. buy.u.cash is the focused Buy UCASH page: the same engine with UCASH locked as the output for a one-step buy. Converters are a pay.u.cash concept: retail merchants who use pay.u.cash payment links to help customers move between cash and crypto, a human-assisted on- and off-ramp rather than a self-service DEX. If you want to swap tokens yourself, use swap.u.cash; to buy UCASH specifically, use buy.u.cash. Open →

What is buy.u.cash?

buy.u.cash is a focused app for buying UCASH, the U.CASH network token. You pay with any token and UCASH is delivered to your wallet in one non-custodial transaction at the market price. It is powered by the swap.u.cash engine but locks UCASH as the output so you do not have to configure the receive side yourself. Open →

What is the DEX aggregator mode?

The aggregator mode is the non-custodial DEX swap. It routes your trade across on-chain decentralized exchanges to find the best rate. On EVM chains it uses the EVM DEXs protocol (which already includes RFQ market-maker pricing in addition to AMM pools); on Solana it uses Solana DEXs; for cross-chain swaps between different chains it uses cross-chain bridges to bridge. Your wallet signs the on-chain transaction directly and the swap settles against the underlying liquidity pools, so no intermediary ever holds your funds. Open →

What is the instant-exchange mode?

Instant mode is for coins the non-custodial DEX cannot reach, like Bitcoin, Litecoin, XRP, TRX, and Dogecoin. It shops three custodial partner services (a vetted exchange partner, a vetted exchange partner, and a vetted exchange partner), ranks their offers by the best output amount, and lets you pick one. You send funds to a deposit address the partner issues and the partner pays out to your destination address. swap.u.cash acts only as an introducer and never holds your funds; the partner handles custody, payout, and KYC. Open →

Is swap.u.cash part of U.CASH?

Yes. swap.u.cash is the U.CASH exchange, one of the U.CASH product apps alongside pay.u.cash, buy.u.cash, names.u.cash, agents.u.cash, and others. It is the swap and exchange surface of the U.CASH platform. Open →

What is the reserve swap?

The reserve swap is the classic U.CASH swap, served at swap.u.cash/reserve.html. Use the mode toggle on the homepage to switch to it. The DEX aggregator and instant-exchange modes are the primary swap paths. Open →

What are the swap modes on swap.u.cash?

swap.u.cash has three modes. (1) Aggregator: a non-custodial DEX aggregator that finds the best on-chain route for token-to-token swaps across 19 EVM chains and Solana. (2) Instant: an instant-exchange mode that shops custodial partner services (vetted exchange partners) to cover Bitcoin and roughly 1,500 coins the DEX rails cannot reach. (3) Reserve: the classic reserve swap. Switch between them with the mode toggle on the homepage. Open →

What is swap.u.cash?

swap.u.cash is the U.CASH exchange. It is a non-custodial multi-chain swap app that lets you exchange one cryptocurrency for another. It combines three modes: a DEX aggregator that routes your trade across on-chain liquidity pools, an instant-exchange mode that shops custodial partner services for coins the DEX cannot reach, and a reserve swap. You connect your own wallet, your wallet signs every transaction, and funds never leave your control. Open →

Can I buy UCASH on Ethereum and receive it on Base or Polygon in one transaction?

Yes. When you pay from Ethereum, buy.u.cash can buy UCASH and bridge it to Base or Polygon in a single transaction using a non-custodial bridge router contract. The router buys UCASH on Ethereum through the DEX and then deposits it across the canonical L1-to-L2 bridge to your address, so you get UCASH on your chosen L2 without a separate bridging step. Select your destination (Ethereum, Base, or Polygon) in the destination selector. Open →

Who pays gas when buying UCASH?

You pay gas from your own wallet in the native coin of the chain you pay from (ETH on Ethereum, etc.), because the buy is a non-custodial DEX swap. If your buy crosses chains (for example paying on Base to receive UCASH bridged to Ethereum) you only pay gas on the source chain; the bridge handles destination-chain costs. Open →

How does buy.u.cash work?

Connect your wallet, choose the token and chain you want to pay with, enter an amount, and buy.u.cash quotes how much UCASH you will receive at the current market rate. UCASH is locked as the output token. When you confirm, your wallet signs a single on-chain swap and UCASH is sent to your wallet. There is no contract you have to interact with separately and no admin-set price; the rate comes from live on-chain liquidity. Open →

What can I pay with to buy UCASH?

You can pay with any token supported on the swap.u.cash aggregator, including ETH, USDC, USDT, and thousands of other ERC-20 tokens across the supported EVM chains, plus SOL and SPL tokens on Solana. Choose your source token and chain, enter an amount, and the page quotes the UCASH you will receive. UCASH is delivered to your wallet in one transaction. Open →

Should I use buy.u.cash or swap.u.cash?

Use buy.u.cash if your goal is simply to acquire UCASH: the output is locked to UCASH so it is a one-step buy. Use swap.u.cash if you want to swap between arbitrary tokens, explore rates, or use the instant-exchange mode for coins like Bitcoin. buy.u.cash is the simpler, focused path; swap.u.cash is the full exchange. Open →

Which wallets can I use to buy UCASH?

You can use any EVM wallet (such as MetaMask or Coinbase Wallet) to pay from an EVM chain, or a Solana wallet (such as Phantom or Solflare) when paying from Solana. buy.u.cash reuses the swap.u.cash wallet connection layer. Open →

Can I swap Bitcoin on swap.u.cash?

Yes, via the instant-exchange mode. Bitcoin cannot be swapped non-custodially through EVM or Solana DEX rails, so BTC pairs go through the partner services (vetted exchange partners). You send BTC to a partner deposit address and receive your chosen coin at a destination address. The partners rank their offers so you can pick the best rate. The DEX aggregator itself does not handle native Bitcoin. Open →

Can the destination address be different from my connected wallet?

Yes. For cross-chain swaps the destination is decoupled from the source wallet: your source wallet signs the source-chain transaction, and you can specify any valid destination address on the destination chain. This also enables swaps between different wallet families, for example swapping from an EVM wallet to a Solana address. For same-chain swaps the destination defaults to your connected wallet. Open →

Who pays gas on a swap?

You pay gas (network fees) from your own wallet, in the native coin of the source chain. EVM swaps cost gas in ETH (or the chain's native token) on the source chain; Solana swaps cost gas in SOL. swap.u.cash does not pay gas for you because it is non-custodial and never holds your funds. Gas estimates are returned per quote. Cross-chain swaps only require gas on the source chain; the bridge covers destination-chain costs. Open →

How does a DEX swap execute and who signs it?

In aggregator mode you connect your wallet (for example MetaMask), enter the pair and amount, and approve the swap. Your wallet signs the on-chain transaction and submits it to the network. For ERC-20 token sells the per-swap permission is an off-chain Permit2 signature, so the swap is one on-chain transaction after a one-time approval. For native coin (ETH) sells a non-custodial router contract wraps and swaps in one transaction. Funds move directly from your address to the destination through the on-chain liquidity route; swap.u.cash never takes custody. Open →

How do I make a swap on swap.u.cash?

Go to swap.u.cash, choose Aggregator or Instant mode, select the coin you are sending and the coin you want, enter the amount, and connect your wallet (for aggregator mode). Review the quoted rate and the 0.30% fee, then confirm. In aggregator mode your wallet signs the on-chain transaction. In instant mode choose an offer, enter your destination address, confirm, and send your coins to the deposit address the partner shows you. Open →

Can I use instant-exchange without a browser wallet?

Yes. The instant-exchange mode does not require a wallet extension. You enter the coin and amount you want to send, choose the best partner offer, and provide a destination address (and optionally a refund address). The partner issues you a deposit address; you send your coins there from any wallet or exchange, and the partner pays out the destination coin to your address. This is how swap.u.cash covers coins and users that the non-custodial DEX cannot. Open →

What is the refund address in instant-exchange for?

For non-EVM coins in instant-exchange mode (such as BTC, LTC, XRP, TRX, DOGE) you can optionally provide a refund address on the same network. If a swap fails or is underpaid and the partner has to return funds, the partner sends them to this refund address. For EVM coins the refund reliably goes back to the sender, so the field is hidden there. It is optional but recommended for UTXO and account-model coins where a sender refund is otherwise ambiguous. Open →

How do cross-chain swaps work?

When you swap a token on one chain for a token on a different chain, swap.u.cash routes the trade through cross-chain bridges, a cross-chain bridging aggregator. cross-chain bridges picks a bridge (such as Across or deBridge) and handles the source-chain transaction plus the destination-chain payout. You sign one transaction on the source chain, and the destination coin arrives at an address you specify on the destination chain. Cross-chain swaps take longer than same-chain swaps because they wait for the bridge to finalize. Open →

Is there a minimum amount for an instant swap?

Yes. Each partner sets a minimum amount per pair. When you enter an amount in instant-exchange mode, swap.u.cash shows and enforces the partner minimum, so if your amount is too low you will see the minimum required for that pair before you confirm. DEX aggregator swaps are limited only by on-chain liquidity and gas cost. Open →

Where can I see my past swaps?

Your swaps are recorded and viewable on the My Swaps page. DEX aggregator swaps are logged when they execute, and instant-exchange swaps are tracked from deposit through payout with live status. Note that because the DEX is non-custodial, the on-chain transaction in your wallet is the definitive record; the My Swaps page is a convenience view. Open →

Do I have to approve a token every time I swap?

No. With Permit2 you approve each ERC-20 token to the Permit2 contract once, and after that each swap of that token is a single signed transaction (the per-swap authorization is an off-chain signature, not an on-chain tx). For a brand-new token the first swap is two transactions (one approval, one swap); subsequent swaps of the same token are one transaction. Native coin sells are a single transaction via a non-custodial router. Open →

Which wallets can I use with swap.u.cash?

For EVM chains you can use any injected EVM wallet, including MetaMask and Coinbase Wallet. For Solana you can use Phantom or Solflare (and other Solana wallets via the wallet standard). The instant-exchange mode does not require a wallet extension at all because you send to a deposit address and receive at a destination address you provide. Open →

How do I find a token to swap?

Use the token search in the swap panel. Popular tokens are listed by default; you can also search by symbol or name. If a token is not listed you can paste its contract address directly. Always verify the contract address against the project's official source before swapping, because anyone can deploy a token with a given symbol. Open →

What happens if I buy UCASH from a chain with no UCASH liquidity?

Because UCASH DEX liquidity is concentrated on Ethereum, when you pay from a chain like Base or Polygon buy.u.cash performs a cross-chain swap: it trades your token for UCASH on Ethereum (where the liquidity is) and bridges the UCASH to your wallet on the destination chain. The page shows a cross-chain badge and the destination address so you know where the UCASH will arrive. Open →

What fee does buy.u.cash charge?

buy.u.cash uses the same flat 0.30% swap fee as swap.u.cash, since it routes through the same DEX engine. The fee is taken from the swap output. There is no separate buy fee on top. Open →

Is buy.u.cash live?

Yes, buy.u.cash is live. It is a static single-page app that routes through swap.u.cash for quotes and execution. You can connect a wallet and buy UCASH at market price with any supported token. Open →

How is the UCASH price determined on buy.u.cash?

The price comes from live on-chain DEX liquidity, routed through the swap.u.cash engine. There is no admin-set sale price and no fixed rate. When you enter an amount you get a real executable quote for the UCASH you will receive, and the 0.30% swap fee applies the same as on swap.u.cash. Because it is a market-priced DEX swap, the rate moves with liquidity. Open →

Do I need to interact with a sale contract to buy UCASH?

No. There is no UCASH sale vault, claim contract, or admin-priced sale mechanism on buy.u.cash. Buying UCASH is a standard non-custodial DEX swap routed through on-chain liquidity: your wallet signs one swap transaction and UCASH is delivered to you. Earlier vault and claim-contract approaches were abandoned in favor of the simpler, market-priced DEX model. Open →

Is buy.u.cash non-custodial?

Yes. buy.u.cash is non-custodial. Your wallet signs the swap transaction and UCASH is delivered directly to your address by the on-chain liquidity route. buy.u.cash never holds your funds and there is no U.CASH custody account. It routes through the swap.u.cash DEX engine, which is itself non-custodial. Open →

What are the UCASH contract addresses?

UCASH is an ERC-20 token (8 decimals) deployed on three networks. Ethereum: 0x92e52a1a235d9a103d970901066ce910aacefd37. Polygon: 0xa94880d3a4b39746e90cdb57f8de3732c984de14. Base: 0x26cf750abaf38af7109effdbdf79ba50d2ee09a1. Always verify an address against the official source before sending funds. Open →

Which chains can I buy UCASH on?

UCASH lives on Ethereum, Polygon, and Base. Real DEX liquidity for UCASH is deepest on Ethereum, so when you pay on another chain buy.u.cash automatically bridges your UCASH to Ethereum or to your chosen destination via the cross-chain bridge. You can also bridge UCASH to Base or Polygon in the same buy transaction using the destination selector when paying from Ethereum. Open →

Why is UCASH locked as the output on buy.u.cash?

buy.u.cash is a dedicated Buy UCASH page. Locking UCASH as the output means the receive side is fixed, the invert button is hidden, and you cannot accidentally select a different receive token. It turns the general-purpose swap engine into a one-step buy flow: pick what you pay with, confirm, and UCASH arrives. For arbitrary token-to-token swaps use swap.u.cash instead. Open →

What is EVM DEXs and what does it do on swap.u.cash?

EVM DEXs is a DEX aggregation protocol. On swap.u.cash the EVM aggregator uses the EVM DEXs Swap API to find the best on-chain route for token swaps. EVM DEXs already combines automated market-maker liquidity with RFQ (request-for-quote) market-maker pricing, which often beats pure AMM routing. swap.u.cash holds its EVM DEXs API key server-side and injects its affiliate fee into the quote; your wallet executes the returned calldata directly against the the DEX settler contract. Open →

Why might a chain route through a different aggregator?

On a few EVM chains the primary DEX protocol may not return liquidity for our key at a given time. swap.u.cash automatically falls back to cross-chain bridges same-chain routing for those chains so you still get a quote and a working swap. This fallback is automatic and heals itself if the primary protocol re-enables the chain. From your perspective the swap just works; the routing happens behind the scenes. Open →

What fee does swap.u.cash charge?

swap.u.cash charges a flat 0.30% fee on DEX aggregator swaps (30 basis points), taken from the swap output. For Solana and cross-chain swaps the fee is applied via the underlying aggregator's fee mechanism. In instant-exchange mode swap.u.cash adds no extra markup on top of the partner rate; revenue comes from the affiliate commission paid by the partner, not an added user fee. Open →

Does instant-exchange add a markup on top of the partner rate?

No. In instant-exchange mode swap.u.cash applies zero extra markup to the partner's rate. The rate you see is the partner's rate, and swap.u.cash earns an affiliate commission from the partner rather than adding a fee on top. This is the introducer posture: the partner is the service provider and swap.u.cash simply ranks the partners' offers for the best payout. Open →

Which instant-exchange partners does swap.u.cash use?

The instant-exchange mode shops three custodial partner services: a vetted exchange partner, a vetted exchange partner, and a vetted exchange partner. When you request an instant swap, swap.u.cash fetches a quote from each available partner for your pair and ranks them by the best output amount, so you can pick the offer that pays out the most. swap.u.cash is an introducer (affiliate) for these partners and does not custody funds itself. Open →

How do Solana swaps work on swap.u.cash?

Same-chain Solana swaps use Solana DEXs, the Solana DEX aggregator. You connect a Solana wallet such as Phantom or Solflare, and your wallet signs the Solana transaction. Solana DEXs routes across Solana liquidity pools to find the best rate. An affiliate fee is applied via Solana DEXs's platform-fee mechanism. Cross-chain swaps that start or end on Solana are bridged via cross-chain bridges instead. Open →

Does swap.u.cash require KYC?

The DEX aggregator mode is non-custodial and requires no KYC because no intermediary holds your funds. The instant-exchange mode is operated by partner services (vetted exchange partners) which are regulated VASPs and may apply KYC or AML checks depending on the pair, amount, and your jurisdiction. swap.u.cash forwards your real IP address to the partner so KYC and geo checks apply to the actual user, not to swap.u.cash. swap.u.cash itself is only an introducer and does not perform KYC. Open →

Why are native ETH swaps only one transaction?

The underlying DEX protocol spends wrapped native tokens, not raw ETH, which would normally require a wrap, an approval, and a swap (three transactions). swap.u.cash deploys a non-custodial router contract called UcashNativeRouter that wraps your ETH, approves the spender, and executes the swap in a single transaction, forwarding the output straight back to you. The router holds no funds and has no owner. Its address is listed on the Networks page. Open →

Where can I see the supported networks and contract addresses?

The Networks and Contracts page at swap.u.cash/networks/ lists every supported network, the deployed non-custodial contract addresses (the Permit2 allowance contract and the UcashNativeRouter used for one-transaction native-coin sells), and which chain each applies to. It also documents that Solana uses Solana DEXs and that ERC-20 sells use Permit2. It is the transparency page for the DEX. Open →

What does non-custodial mean for swaps?

Non-custodial means swap.u.cash never holds your cryptocurrency. In aggregator mode your own wallet signs every transaction and the trade settles directly on-chain against liquidity pools, so funds move from your address to the destination you choose without passing through any U.CASH-controlled wallet. There is no U.CASH account that stores your balance and nothing to be hacked or frozen. The instant-exchange mode is different: there a partner service (a vetted exchange partner, a vetted exchange partner, or a vetted exchange partner) takes temporary custody of your deposit before paying out, which is why that mode is labeled separately. Open →

What is Permit2 and why does swap.u.cash use it?

Permit2 is a token-approval mechanism that lets you authorize a swap with an off-chain signature instead of a separate on-chain approval transaction. swap.u.cash uses Permit2 (the contract at 0x000000000022D473030F116dDEE9F6b43AC78BA3) for ERC-20 token sells so that, after a single one-time approval to Permit2, future token swaps collapse to a single signed transaction. If you have used other apps that rely on Permit2 (such as Uniswap), you may need zero approval transactions. Native coin (ETH) sells use a non-custodial router contract instead. Open →

How does swap.u.cash find the best price?

Each mode finds price differently. The DEX aggregator asks EVM DEXs or Solana DEXs, which each split and route your trade across many liquidity pools and, for EVM DEXs, also solicit RFQ market-maker quotes to find the best net rate. The instant-exchange mode fetches live estimates from a vetted exchange partner, a vetted exchange partner, and a vetted exchange partner and ranks them so you can choose the highest payout. Cross-chain swaps route through cross-chain bridges which compares bridges. The displayed rate is the real executable quote, not an estimate. Open →

Does a swap quote expire?

Yes. Firm DEX quotes from the underlying protocols expire quickly (on the order of tens of seconds) because on-chain prices move. For swaps that need several steps (for example wrapping ETH before swapping) swap.u.cash fetches a fresh quote immediately before you submit, so the rate you confirm reflects current market conditions. If a quote has expired by the time you confirm, re-fetch it. Open →

What is slippage and how does swap.u.cash handle it?

Slippage is the difference between the quoted price and the price your transaction actually gets when it lands on-chain, caused by liquidity moving between quote and execution. swap.u.cash protects you with a minimum-output check: every swap is quoted with a minimum buy amount, and if on-chain execution would return less than that minimum the transaction reverts so you keep your funds. The EVM DEXs protocol returns chain-specific slippage parameters per quote. Open →

Which blockchains does swap.u.cash support?

The DEX aggregator supports 19 EVM chains plus Solana. The EVM chains are Ethereum, Polygon, Arbitrum, Optimism, Base, BNB Chain, Avalanche, Linea, Scroll, Mantle, Berachain, Monad, Plasma, World Chain, Unichain, Ink, Sonic, Abstract, and HyperEVM. Solana is supported for same-chain swaps via Solana DEXs. Cross-chain swaps between any of these are bridged via cross-chain bridges. The full live list is on the Networks page. Open →

How many coins can I swap?

Through the instant-exchange mode you can reach roughly 1,500 coins across Bitcoin, Ethereum, Litecoin, XRP, TRX, Dogecoin, and many more (the partner services a vetted exchange partner, a vetted exchange partner, and a vetted exchange partner cover a merged universe of about 1,500 coins). Through the DEX aggregator you can swap any token that has liquidity on the supported EVM chains and Solana, including thousands of ERC-20 and SPL tokens. Together the two modes cover far more than either could alone. Open →

Where are the swap.u.cash terms of service?

The swap.u.cash terms are at swap.u.cash/terms/. They include the non-custodial disclaimer: swap.u.cash does not custody your funds in aggregator mode, swaps are executed against on-chain contracts and bridges that carry their own risk, transactions are irreversible, and nothing on the site is financial advice. Read them before swapping. Open →

Why are the aggregator and instant modes different on custody?

In aggregator mode the swap is fully non-custodial: your wallet signs on-chain and no intermediary holds funds. In instant mode the swap is partner-custodial: you send coins to a deposit address issued by the partner (a vetted exchange partner, a vetted exchange partner, or a vetted exchange partner), and that partner holds the deposit and pays out your destination coin. swap.u.cash is only an introducer in instant mode and never touches the funds. The two are separated because coins like Bitcoin cannot be swapped non-custodially through EVM/Solana DEX rails. Open →

When is the @u handle coming?

The @u handle is on the roadmap. U.CASH Names is integrating FIO Protocol so every .u can come with a matching @u handle. There is no fixed launch date yet; reserving your .u now means your matching @u will follow when the integration ships. Open →

What is the difference between a .u domain and an @u handle?

A .u domain (like yourname.u) is a blockchain domain you own as an NFT on Base, used for identity, login, decentralized websites, and crypto payments. An @u handle (like yourname@u) is a FIO Protocol name that pairs with your .u so anyone can send to you across wallets by a human-readable handle, with no address copy-pasting. The .u is live now; the @u handle is on the roadmap and being integrated via FIO Protocol. Open →

Can I use my .u to log in to Web3 apps?

Yes. A .u works as a Web3 single sign-on. You can sign in to the decentralized web in a few clicks without giving up your privacy, proving ownership by signing with the wallet that holds the name. Any app supporting Unstoppable Domains login accepts your .u. Open →

How does names.u.cash fit into the U.CASH network?

names.u.cash is the identity layer of U.CASH. Your .u works with every other U.CASH app: pay to a name at U.CASH Pay, swap across 30 chains at U.CASH Swap with your own keys, buy UCASH at U.CASH Buy, and let agents pay and get paid at U.CASH Agents. One U.CASH account works across all of them, and the whole network lives at u.cash. Open →

What can I do with a .u name?

A .u works as your identity, login, and pay address. You can: receive crypto to a readable name instead of a long address (anyone can send to yourname.u); log in to the decentralized web with Web3 single sign-on; verify your socials and show a profile page; and host a censorship-resistant website on IPFS pointed at your .u. It works across every U.CASH app. Open →

What is names.u.cash?

names.u.cash is the U.CASH app for claiming a Web3 identity. You search for and buy a real .u domain through Unstoppable Domains, then use it as your identity, login, and pay address across Web3. It is part of the U.CASH network alongside Pay, Swap, Buy, Agents, and Verify. A matching @u FIO handle is on the roadmap. Open →

Where can I use my .u name?

Your .u works across the entire U.CASH network: pay to a name at U.CASH Pay, get paid, and manage your identity across all U.CASH apps with one account. Because .u is a real Unstoppable Domain, it also works in any third-party wallet, exchange, or dApp that supports Unstoppable Domains resolution. Open →

Can I buy or manage multiple .u domains at once?

Each .u is purchased individually through search. There is no bulk-buy tool in the app today. If you sign in with your U.CASH account, the 'My domains' view lists all the names tied to your email in one place, each with its status. For large or programmatic orders, contact U.CASH support. Open →

Can I host a website on my .u domain?

Yes. You can host a censorship-resistant site on IPFS and point your .u at it. Manage the IPFS hash record on your name in your Unstoppable Domains account. Your content, your domain, your rules. Open →

How do I buy a .u domain?

Type the name you want in the search bar on names.u.cash and hit Search. We send you to Unstoppable Domains to check live availability and complete the purchase. It is a one-time payment, and the domain is yours for life. The purchase and minting happen on Unstoppable Domains, so you manage your name there after buying. Open →

How do I manage the .u domains I own?

Your .u domains are managed in your Unstoppable Domains account, where you set addresses and records. On names.u.cash, you can optionally sign in with U (your U.CASH account) to see a 'My domains' view that lists orders linked to your email, with their payment and mint status. Sign-in is optional; the app works anonymously too. Open →

How do I check the status of my order?

Each order has a private status page at names.u.cash/order/<your-order-id>. The page shows your payment and mint status in near-real-time: waiting for payment, payment confirmed and minting, or your .u is live. The page polls automatically, so leave the tab open after paying. The domain is live once minting completes on-chain. Open →

What wallet do I need to buy a .u?

You need an EVM-compatible wallet (Ethereum, Base, or Polygon) to mint the .u, since it is minted as an NFT on Base. Provide a standard EVM DEXs Ethereum-style address when you buy. After minting, you set addresses for other chains (Bitcoin, Solana, and so on) on the name so it can receive any coin. Open →

Can I pay someone using their .u name?

Yes. In any U.CASH Pay checkout, type their .u as the destination instead of a wallet address. U.CASH resolves the name to their wallet and sends the payment there. This works anywhere U.CASH accepts an address, including payouts and payment links, and supports ENS (.eth), Unstoppable Domains, and FIO names too. Open →

How do I set my wallet address on my .u name?

After buying your .u on Unstoppable Domains, log in to your Unstoppable Domains account and add the address for each coin you want to receive (Bitcoin, Ethereum, Solana, UCASH, and so on) to the name's records. Once saved, anyone sending to yourname.u will resolve to those addresses. When you buy through names.u.cash, your owner wallet is set automatically during minting for major coins. Open →

Do I need an account to use names.u.cash?

No. You can search and buy a .u without signing in. Signing in with your U.CASH account (Sign in with U) is optional and adds a 'My domains' view that tracks your orders by email. Login uses U.CASH single sign-on, so one account works across names.u.cash, Pay, and the rest of the U.CASH network. Open →

Can I transfer or sell my .u domain?

Yes. The domain is an NFT in your wallet, so you can move it, sell it, or transfer it anywhere you like. Transfers are done from your wallet and Unstoppable Domains account, where the NFT lives. U.CASH does not lock or custody the name. Open →

Who owns the .u domain, and is it non-custodial?

You do. The domain is an NFT in your own wallet; no middleman holds it. You control it with your own keys, and you can move it, sell it, or transfer it any time. U.CASH never custodies your name. During minting, resolution records are set so the name points to your wallet, and you manage those records in your Unstoppable Domains account. Open →

How does a .u name resolve to a wallet?

U.CASH has a name resolution engine that turns human-readable names into on-chain addresses. When you enter a name like yourname.u, the engine queries Unstoppable Domains' resolution service for the crypto record matching the coin you are sending, and returns the wallet address stored on that name. The result is cached so repeat lookups are instant, and the address is validated before the payment is sent. Open →

Is there KYC, and are there region restrictions for buying a .u?

names.u.cash itself does not require KYC to search or initiate a purchase; you can browse and start buying a name anonymously. The actual purchase and minting happen on Unstoppable Domains, so any identity verification, payment-method requirements, and regional restrictions that apply there govern the final transaction. Crypto payments via U.CASH Pay are non-custodial and do not add a KYC step on the U.CASH side. Open →

What is the difference between a .u name and a raw wallet address?

A raw wallet address is a long string of random characters (like 0xd8da6bf2...), easy to mistype and hard to remember or verify. A .u name is human-readable (yourname.u), memorable, and shareable. When you send to a .u, U.CASH resolves it to the correct underlying address for the coin you are sending, so you get the safety of the address with the convenience of a name. Open →

Which cryptocurrencies can I pay with for a .u?

The checkout supports major coins including Bitcoin, Ethereum, Tether (USDT), and UCASH. The exact list is offered at checkout; you pick one when starting a purchase. Since the final purchase happens on Unstoppable Domains, the currencies accepted there apply to the actual mint. Open →

How much does a .u domain cost?

A .u is a one-time payment and you own it for life. Pricing is set per name by Unstoppable Domains at checkout, where you can see the exact price before you pay. Search your name on names.u.cash to be taken to the live price on Unstoppable Domains. Open →

How does U.CASH confirm my payment for a .u?

names.u.cash confirms payment by polling the payment status on a recurring schedule (a background reconciliation job), not by relying on an incoming webhook. This is simpler and more robust: even if a webhook delivery fails, your payment is still detected and your domain is fulfilled once it confirms. The order status page also reconciles on each view for near-real-time updates. Open →

Are there renewal fees or an expiration date?

No. You pay once and own the domain forever. There are no annual renewals and no expiration. The domain is minted as an NFT on Base and stays in your wallet for life. Open →

Does U.CASH show names instead of addresses when displaying wallets (reverse resolution)?

When a name is known for an address, U.CASH displays the human-readable name alongside it (for example, on transaction details and recipient rows). Resolution is forward (name to address) for sending. Setting a primary name on an address for universal reverse display is managed through your Unstoppable Domains and wallet settings. Open →

Which chains does a .u resolve to?

You can set a Bitcoin, Ethereum, Solana, Polygon, Base, UCASH, and more address on a single .u name, so it resolves across the 30+ chains U.CASH supports. Each coin has its own record on the name, so sending BTC to yourname.u hits your BTC address while sending ETH hits your ETH address. Open →

What types of names can I use across U.CASH, not just .u?

U.CASH resolves three families of Web3 names anywhere an address is accepted: Unstoppable Domains (like yourname.u or yourname.crypto), ENS (like yourname.eth), and FIO (like yourname@domain). Detection is based on the name's shape (.eth, name@domain, or name.tld), so new Unstoppable Domains TLDs work automatically without code changes. Open →

How does the buying process work behind the scenes?

names.u.cash is built on the Unstoppable Domains Web3 Partner API v3, the API for Web3/NFT domains like .u. Availability is checked live against Unstoppable Domains. When you search, you are sent to Unstoppable Domains to finish the purchase authoritatively. The app never falsely reports a name as available: if the resolution service is unreachable, it shows availability as unknown and confirms it at Unstoppable Domains. Open →

What is U.CASH's relationship with Unstoppable Domains?

U.CASH partnered with Unstoppable Domains to launch the .u TLD. names.u.cash uses the Unstoppable Domains Web3 Partner API v3 for availability and registration, and the final purchase happens on unstoppabledomains.com. The .u domains are real Unstoppable Domains and work everywhere Unstoppable Domains are supported, not just within U.CASH. Open →

What are the rules for a .u name?

A .u label can be 1 to 63 characters, using lowercase letters, numbers, and hyphens. It cannot start or end with a hyphen, and uppercase is normalized to lowercase. For example, alice.u, my-name.u, and satoshi123.u are all valid. Open →

What is a .u domain?

A .u is a Web3 (blockchain) domain you own as an NFT, minted on Base. It replaces long wallet addresses with a readable name and works as your identity, login, and pay address all in one. U.CASH partnered with Unstoppable Domains to launch the .u TLD. Open →

How do I authenticate API requests?

Send the api_key returned by POST /v1/signup in the X-Api-Key header on seller-side requests. Buyer-side endpoints are public and need no key: the /r/{resource_id} door, POST /v1/verify (buyer-push, resolvable from the public challengeId), and the discovery surfaces (/catalog.json, /catalog.txt, /.well-known/ucp). UCP catalog and checkout endpoints resolve the merchant from the domain or a ?cloud= merchant token, also without a buyer key. You can rotate your api key from the dashboard. Open →

How does a buyer agent discover and pay a merchant?

A buyer agent discovers via GET /catalog.json, GET /catalog.txt, or GET /.well-known/ucp on the merchant's domain (or pay.u.cash?cloud=<merchant-token> for hosted merchants). It then creates a UCP checkout session (POST /checkout-sessions with line_items) or fetches a single resource door (GET /r/{resource_id}). From the returned accepts[] it picks a rail, pays entry.payTo exactly entry.amount out of band from its own wallet (or signs an EIP-3009 authorization for exact USDC, or follows the redirect URL for a card), and either waits for on-chain detection to settle automatically or pushes the transaction hash to POST /v1/verify to settle instantly. No seller key is needed on the buyer side. Open →

Can I accept a token that is not built in?

Yes. POST /v1/custom-tokens with the type (erc-20, bep-20, base-20, polygon-20, arb-20, op-20, avax-20, trc-20, or spl, which selects the chain), a code that must not collide with a built-in coin, the contract address, decimals, and name (plus optional rate, rate_url, and confirmations). Then POST /v1/wallets with that code and your receive address so buyers know where to pay. The token is auto-detected on-chain like any built-in coin (the cron scans the contract transfers). GET /v1/custom-tokens lists them; DELETE /v1/custom-tokens?code= removes one. Optionally set per-token confirmation requirements. Open →

How does a buyer agent discover what a merchant sells?

Three discovery endpoints. GET /catalog.json returns a schema.org/Product JSON-LD catalog consumable by today's crawlers and LLMs. GET /catalog.txt is a plain-text catalog index. GET /.well-known/ucp returns the UCP profile (catalog.lookup, checkout, and ap2_mandate capabilities, the non-custodial detect + redirect payment handlers, and an EC signing key). Per-origin discovery works for custom-domain merchants; hosted merchants are discoverable via a shareable pay.u.cash?cloud=<merchant-token> URL (UCP discovery is per-origin by design). Open →

How does the EIP-3009 transferWithAuthorization flow work?

The buyer signs TransferWithAuthorization(from, to=payTo, value=amount, validAfter, validBefore, nonce) as EIP-712 typed data over the USDC-Base domain, then resubmits the request with that signature (via the PAYMENT-SIGNATURE header, or the x402 X-PAYMENT header, or POST /v1/exact-settle). The server recovers the signer and validates the binding (payee, amount, expiry, unused nonce). Two settlement postures are valid: confirm-then-settle (verify the authorization, settle once the on-chain transfer confirms, exactly like detect treats the chain as the proof), or gasless relay (a relayer submits the buyer-signed authorization on-chain so the buyer pays no gas). Open →

How does a merchant enable agent payments?

Two paths. (1) Sign up directly at agents.u.cash with an email or a username; the account is an agent from the start and works immediately at $0 (no verification, no payment required to begin; the tenant database is created lazily on your first write). (2) An existing pay.u.cash merchant can flip its account into an agent operator in-place: open the dashboard, go to AI Agents, and click 'Link an AI agent'. That sets the agent flag, auto-activates (the merchant is already verified), mints an api key if none exists, and provisions the tenant if needed. Either way you then set receive wallets (Settings, or POST /v1/wallets), create resources (POST /v1/resources), and optionally connect Stripe for cards. Open →

How does an agent actually pay for a resource?

Three steps. (1) GET /r/{resource_id} returns HTTP 402 with an accepts[] array (or a payable HTML page in a browser). (2) The buyer picks an entry and pays entry.payTo exactly entry.amount from its own wallet, out of band; the API never touches the buyer's private keys. (3) The platform detects the on-chain payment and settles automatically within a few minutes. To settle instantly instead of waiting for the detection loop, the buyer can optionally POST /v1/verify with the challengeId and transaction hash. No seller key and no client-supplied cryptographic proof are required for the detect rail: the chain itself is the proof. Open →

How do I get notified when a sale settles?

Set a settlement webhook URL and signing secret via PUT /v1/settings (webhook.url and webhook.secret). When a sale settles, the platform POSTs to your URL with an X-Webhook-Signature HMAC you verify against the secret (you can rotate the secret with webhook.rotate_secret=true). Agent settlements use dedicated agent-webhook keys isolated from any merchant main webhook. Email notifications (sale and underpayment notices) are also available: notifications.email defaults to your signup email when set, so notices work out of the box. Open →

How do I sign up as an agent?

POST /v1/signup with an email OR just a username and a password. Signup is free and instant; the account works immediately at $0 with no verification and no payment required to start. With no email, the agent gets a synthetic <username>@agents.u.cash address (no inbox; it is webhook-only). The tenant database is created lazily on the agent's first write (for example POST /v1/wallets or POST /v1/resources). Verifying an email, when you provide one, is an optional reward: it grants free starter credit (up to a transaction cap) and the overseer dashboard. The signup response returns your api_key directly. Open →

How do I accept card payments?

POST /v1/stripe with your own Stripe account's secret_key, product_id, and webhook_secret (and optionally publishable_key). The platform verifies the key and product against Stripe before storing them, so a misconfiguration fails at config time rather than checkout. Then register the returned webhook endpoint in your Stripe dashboard, subscribing to checkout.session.completed. Buyers then see a redirect (card) entry in accepts[] alongside the coin entries; card payments settle direct to your Stripe account (non-custodial). GET /v1/stripe returns masked config plus the endpoint to register; DELETE /v1/stripe disconnects. Open →

How does the UCP catalog work?

The UCP Catalog REST surface lets a buyer agent search and resolve products: POST /catalog/search (find items), POST /catalog/lookup (resolve a specific item), and POST /catalog/product (fetch full product detail). It mirrors the merchant's storefront catalog (the slug-bearing checkouts plus the agent's open resources). All catalog endpoints resolve the merchant from a custom domain or a ?cloud= merchant token and are public (no auth). They are rate-limited per IP. Open →

How do UCP checkout sessions work?

A UCP checkout session wraps one or more priced resources (a cart; up to 20 items, one currency per cart, quantities 1 to 100). Created via POST /checkout-sessions with line_items, it returns a session with a continue_url pointing at the /r/{resource} door. The buyer completes each item's challenge; the session reaches ready_for_complete when payments land, then completed once all items settle. Multi-item mixed-currency carts are supported: per-item original amounts drive the on-chain payment, only the displayed total converts to one cart currency. Endpoints: POST /checkout-sessions (create), GET /checkout-sessions/{id}, POST /checkout-sessions/{id}/complete (with an optional ap2.checkout_mandate), POST /checkout-sessions/{id}/cancel. Open →

How do UCP orders work?

After a checkout session completes, an order is created. GET /orders/{id} returns the order with per-item fulfillment status and a fulfillment event per settled item. For multi-item carts, the order reports each item's fulfillment independently. Orders are read-only records of what was bought and settled, consistent with the non-custodial model (the platform indexes on-chain settlement; it does not hold goods or funds). Open →

What is 402.onl?

402.onl is the vendor-neutral home of the 402 Online Protocol. It is brand-agnostic (not U.CASH-branded) and documents the protocol itself: the stateless flow, the accepts[] structure, the three scheme families (detect, redirect, exact) and the scheme registry, two-sided capabilities, an integration guide, a spec-at-a-glance, the security and non-custodial model, and the relationship to x402. agents.u.cash is cited only as the reference implementation. The full spec is at 402.onl/spec.md. Open →

What is the 402 Online Protocol?

The 402 Online Protocol is a vendor-neutral, non-custodial HTTP-402 payment protocol (version 0.1, draft). A seller's single 402 challenge advertises every asset the seller accepts in one multi-coin 'accepts[]' array, and the client pays through whichever rail it chooses. It generalizes x402 by adding two scheme families x402 lacks: 'detect' (pay-and-detect for any address-based coin) and 'redirect' (hosted card/fiat checkout through the seller's own processor), alongside 'exact' (x402-style signed-payload push for USDC on Base). The protocol spec and reference implementation live at 402.onl; agents.u.cash is the product surface. Open →

What is the detect payment scheme?

detect is the universal pay-and-detect scheme that covers any address-based coin: Bitcoin, Ethereum and ERC-20s, stablecoins, Solana, Tron, UCASH, and custom tokens. The buyer pays the seller's own address a randomized exact amount; the server detects that payment on-chain (via its detection loop, scanning the relevant chain or token contract) and confirms it. Because the buyer pays direct to the seller and the chain is the proof, no relayer, no funded platform key, and no client-supplied cryptographic proof are needed. It is the primary settlement path; submitting the transaction hash to /v1/verify is an optional instant-settle shortcut, not a coverage backstop (custom tokens are auto-detected too). Open →

What is the exact (x402) payment scheme?

exact is the signed-payload-push rail, x402-compatible, implemented for USDC on Base via EIP-3009 transferWithAuthorization. The buyer signs an off-chain authorization (the EIP-712 typed-data message TransferWithAuthorization with from, to, value, validAfter, validBefore, nonce over the USDC-Base domain) and submits it; the platform verifies the signature, checks it binds to the challenge (payee, amount, expiry, unused nonce), and settles. Funds still move direct buyer to seller; the platform never signs the value move and never holds funds. It adds instant, gasless payment and interoperates with off-the-shelf x402 clients. Open →

How does gasless settlement work for USDC on Base?

The U.CASH reference implementation ships a platform-operated, platform-funded relayer that is on by default (opt-out). A stock x402 client signs the EIP-3009 authorization and expects the facilitator to relay it; the relayer submits transferWithAuthorization on-chain, so the buyer pays no gas and no USDC approve. The relayer's Base ETH pays the gas. The seller is billed that gas plus a 21% premium per settle, debited from the seller's prepaid credit. The relayer is non-custodial meta-transaction relaying: it signs only a gas-paying wrapper around a buyer-authored message it cannot alter (from/to/value are buyer-signed), never the value move itself. A seller may opt out to verify-only (buyer-pays-gas) via POST /v1/exact-relay {enabled:0}. Open →

What does HTTP 402 mean for agent payments?

HTTP 402 is the 'Payment Required' status code, reserved in the HTTP spec but historically unused. The 402 Online Protocol revives it for machine-to-machine payments: when a buyer agent requests a priced resource, the server responds with HTTP 402 plus a body describing exactly what is accepted (the 'accepts[]' array: one entry per accepted asset, each with a scheme, the seller's address, an exact amount, and an expiry). The buyer then pays and re-requests. It turns an HTTP GET into a paid request without accounts, logins, or session state on the buyer side. Open →

Is there an MCP server?

Yes. A stdio MCP server (newline-delimited JSON-RPC 2.0) lets an AI agent such as Claude drive its seller account as tools. Configure it in Claude Desktop with env UXC_API_KEY set to your api key and UXC_BASE_URL. Tools include uxc_get_agent, uxc_set_wallet, uxc_set_webhook, uxc_create_resource, uxc_list_resources, uxc_get_resource, uxc_get_settlements, uxc_view_door (the public /r/ 402 door), uxc_verify_payment (buyer-side push-verify, no key), plus Stripe (uxc_set/get/clear_stripe), custom-token (uxc_set/get/delete_custom_token), and settings (uxc_get/set_settings) tools. CLI-guarded, not served over HTTP. Source and config are in the github.com/UdotCash/agents-u-cash repository under mcp/. Open →

Can I withdraw my agent earnings?

No, and that is by design. Agent earnings are a read-only on-chain record, like a block explorer: the platform indexes the payments that landed in the seller's own wallet but never holds them, so there is nothing to withdraw. The funds were already paid direct to the seller's self-custody wallet or Stripe account at the moment of payment. There is no internal withdrawable balance and no payout function, ever. The only internal credit is the non-withdrawable fee-credit balance used to prepay platform fees. Open →

What does non-custodial mean for agents.u.cash?

Non-custodial means every payment goes direct buyer to seller. For detect, the buyer pays the seller's own wallet on-chain and the platform only detects it. For redirect, the buyer pays the seller's own Stripe account. For exact, the buyer's signed authorization pays the seller's own address and the platform only verifies it (and, if the relayer is on, submits the gas wrapper it cannot alter). The platform holds no user funds and no user private keys. Under FinCEN's 'control' test this keeps it out of money-transmitter scope: it is a verifier, detector, and relayer, not a custodian. There is no internal balance representing user funds, no withdrawal-from-balance function, and no moment the platform controls a coin owed to a user. Open →

Is there an OFAC sanctions screen?

A lightweight OFAC sanctioned-address screen runs at signup and wallet setup. It checks receive addresses against Treasury's published list of sanctioned digital-currency addresses (the SDN list, refreshed periodically from treasury.gov), the one stable identifier the platform holds. A blocked address is rejected with a neutral error (the address cannot be used). Because the platform is non-custodial with no control over funds, party-wide mandatory OFAC screening is not clearly required; this address-only screen is insurance. Sanctioned addresses never appear in any public doc by name.

Where are the API docs and OpenAPI spec?

agents.u.cash serves three forms from one endpoint. The HTML landing page is at agents.u.cash. Append ?llms=1 for llms.txt (the LLM entry point: the full API, flows, concepts, and links). Append ?openapi=1 for the OpenAPI 3.1 JSON (structured, for tooling and SDK generation). The structured API reference, the 402 payment endpoints, the account endpoints, and the buyer flow are all documented there. The protocol-level spec (vendor-neutral) is at 402.onl/spec.md. Open →

What payment methods can an agent accept?

Three families. (1) Exact crypto via detect: any address-based coin the seller has a wallet for, including Bitcoin, Ethereum and ERC-20s, USDT, Solana, Tron, UCASH, and custom tokens. (2) x402 via exact: gasless USDC on Base through EIP-3009 transferWithAuthorization. (3) Cards and fiat via redirect: through the seller's own connected Stripe account. A single priced resource can advertise all three at once (e.g. a $0.01 resource accepting Bitcoin, USDC, UCASH, and cards returns four accepts[] entries: detect x3 plus redirect x1). The client chooses which rail to pay through. Open →

How is the platform fee charged?

The buyer pays the seller the full amount, direct. The platform fee is a small percentage that the seller prepays as a non-withdrawable credit balance; it is debited separately when a sale settles, never taken from the payment and never held. For the gasless exact rail specifically, the seller is also billed the relayer's gas plus a 21% premium per settle (the relayer's Base ETH pays the gas; the seller reimburses gas plus premium from credit). No intermediary ever controls the transaction funds. Open →

What is the redirect payment scheme?

redirect is the hosted-checkout scheme for cards and fiat. The buyer is redirected to a checkout session built on the seller's own Stripe account; the card payment settles direct to that seller's Stripe, and the platform's per-sale fee is debited from the seller's prefunded credit. It is non-custodial because the platform never touches the card payment. A redirect entry appears in accepts[] only when the seller has connected their own Stripe keys (POST /v1/stripe); resources may be card-only or accept cards alongside coins. Open →

How are refunds and underpayments handled?

Because funds move direct buyer to seller on-chain, there is no platform-held pool to refund from. If a buyer sends less than the exact amount, the challenge reports status 'underpaid' and does not settle (a seller can choose to accept underpayments via the accept_underpayments setting, but the default is to require the exact amount). A refund, when needed, is between buyer and seller directly, on-chain, just like any self-custody crypto transfer. The platform records what was paid and whether it matched; it cannot claw back or move funds it never held. Open →

How is agents.u.cash related to pay.u.cash?

An agent on agents.u.cash is a pay.u.cash tenant. agents.u.cash is the agent-and-merchant product surface for the 402 Online Protocol; pay.u.cash is the underlying merchant platform. The same account, wallet, settings, and tenant database back both. An agent's human operator signs in to the full dashboard at pay.u.cash/admin with the signup email or username and password to view 402 sales, credit balance, and per-sale fee history (agents.u.cash/admin redirects there). Agent 402 sales land in the agent's own tenant transaction table, tagged as UXC 402 sales, not in the platform credit ledger. Open →

What is a resource?

A resource is a priced listing the agent sells (a unit of work, data, or access), identified by a res_id. It is backed by an agent-enabled checkout in the tenant. Each resource has a price and a set of accepted assets; when a buyer requests its door (GET /r/{res_id}), the platform mints a 402 challenge with one accepts[] entry per accepted asset (each pointing at the seller's own wallet with a randomized exact amount and an expiry). A resource can be coin-only, card-only, or both. Resources are created with POST /v1/resources and listed with GET /v1/resources (which includes a settled flag). Open →

Are API responses signed?

Yes. Every merchant-origin UCP REST response is RFC 9421-signed (ES256) with the merchant's profile key, emitting Content-Digest (RFC 9530), Signature-Input, and Signature headers covering the status, content-digest, and content-type components. Signed inbound requests are passively verified (the response records UCP-Request-Signature as verified, unverified, or absent; currently non-blocking so it cannot break a client that does not sign). The published EC P-256 JWK at /.well-known/ucp is the verification key. AP2 mandates (SD-JWT-VC) add buyer holder-proof for checkout completion. Open →

Where is the JavaScript SDK published?

The JavaScript SDK is published on npm as 'agents-u-cash' (maintainer account 'ucash', MIT license, zero dependencies, ESM, requires Node 18+). Install with 'npm install agents-u-cash'. Repository: github.com/UdotCASH/agents-u-cash. It mirrors the full seller and buyer API surface. Open →

Where is the Python SDK published?

The Python SDK is published on PyPI as 'agents-u-cash' (zero dependencies, uses only the standard library urllib, Python 3.7+). Install with 'pip install agents-u-cash'. Repository: github.com/UdotCASH/agents-u-cash. A note for direct users: Cloudflare bot-protection blocks Python's default Python-urllib user agent, so the SDK sends a real browser-style user agent. Open →

Are there SDKs for agents.u.cash?

Yes, two zero-dependency SDKs. JavaScript: install with 'npm install agents-u-cash' (Node 18+, ESM, also works in browsers). Python: install with 'pip install agents-u-cash' (Python 3.7+, uses only the standard library urllib). Both wrap the full two-sided surface: seller operations (signup, top-up, set wallet, set webhook, create resource, list resources, create challenge, get settlements, settings, Stripe, custom tokens) and buyer operations (view the door as JSON or payable HTML, push-verify a payment). Source lives in the github.com/UdotCASH/agents-u-cash repository. Open →

Which coins and chains are supported?

Native L1s include Bitcoin, Ethereum, and others. EVM L2s include Base, Arbitrum, Optimism, Linea, Mantle, Berachain, Sonic, Unichain, World, Monad, Plasma, Abstract, Scroll, Ink, and Hyperliquid (native gas plus ETH-bridged). Stablecoins include USDT on Ethereum, BSC, and Tron, USDC on Ethereum, and native USDC on Base (the x402 gasless rail). The platform token is UCASH on Ethereum. Any other ERC-20, BEP-20, Base-20, Polygon-20, Arb-20, Op-20, Avax-20, TRC-20, or SPL token can be added via POST /v1/custom-tokens and is auto-detected on-chain like any built-in coin. The detect scheme covers all of them. Open →

What is UCP (Universal Commerce Protocol)?

UCP (Universal Commerce Protocol) is an open industry standard, co-developed by companies across shopping (Google, Shopify, Etsy, Wayfair, Target, Walmart, Amazon, Microsoft, Meta, Salesforce, Stripe), lodging (Amadeus, Booking.com, Expedia Group, Hilton, Marriott, Trip.com), and food (DoorDash, Square, Toast, Uber Eats), with broad ecosystem endorsement (including Visa, Mastercard, PayPal), published at ucp.dev (Apache 2.0-licensed). A business publishes capabilities and a signing key at /.well-known/ucp; an AI agent or platform discovers and negotiates the intersection. agents.u.cash implements UCP for agentic commerce: catalog discovery, multi-item mixed-currency checkout sessions, AP2 mandates, and RFC 9421-signed responses. It is not a Stripe API; it is the open standard agents.u.cash interoperates with. Open →

Which USDC contract does the exact rail use?

The exact rail uses native USDC on Base, contract 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 (the Circle-deployed FiatTokenV2, EIP-3009-capable). The EIP-712 domain is name 'USD Coin', version '2', chainId 8453, with verifyingContract set to that address. The version '2' is load-bearing: the contract is an upgradeable proxy and a wrong domain version silently fails every signature. v1 ships this single contract and domain; Permit2 and additional chains are a future generalization. Open →

What is at /.well-known/ucp?

/.well-known/ucp returns a merchant's UCP business profile: the protocol version, the capabilities it supports (dev.ucp.shopping.checkout, dev.ucp.shopping.catalog.lookup, dev.ucp.shopping.ap2_mandate), the payment handlers it offers (the non-custodial detect and redirect schemes), and a published EC P-256 JWK signing key used for RFC 9421-signed responses. It is the standard discovery entry point an AI agent reads to learn what a business can do. A bare platform host (no merchant context) returns a platform-level profile with catalog guidance. Open →

What is agents.u.cash?

agents.u.cash is the agent and merchant product surface for the 402 Online Protocol: a non-custodial way for AI agents, humans, and merchants to pay and be paid over plain HTTP. It makes AI agents first-class merchants on pay.u.cash. The same account is two-sided: it can sell (get paid to its own self-custody wallet) and buy (pay for resources from other agents). It is a live reference implementation of the open protocol documented at 402.onl. Funds always go direct buyer to seller; the platform never holds funds or private keys, so it is not a money transmitter. Open →

Does it work with standard x402 clients?

Yes. The /r/{resource_id} door emits WWW-Authenticate: x402 and projects each exact entry into the x402 v1 PaymentRequirements shape (maxAmountRequired, mimeType, the USDC asset, an atomic amount, the EIP-712 domain, and a gasless flag). It consumes an inbound X-PAYMENT header (base64url PaymentPayload) and returns X-PAYMENT-RESPONSE, with facilitator endpoints POST /v1/exact-verify (pure signature check) and POST /v1/exact-settle (verify plus settle). An off-the-shelf x402 client that signs an EIP-3009 authorization and expects the facilitator to relay pays gasless without changes. Clients that hard-code the x402.org facilitator URL need it pointed at the seller's door; configurable-facilitator clients work unchanged. Open →

Is portal.u.cash my account or a separate product?

It is your account, not a separate product you opt into. There is one U account per email across all of U.CASH. portal.u.cash is the home for that account: the sign-in credentials, profile photo, name, security settings (two-factor, passkeys, trusted devices), UCASH balance, and full transaction history. A merchant account on pay.u.cash is just a U account that was given merchant powers; the underlying identity is the same. Open →

How does my avatar work across U.CASH apps?

Your avatar is stored on your U account and served from portal.u.cash, so a photo you upload here shows up on pay.u.cash, agents.u.cash, una.u.cash, and the other apps automatically. The default avatar is your initials on a U.CASH gold circle; upload a photo to replace it. The avatar is keyed by a random per-account key (never your email), so no email ever appears in an avatar URL or log. A new photo takes about 5 minutes to propagate to other apps due to short-lived caching. Open →

What will I see on the dashboard?

After signing in you land on the dashboard. It shows your balances (UCASH, BTC, ETH, USDT, USDC), your account status and KYC status, and how long you have been a member. Below that is a withdrawal form for your UCASH balance, a list of any withdrawal requests you have made, and your full transaction history, paginated 25 rows per page with date, description, amount, running balance, and status. Open →

What is the difference between a consumer account and a merchant account?

portal.u.cash is a consumer and end-user portal: the place for your personal U account, balances, and identity. The merchant tooling (accepting payments, managing a store, payouts) lives on pay.u.cash. Because identity is shared through SSO, a merchant is just a U account that has been given merchant powers on pay.u.cash; you do not create a separate login. New merchant signup is intentionally blocked on the portal itself, which is focused on consumers and users. Open →

If I sign out of one app, am I signed out everywhere?

Yes. Signing out performs true single-logout (the Google model). When you sign out of any app, that app calls the portal, which ends your portal session and revokes every central session for your account across all devices and apps. It also loads hidden sign-out pings to each app so their local cookies are cleared. This stops any open tab or app from silently signing you back in. (Self-contained apps like swap.u.cash and buy.u.cash have no local session, so they sign out with the shared session cookie.) Open →

Do I need a separate login for each U.CASH app?

No. One U account works everywhere. Sign in once on portal.u.cash and you are signed in to pay.u.cash, agents.u.cash, una.u.cash, uantum.u.cash, ai.u.cash, names.u.cash, verify.u.cash, swap.u.cash, and buy.u.cash. This is single sign-on (SSO): portal.u.cash is the identity provider, and the other apps are relying parties that trust it. If you start on, say, pay.u.cash and are not signed in, you are sent to the portal to sign in, then returned to pay automatically. Open →

What is step-up and when am I asked for a code even though I am already signed in?

Step-up is an extra confirmation for sensitive actions (for example, when an app needs to perform a payout, rotate an API key, or add a withdrawal address). If your last successful two-factor check is more than 12 hours old, the app bounces you to the portal to re-enter a code (or use a passkey), then returns you. This keeps high-risk operations protected even on a long-lived login. Accounts with no factor enrolled are not stepped up, since there is nothing to challenge. Open →

What is portal.u.cash?

portal.u.cash is your U account, the single account and identity hub for every U.CASH app. Sign in once and you reach your balances and history, plus pay.u.cash, agents.u.cash, una.u.cash, uantum.u.cash, ai.u.cash, names.u.cash, verify.u.cash, swap.u.cash, and buy.u.cash without re-entering your password. Your profile, avatar, two-factor settings, and UCASH balance all live here. It is also the place you manage withdrawals from your portal UCASH balance. Open →

How do I close my account?

There is no self-service delete button on the portal. To close or deactivate your account, contact [email protected]. Be aware that your account holds your historical UCASH balance and ledger (including the migrated IBO distribution), so closure is handled manually to preserve an accurate record and to address any open withdrawal requests. Sign out from any app to perform a full single-logout if you simply want to end your sessions.

What are backup codes and what if I lose them?

When you enable 2FA you get 10 single-use backup codes. Use one in place of a 6-digit code if you lose your device. Each works once. If you run low or lose them, go to Security and choose Regenerate backup codes, which issues a fresh set and invalidates the old one. Store them offline (print or password manager), because they are displayed only when first generated. Open →

How do I change my password when I already know it?

Use the Forgot password flow even when you know your current password: go to portal.u.cash/forgot, enter your email, and follow the set-password link. Setting a new password immediately revokes every other session on your account (all apps and devices), so anyone else is signed out. This is the recommended way to rotate your password or respond if you suspect a device is compromised. Open →

How do I create a U account?

Go to portal.u.cash/register and enter your email, a password of at least 8 characters, and optionally your first and last name. You will be sent a verification email; click the link to verify your address, then sign in. New accounts start unverified and are not auto-logged-in, because verifying the email first is required to enable cross-app sign-in. Creating the account also quietly pre-creates your identity on pay.u.cash/agents.u.cash so you are ready there once verified. Open →

How do I turn off two-factor authentication or remove a device?

On the Security page, each enrolled factor has a Remove option. Removing an authenticator factor requires your password to confirm (so a hijacked session cannot weaken your account). Removing a passkey does not. You can also remove any trusted device from the Trusted devices list. If you remove your last factor, 2FA is effectively off for your account. Open →

Can I change the email address on my account?

Your email is the identity key for your U account and for single sign-on, and is not changed from the profile page. To change your email, contact [email protected] so the change can be handled with re-verification of the new address (the same verify-email gate that protects SSO applies). This prevents an attacker or a compromised session from silently switching your account to an address you do not control.

Why do I need to verify my email, and what does it unlock?

A verified email is the gate for single sign-on. When you create an account you are sent a verification link (valid 3 hours). Clicking it confirms you own the address and enables sign-in across every U.CASH app. Until you verify, you can still sign in to the portal itself with your password, but other apps will not accept the sign-in. You can resend the verification email from the verify-email screen. (Legacy accounts imported from the original U.CASH platform are treated as already verified.) Open →

How do I set up an authenticator app?

Go to Security and choose Enable two-factor. Scan the QR code with your authenticator app (or enter the secret key manually), then type the 6-digit code the app shows to confirm. Once confirmed, 2FA is on and you are given 10 single-use backup codes. Save these somewhere safe (print them or use a password manager); each works once and they are shown only that one time. Open →

How do I reset a forgotten password?

Go to portal.u.cash/forgot and enter your email. If an active account exists for that address, a password-set link is emailed (valid 3 hours). Click it and choose a new password of at least 8 characters. For security the response is identical whether or not the account exists, so this cannot be used to discover which emails are registered. If your account is inactive, banned, or frozen, contact [email protected] to regain access. Open →

I am a returning U.CASH user and have no password. Why am I asked to set one?

Accounts carried over from the original U.CASH platform (2015 to 2019) were imported without passwords, for security. The first time you sign in, use Forgot password to set a new one. Once set, your password works normally. This forced reset applies only to imported legacy accounts; new signups choose a password at registration. Open →

Can I sign in with a passkey instead of a password?

Yes. Passkeys (WebAuthn) let you sign in with your fingerprint, face, or device screen lock, with no password and no code. Passkeys are phishing-resistant and work across every U.CASH app. Add one on the Security page with Add a passkey. On the sign-in page, choose Sign in with passkey. You can keep your password and 2FA as backups, and remove any passkey at any time. Open →

How do I change my name or other profile details?

Go to Profile (top-right once signed in). You can edit your first and last name (up to 64 characters each) and upload an avatar photo, then Save profile. Your name and avatar are part of your U account and appear across the U.CASH apps. The email on your account is your identity key and is not changed from this page. Open →

I did not get my verification email. What do I do?

Open the verify-email screen (use the Resend option, or go to portal.u.cash/consumer.php?action=resend) and enter your email to send a fresh link. The link expires after 3 hours, so request a new one if yours has lapsed. Check your spam folder too. If the address is wrong, you will need to create a new account with the correct email, since email verification also confirms the address is yours. Open →

How do I get help with my account?

For account issues that cannot be self-served (frozen or banned accounts, email changes, account closure, balance disputes, or non-UCASH withdrawals), start a ticket at pay.u.cash/support or email [email protected]. Include your account email. For password resets, verification resends, profile and avatar edits, two-factor setup, and UCASH withdrawals, use the self-service pages at portal.u.cash directly. Account questions cannot be handled over public channels because U.CASH is non-custodial. Open →

What does Trust this device for 30 days do?

When entering your 2FA code you can check Trust this device for 30 days. On that device and browser you will skip the code at sign-in and during step-up for 30 days. The trust is bound to your browser fingerprint, so a stolen cookie will not work on a different browser. You can review and remove trusted devices anytime on the Security page under Trusted devices. Open →

What is two-factor authentication and should I turn it on?

Two-factor authentication (2FA) asks for a 6-digit code from an authenticator app (Google Authenticator, Authy, Microsoft Authenticator, 1Password) in addition to your password at sign-in. It stops anyone who only has your password from getting in. You can enable it on the Security page. Because the portal is the identity provider, turning on 2FA here protects every U.CASH app at once, not just the portal. Open →

What are the avatar upload rules?

On the Profile page, choose a JPG, PNG, WEBP, or GIF file under 2 MB. The image is automatically center-cropped to a square and resized to 256x256, then saved as webp (with a png fallback). Originals are not kept, only the processed square. To revert to your initials, check Remove current photo and save. There is no manual crop tool; pick a roughly square source image for best results. Open →

How do I withdraw UCASH to an external wallet?

On the dashboard, open the Withdraw section. Choose a chain (Ethereum, Base, or Polygon), enter the amount and your EVM DEXs receiving address, and submit. A per-chain fee applies (500 UCASH on Ethereum, 1 on Base, 1 on Polygon) and is added to the amount. The request is created as Pending and an admin reviews it; you will see it listed under Your withdrawal requests with its status. Withdrawals are currently UCASH only. Open →

What happens after I request a withdrawal?

Your request is recorded as Pending and the total (amount plus the chain fee) is debited from your balance immediately, with a Processing transaction in your history. An admin is notified to review and send it. If a request is rejected, the full total is refunded to your balance and a Completed credit row is added. Completed withdrawals show the on-chain transaction hash once sent. You can track each request under Your withdrawal requests on the dashboard. Open →

What do the account statuses (active, frozen, banned, inactive) mean?

Accounts can be active, inactive, frozen, or banned, inherited from the original platform's controls. Active accounts can sign in normally. Frozen or banned accounts cannot complete sign-in and must contact [email protected] to regain access. Inactive accounts similarly cannot sign in until reactivated. Only active accounts can request a password reset link. Status is shown as a pill on your dashboard. Open →

Where does my UCASH balance and history come from?

Your balance and transaction history come from your U account ledger. For accounts carried over from the original U.CASH platform, the balance is the running balance from your historical ledger (the authoritative last-entry value), and the history includes the 2017 to 2018 Initial Bounty Offering (IBO) token distribution, credits, withdrawals, and transfers that were recorded for your account. Newly earned or spent UCASH (for example AI usage charges) appends to the same ledger going forward. Open →

Does U.CASH still run bounties? What about my old bounty tokens?

The UCASH you see in your balance includes tokens distributed through the original 2017 to 2018 Initial Bounty Offering (IBO), where contributors earned UCASH for helping build and promote the network. Those tokens were migrated into your U account balance at launch. There is no active bounty program run from the portal today; the portal describes itself as your account, wallets, and bounties across every U.CASH app, with the IBO distribution forming the historical part of your balance. Open →

What does the KYC status on my dashboard mean?

Your dashboard shows whether your account is marked KYC verified or unverified, carried over from the original platform's identity records. KYC status is informational on the consumer portal. Certain activities that require stronger identity verification may prompt for additional steps through the relevant app; the portal itself does not host a self-service KYC submission flow today. Contact [email protected] if you believe your status is incorrect. Open →

Where did the 400,000+ accounts and billions of UCASH come from?

Your U account and balance were migrated from the original U.CASH production database (ucashdbprod), which ran from 2015 to 2019 and held roughly 405,000 consumers with about 8.64 billion UCASH in total, including the Initial Bounty Offering distribution. Balances were computed from each account's authoritative running ledger balance (not a naive sum, which would double-count some historical entries). The original database is preserved read-only as the source of truth; the portal is the new, active front end for those accounts. Open →

Why am I locked out after too many sign-in attempts?

To stop brute-force guessing, sign-in attempts are rate-limited per email and per IP (the stricter of the two wins). After 10 failed attempts, the account is locked for 15 minutes. The same throttle applies to 2FA code attempts and to passkey attempts. Wait for the lock to expire, then try again. Successful sign-in resets the counter.

Why does my account say two-factor is required?

Some accounts (typically staff or admin) have two-factor marked as required. If your account is required to use 2FA but has no factor yet, the first time you sign in you are walked through enrolling an authenticator app inline before you can continue. You cannot skip it. This applies only to accounts flagged as required; regular users can choose whether to enable 2FA. Open →

What are the password requirements?

Passwords must be at least 8 characters. They are stored as one-way bcrypt hashes (we never see or store your plain password). When you set or change your password, every other active session on your account is revoked, so any other device or app is signed out and must sign in again with the new password.

Was portal.u.cash always a consumer portal?

No. portal.u.cash was originally built as a second, standalone copy of the pay.u.cash platform (a merchant platform). It was then pivoted to be the consumer and end-user portal, backed by the original U.CASH production database. The merchant machinery is now dormant on the portal, new merchant signup is blocked, and the portal runs its own consumer-focused app. This is why the portal and pay share a codebase lineage but are now separate apps with separate concerns. Open →

How are my sessions kept secure?

Session cookies are server-set and marked HttpOnly, Secure, and SameSite, so browser JavaScript cannot read them and an XSS attack cannot lift them. Sign-in is throttled per email and per IP, with accounts locked for 15 minutes after 10 failed attempts. Password changes revoke all other sessions. SSO one-time codes are single-use and expire in 60 seconds, and every authentication event is recorded in an audit log. Operator and admin cookies on the back office have their own stricter timeouts.

How does single sign-on actually work?

When you visit an app while signed out, that app sends you to portal.u.cash to authenticate. If you already have a verified portal session, the portal hands the app a single-use, short-lived code (valid 60 seconds, usable once) which the app exchanges securely for your identity. A shared session cookie scoped across *.u.cash then keeps you signed in, so visiting another app logs you in transparently with no new prompt. The exchange is HMAC-signed between the portal and each app, and codes cannot be replayed or reused. Open →

Which apps accept my U account sign-in?

Your U account works on pay.u.cash (payments), agents.u.cash (HTTP-402 agent payments), una.u.cash (the Una assistant), uantum.u.cash (general-purpose Uantum AI), ai.u.cash (the U.CASH FAQ agent), names.u.cash (buying .u domains), verify.u.cash, swap.u.cash (the exchange), and buy.u.cash (buy UCASH). The portal mints the sign-in code only for these registered apps, and a return URL is only accepted if it matches the app you came from, so a sign-in cannot be redirected to an arbitrary site. Open →

How does UCASH billing work for the AI apps?

When you use an AI app (una.u.cash, uantum.u.cash, ai.u.cash), the real cost of each turn is reported to the portal, which debits UCASH from your balance. The UCASH charge is the real cost multiplied by a small per-tier markup (3x for economy models, 4x for performant models) divided by the system UCASH price. The portal owns the price and the markup, so the apps themselves never need to know the conversion. Charges are atomic and overdraft-safe: if your balance cannot cover a turn, the charge is refused rather than going negative.

What is the UCASH price used for billing?

The system UCASH price is a fixed reference rate (set by the platform, currently the equivalent of $0.0021 per UCASH) used to convert real USD costs into UCASH charges. It is owned by the portal and exposed so apps can display equivalent values. Holding UCASH is cheaper for AI usage than paying in credit only because of the favorable system rate; the per-tier markup applies in both modes.

Are there benefits to holding more UCASH?

Yes. U.CASH uses holding-based tiers that reduce platform fees as your UCASH balance grows. The tiers run from 1,000 UCASH (a 10 percent fee discount) up to 210,000 UCASH (a 50 percent fee discount), with steps in between (10,000 at 20 percent, 50,000 at 30 percent, 100,000 at 40 percent). The higher your tier, the lower the fees applied on qualifying platform activity.

What is the unified balance and how does it combine my UCASH?

The unified balance is the total UCASH you can spend across U.CASH, adding your portal UCASH balance to any UCASH held on the pay.u.cash side. When an AI app charges you, it draws from pay-side UCASH first and falls back to the portal balance, refunding the pay side if the portal leg then fails, so the displayed total always matches what you can actually spend. You can also choose whether AI usage is billed in UCASH or in merchant fiat credit.

Can I withdraw BTC, ETH, USDT, or USDC?

Direct self-service withdrawal is supported for UCASH only. For BTC, ETH, USDT, and USDC balances shown on the dashboard, the withdrawal form indicates these are not currently available from the self-service portal in your region or account. Contact [email protected] for help moving those balances. This is a deliberate limitation of the consumer portal, not an error. Open →

What is U.CASH Agents?

U.CASH Agents (agents.u.cash) puts AI agents on the HTTP-402 protocol so they can sell priced resources and buy services per request, in crypto or by card, non-custodial end to end. It is built on the open Universal Checkout Protocol (UCP) standard. One account can earn from its own resources (sellers get paid per call) and pay for others (buyers pay per request). Open →

What is U.CASH Buy?

U.CASH Buy (buy.u.cash) is the dedicated buy-UCASH flow. It buys UCASH at market price in one non-custodial step, powered by the swap engine. You get UCASH routed directly to your wallet without a custodial middleman. Open →

What is U.CASH Names?

U.CASH Names (names.u.cash) is the web3 identity app. Claim a .u domain (Unstoppable Domains), an @u handle (FIO), and other UCASH web3 names that resolve to your wallet. The name becomes a human-readable address you can pay and be paid through, replacing long copy-pasted addresses. Open →

What is U.CASH Pay?

U.CASH Pay (pay.u.cash) is the flagship payments app: one white-label, non-custodial checkout that accepts every coin and card. Connect your own xpubs and per-chain wallets, run fiat cards through your own merchant account, and funds settle directly to addresses you control. It includes multi-store support, requests and invoices, REST API with signed webhooks, SDKs, web3-name payouts, and per-coin confirmation policies. Hundreds of coins across 30+ chains. Open →

What is the U.CASH Portal?

The Portal (portal.u.cash) is your single account across every U.CASH app. Register once and the same U.CASH account works across pay, swap, buy, names, agents, send, and verify, with no separate logins. From the portal you manage your account, wallets, balances, activity, and bounties. It also acts as the identity provider (SSO) for the other apps. Open →

What is U.CASH Swap?

U.CASH Swap (swap.u.cash) is a non-custodial exchange and aggregator that routes trades across 30 chains via multiple connected aggregators, plus instant exchange for Bitcoin and 1,500+ coins. Your wallet signs every swap, so funds never leave your control. It charges a flat 0.30% fee. It is the engine behind the buy-UCASH flow at buy.u.cash. Open →

What are U.CASH Converters?

Converters are retail merchants (people) who use U.CASH Pay to buy and sell, moving cash and crypto for their customers in person. A converter is the human, real-world fiat-to-crypto on/off-ramp: a customer brings cash, the converter uses pay.u.cash request-info and payment links to settle the crypto side. Converters are distinct from swap.u.cash, which is crypto-to-crypto token swapping on-chain. Open →

What apps are part of U.CASH?

The core U.CASH apps are: Pay (accept crypto and cards in one non-custodial checkout), Swap (trade across 30 chains non-custodial), Buy (get UCASH in one non-custodial step), Names (claim a .u or @u web3 name), Agents (HTTP-402 AI agent payments), Send (mass-send tokens to many wallets from a CSV), Verify (verify your UCASH balance and email to unlock benefits), and the Portal (your single account, balances, and bounties). The wider Ucosystem adds the domain industry (undomains, unregistry, unregistrar), Umerce, u.builders, and more. Open →

How do the U.CASH apps connect to each other?

The apps connect through U.CASH single sign-on (SSO) run by the Portal. The Portal (portal.u.cash) is the identity provider, and each app is a relying party. When you sign in to the Portal it sets a shared session, so visiting any other U.CASH app already recognizes you without a second login. Signing out of one app triggers a true single-logout that revokes the central session across all of them. Open →

Is U.CASH custodial?

No. U.CASH is non-custodial by design. No U.CASH app ever holds your money. Payments settle straight to wallets you control, fiat card payments run through your own card-processor merchant account, and swaps settle on-chain to addresses you sign with. Funds always remain yours, by design. Open →

Do I need a separate account for each U.CASH app?

No. A single U.CASH account, created once at the Portal, works across pay, swap, buy, names, agents, send, and verify. There are no separate logins. The Portal acts as the identity provider and signs you into every app via U.CASH single sign-on (SSO), so one login carries across the whole network and one logout signs you out everywhere. Open →

What does 'open money infrastructure' mean?

U.CASH describes itself as the open money layer for the open internet. In practice that means a shared set of non-custodial payment, swap, and identity rails that any application, merchant, or AI agent can build on top of, across 30+ chains. Instead of one closed payments company holding your funds, U.CASH provides open APIs, signed webhooks, SDKs, and open standards (UCP, HTTP 402) so money moves the way information does on the open web. Open →

What is the u.cash website?

u.cash is the U.CASH product hub. It is the central site that ties together the family of apps living on *.u.cash subdomains: pay.u.cash, swap.u.cash, buy.u.cash, names.u.cash, agents.u.cash, verify.u.cash, send.u.cash, and portal.u.cash (your account). The hub explains the open-money thesis, lists the apps, covers the UCASH token and the network economy, and links to developer resources. One account works across every app. Open →

What is the difference between U.CASH and U.ONLine?

U.CASH (u.cash) and U.ONLine (u.onl) are complementary siblings under the Ucosystem umbrella. U.CASH is the open-money and payments infrastructure: the pay, swap, buy, names, agents, send, and verify apps, all non-custodial, across 30+ chains. U.ONLine is the business-apps infrastructure: B2B and B2C commerce, services, AI tools, and related business applications. The two are complementary, UCASH is the network access and loyalty token running through both, and revenue from across the Ucosystem feeds the U.CASH economy. Open →

What is the Ucosystem?

The Ucosystem (ucosystem.com) is the umbrella over U.CASH, U.ONLine, and a broad network of decentralized and centralized apps, agents, and services. It organizes everything into four infrastructures: DNS (domains and identity), Crypto (payments and assets, which is U.CASH), AI (agent payments), and Apps (business applications, which is U.ONLine). Revenue from across the entire Ucosystem flows into and supports the U.CASH economy and the UCASH token. Open →

What is U.CASH?

U.CASH is open money infrastructure: a non-custodial network of apps for pay, swap, buy, names, agent payments, send, and verify, all running across 30+ blockchains. The internet runs on open protocols for everything except money, and U.CASH is the open money layer any app or agent can build on. One account works across every app, and funds always settle to wallets you control. U.CASH has been active since 2015. Open →

Do I need to hold UCASH to use U.CASH?

No. You do not need to hold UCASH to use the core U.CASH apps. You can accept payments, swap, buy, and use names without holding a minimum balance. Holding UCASH unlocks additional benefits: premium features, priority services, holder discounts, and it serves as a settlement asset for agent commerce. It is a network access and loyalty token, not a requirement to participate. Open →

What is UCASH used for?

UCASH is a network access and loyalty token. Across the Ucosystem you use it to access services, unlock premium features and discounts, pay and transact on-chain, settle machine-to-machine agent payments over HTTP-402, register and use .u and @u web3 names, and mint or use custom assets. Holding UCASH also unlocks holder discounts on domains, hosting, commerce, and services through U.ONLine and other Ucosystem properties. Open →

How is UCASH used by AI agents?

UCASH and other tokens settle machine-to-machine payments for AI agents over the HTTP-402 protocol. On U.CASH Agents, buyers pay per request and sellers earn per call. UCASH acts as one of the settlement assets agents use to sell priced resources and buy services autonomously, non-custodial end to end. Open →

Do UCASH holders get discounts?

Yes. Holding UCASH unlocks holder discounts on domains, hosting, commerce, and services through U.ONLine and Ucosystem properties, plus premium features and priority services across U.CASH apps. UCASH is the network access and loyalty token, so benefits scale with participation and holdings. Open →

Why is UCASH called the network access token?

UCASH is the connective token running through every U.CASH app: pay, swap, buy, names, agents, send, and verify. It provides network access (reaching services and features), loyalty (premium benefits and discounts for holders), and a settlement asset for on-chain and agent transactions. It ties the whole Ucosystem together. Open →

Can I pay with UCASH?

Yes. You can use UCASH (and other assets) to pay for goods, services, and transactions across the ecosystem with fast on-chain settlement. Merchants on U.CASH Pay can accept UCASH alongside hundreds of other coins and cards in one non-custodial checkout. Open →

What is the UCASH token?

UCASH is the network access and loyalty token of the U.CASH ecosystem and the wider Ucosystem. It is a standard ERC-20 token, deployed in January 2018, used to access services, unlock premium features and discounts, pay and transact on-chain, and settle agent commerce. It is the connective token running through pay, swap, buy, names, agents, send, and verify. UCASH is a network access and loyalty token, not a security or investment. Open →

How do I get started with U.CASH?

Three steps. First, create your account at the U.CASH Portal (portal.u.cash): one account works across every app. Second, connect the wallets you already use: Bitcoin xpubs, EVM addresses, Solana, Tron, and more, so funds settle to addresses you control. Third, use any app: accept a payment, swap a token, buy UCASH, claim a .u name, or let an agent sell for you. Start anywhere and the rest is one click away. Open →

How do I earn UCASH?

UCASH is earned through real contribution, not given away. Bounties: complete tasks and claim UCASH through the u.builders bounty program, open to everyone with no job offer required. Service-usage rewards: stay active across the apps and earn through rewards and loyalty programs. You can also earn by building dApps and integrations, running a converter, or selling services and agent resources. Open →

How do I buy UCASH?

Buy UCASH at market price in one non-custodial step at buy.u.cash, which is the dedicated buy-UCASH flow powered by the swap engine. Alternatively, swap any asset into UCASH at swap.u.cash. Both route UCASH directly to a wallet you control. Always verify the official contract address for your chain (Ethereum, Polygon, or Base) first. Open →

How do I get UCASH?

Three ways. Buy: get UCASH at market price in one non-custodial step at buy.u.cash. Swap: swap any asset into UCASH across 30 chains at swap.u.cash. Earn: earn UCASH through rewards, loyalty programs, and bounties in the Portal. Always confirm you are interacting with the official contract address before buying or swapping. Open →

How do I swap another token for UCASH?

Swap any asset into UCASH at swap.u.cash, a non-custodial aggregator routing across 30 chains with a flat 0.30% fee. Your wallet signs every swap, so funds settle on-chain to addresses you control. Select UCASH as the output token on your chain (Ethereum, Polygon, or Base) and confirm the official contract if prompted. Open →

Where do I store UCASH?

Store UCASH in any compatible ERC-20 wallet on Ethereum, Polygon, or Base. Because it is a standard ERC-20, it works with MetaMask, hardware wallets, and any wallet that supports custom ERC-20 tokens. For Polygon or Base UCASH, add the corresponding contract address to your wallet to make the balance visible. Open →

Where can I verify UCASH holdings?

On the public block explorers. Ethereum: etherscan.io/token/0x92e52a1A235d9A103D970901066CE910AAceFD37. Polygon: polygonscan.com/token/0xA94880d3A4b39746E90Cdb57f8De3732c984DE14. Base: basescan.org/token/0x26cf750abAf38aF7109Effdbdf79bA50d2EE09A1. The labeled top holdings on Ethereum are listed on the U.CASH economy page, each linked to its explorer, and the full holder list is public record on-chain. Open →

Where does Ucosystem revenue come from?

Revenue comes from a wide mix of businesses and services across the Ucosystem: domain registration, registry, hosting, and email (undomains, unregistry, unregistrar); payment processing and swap fees; agent commerce; B2B and B2C commerce and services through Umerce; financial services; names and identity; and premium verification. A share of all of it supports the U.CASH network, the UCASH token, and the apps built on top. Open →

How is U.CASH revenue used?

Revenue is put back to work: maintaining and expanding the rails across 30+ chains, REST APIs, signed webhooks, and SDKs; funding bounties that pay contributors in UCASH; supporting decentralized applications and grants built on U.CASH; and keeping UCASH reachable across chains, bridges, and venues. A portion of revenue from every Ucosystem app and service is also used to acquire more UCASH, which funds future bounties, allocations, and initiatives. Open →

Which blockchains does U.CASH support?

U.CASH supports 30+ chains out of the box, including Ethereum, Polygon, Base, Bitcoin, Solana, Tron, and more. For payments it covers native L1s (BTC, ETH, SOL, TRX, XRP, LTC, DOGE, BCH, XMR, ALGO, DOT, XLM, XTZ, TON) plus EVM chains (Base, Arbitrum, Optimism, Polygon, BNB Chain, Avalanche, Linea, Mantle, Berachain, Sonic, Unichain, World Chain, Monad, Plasma, Abstract, HyperEVM, Scroll, Ink). You can also add any custom token by wallet plus contract across the supported networks. Open →

What is the UCASH Base contract address?

On Base, the UCASH contract is 0x26cf750abAf38aF7109Effdbdf79bA50d2EE09A1. Verify it on Basescan at basescan.org/token/0x26cf750abAf38aF7109Effdbdf79bA50d2EE09A1. Base holds about 2.4% of supply, custodied by the Base bridge contract on Ethereum. Open →

What are the UCASH bounty offerings?

About 42% of UCASH supply sits in five labeled bounty-offering reserves that fund ecosystem work. They are FBO (Future Bounty Offering, ~15.45%), OBO (Ongoing Bounty Offering, ~13.41%), BBO (Build Bounty Offering, ~8.65%), PBO (Partner Bounty Offering, ~3.65%), and LBO (Liquidity Bounty Offering, ~0.89%). Some balance in these accounts is held on behalf of legacy portal users who have not yet withdrawn their original UCASH; only the share earmarked for future ecosystem work counts as not circulating, roughly a third of total supply. They pay out through the u.builders bounty program. Open →

Which blockchains is UCASH on?

UCASH is an ERC-20 on three chains: Ethereum, Polygon, and Base. Each has its own contract address. Ethereum is the home chain holding the large majority of supply, while the Polygon and Base bridge contracts on Ethereum custody the cross-chain supply. Always verify the address for the specific chain before interacting. Open →

How much UCASH is in circulation?

About 14 billion UCASH (14B+) is in circulation, approximately 66.7% of the 21B max cap. The remaining roughly 33.3% (about 7B) is reserved to the cap. The portion earmarked for future ecosystem work in the bounty reserves counts as not yet circulating. Open →

What are the official UCASH contract addresses?

UCASH is an ERC-20 on three chains. Ethereum (ERC-20): 0x92e52a1A235d9A103D970901066CE910AAceFD37 (view on Etherscan). Polygon: 0xA94880d3A4b39746E90Cdb57f8De3732c984DE14 (view on PolygonScan). Base: 0x26cf750abAf38aF7109Effdbdf79bA50d2EE09A1 (view on Basescan). Always verify the contract address before interacting, since fake tokens with similar names exist. Open →

How is UCASH distributed across chains?

Most UCASH stays on Ethereum, the home chain: about 94.9% of supply. Polygon holds about 2.7% and Base about 2.4%, with both cross-chain portions custodied by their respective bridge contracts on Ethereum. The bridge contracts on Ethereum hold the bridged supply, so the cross-chain tokens are fully backed on the home chain. You can verify the custody addresses on Etherscan. Open →

When was UCASH launched?

The UCASH ERC-20 token was deployed in January 2018 as the network access and loyalty token for the U.CASH ecosystem. The U.CASH project itself has been active since 2015. Open →

What is the UCASH Ethereum contract address?

On Ethereum (ERC-20), the UCASH contract is 0x92e52a1A235d9A103D970901066CE910AAceFD37. You can verify it on Etherscan at etherscan.io/token/0x92e52a1A235d9A103D970901066CE910AAceFD37. Ethereum is the home chain and holds about 94.9% of the total UCASH supply. Open →

How many UCASH holders are there?

There are 318,000+ (318K+) on-chain UCASH holders spread across more than 318K wallets, alongside over 1 million (1M+) lifetime signups on the U.CASH network. The largest holdings are not private allocations but labeled network functions such as bounty reserves, bridge contracts, exchange wallets, and liquidity venues. Open →

Who holds the most UCASH?

The largest UCASH holdings on Ethereum are not private allocations but labeled network functions. The top labels are the bounty-offering reserves: FBO (Future Bounty Offering, ~15.45%), OBO (Ongoing Bounty Offering, ~13.41%), and BBO (Build Bounty Offering, ~8.65%), followed by exchange wallets such as Yobit (~4.41%) and C2CX (~3.95%), then PBO (Partner Bounty Offering, ~3.65%), the Polygon and Base bridge contracts, a liquidity pool, and operational accounts. The remainder is spread across 318K+ wallets. Each address is public and viewable on Etherscan. Open →

Is UCASH an investment or security?

No. UCASH is explicitly described as a network access and loyalty token, not a security or investment. Its purpose is to access services, unlock premium features and discounts, pay, transact, and settle agent commerce across the U.CASH network. As with any token, always do your own research. Open →

What is the UCASH Polygon contract address?

On Polygon, the UCASH contract is 0xA94880d3A4b39746E90Cdb57f8De3732c984DE14. Verify it on PolygonScan at polygonscan.com/token/0xA94880d3A4b39746E90Cdb57f8De3732c984DE14. Polygon holds about 2.7% of supply, custodied by the Polygon bridge contract on Ethereum. Open →

What token standard is UCASH?

UCASH is a standard ERC-20 token. It is deployed on Ethereum (the home chain, ERC-20) and bridged to Polygon and Base, each as an ERC-20 with its own contract address. You can store it in any compatible ERC-20 wallet on Ethereum, Polygon, or Base. Open →

What is the UCASH total supply?

UCASH has a fixed maximum cap of 21 billion (21B) tokens. About 14 billion (14B+) is in circulation, roughly 66.7% of the cap, leaving around 7B remaining to the 21B cap. The 21 billion max cap is hard and does not increase. Open →

Is U.CASH Send non-custodial?

Yes. Send is non-custodial. Each batch is one transaction to the open uDisperse contract, and funds go directly from your wallet to your recipients. The contract holds nothing between calls, so there is no pooled custody and no withdrawal risk. Your wallet signs every transaction, and the contract code is public in the UdotCASH/send.u.cash-dapp repository for anyone to audit. Open →

What can I send with U.CASH Send?

You can send three kinds of assets: native coin (for example ETH on Ethereum), UCASH, or any ERC-20 token by pasting its contract address. This makes Send useful for UCASH distributions, token airdrops, payroll, and multi-recipient payouts of any EVM token, all in one batched transaction. Open →

What is U.CASH Send used for?

Send is used for any payment to many recipients at once: UCASH distributions and airdrops, token airdrops to community lists, payroll and contractor payouts, affiliate or bounty distributions, and refunds. By batching many transfers into one on-chain transaction, it saves gas and time compared to sending individually, while keeping you in full custody of your funds. Open →

What is U.CASH Send?

U.CASH Send (send.u.cash) lets you mass-send UCASH, native coin, or any ERC-20 token to many recipients in one on-chain batch. Upload a CSV of address and amount pairs, preview the list, then confirm a single transaction per batch with your wallet. It is fully non-custodial: your wallet signs and funds go directly to recipients through the uDisperse contract, which holds nothing between calls. Open →

What is U.CASH Verify?

U.CASH Verify (verify.u.cash) lets you verify your UCASH balance and associate your email address with your Ethereum wallet to unlock benefits and premium features across U.CASH and the wider Ucosystem. You sign in with your Ethereum wallet, the service reads your on-chain UCASH balance, you submit and confirm an email, and your address is then linked to a verification level that other Ucosystem services can use to unlock perks. Open →

What does U.CASH Verify check?

Verify checks two things. First, your on-chain UCASH balance, read directly from the Ethereum UCASH contract (0x92e52a1A235d9A103D970901066CE910AAceFD37) via ethers.js. Second, that you control the email address you submit, confirmed by clicking a verification link. It then links the verified email to your wallet address and assigns a level based on your holdings. Open →

Who uses U.CASH Verify?

Anyone who wants to unlock benefits across U.CASH and the Ucosystem. By linking a verified email to your wallet and establishing a holdings-based level, other Ucosystem services can offer you premium access, priority support, and holder discounts without you re-proving your balance each time. The verification is reusable: services query the Verify API to check an address's verified email status (the API returns the linked email and verified flag, not the holdings level). Open →

What is the CSV format for U.CASH Send?

Two columns: address and amount, in that order. A header row is optional. Separators can be comma, tab, or semicolon. For example: 0xabc...,1.5 on one line and 0xdef...,42 on the next. You can either drop a .csv or .txt file onto the upload area or paste rows directly into the text box. Each batch processes up to 150 recipients. Open →

How does U.CASH Send work?

Choose your network and asset (native coin like ETH, UCASH, or any ERC-20 by pasting its contract address), then upload a CSV or paste rows of recipients in the format address,amount (two columns; header row optional; comma, tab, or semicolon separators). Preview the parsed list, connect your wallet (MetaMask), and confirm one on-chain transaction for the batch. Each batch sends up to 150 recipients in a single transaction. Open →

How does U.CASH Verify work?

Four steps. Step 1: sign in with your Ethereum wallet (MetaMask) to connect your address. Step 2: submit your email address. Step 3: click the verification link in the email you receive. Step 4: refresh the page to check your status. The service reads your on-chain UCASH balance, cryptographically links your email to your wallet, and assigns you a level. Login via U.CASH SSO (Sign in with U) is optional; the wallet-based flow works on its own. Open →

Do I need an account to use U.CASH Verify?

No account is required for the core flow. The primary path is wallet-based: connect your Ethereum wallet (MetaMask), and the service reads your on-chain UCASH balance and lets you link an email. U.CASH SSO (Sign in with U) is offered as an optional convenience on top of the wallet flow, but you can verify purely with your wallet. Open →

How many recipients can I send to at once with U.CASH Send?

Each batch sends to up to 150 recipients in a single on-chain transaction. If your CSV has more than 150 recipients, you send multiple batches, one transaction each. Splitting into batches keeps each transaction within block gas limits while still being far cheaper and faster than sending one-by-one. Open →

Which chains does U.CASH Send support?

Send supports EVM networks including Ethereum, Polygon, Arbitrum One, OP Mainnet, Base, BNB Smart Chain, Avalanche, Linea, Scroll, Mantle, Berachain, Monad, Plasma, World Chain, Unichain, Ink, Sonic, Abstract, and HyperEVM, with TON available as an additional network. Select your network and the asset before uploading your recipient list. Open →

Does U.CASH Verify have an API?

Yes. Verify exposes a RESTful API for third-party integration. The main endpoints are GET /api/isVerified (check if an address is verified; returns the linked email and a verified boolean), POST /api/sendVerificationEmail (trigger the verification email), and GET /api/getAllEmails (retrieve verified emails, access-restricted). Other Ucosystem services use isVerified to look up an address's verified-email status before unlocking perks; the holdings-based uLevel is computed client-side from the on-chain balance and is not returned by the API. Open →

What are the U.CASH Verify levels?

Verify assigns a uLevel based on your UCASH holdings: User (Level 1, 1+ UCASH), Unifier (Level 2, 100+ UCASH), Unleasher (Level 3, 1,000+), Unrelenter (Level 4, 10,000+), Utopian (Level 5, 100,000+), and Ultimate (Level 21, 1,000,000+ UCASH). Higher levels unlock greater benefits, premium access, priority support, and discounts across the Ucosystem. Open →

Which chain does U.CASH Verify read my balance from?

Verify reads your UCASH balance from the Ethereum contract (0x92e52a1A235d9A103D970901066CE910AAceFD37) using ethers.js, querying the balanceOf for your connected wallet address. Since Ethereum is the home chain holding the large majority of supply, verification levels are based on your Ethereum UCASH balance. Open →

What is the difference between U.CASH, Uantum AI, and the Una assistant?

U.CASH is the open money network: the suite of pay, swap, buy, names, agents, send, and verify apps plus the portal, all non-custodial. Uantum (uantum.u.cash) is a separate general-purpose AI product that bills per turn in UCASH through the same account. Una (una.u.cash) is a merchant-facing AI assistant that helps U.CASH Pay merchants manage their store and settings conversationally. They are distinct products that share the U.CASH single sign-on identity and the UCASH billing layer, but they serve different purposes. Open →

Can U.CASH recover my funds if I lose access?

No. Because U.CASH is non-custodial, it never holds your funds or your private keys. Funds settle on-chain to addresses you control, and on-chain transactions are irreversible. If you lose access to your wallet or your keys, U.CASH cannot retrieve or reverse those funds, just as no one can reverse a blockchain transfer. Keep your seed phrases and private keys safe and backed up. This is the tradeoff of self-custody. Open →

What are the fees across the U.CASH network?

There is no monthly subscription. U.CASH Swap charges a flat 0.30% on swaps. U.CASH Pay charges a small platform fee per transaction (UCASH holders get a discount). Fiat card payments are processed through your own merchant account, so card fees are set by your card processor, not U.CASH. AI agent turns are billed per request in tiny fractions of UCASH or prepaid credit. You also pay the on-chain gas fee for the chain you transact on. Check each app for its exact current rate. Open →

How does U.CASH make money?

U.CASH earns fees on activity across the network: a percentage on payment processing through U.CASH Pay, a 0.30% fee on swaps at U.CASH Swap, per-turn billing on AI agent commerce, and revenue from names, verification, and the wider Ucosystem of apps and services. A portion of network revenue is used to acquire UCASH on the open market, which supports the token economy. U.CASH does not earn by holding or lending user funds, because it never holds them. Open →

Does U.CASH hold, pool, or lend user funds?

No. U.CASH never holds, pools, lends, or rehypothecates user funds, because it never has them. Every payment moves directly from buyer to seller on-chain. The only internal balance on U.CASH Pay is a non-withdrawable fee-credit balance used to pay processing fees, which cannot be withdrawn as funds. This is the core of the non-custodial model and the reason U.CASH is not a money transmitter under U.S. federal FinCEN rules. Open →

Is there a monthly subscription or recurring fee?

No. U.CASH apps do not require a monthly subscription or recurring membership. You pay per use: a percentage fee on swaps and payment processing, per-turn billing for AI agents, and the on-chain gas fee for your transactions. Some premium features on U.CASH Pay unlock based on your lifetime account activity rather than a subscription.

What does 'non-custodial' mean for me?

Non-custodial means U.CASH never holds your funds or your private keys. Payments settle directly to wallet addresses you control. U.CASH does not pool, lend, or rehypothecate customer funds, because it never has them. Your seed phrases and private keys stay in your wallet. The practical effect: there is no central U.CASH balance that can be lost, frozen, or seized. You are responsible for keeping your own keys safe. Open →

Do I need a separate account for each U.CASH app?

No. One U.CASH account, managed at portal.u.cash, works across pay, swap, buy, names, agents, send, and verify. The portal is the single sign-on identity provider: when you sign into any U.CASH app, you are authenticated through the portal and your session spans the whole network. Signing out of one app signs you out everywhere. Open →

How is U.CASH secured?

U.CASH security is architectural. Funds settle directly to wallets you control, so U.CASH never holds balances to lose. Session cookies are encrypted with AES-256-GCM. Webhooks are HMAC-signed and replay-safe (a 5-minute timestamp window plus constant-time signature compare). Platform APIs carry CSRF protection, and sensitive actions require an authenticated session. Wallet addresses are screened against the OFAC sanctions list at signup and when wallets are added. Card data never touches U.CASH; fiat cards run through your own processor. Open →

What is UCASH used for across the network?

UCASH is the U.CASH network access and loyalty token. It is used to bill AI agent turns (in tiny fractions per request), it earns fee discounts on U.CASH Pay based on how much you hold, and it underpins rewards and premium features across the network. Holding UCASH on a verified wallet raises your tier and unlocks lower processing fees and feature gates. UCASH is an ERC-20 on Ethereum, Polygon, and Base. You can buy it at buy.u.cash or swap for it at swap.u.cash. Open →

Who founded U.CASH, and who is on the team?

U.CASH was started in 2015 by an independent team. For more, see u.cash/about. Open →

Where is the developer hub, and what is in it?

The developer hub is at u.cash/developers. It covers the universal embed, the REST API with signed webhooks, SDKs across 12 language registries, the MCP server for agent runtimes, and the open standards (HTTP 402 and UCP). There is a quick start with three paths: drop in the embed script, call the API server-side, or verify a webhook. Full API and webhook reference for U.CASH Pay lives at pay.u.cash/docs. Open →

What is the fastest way to integrate U.CASH payments?

The fastest path is the universal embed: add a script tag pointing at pay.u.cash/embed.js with your publishable store cloud token (data-cloud="st_..."), an amount, and a currency. No server is needed, and the token is browser-safe. For server-side control, POST to pay.u.cash/payment/ajax.php with function=create-transaction, your cloud token, amount, currency, and an external_reference (the request is idempotent per external_reference). You get back a payment link to redirect the buyer to. Open →

I see an 'insufficient balance' or 'insufficient funds' error. What do I do?

This means the wallet or account does not have enough of the required asset to complete the action. For a swap, top up the input token in your connected wallet and make sure you also have enough of the chain's native token (e.g. ETH on Ethereum) to cover gas. For an AI agent or U.CASH Pay fee-credit action, add credit or UCASH to your account balance. Double-check the asset and the network: a token on the wrong chain will read as zero balance even if you hold it elsewhere.

I see an 'invalid address' error. What does it mean?

It means the wallet address you entered is not valid for the selected cryptocurrency or network. Each chain has its own address format: Bitcoin addresses look different from Ethereum (EVM DEXs...) addresses, which look different from Solana addresses. Check that the address matches the coin and the network you have selected, that you pasted the full address without truncation, and that you are not sending a token on the wrong chain. For human-readable addresses, U.CASH can resolve ENS, Unstoppable Domains, and FIO names to the correct wallet.

My wallet was rejected as not allowed. What happened?

U.CASH screens wallet addresses against the OFAC sanctions list at signup and when wallets are added, and the list refreshes daily. If a wallet is on that list, it cannot be used on U.CASH and you will see a neutral 'this address cannot be used' message. If you believe a wallet was flagged in error, contact support via the portal or [email protected]. This screening applies only to addresses used on U.CASH; it does not affect your on-chain funds, which remain fully under your control. Open →

A payment link shows 'transaction not found'. What do I do?

This usually means the payment link is expired, was already completed, or the token in the link no longer resolves to a store. Check that you opened the full, untruncated link and that it has not expired. If you are the merchant, verify your store's cloud token is still valid in your pay.u.cash dashboard. If you are a buyer and the link came from a merchant, ask the merchant to generate a fresh link. Because U.CASH is non-custodial, no funds are at risk from a stale link; nothing was held.

How do I get support or contact U.CASH?

The best way to get support is to start a ticket at pay.u.cash/support or email support\@u.cash. For anything tied to your account, sign in at portal.u.cash or pay.u.cash. Email routing: - hello\@u.cash - general questions - partners\@u.cash - partnerships - press\@u.cash - press and media - security\@u.cash - security reports Account questions cannot be handled over public channels because U.CASH is non-custodial and account access is self-managed through the portal. Open →

How do I get started with U.CASH?

Create one account at the U.CASH portal (portal.u.cash). That single login works across pay, swap, buy, names, agents, send, and verify. Then connect wallets you already control (Bitcoin xpubs, EVM addresses, Solana, Tron, and more) and start in whichever app fits: accept a payment at pay.u.cash, swap at swap.u.cash, buy UCASH at buy.u.cash, or claim a .u name at names.u.cash. There are no separate signups per app. Open →

I lost my 2FA device or authenticator. What do I do?

When you enrolled two-factor authentication at the portal, you were given one-time backup codes: use one of those to sign in and then re-enroll a new factor. If you enrolled a passkey on another device, you can use that. If you have neither backup codes nor another factor, contact support via the portal or [email protected] to start an account-recovery review. Note that 2FA protects your U.CASH login; it does not control your on-chain funds, which remain accessible to whoever holds your wallet keys. Open →

I lost my password. How do I recover my account?

Use the Forgot password link on the portal.u.cash sign-in page to receive a reset link by email. U.CASH cannot see or change your password for you. Because U.CASH is non-custodial, recovering your portal password restores access to your account dashboard and settings, but it does not recover your crypto wallets: funds are on-chain and controlled by whoever holds the wallet keys, independent of your U.CASH login. Open →

My payment is stuck 'pending' or 'confirming'. What should I do?

A payment stays pending until it reaches the required number of block confirmations for its coin. Slow confirmation usually means network congestion or a low gas fee on the sender's transaction. First, check the transaction on a public block explorer for that chain to see its confirmation progress. If it is confirmed on-chain but still pending in U.CASH, allow a few minutes for detection. For U.CASH Pay, the merchant's per-coin confirmation policy sets the threshold; you can ask the merchant or check your own store settings. You cannot speed up an on-chain transaction from U.CASH.

How do I report a security vulnerability?

Email [email protected] with details before any public disclosure so the team can investigate and fix it. U.CASH follows responsible disclosure. The plugins and SDKs are open source in the public GitHub org (github.com/UdotCASH), so you can review and report issues there too. Do not report security issues over public social channels. Open →

Which app should I use first?

It depends on your goal. To accept payments from others, start with U.CASH Pay (pay.u.cash). To trade one crypto for another, start with U.CASH Swap (swap.u.cash). To acquire the UCASH token, start with U.CASH Buy (buy.u.cash). To get a web3 identity like a .u name, start with U.CASH Names (names.u.cash). All of them share one account, so the rest are one click away once you sign in. Open →

What is the HTTP 402 (402.onl) protocol?

HTTP 402 (Payment Required) is the unused HTTP status code originally reserved for digital cash. The 402 Online Protocol, documented at 402.onl, turns any URL into a priced resource: a client requests it, the server returns 402 with a machine-readable 'accepts' list of payment options, the client pays (on-chain or by card), and retries with a payment receipt to get the content. It is what lets AI agents pay per request autonomously. U.CASH Agents is the reference implementation, and the spec is vendor-neutral and open. Open →

Is U.CASH accessible? Does it support accessibility needs?

U.CASH web apps are built with accessibility in mind: semantic HTML, keyboard navigation, skip-to-content links, ARIA labels on interactive controls, and a theme toggle for dark and light modes. The coin network pages and apps follow the same shared stylesheet and component patterns. If you hit an accessibility barrier in a specific app, please report it via the contact page or [email protected] so it can be addressed. Open →

How are my sessions protected?

Your U.CASH session cookie is encrypted with AES-256-GCM (authenticated encryption), which means a stolen cookie alone is not enough to act on your account. Sessions have an idle timeout and an absolute expiry, and login is protected by rate limiting and lockout to block brute force. Sensitive operations (like rotating API keys or changing payout addresses) can require a recent step-up authentication if you have a second factor enrolled. Open →

Where is the full API reference for U.CASH Pay?

The full API, webhook, and SDK reference for U.CASH Pay lives at pay.u.cash/docs, including the create-transaction and create-checkout endpoints, the test-connection endpoint for validating a webhook URL, the X-Webhook-Signature signing contract, and per-store credentials. The developer hub at u.cash/developers summarizes the same contract with quick-start examples. Base API URLs are pay.u.cash/payment/api.php (payment API), pay.u.cash/cloud/api.php (cloud API), and pay.u.cash/payment/ajax.php (checkout creation). Open →

What is the difference between a cloud token and an API key?

On U.CASH Pay, the store cloud token (a string starting with st_) is publishable and safe to put in buyer-facing URLs and embed code: it identifies which store a checkout belongs to. The API key (a 40-hex secret) is a server-side credential for the REST API and must never be exposed in a browser. This mirrors the publishable/secret key model. Each store gets its own cloud token and webhook secret, scoped to that store, not your whole account. You can rotate both from your dashboard. Open →

How many block confirmations are required, and can I change it?

Each cryptocurrency has a default confirmation policy tuned to its chain (for example, more confirmations for Bitcoin, fewer for fast finality chains). On U.CASH Pay you can set your own confirmation policy per coin, per store, so you decide what 'paid' means and balance speed against finality. You can also set a threshold above which a payment requires extra confirmations for large amounts. A payment is credited once it reaches the required confirmations on its chain. Open →

Is my data private? What does U.CASH store about me?

U.CASH stores only what is needed to operate the platform: your account email, the wallet addresses you connect, transaction records for settlement indexing, and notification preferences. U.CASH does not require or store government IDs. Each merchant's data lives in an isolated database. Wallet addresses are screened against the OFAC sanctions list for abuse prevention. See the privacy page for the full details on what is collected and why, and reach [email protected] with specific requests. Open →

Which SDKs and libraries does U.CASH offer?

U.CASH ships zero-dependency SDKs across 12 language registries: JavaScript/TypeScript (npm, including React, Vue, Svelte, Solid, Preact, Angular, Next, Nuxt, Astro, Deno), Python (PyPI), Rust (crates.io), Java (Maven Central), .NET (NuGet), Elixir (Hex), Deno (JSR), Flutter/Dart (pub.dev), Ruby (RubyGems), PHP (Packagist, Laravel and Symfony), Swift (Swift Package Manager), and Go (pkg.go.dev). All share the same createCheckout and verifyWebhook contract. Some are live on their registry; others are build-ready in their public GitHub repo. Open →

Who pays the network (gas) fee?

On U.CASH Pay, the buyer sends a real on-chain transaction to the seller's wallet, so the buyer pays the network (gas) fee for their own chain. For swaps at swap.u.cash, your wallet signs the swap and pays the gas for the chain you transact on. For agent payments over the gasless exact (EIP-3009) rail, the buyer signs an off-chain authorization and a platform relayer submits the on-chain transaction, so the buyer pays no gas (the seller is billed the relayer's gas plus a small margin). U.CASH itself does not subsidize gas except through that relayer path. Open →

How does one account work across all the apps?

portal.u.cash is the U.CASH identity provider. Each app (pay, swap, buy, names, agents, send, verify) is a relying party. When you sign into an app, it delegates authentication to the portal over a signed, single-use code exchange, then issues a shared session cookie scoped across u.cash. You log in once at the portal and every app recognizes you. The same factor (password, TOTP, or passkey) protects every app. Open →

How many integrations and plugins does U.CASH have?

U.CASH has 125+ open-source plugins, SDKs, and integrations across e-commerce (WooCommerce, Shopify, Magento 2, BigCommerce, PrestaShop, and more), billing and invoicing (WHMCS, Invoice Ninja, QuickBooks, Xero), point of sale, memberships, donations, creator platforms, chat and social bots, automation (Zapier, n8n, Make), AI agent frameworks (LangChain, LlamaIndex, crewAI), and native mobile frameworks. All are non-custodial: funds settle direct to your wallet. Browse the full catalog at u.cash/integrations and github.com/UdotCASH/awesome-ucash. Open →

Does U.CASH require KYC (identity verification)?

No. U.CASH itself does not require or store government IDs. Because U.CASH is non-custodial and never holds your funds, it does not run a KYC program on its users. Wallet addresses are screened against the OFAC sanctions list at signup and when wallets are added. Note that some third-party partner services you can reach through U.CASH, such as the instant-exchange provider behind some swaps, may have their own KYC requirements under their own terms. Open →

Is there an MCP server for U.CASH?

Yes. mcp-ucashpay is on PyPI and exposes U.CASH Pay as MCP tools for Claude Desktop, Cursor, and any MCP-compatible client. It lets an AI agent drive seller actions like creating checkouts, listing resources, and viewing settlements over the same API. There is also a separate agents-u-cash SDK (npm and PyPI) for the HTTP-402 buyer and seller flow, and a ucashpay-skills pack with a Cursor rule and a Claude Code skill. Open →

Does U.CASH have a mobile app or is it desktop only?

U.CASH apps are web apps that work in any modern browser on desktop and mobile, and they are designed mobile-first. Web3 wallet features use wallet extensions or mobile wallet apps that you already have. There are also platform SDKs (React Native, Flutter, Swift, Android) so developers can embed U.CASH payments inside native mobile apps. There is no separate U.CASH consumer mobile app to install; you use the web apps at pay.u.cash, swap.u.cash, and so on. Open →

Where is the U.CASH roadmap or whitepaper?

U.CASH does not publish a single traditional whitepaper. The closest equivalents are the Economy page (u.cash/economy), which explains the UCASH token, the Ucosystem revenue model, and how network revenue feeds the token, and the Technology page (u.cash/technology), which covers settlement, multi-chain routing, webhooks, and confirmations. The About page (u.cash/about) covers the company story from 2015 onward. For developer direction, the open standards (HTTP 402 at 402.onl and UCP at ucp.dev) and the public GitHub org reflect what is being built. Open →

How do U.CASH webhooks work and how do I verify them?

When a payment is confirmed, U.CASH Pay sends an HTTP POST to your webhook URL with an X-Webhook-Signature header of the form t=<unix-seconds>,v1=<hex>. The v1 value is HMAC-SHA256 of the string "<t>.<raw-request-body>" keyed with your webhook secret. To verify: parse t and v1, reject if the timestamp is older than 300 seconds (replay protection), recompute the HMAC over the raw body, and compare in constant time. Use the event_id field to deduplicate, since the same confirmed transaction may be delivered more than once. Always hash the exact bytes you received; re-encoding the JSON breaks the signature. Open →

Where is the U.CASH status page?

The status directory is at u.cash/status. It lists what is running and where to check each service directly, rather than publishing synthetic uptime percentages. If a service looks degraded, the fastest way to confirm is to open the app itself or start a ticket at pay.u.cash/support. For Pay-specific operational status, see pay.u.cash/status. Open →

How many blockchains and tokens does U.CASH support?

U.CASH supports 30+ blockchains out of the box, including Bitcoin, Ethereum, Solana, Tron, Polygon, Base, Arbitrum, Optimism, BNB Chain, and Avalanche, plus 12 newer EVM chains (Linea, Mantle, Berachain, Sonic, Unichain, Worldchain, Monad, Plasma, Abstract, HyperEVM, Scroll, Ink). You can also add any custom token across 22 networks (ERC-20, BEP-20, Base, Polygon, Arbitrum, Optimism, TRC-20, SPL, and more). U.CASH Swap reaches 1,500+ swappable coins. UCASH itself lives on Ethereum, Polygon, and Base. Open →

Which countries or regions does U.CASH support?

U.CASH is internet-native and is not gated by country: the apps are reachable globally and crypto settlement works wherever the underlying blockchains do. Because U.CASH is non-custodial and does not hold fiat, it does not impose per-country access the way a fiat on-ramp would. You are responsible for complying with your local laws, including any restrictions on crypto use and your tax reporting obligations. Some partner services (for example instant-exchange providers) may have their own regional restrictions and KYC requirements. Open →

Does U.CASH provide tax reporting or statements?

U.CASH does not issue tax forms and does not report to tax authorities. You can view and export your transaction history from each app (for example the Pay dashboard and Swap history). Because crypto transactions are taxable events in many jurisdictions, you are responsible for keeping your own records and reporting accurately. U.CASH recommends consulting a tax professional familiar with cryptocurrency in your country. Open →