Cardano does not behave like an EVM chain, so the integration playbook you know from Ethereum only gets you part of the way. There is no eth_getBalance, no account that simply holds a balance, and tokens are not ERC-20 contracts. To integrate Cardano into a web3 project, you connect to a node, read on-chain data in the format Cardano actually uses, build transactions around its accounting model, and let users sign with a Cardano wallet.
This guide walks through that process from the ground up: what a Cardano integration involves, how the chain differs from Ethereum, the tools you will reach for, and the order to wire them together.
What does integrating Cardano actually involve?
Integrating Cardano means giving your application four abilities: reading the state of the blockchain, building and submitting transactions, connecting user wallets, and, when your logic needs it, running smart contracts.
Cardano is a proof-of-stake layer-1 that uses the Ouroboros consensus protocol. Time is divided into epochs and slots, and a new block is added on average every 20 seconds. For a developer, the part that matters is not the consensus math but the data model it produces, because that model shapes every integration decision below.
Why developers build on Cardano
Cardano solves a few problems that matter for production apps. Transaction fees are low and predictable, because the cost of a transaction is derived from its size and script execution rather than a volatile gas auction.
Tokens are first-class citizens. Cardano supports native assets directly at the ledger level, so minting a token does not require deploying a smart contract the way an ERC-20 does. That removes a whole class of contract bugs for simple token use cases.
The chain is also built for predictability. Smart contract validation is deterministic, so a transaction’s outcome and fee can be checked before it is submitted — a transaction that would fail is rejected rather than consuming funds. Staking is non-custodial too: ADA never leaves the holder’s wallet when it is delegated to a stake pool, which is part of why staking ADA stays popular with long-term holders.
How Cardano differs from Ethereum-style chains
The single biggest adjustment is the accounting model. Ethereum is account-based: an address has one balance, and a transaction mutates it. Cardano uses the extended unspent transaction output (eUTXO) model, closer to Bitcoin. A wallet balance is the sum of discrete UTXOs, and a transaction consumes specific inputs and creates new outputs.
That difference changes how you write code. There is no single JSON-RPC method set like Ethereum’s eth_*. Instead you read UTXOs, addresses, and transaction history, then build a transaction by selecting inputs, defining outputs, and balancing the two against the fee. Smart contracts do not hold mutable state and “run”; they are validators that approve or reject the spending of a UTXO under set conditions.
If your background is EVM, it helps to see the two side by side. For anyone who has built a dApp on Ethereum, the table below maps what changes.
| Concept | Ethereum (account / EVM) | Cardano (eUTXO) |
|---|---|---|
| Balance | One balance per account | Sum of UTXOs at an address |
| Transaction | Mutates account state | Consumes inputs, creates outputs |
| Tokens | ERC-20 smart contract | Native assets at the ledger level |
| Smart contract | Executes and stores state | Validates spending conditions |
| Reading data | eth_* JSON-RPC | UTXO/REST, GraphQL, or Ogmios |
| Contract language | Solidity / Vyper | Plutus or Aiken |
Who integrates Cardano, and for what?
Cardano shows up across most web3 categories:
- Wallets read balances and transaction history and broadcast signed transactions.
- DeFi apps and dApps read chain state, submit transactions, and call validators.
- Exchanges and custodians generate deposit addresses, monitor the chain, and process withdrawals.
- Payment platforms watch addresses for incoming ADA or native tokens.
- NFT and token projects mint native assets and track ownership.
The components you need depend on which of these you are building, but they all draw from the same stack.
The Cardano integration stack
A Cardano integration is usually assembled from five layers. You will not always need all five — a read-only explorer skips transaction building, and a simple token mint skips smart contracts.
Node access
Everything starts with a connection to cardano-node, the core software that validates blocks and holds chain state. The client is on its 11.x release line (version 11.0.1 as of May 2026). You can run your own node, but a full node needs meaningful disk space, takes significant time to sync, and has to be kept current through each hard fork.
The alternative is a hosted endpoint. A provider such as NOWNodes exposes Cardano through RPC, a Blockfrost-compatible API, GraphQL, and an Ogmios WebSocket endpoint, so you query the chain with an API key instead of operating infrastructure. If you are weighing self-hosting against a managed endpoint, it helps to understand the types of blockchain nodes first.
On-chain data
To read Cardano, you query an indexed data layer rather than scanning the chain yourself. Common options are a Blockfrost-style REST API for addresses, transactions, and assets; a GraphQL endpoint for flexible queries; and Ogmios, a lightweight WebSocket bridge to the node for real-time updates. Koios, a community-run REST service, is another route. Pick the one that matches your access pattern — REST for simple lookups, WebSocket for live monitoring.
Transaction building
Because you assemble transactions from inputs and outputs, an off-chain library handles coin selection, fee calculation, and serialization. In the TypeScript ecosystem the two main choices are Mesh SDK and Lucid Evolution, both listed in Cardano’s developer tools. They let you build, balance, and sign a transaction in a few lines instead of constructing the CBOR by hand.
Wallet connection
Browser dApps connect to user wallets through CIP-30, the Cardano dApp-wallet web bridge standard. Once a user grants access, your app can read their addresses and UTXOs and ask the wallet to sign a transaction. CIP-30 is supported by the common wallets — Lace, Eternl, Nami, and Vespr — so one integration reaches all of them.
Smart contracts
If your app enforces custom logic such as a DEX, an escrow, or a vesting schedule, you will write validators. Plutus is the original smart contract platform, written in Haskell. Aiken is a newer, purpose-built language with a friendlier syntax and its own tooling, now documented in the official Cardano developer resources. Minting a straightforward native token needs only a minting policy, not a full validator.
How to integrate Cardano step by step
With the pieces understood, here is a practical order to build in.
- Choose your network and node access. Start on a testnet — Cardano runs preprod and preview networks — and decide whether to run cardano-node or connect to a hosted endpoint.
- Get read access to chain data. Generate an API key and pick your interface: a Blockfrost-compatible REST API, GraphQL, or an Ogmios WebSocket for streaming.
- Add an off-chain SDK. Wire in Mesh or Lucid Evolution to build and balance transactions.
- Connect a wallet. Implement CIP-30 so users can approve and sign from Lace, Eternl, or another supported wallet.
- Add validators if needed. Write and test smart contracts in Aiken or Plutus only when your logic requires on-chain enforcement.
- Test, then promote to mainnet. Confirm the full flow on preprod or preview before pointing your app at mainnet.
Common pitfalls when integrating Cardano
A few things catch EVM developers off guard. Every UTXO has to hold a minimum amount of ADA, so an output carrying native tokens still needs some ADA attached — budget for it when building transactions.
Transactions are validated against the exact UTXOs they reference. If another transaction spends one of your selected inputs first, yours fails and has to be rebuilt, so plan for retries in a busy wallet. And because the chain finalizes over slots and epochs, handle confirmations by block depth rather than assuming instant settlement.
Getting started
Integrating Cardano is less about new APIs and more about a different mental model: outputs instead of balances, validators instead of mutable contracts, and native assets instead of token contracts. Once that clicks, the tooling — hosted nodes, data APIs, TypeScript SDKs, and CIP-30 — maps cleanly onto the app you want to build. Start on a testnet, connect through your own node or a Cardano node endpoint, and add one layer at a time.
FAQ
Can I connect MetaMask to Cardano?
No. MetaMask works with EVM chains, and Cardano is not EVM-compatible. Cardano dApps connect through CIP-30 wallets such as Lace, Eternl, Nami, and Vespr instead.
Is ADA required to pay Cardano transaction fees?
Yes. Fees are always paid in ADA, calculated from transaction size and script cost. On top of that, every UTXO must carry a minimum amount of ADA, so even an output holding only native tokens needs some ADA attached.
What does it cost to access a Cardano node through NOWNodes?
NOWNodes offers a free Start plan with 100,000 requests, and paid shared plans begin at €20 per month; check current pricing before you commit. There are also free public endpoints capped at 5 requests per second for prototyping, with no API key required.
How long does it take to sync a full Cardano node?
Syncing a full node from scratch can take many hours to a few days, depending on your hardware and bandwidth, plus ongoing disk for the growing chain. A hosted endpoint skips the sync entirely, which is why many teams start there.
