Login
Access to full transaction data on all transactions & addresses
Broadcast and verify transactions with real-time monitoring
Retrieve blockchain data, balances, and transactions
Detailed blockchain history and transaction data for any address.
Full smart contracts metadata, including token symbols & token names
Dedicated nodes infrastructure for leading blockchains using JSON-RPC
Address validation, encoding & cryptographic tasks optimizations
Shared node infrastructure for top blockchains using JSON-RPC.
Real-time notifications for events on top blockchains. Response under 100ms.
AML address screening across 20+ blockchains
14 MCP servers + n8n MCP client for AI agents
Precise blockchain transaction fee estimates based on transaction priority
Sync and manage HD wallets, keys and addresses
Prepare EVM transactions, including token transfers
Access to full transaction data on all transactions & addresses
Get live crypto prices, exchange rates, supply and token contracts across protocols via one REST API.
Test EVM transactions, optimize gas fees and identify security flaws
Take Bitcoin, Ethereum and stablecoin payments with a REST API where your private keys never leave your own infrastructure. Point us at a wallet address you already control — or derive a fresh one per order — get a webhook the moment it's paid, and sweep funds by signing offline. No custody, no node to run.
Most "crypto payment" tools ask you to trust them with the keys that control your money — funds land in their wallet and you request payouts. That's a custodial relationship, with the counterparty risk that comes with it.
CryptoAPIs is built the other way around. You hold your own extended public key (xPub); we derive receiving addresses from it and watch the chain for you, but we only ever see public data. When you move funds, you build the transaction through the API, sign it offline with your own private key, and broadcast it. At no point does a private key touch our servers.
Accept payments to a wallet address you already control — no custodian, nothing to hand over. This guide uses that single-address setup; both steps below are read-only to us, and you sweep by signing offline.
Watch an address, get notified on payment, sweep by signing offline — on any of 20+ supported chains.
Take the wallet address you already control and use it as your deposit address — nothing to create, nothing to hand over. That's your starting point for the next steps.
Subscribe to confirmed incoming transactions on your address. Your backend is notified the moment the customer pays — no polling. This is a read-only subscription; it never touches keys.
When you move collected funds to treasury, build the unsigned transaction through the API (fee, nonce and inputs calculated for you), sign it offline with your own private key, then broadcast the signed result. The private key stays in your environment the whole time.
prepare-transactions endpoints (ERC-20 / TRC-20) to sweep, still signing offline. One integration, coins and tokens across chains.
The whole money-movement path is just two API calls with your own offline signing in between — the private key never touches an endpoint.
1. Prepare — builds the unsigned transaction, with inputs, fee and change calculated for you. No keys sent.
2. Sign offline — sign the prepared transaction with your own private key, in your own environment. Our open-source @cryptoapis-io/offline-signer signs EVM, UTXO, Tron and XRP transactions entirely on your machine — no HTTP call, no API key — so the key never leaves your infrastructure. Any signing library works.
3. Broadcast — submits the transaction you signed offline. Takes only the signed hex.
The hard parts of payment acceptance — running full nodes for every chain, indexing addresses, reorg-safe confirmation tracking, fee estimation, mempool monitoring — are the API's job. You keep the one thing that should never be outsourced: control of your keys.
No. You keep your own keys. CryptoAPIs derives receiving addresses from your extended public key and watches the chain, but private keys are generated and used only in your environment. Every outgoing transaction is signed offline by you and only then broadcast.
Point the API at an address you control — either a single existing wallet address or one derived from your xPub — subscribe to a confirmed-transaction webhook on it, and you're notified the moment a customer pays. Across Bitcoin, Ethereum and 20+ chains, with no node or infrastructure to maintain.
Either works. The simplest setup — this guide — is a single wallet address you already control: just watch it and sweep by signing offline. If you want a unique address per customer or invoice for easier reconciliation at scale, use an HD wallet (xPub), covered in How to build a crypto wallet.
Yes. Token payments use the same derive-and-watch flow; sweeping uses the token prepare-transaction endpoints (ERC-20, TRC-20 and more), still signed offline with your own key.
Typical gateways are custodial — funds settle in the provider's wallet. Here funds land in addresses you derive and control, and you move them by signing offline. It's payment infrastructure, not a custodial middleman.
Bitcoin, Ethereum, BSC, Polygon, Tron, XRP, Litecoin, Dogecoin and 20+ others, across the same unified REST API.
Build the non-custodial flow on a free tier — derive addresses, watch for payments and sweep by signing offline, across 20+ chains.