# Set up auto-swap
Source: https://guide.crypto-now.io/auto-convert-deposits-to-stablecoins-auto-swap
Create a per-account rule that automatically converts incoming crypto to the coin you want to hold, every time a wallet is topped up past a threshold.
Auto-swap turns one currency into another automatically. You set a rule once — *when this wallet receives at least \$X, convert it from coin A to coin B and send it here* — and CryptoNow runs the conversion on every qualifying replenishment, with no manual step. It's how you keep your treasury in a stable coin without watching wallets.
Rules are **per Account**, so set the **Account** toggle (top-right) to the account you want the rule on before you start.
Go to **Settings** (the gear in the left nav) and scroll to the **Auto swap** card. Click **Create new**.
Fill in the five fields, then click **Submit**:
* **Name of rule** — a label for your own reference (e.g. *BTC to USDT (ERC20)*).
* **You send** — the currency to convert.
* **You get** — the currency to receive.
* **Minimum amount in USD** — the threshold. When a top-up brings the sender wallet to at least this value, the swap fires.
* **Sender's wallet** — the wallet that's watched; its incoming funds get converted.
* **Destination wallet** — where the converted currency lands.
The saved rule appears in the Auto swap card, with edit and delete controls. It's now active and will run on the next qualifying replenishment.
Auto-swap relies on **auto-sign being enabled** (it's on by default). If auto-sign is off, the rule can't execute. See **Secure your account** for the auto-sign setting.
Each auto-swap is a live exchange, so it carries the usual swap cost — the network (miner) fee plus the third-party exchange provider's fee, taken from the amount converted. Conversions run on mainnet.
# Create your account
Source: https://guide.crypto-now.io/create-your-account
Register your CryptoNow account with email and get to your dashboard in a couple of minutes.
Creating your CryptoNow account takes about two minutes. You can sign up four ways — **email, phone, Google, or MetaMask** — and this guide walks through email, the most common. The steps are nearly identical for the others.
Go to [app.crypto-now.io](https://app.crypto-now.io) to begin.
## Sign up
On the welcome screen, pick **Sign up with email**. Phone, Google, and MetaMask sit right beside it if you'd rather use one of those — Google and MetaMask double as login later if the account already exists.
Type the email you want the account tied to, then set a password.
Your password must be at least **8 characters**, with at least **one uppercase letter** and **one digit**. The strength meter below the field updates as you type.
Click **Sign up**. CryptoNow creates your account and signs you in.
A "Congratulations, registration is complete" message appears. Click **OK** to land on your dashboard.
## What you'll see
You arrive on your **dashboard** — total balance up top, and your full list of coins and tokens below, each starting at zero. This is home base. Your wallets are already created for you; nothing to set up there.
**One quick thing before you take any money in.** CryptoNow lets you sign up and look around freely, but the moment you go to **withdraw funds, view a private key, or view an API key**, you'll be asked to turn on two-factor authentication (email + Google Authenticator). It's worth setting up now so it's not in your way later — see [Secure your account](/getting-started/secure-your-account).
Want to rehearse the whole flow without real funds first? Switch your account to **Testnet** using the network switcher (top-right). Everything works exactly the same, with test currency.
Getting started takes about two minutes: create an account, confirm your email, and you're in.
**Every CryptoNow account is a Business account.** There's no plan to pick at sign-up — you get up to 5 accounts, unlimited clients and wallets, commission controls, API access, and e-commerce integrations from the start.
## Sign up
You can register four ways — **Email, Phone, Google, or MetaMask**. Google and MetaMask double as your login afterwards. This guide uses email.
Head to the sign-up page, enter your email, and choose a password. The strength meter should read **Secure** before you continue.
Click **Sign up**. CryptoNow confirms the account was created and asks you to activate it by confirming your email.
Open the **Email confirmation** message from CryptoNow and click **Confirm email**. Your account isn't active until you do this.
You land on your dashboard — total balance, **Send / Receive / Swap**, and your full list of supported coins and tokens, all at zero until your first payment.
## What's next
Two-factor authentication isn't forced at sign-up, but **email + Google Authenticator 2FA are required before any money or key action** — withdrawing, moving funds, viewing keys, or generating API keys. Set this up first in [Secure your account](/secure-your-account).
# Create a payment link
Source: https://guide.crypto-now.io/create-your-first-payment-link
Configure a hosted checkout, pick one of four payment types, brand it, and share a link to start accepting crypto.
A **checkout** is the reusable object behind your payment links, buttons, and iFrames. Create one once, then share its link anywhere — email, chat, social, a QR code — and your customer pays in crypto on a CryptoNow-hosted page. No code required.
## Create a checkout
Go to **Payments → Checkouts** and click **Create Checkout**.
Pick one of the four payment types. This is the first decision and it shapes the rest of the form.
* **Accept crypto** — customer chooses any amount (deposits, top-ups, donations).
* **Sell a product** — fixed price in fiat (stores, digital goods, invoices).
* **Sell currency** — customer sends one coin and receives another (in-widget exchange).
* **Cart** — no stored amount; the total and fiat currency are passed in the link as parameters.
The steps below use **Sell a product** as the worked example.
Decide whether to capture the payer's details: nothing, full name, and/or email. Click **Next**.
Set the product name, description, post-payment **Website** (where the customer lands after paying), **Payment methods** (which coins you accept), **price + fiat currency**, and **Expire time** (how long a charge stays open — 10 / 30 / 60 min). Brand it with a checkout photo, logo, background and accent colour. Then click **Create**.
**Accept crypto** uses this same form without the price field — the customer enters any amount at pay time.
On success you get three ways to deliver the checkout — **Link**, **Embed** (button snippet), and **iFrame** — plus the **clickId** option. Copy the link and you're live.
This is what your customer sees when they open the link — your branding, the total, and the coins you accept:
## Track payments with clickId
Enable **clickId** on the share panel and append your own id to the link (`?clickId=...`) — an order id, customer id, or any other reference (numbers and characters). It's attached to the transaction, **searchable**, echoed back in callbacks, and returned in the API as `outsideOrderId`. This is how you reconcile an on-chain payment to a specific order or user in your CRM.
## The other checkout types
### Sell currency
The customer sends one coin and receives another. Set **Receive payment** (the coin you pay out), the **Merchant wallet** it pays from, **min / max** amounts, and **Fixed** or **Market** price.
The payer enters a "you send" amount, sees the live rate, and provides a recipient wallet for the coin they receive. If they send less than quoted they get proportionally fewer tokens (but never below `min`); if more, never above `max`.
### Cart
A Cart checkout stores **no price** — just a fiat currency. The amount is passed in at pay time, which makes it the right choice for a shopping basket with dynamic totals.
Its share panel adds an **amount and fiatCurrency** toggle — those two values travel as URL parameters on each charge, alongside the optional `clickId`.
Need to embed the checkout on your own site instead of sharing a link? See **Embed payments on your site**.
# Embed payments on your site
Source: https://guide.crypto-now.io/embed-payments-on-your-site
Put a CryptoNow checkout on your own website — a 'Pay with Crypto' button or an inline iframe. No backend, no card networks in between.
You can drop a checkout onto your site two ways: a **button** that opens the CryptoNow payment widget, or an **iframe** that shows it inline. Both are copy-paste — no API keys, no server code. The customer pays on CryptoNow's hosted widget, and the payment settles to your account wallet carrying your order's `clickId` for reconciliation.
The widget is CryptoNow's hosted page (the footer reads "Payments processed by Crypto Now"). A **custom domain** can white-label that URL — see the Tip at the bottom.
Open the checkout in **Payments → Checkouts**, then **Product information**. You'll see three tabs:
* **Link** — a plain URL (opens the widget in a new tab; good for emails/QR).
* **Embed** — a ready-made **button** snippet.
* **iFrame** — an inline embed snippet.
Tick **amount and fiatCurrency** if it's a Cart checkout (so the snippet carries the basket total), and **clickId** to attribute the payment to a specific order or customer.
The **Embed** (button) snippet:
```html theme={"system"}
```
The **iFrame** (inline) snippet:
```html theme={"system"}
```
Paste the button (or iframe) snippet into your page. The button renders wherever you place it — here on a storefront's cart.
The customer fills their cart and selects **Pay with Crypto**. The hosted widget opens with the order total.
They choose a currency and network, then **Proceed to the payment**.
The widget shows the exact amount, a deposit address, and a QR code, with a countdown until the charge expires.
Once the funds confirm, the widget shows success with the received amount and transaction hash.
The payment appears in **Transaction's → History** as a **Replenishment**, carrying your **clickId** and an **IncomingHash** that matches the widget's hash — so you can tie each on-chain payment back to the exact order.
**Button vs iframe.** The **button** opens the widget in a popup or new tab. The **iframe** keeps the widget inline on your page so the customer visually stays on your site. Both run the same hosted checkout.
**Settlement.** The funds land in your account wallet as a replenishment, net of the standard 0.5% replenishment fee, with your `clickId` echoed back on the transaction (`outsideOrderId` in the charge response). Match on `clickId` to reconcile against your store.
The widget URL is `checkouts.crypto-now.io`. Set a **custom domain** on the checkout to white-label it as your own.
# Permanent deposit addresses
Source: https://guide.crypto-now.io/give-clients-a-permanent-deposit-address
Give each customer a fixed deposit address — minted by the API when they start a deposit — so repeat deposits always credit, funds settle to your treasury, and a callback fires on every payment.
For deposit-driven businesses (casinos, brokers, prop firms), each customer gets a **permanent** deposit address they reuse for every deposit. Your platform calls the API to mint that address the moment a customer starts a deposit, shows it natively in your own UI, and funds sweep into your account (treasury) wallet automatically — with a **callback** on every payment so you can credit the user. A returning customer reuses the **same address**, so repeat deposits are never lost.
The deposit loop:
picks a method and confirms.
on-demand — the address is minted at this moment.
natively, no redirect.
they land at the address.
you credit the user in your system.
**Static client wallet vs checkout charge — critical.** A client wallet assigned to a customer is **permanent**: repeat deposits to the same address are **always credited**. A checkout charge mints a **single-use** wallet — re-sending to a previous charge address is **not tracked**. "Same address every time" applies to client wallets only.
## 1. Set the callback URL, then generate API keys
Order matters: set the **Callback Url** *first*, Submit, and only **then** generate keys. In **Settings → Account Data**, enter your callback endpoint, Submit, then click **Generate new API keys** — you get a **Public key** and **Private key**.
The **Private key** is server-side only — never ship it to the browser. Treat the keys and the passphrase below as secrets.
## 2. Get your account wallet's Wallet ID + passphrase
Wallet operations (and withdrawals) need the **account wallet's Wallet ID + passphrase** for the network you settle on — here the **EVM / Ethereum** account wallet. In **Wallets → Account wallets**, open the wallet's menu → **Passphrase** → **Send code** (passes 2FA) → the **Wallet ID** and **Passphrase** are revealed.
This is the **account** wallet's ID. You never fetch a client wallet's ID — client wallets are created **by the API**, on demand, in the next step.
## 3. The customer starts a deposit — and the wallet is minted
In your platform's deposit screen, the customer picks the method and clicks **Confirm**.
That **Confirm** is what triggers your backend to call the API. API base: `https://napi.crypto-now.io`. Authenticate with the keys, look up the `currencyId` for the network, then create the client wallet (`typeWallet: user`) — the response's `address` is what you display.
```bash theme={"system"}
# 1. Authenticate → JWT
curl -X POST https://napi.crypto-now.io/api/public/auth \
-H "Content-Type: application/json" \
-d '{ "publicKey": "", "privateKey": "" }'
# → { "token": "" }
```
```bash theme={"system"}
# 2. Find the currencyId (e.g. USDT-ERC20)
curl https://napi.crypto-now.io/api/public/currency \
-H "Authorization: Bearer "
```
```bash theme={"system"}
# 3. Create the user's client wallet → returns its address
curl -X POST https://napi.crypto-now.io/api/public/wallet/ \
-H "Authorization: Bearer " \
-H "Content-Type: application/json" \
-d '{ "typeWallet": "user" }'
# → { "data": { "id": "", "address": "0x...", "passphrase": "..." } }
```
Your platform shows the returned **address + QR**:
Store `user → { walletId, address }` and reuse it for that user. The wallet you just minted now appears in CryptoNow under **Client wallets** at `$0.00` — it didn't exist before the customer confirmed:
There's also a Node SDK — `crypto-now-node-api-sdk` (npm) — wrapping these calls.
## 4. Repeat deposits reuse the same address
Because you stored and reuse the wallet, a returning customer gets the **same address**. Below, a second, separate deposit (different deposit ID) resolves to the identical address — so a customer who re-uses an old address is still credited.
## 5. The customer pays
Once the payment lands, your platform shows it as deposited:
## 6. Receive the callback
CryptoNow fires a callback to your URL on each client-wallet replenishment. The body is encrypted; the JWT carries the `walletId` and an encrypted `salt`, so the decrypt is self-contained (decrypt code for Node / PHP / Python is in the API docs). Decrypted, it carries the transaction details you use to credit the user.
```js theme={"system"}
import CryptoJS from 'crypto-js';
const decrypt = (encrypted, salt) =>
CryptoJS.AES.decrypt(encrypted, salt).toString(CryptoJS.enc.Utf8);
// req.headers.authorization = "Bearer "; req.body.data = encrypted payload
const { id: walletId, salt } = decodeJwt(req.headers.authorization.slice(7));
const finalSalt = decrypt(salt, walletId);
const payload = JSON.parse(decrypt(req.body.data, finalSalt));
// → { typeTransaction: "Replenishment", currency: "USDT", amount: "10",
// wallet: { id }, payer, incomingTxHash, ... }
```
Confirm deliveries under **Settings → Outgoing Webhooks** — an `InitialReplenishmentDetect` then a `Replenishment`, both delivered (Status `True`):
If you passed a `clickId` when creating the charge/wallet, it comes back as `outsideOrderId` — use it to map the payment to your order/user.
## 7. Settlement: throughput vs. actual balance
The **client wallet** doesn't hold funds — it sweeps everything to your account wallet — so the figure it shows is **cumulative throughput**, not a live balance. Here it reads **10 USDT** (the amount that passed through):
The **account wallet** holds the actual funds: **9.95 USDT** — the 10 USDT deposit minus the **0.5% system fee** (0.05 USDT) on replenishment. The swept replenishment transaction shows the client → account hop, the miner fee (paid in ETH from the account wallet) and the on-chain hashes.
This whole flow relies on **auto-sign being ON** (the default). It fronts gas for the sweep and lets the callback complete — disabling it breaks deposits. See **Secure your account**.
# How wallet balances work
Source: https://guide.crypto-now.io/how-wallet-balances-work
Account wallets versus client wallets, and why the number on a client wallet is throughput — not a spendable balance.
CryptoNow has two kinds of wallets, and the figure shown on each means something different. Getting this right matters: the number on a **client wallet** is not money you can spend — it's a running total of everything that has ever passed through.
| | Account wallet | Client wallet |
| -------------------- | ---------------------------------- | ------------------------------------------------------------- |
| **What it is** | Your own treasury wallet | A deposit address assigned to one end-client, per network |
| **Balance shown** | Your **actual, spendable** balance | **Cumulative throughput** — everything ever received |
| **Permanent?** | Yes | Yes, for a static/API client wallet (same address every time) |
| **You pay out from** | This one | Never — funds have already swept out of here |
Find both under **Wallets** in the sidebar: **Account wallets** (your treasury) and **Client wallets** (per-client deposit addresses).
## Where the money actually sits
When a client sends funds to their client wallet, those funds **auto-forward (sweep)** to your default **account wallet** as a **replenishment** — net of the standard **0.5% replenishment fee** — and a **callback** fires. So your spendable money lives in the account wallet, not the client wallet.
The client wallet's "balance" is **cumulative throughput**, not a current or spendable balance. Don't read it as funds on hand and don't try to pay out against it. Always use the **account wallet's** real balance for payouts.
## Worked example
A client sends **10 USDT** to their permanent deposit address:
* The funds sweep to your account wallet, which credits **≈9.95 USDT** (10 − 0.5% replenishment fee).
* A callback fires, carrying your `clickId` so you can attribute the deposit.
* The **client wallet** figure goes up by the full 10 (throughput); the **account wallet** shows the real **≈9.95** you can actually use.
**Permanent vs single-use.** A static client wallet keeps the **same address every time**, so repeat deposits are always credited — the right pattern for recurring depositors. A **checkout charge** mints a single-use address instead; re-sends to a past charge address are **not** tracked. The "same address every time" promise is the static client wallet, not a checkout link.
Reconcile deposits against your own system by matching on **`clickId`** (it echoes back on the transaction as `outsideOrderId`).
# Get started with CryptoNow
Source: https://guide.crypto-now.io/index
Accept crypto payments, pay people out, and manage your treasury — with your funds under your control the whole way through.
Everything you need to accept crypto payments, pay people out, and manage your treasury — with your funds staying under your control the whole way through. Pick a track below, or use the sidebar to jump straight to any step.
Create your account, switch on two-factor security, and find your way around the dashboard.
Payment links, on-site checkout, WooCommerce, permanent deposit addresses, and subscriptions.
Withdraw to any address, or pay many recipients at once with a single multisend.
Swap between coins and auto-convert incoming deposits to the currency you want to hold.
Understand what wallet balances really mean and decode every transaction status and type.
Full API reference and integration guides for building directly on CryptoNow.
# Make a withdrawal
Source: https://guide.crypto-now.io/make-a-withdrawal
Send crypto out of your CryptoNow account to any external address, another internal wallet, or a saved contact — with fees, gas priority, and two-factor security.
When funds land in your account wallets, you withdraw them straight from the dashboard. CryptoNow estimates the network (miner) fee and the system fee, takes both **on top** of the amount you enter, and asks for two-factor confirmation before anything moves.
**Fees are added on top — the recipient gets exactly what you type.** Your wallet is debited the amount **plus** the miner fee **plus** the 0.5% system fee. You never have to back the fees out of the amount yourself.
## Before you start
* The wallet you're withdrawing from needs the **native gas coin** of that network. For an ERC-20 token like USDT, that means the account wallet must hold some **ETH** to pay the miner fee. (See [Set up your treasury & gas](/set-up-your-treasury-and-gas).)
* Both 2FA factors must be active: an **email code** and **Google Authenticator**. (See [Secure your account](/secure-your-account).)
## Withdraw funds
Go to **Transaction's → Withdraw** (or click **Send** on a funded wallet from Home). Your wallets that hold a balance appear here.
In the **Withdraw** dialog:
* **Currency** — the coin/token to send (only currencies with funds are listed).
* **Wallet address** — the source account wallet. The line beneath it shows the native-gas balance available to pay the miner fee (e.g. `ETH: 0.0058… — $9.22`).
* **Sent to** — choose **External wallet** (paste any address), **Internal wallet** (move between your own wallets), or **Address Book** (a saved contact).
* **Amount** — type a figure or hit **MAX**. The **Minimum** is per-coin and small (here `$0.01`) — there is no flat minimum.
* **Gas priority** — **Low / Normal / Fast**. Faster confirmation costs more miner fee.
* **Exchange rate in USD** — a helper to size the amount in dollars.
The dialog shows the running **Total** as *Amount + Miner Fee + System Fee*.
A **0.5% system fee** applies to withdrawals — the dialog states this directly. On a 2 USDT withdrawal that's 0.01 USDT.
Press **Submit**. CryptoNow emails a one-time code — enter it and click **Confirm**.
Then enter the current code from **Google Authenticator** and click **Confirm**. Withdrawals require **both** factors.
You'll see a **Success** confirmation, and the **Withdrawal** appears in your transaction list with its hashes and the exact miner and system fees. The wallet balance drops by the amount plus the system fee; the miner fee is paid in the network's native coin.
## Where the fees come from
| Fee | Paid in | Taken from |
| ----------------------- | ------------------------------------------ | ------------------------- |
| **Miner (network) fee** | the network's native coin (ETH, BNB, TRX…) | the source account wallet |
| **System fee (0.5%)** | the coin being withdrawn | the source account wallet |
The **gas-payer toggle** in your account settings ("Miner Fee for withdrawal / replenishment pays…") governs **client-wallet** flows — replenishment sweeps and client-wallet withdrawals. An **account-wallet** send like this one always draws its miner fee from the account wallet itself, so keep a little native gas there.
## Worked example
Withdrawing **2 USDT** from a 9.95 USDT wallet:
* Recipient receives exactly **2 USDT**.
* **System fee:** 0.01 USDT (0.5% of 2).
* **Miner fee:** \~0.0000883 ETH, paid from the account wallet's ETH.
* New USDT balance: **7.94** (9.95 − 2 − 0.01).
# Pay many people at once
Source: https://guide.crypto-now.io/pay-many-people-at-once-multisend
Send the same coin or token to many addresses in a single multisend — one on-chain transaction covers up to 200 recipients.
Multisend pays out to many addresses at once. You paste a list of addresses and amounts, the dashboard estimates the fees, and it settles in as few transactions as possible.
One on-chain transaction covers up to **200 addresses**. Larger lists are split automatically — 1,000 recipients run as 5 transactions, for example.
Go to **Payments → Multisend**. On the left, **Token multipayment** lists what each wallet holds — select the coin or token to send. Then choose the source wallet in the **Multisend** panel.
In **Addresses with Amounts**, add one recipient per line as `address;amount` (address and amount separated by a semicolon). For long lists, use **Upload file** with a `.csv`. **Show examples** demonstrates the correct format.
The footer states the System Fee directly: **\$0.10 per address**. Duplicate addresses can be merged or kept, depending on the option you pick.
Select **Next**. To estimate the Miner Fee, the dashboard makes an external call that itself costs a small blockchain fee — confirm with **Continue**.
Check the recipient list and the **Summary**: total addresses, transactions needed, the approximate **Miner Fee** (network) and **System Fee** (\$0.10 per address), and your balance.
Select **Confirm**. You'll see a confirmation that the transaction was processed.
The payout appears in **Transaction's → History** as a single **Multisend** entry, first **Pending** then **Done**. Expand it for the Payment ID, Miner Fee, System Fee, and hash; **Show multisend addresses** lists every recipient.
Both fees are paid from the sending wallet's **native coin** (ETH, BNB, etc.): a \$0.10 System Fee per address plus the network Miner Fee. Make sure the wallet holds enough native coin to cover gas and fees before you send.
Sending an **ERC-20 token** (USDT, USDC) adds a one-time on-chain **approval** before the payout, so the contract can move that token on your behalf. Sending a **native coin** like ETH skips this step.
**Worked example.** 3 Ethereum recipients settled in 1 transaction. Approximate Miner Fee ≈0.0000299 ETH; System Fee ≈0.000192 ETH ($0.30 = 3 × $0.10), both drawn from the sending wallet's ETH.
# Recover a wrongly-sent token
Source: https://guide.crypto-now.io/recover-a-wrongly-sent-token
When someone sends an unsupported token to one of your client wallets, you can still get it out — by exporting that wallet's private key and moving the token from an external wallet you control.
CryptoNow automatically credits and sweeps the tokens it supports. If a client sends a **token CryptoNow doesn't recognise** (an obscure ERC-20, an LP token, the wrong network's asset) to one of your static client wallets, it won't auto-credit — it simply sits at that address on-chain, untouched.
Because **you hold the keys to every wallet**, nothing is lost. You export the client wallet's private key, import it into any self-custody wallet, and send the token wherever you want.
Exporting a private key gives **full control of that wallet** to anyone who holds it. Treat this as a break-glass recovery: do it deliberately, never paste the key anywhere untrusted, and consider the wallet's key "spent" afterwards.
**The wallet needs native gas to send the token out.** A client wallet usually keeps a little ETH/BNB/etc. from earlier sweeps. If it's empty, send a small amount of the network's native coin to the wallet address first.
## Recover the token
Paste the client wallet address into a block explorer (Etherscan for EVM). You'll see the incoming token transfer that never got swept.
In CryptoNow, go to **Wallets → Client wallets**, search for the wallet by address, open the **⋮** menu and choose **Show private key**.
Enter the code from **Google Authenticator** and send it. (See [Secure your account](/secure-your-account) if 2FA isn't set up.)
The key is shown once — copy it.
Open any self-custody EVM wallet — this example uses **Ctrl Wallet**; **MetaMask**, **Phantom**, etc. work too, depending on the token's network. Choose **Add → Import wallet or account → Import with Private Key**, pick the network, paste the key, and give it a name.
The imported wallet now shows the stuck token alongside any leftover native gas.
Send the token out — to the client's correct wallet, to your account wallet, or to an exchange. The network fee is paid from the native coin on the wallet.
## Why this happens
CryptoNow sweeps **supported** assets to your account wallets automatically. Anything outside that set — an LP token, a one-off ERC-20, a token sent on a network the wallet wasn't created for — lands at the address but isn't tracked. The static client wallet is a **real on-chain wallet you control**, so the funds are always reachable with its key; this recovery is simply how you reach them.
Send the token to whichever wallet you want it in — typically the client's correct address or your own account wallet — and the recovery is complete.
# Secure your account
Source: https://guide.crypto-now.io/secure-your-account
Confirm your email and switch on Email 2FA and Google Authenticator in CryptoNow. Both are required before you can view keys, withdraw, or move funds.
CryptoNow protects every money- and key-related action with two independent layers: **Email 2FA** and **Google Authenticator**. This guide confirms your email (a prerequisite) and turns both on.
**Both layers are effectively mandatory.** Email 2FA and Google Authenticator each gate viewing private keys, viewing API keys, withdrawing, moving funds, deleting a wallet or account, and login. They aren't forced at first login — they're enforced the first time you try to act. Enable both now so you're not blocked later.
## Confirm your email
From the dashboard, open the **User** menu (top-right) and click **Profile**.
In the **Confirm E-mail** section, click **Send link**. (The button greys out once your email is confirmed.)
Open the email from CryptoNow and click **Confirm email**. If the button doesn't work, paste the fallback link shown in the message into your browser.
On the **Your email has been verified** screen, click **Browse your CryptoNow**, then switch back to the app to continue.
## Turn on Email 2FA
In the **Enable E-mail 2FA** section of your profile, click **Enable 2FA**. You'll see a success confirmation. This is the first of the two layers.
## Turn on Google Authenticator
This is a **separate toggle** from Email 2FA. It lives in the **Two-factor authentication** section — not the **Enable E-mail 2FA** section above it. You need both.
In the **Two-factor authentication** section, click **Enable 2FA** to open the setup dialog with the QR code.
In Google Authenticator on your phone, add an account and scan the QR code. If you can't scan, enter the setup key shown beneath it manually.
Type the current 6-digit code from Google Authenticator into the **Authenticator Code** field.
Click **Enable 2FA** to confirm. Google Authenticator is now active alongside Email 2FA.
**Set your backup phrase too.** In the **Backup Phrase** section, click **Start Backup** to generate your 12-word recovery phrase. It's created once, can't be changed, and is the way to reset your password if you're locked out. Write it down and store it offline — never in the browser or a screenshot.
**Leave Autosign ON.** Autosign is on by default and is load-bearing — disabling it breaks token checkouts, client-wallet sweeps, swap, and auto-swap. Don't turn it off while hardening your account.
**Using the API?** You can further restrict public-API access by **IP**, **Origin**, and **User-Agent** allowlists in your account's Security settings.
## Turning 2FA off
You can disable either layer later with the **Disable 2FA** button, but you'll need to pass your current 2FA to do it. We recommend keeping both on — they're required before any withdrawal or key action regardless.
## Next step
Fund your account wallet for gas and learn who pays network fees on deposits vs. withdrawals.
CryptoNow doesn't force two-factor authentication at sign-up, but it's required the moment you do anything that matters.
**Email 2FA and Google Authenticator are effectively mandatory.** Both must be on before you can withdraw, move funds, view private or API keys, or delete a wallet or account. Set them up now so nothing blocks you later.
Everything here lives under **Settings → Security**.
Under **Confirm E-mail**, click **Send link**, then open the message and confirm. The status flips to **Confirmed**.
Click **Enable 2FA** under **Enable E-mail 2FA**. From now on, a code is emailed to you for sensitive actions.
Under **Two-factor authentication**, click **Enable 2FA**, scan the QR code with Google Authenticator (or any TOTP app), and enter the 6-digit code to confirm.
Store your authenticator backup somewhere safe. If you lose the device, regaining access means contacting support.
Under **Backup Phrase**, click **Start Backup** and write down the 12 words in order, offline. This recovers your account if you lose your password.
Both factors on, your account looks like this:
## Restrict API access (for API users)
If you'll use the API, lock it down under **Settings → Security** by allowlisting the **IP**, **Origin**, and **User-Agent** that may call it. Skip this if you're not building an integration.
One thing **not** to touch: leave **autosign on**. It's on by default and signs your checkouts, sweeps, and swaps automatically — turning it off breaks those flows.
# Set up subscription payments
Source: https://guide.crypto-now.io/set-up-subscription-payments
Create an on-chain subscription plan, publish it, and share it so customers can subscribe and pay you automatically every period.
Recurring billing lets you charge customers on a repeating schedule — daily, weekly, monthly, or yearly — directly on-chain. You create a **plan**, publish it, and share a link. Your customer approves once in their wallet, and each period the amount settles straight to your payee wallet. You stay in control of the funds the whole way.
A subscription plan lives on-chain. Once published, the plan can accept subscribers immediately through its link, embed button, or iframe.
## Before you start
You'll need:
* A CryptoNow account.
* A **payee wallet** — the address that receives each payment.
* An **owner wallet** with a little native coin (ETH, BNB, etc.) to cover the one-time publish fee. The owner wallet is the one that publishes the plan on-chain.
* Your plan basics decided: the token and network, the price, and the billing period.
## Create and publish a plan
In the dashboard, go to **Payments → Recurring billing**, then select **Create Plan**.
Give the plan a **name** and **description**, choose the **payee address** that will receive payments, then set the **price** and the **token / network**.
Subscriptions are billed in stablecoins on the supported networks:
Pick how often the customer is charged under **Period Type**:
Finally, choose the **owner** wallet (this publishes the plan and pays the small publish fee). You can optionally add a plan photo, logo, and brand colours.
Select **Next** to review. Publishing costs a small network fee, shown as an estimate before you confirm. Choose **Save as Draft** to keep it off-chain for now, or **Publish** to make it live.
Publishing is **non-revertible** — the plan is written on-chain. You can still deactivate or stop subscriptions later, but the published plan itself can't be undone.
Once published, the plan appears in your list as **Active**.
## Share the plan with customers
Open the plan's actions and choose **Plan information**. You have three ways to start accepting subscribers:
* **Link** — a hosted subscribe page you can send anywhere.
* **Embed** — a "Buy with Crypto" button for your site.
* **iFrame** — the subscribe page embedded inline.
Toggle **clickId** to tag the link with your own reference (for example an order or customer ID) so you can attribute each subscriber back to your system.
## What your customer sees
When a customer opens the link, they see the plan, enter their details, and connect a Web3 wallet. They select **Recurring**, approve the charge once, and from then on each period is collected automatically. They can cancel at any time.
## Manage your plans
Use the actions menu (**⋮**) on any plan row to manage it after launch:
* **Subscriptions** — view everyone subscribed to the plan.
* **Activities** — the per-period charge history for the plan.
* **Edit** — update details, or deactivate and reactivate the plan.
* **Duplicate** — spin up a similar plan quickly.
* **Delete** — remove a plan.
As customers subscribe, the **Subscribers (Active / All)** count and the **Activities** log fill in, giving you a running view of who's active and what has been charged.
# Set up WooCommerce
Source: https://guide.crypto-now.io/set-up-woo-commerce
Accept crypto on your WordPress/WooCommerce store using the CryptoNow plugin.
The CryptoNow plugin lets your WooCommerce store accept crypto. When a customer picks **Pay with CryptoNow** at checkout, the payment address, amount and QR code appear right on your order page — the customer never leaves your store. Funds settle straight into your CryptoNow account wallet, and the order is marked paid automatically.
You'll need a [CryptoNow account](/create-your-account) and a working WordPress store with WooCommerce installed.
## Step 1 — Install the plugin
Download the latest CryptoNow plugin: [**cnow-v2.6.zip**](https://raw.githubusercontent.com/JohnAmun/docs/recover/cnow-v2.6.zip). Keep it zipped — you upload the `.zip` as-is.
In your WordPress admin, go to **Plugins → Add New → Upload Plugin**, choose the `cnow.zip` file, and select **Install Now**.
When the upload finishes, select **Activate Plugin**.
CryptoNow now appears in your plugin list with a **Configure** link.
## Step 2 — Create a Cart checkout in CryptoNow
The plugin connects to a **Cart** checkout in your CryptoNow account. This checkout type accepts a dynamic amount, which is what WooCommerce sends for each order.
In CryptoNow, go to **Payments → Checkouts → Create Checkout** and choose **Cart**. Select the currencies you want to accept.
Open the checkout, and from the **Link** tab copy its URL. You'll paste this into the plugin in the next step.
The checkout must be the **Cart** type. Other types don't accept the per-order amount WooCommerce sends, so the payment total won't match.
## Step 3 — Configure the gateway
In WordPress, go to **WooCommerce → Settings → Payments → CryptoNow**.
Tick **Enabled**, and leave **Payment mode** on **On-site** — this shows the address and QR on your store instead of redirecting the customer away.
Paste the link from Step 2 into **Checkout url**, then **Save changes**.
## Step 4 — Set your callback URL
The callback is how CryptoNow tells your store an order has been paid. In CryptoNow, open **Settings → Account settings** and set **Callback Url** to:
```text theme={"system"}
https://your-store.com/wp-json/crypto-now-webhook/v1
```
Replace `your-store.com` with your store's domain, then **Submit**.
Your store must be reachable at a public `https` address for the callback to arrive. A local-only site can't receive it, so orders would stay in "pending" until confirmed.
## Step 5 — Take a test payment
On your storefront, add a product to the cart and go to checkout. Choose **Pay with CryptoNow** and place the order.
Your customer lands on the payment page. They pick a network and currency…
…and get the exact amount, address and QR to pay.
Once the payment confirms on-chain, CryptoNow calls back and WooCommerce marks the order received.
## Match a payment to an order
Every payment carries the WooCommerce order number so you can reconcile the two. In CryptoNow, open **Transaction's → History** and expand the replenishment — its **clickId** equals the **Order #** in WooCommerce.
The credited amount is net of the 0.5% system fee shown on the replenishment — e.g. a 1.00 USDT payment credits about 0.9950 USDT to your account wallet.
## Troubleshooting
**Order stuck on "pending payment".** The callback didn't arrive. Check that the Callback Url in your CryptoNow account exactly matches `https://your-store.com/wp-json/crypto-now-webhook/v1`, and that your store is publicly reachable over `https`.
**Order marked "Wrong amount".** The customer sent a different amount than the order total. The payment is safe in your account wallet — review the order and reconcile manually, or refund from your account wallet.
**CryptoNow isn't offered at checkout.** Make sure **Enabled** is ticked and a valid **Cart** checkout URL is saved in the gateway settings.
# Find your way around
Source: https://guide.crypto-now.io/set-up-your-treasury-wallet-and-gas
A quick tour of where everything lives in CryptoNow — your account, Account wallets, and Client wallets — so you always know where your money sits and where customers pay in.
A 60-second orientation so you always know where your money sits and where your customers pay in.
**The structure in one line:** you log in as a **User**. Inside, you have one or more **Accounts** — switch between them with the toggle at the top right. Each account holds two wallet groups: **Account wallets** (your own money) and **Client wallets** (where your customers pay in). A **Client** is any customer sending you funds.
## Account wallets — your treasury
Account wallets hold your own funds — one wallet per coin and network, each with its own address. The amount shown is the **real balance** held in each. This is also where the account keeps the gas it needs to move crypto on your behalf.
## Client wallets — where customers pay in
Client wallets are permanent deposit addresses, one per client — the same address every time that client pays you.
Funds never sit in a client wallet — every deposit sweeps to your Account wallets automatically. So a client wallet's figure is **total throughput over time, not a current balance**.
## Run more than one brand
Each brand can have its own account — up to **five** — with completely separate wallets and books. Switch between them with the **Account** toggle at the top right.
## Home — your dashboard
Home shows your total balance and every coin at a glance for the account you're currently in.
## Next step
Now that you know the layout, take your first crypto payment.
Your **account wallets** are your treasury — one wallet per network, holding what you've earned. On-chain actions (sweeping client deposits, swapping, sending out) cost a network miner fee, paid in that chain's **native gas token** (ETH on Ethereum, BNB on BNB Chain, and so on). Keep a little gas in each network you use, or those actions can't execute.
## See your treasury
Go to **Wallets → Account wallets** for the per-network view of your balances.
## Fund gas
Open **Receive** on the native coin of a network you'll use (e.g. Ethereum), then send a small amount of that token to the address shown — scan the QR or copy the address.
You only need gas on the networks you'll actually transact on. A few dollars of native token per network is plenty to start.
## Choose who pays gas
In **Settings → Account Settings**, the **Miner Fee for withdrawal / replenishment pays** toggles decide whether **you (Me)** or **the customer** covers the network fee. The same panel holds your **Account fee** percentages — your optional commission on withdrawals and replenishments.
**This toggle only affects client-wallet flows** — client replenishment sweeps and client-wallet withdrawals. It does **not** change who pays gas on your own account-wallet sends or swaps; those always draw native gas from the account wallet itself. That's why funding gas above matters regardless of this setting.
# Swap your crypto
Source: https://guide.crypto-now.io/swap-your-crypto
Exchange one cryptocurrency for another straight from your account wallets, settled through an exchange partner. Mainnet only.
Swap lets you exchange a currency you hold for one you need, without leaving CryptoNow. Funds move out of one account wallet and the exchanged currency lands back in another.
Swap runs on **mainnet only**. If you open it on a testnet network, you'll be prompted to switch before you can continue.
The destination-currency wallet must already exist before you swap. If you don't have a wallet in the currency you want to receive, create it first under **Account wallets**.
Go to **Transaction's → Swap** and select **Create New Swap**. The first time, your swap history is empty.
In **YOU SEND**, enter the amount and pick the currency to spend. In **YOU GET**, pick the currency to receive — the estimated amount fills in automatically. **MAX** fills in the largest amount you can swap from that wallet after fees.
Before you go further, the **Total** line itemises the full cost: the amount, the network **Miner Fee** (paid in the source network's native coin), and the **System Fee**. The exchange partner's rate is applied on top when you view offers.
Select **View offers**. Each offer shows the **Rate**, **ETA**, and a **KYC Risk** indicator. Pick one and select **Exchange**.
The summary confirms the exact send and receive amounts, the **exchange rate**, the **Partner**, and the rate **Type** — **Fixed** (rate locked for a short window) or **Floating** (final amount can move with the market).
Enter the code from your Google Authenticator and select **Confirm**. If the locked rate expires while you're confirming, use **Update rate** and try again.
You'll see a confirmation that the swap was processed.
The swap appears in **Transaction's → History**, first as **Pending**, then **Done**. Expand it to see the Payment ID, addresses, Miner Fee, System Fee, and on-chain hash. The exchanged currency arrives in your destination account wallet as a **Replenishment** entry.
On a **Floating** rate the amount you receive can change between confirmation and settlement. Choose **Fixed** if you need the quoted amount guaranteed within the partner's time window.
**Worked example.** 5 USDT (ERC-20) → ≈0.00311 ETH via *sideshift* on a fixed rate. The Total line showed a miner fee of ≈0.0000226 ETH and a System Fee of 0.05 USDT; the received ETH landed in the Ethereum account wallet as a Replenishment.
# Transaction statuses & types
Source: https://guide.crypto-now.io/transaction-statuses
What each entry in your transaction history means — the lifecycle states and the transaction types you'll see.
Every money movement shows up in **Transaction's → History**. Each row has a **type** (what the entry is) and a **status** (where it is in its lifecycle). Expand a row for the full on-chain detail.
## Statuses
Transactions move through two states:
* **Pending** — submitted and awaiting on-chain confirmation.
* **Done** — confirmed and complete.
A hosted **checkout charge** has its own lifecycle before it becomes a transaction:
* **New** — created, waiting for the customer to pay.
* **Pending** — payment detected, confirming on-chain.
* **Done** — payment confirmed; it lands in your account wallet as a Replenishment.
* **Expired** — the payment window elapsed with no (or insufficient) funds.
## Types
You can filter History by type. The common ones:
| Type | What it is |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Replenishment** | Funds arriving into an account wallet — a client-wallet sweep, a swap output landing, or a checkout payment settling. Carries your `clickId` when one was passed. |
| **Withdrawal** | Funds sent out from an account wallet to an external address. |
| **Swap** | An exchange between two currencies via an exchange partner. |
| **Multisend** | A batch payout to many addresses in one transaction. |
| **Internal Transfer** | An off-chain move between wallets on the platform — no network gas. |
| **External Call** | An on-chain call the platform makes (for example, estimating a multisend miner fee), which itself costs a small blockchain fee. |
| **Refund Miner Fee** | A return of unused miner fee. |
| **System Fee** | A CryptoNow system-fee charge shown as its own entry. |
| **Error** | An operation that failed. |
## What's in a row
Expand any transaction to see the detail:
* **Payment ID** — CryptoNow's internal reference for the entry.
* **To / From** — the on-chain addresses.
* **Miner Fee** — the network fee, in the source network's native coin.
* **System Fee** — the CryptoNow fee (for example, 0.5% on a replenishment).
* **Hash** — the on-chain transaction hash (links to the explorer).
* **IncomingHash** — for a settled payment, the hash of the customer's inbound transfer.
* **clickId** — your attribution reference, when one was passed (echoes back as `outsideOrderId`).
Reconcile against your own system by matching on **`clickId`** — it ties each Replenishment back to the exact order or customer.