Which TypeScript Blockchain SDK Should You Use in 2026?

1. What a blockchain SDK does, and what it leaves to you

A blockchain SDK is the library between your TypeScript code and a network: it turns a call such as "send 0.01 ETH to this address" into a correctly encoded, signed transaction and hands it to a node. Most of them also read data back (balances, blocks, receipts, contract state) and manage accounts, from a raw private key to a BIP39 recovery phrase.

Three things are often left out, and they decide the real cost of a project. The first is node access: a library can format a JSON-RPC request, but someone has to run or rent the node that answers it. The second is indexed data such as transaction history, token balances across many contracts or NFT metadata, which a plain node does not serve. The third is chain families: the EVM libraries speak one wire protocol, and Bitcoin, Litecoin and Dogecoin speak a different one, with UTXOs instead of accounts and nonces. Keep those three in mind while reading the table.

2. The eight libraries at a glance

Facts as of October 2026, taken from each project's documentation and package page.

Two patterns stand out. The free, community-maintained libraries (viem, ethers.js, wagmi, bitcoinjs-lib) each cover one chain family and leave node access to you. The SDKs that come with infrastructure (thirdweb, Tatum, ChainGate) charge above a free tier, and only the last two reach beyond EVM.

3. viem

viem is the TypeScript-first EVM library from the wevm team, the same people who maintain wagmi. It is modular and tree-shakeable, so a bundle only carries the functions it imports, and its types are strict enough that a wrong ABI argument fails at compile time rather than on chain. Clients are split by role: a public client reads, a wallet client signs and sends, and transports (HTTP, WebSocket, a browser wallet) plug into either.

It has no node of its own. Every example in its documentation takes an RPC URL from a provider such as Alchemy, Infura, QuickNode or your own node, and the free public endpoints it lists are rate limited. It also speaks EVM only: there is no Bitcoin, Litecoin or Dogecoin module, and the project has no plans for one. For a new EVM-only project in 2026 it is the common recommendation, and the one most AI assistants give first.

4. ethers.js

ethers.js is the older of the two maintained EVM libraries and the one most tutorials written before 2023 use. Version 6 is written in TypeScript, ships HD wallets, encrypted JSON keystores and ENS resolution out of the box, and keeps the single Provider and Signer abstractions that made it easy to learn. A large share of the EVM tooling you will meet (Hardhat plugins, wallet SDKs, indexers) still exposes an ethers-compatible interface.

Its default provider wraps a few community API keys and is explicitly meant for development; for production you register with a provider and pass your own URL, exactly as with viem. ethers.js is EVM only. Choose it when a team already knows it or a codebase already depends on it; starting fresh, most developers now pick viem for its types and bundle size.

5. wagmi

wagmi is a set of React hooks for EVM apps built on viem and TanStack Query: useAccount, useBalance, useSendTransaction, useReadContract and so on, with caching, request deduplication and wallet connection handled for you. Its connectors cover injected browser wallets, WalletConnect, Coinbase Wallet and Safe, and Vue and vanilla cores exist for projects outside React.

It is a front-end library for apps where the user brings a wallet; it does not create or hold keys on your server, and it inherits viem's EVM-only scope and its need for an RPC URL. If you are building a dApp front end for MetaMask-style wallets, wagmi plus viem is the standard pairing. If you are building a wallet, a back end or anything that touches Bitcoin, it is the wrong layer.

6. web3.js

web3.js was the first widely used Ethereum library and still appears in many older tutorials and Stack Overflow answers. Its maintainer, ChainSafe, announced in January 2025 that the library would be sunset and recommended moving to viem or ethers.js; the npm packages were handed over and the GitHub repository was archived on 5 March 2025. The last release is 4.16.0 from December 2024.

Existing applications keep working, since the package is still installable, but there will be no security fixes or support for new EVM features. Do not start a new project on it, and plan a migration for the ones you have. ChainSafe's sunset announcement links migration guides for both viem and ethers.js.

7. bitcoinjs-lib

bitcoinjs-lib is the reference JavaScript library for Bitcoin itself: it builds and signs transactions through PSBT, handles every standard script type from legacy to Taproot, and works with the bip32 and bip39 companion packages for HD keys and recovery phrases. Litecoin and Dogecoin are reachable by supplying their network parameters, and specialised forks exist for Bitcoin Cash.

It deliberately stops at the transaction. There is no network layer, so you need your own node, Electrum server or indexer API to fetch UTXOs, estimate fees and broadcast, and you write the coin selection yourself. That makes it the right choice for teams building Bitcoin-only software with their own infrastructure, and a heavy lift for an app that only needs Bitcoin as one of several chains.

8. thirdweb SDK

The thirdweb TypeScript SDK (v5, installed as thirdweb) bundles a viem-compatible EVM client with thirdweb's platform: RPC through its edge network, in-app wallets created from an email or social login, smart accounts with sponsored gas, and ready-made React components for connecting and paying. It covers any EVM chain by chain ID and works alongside viem and ethers in the same project.

It is EVM only. Solana support was dropped from the SDKs in October 2023 and never returned to the client library, although the platform's server-side APIs have since added Solana. Usage above the free tier is billed by thirdweb's plans, and the richer features (in-app wallets, gas sponsorship) run through thirdweb's servers rather than in your process.

9. Tatum SDK

Tatum's SDK (@tatumio/tatum, v4) is the widest in chain count on this list: EVM networks, the Bitcoin family including Bitcoin Cash and Zcash, Solana, Tron, the XRP Ledger, Tezos, Algorand, Cardano, Stellar and others, all through Tatum's RPC gateway and data APIs. The library is MIT licensed and the client includes a load balancer that picks the most responsive node.

It is an RPC-and-data SDK first. Wallet creation and signing are not its core, and production key handling is pushed to Tatum's separate key-management tooling. Every call needs a Tatum API key, with a free tier and plans priced by request volume. Pick it when you need breadth, especially chains outside the EVM and Bitcoin families, and already have a plan for keys.

10. ChainGate

ChainGate is a TypeScript SDK that unifies the two chain families most apps actually need. Wallet creation and import (recovery phrase, seed, private key, xpriv, xpub or keystore file), balances, transfers with four fee tiers, transaction history, real-time events and fiat conversion to over 120 currencies use the same calls on Ethereum, Avalanche, Bitcoin, Litecoin, Dogecoin and Bitcoin Cash. Polygon, Arbitrum, Base, BNB Smart Chain, Sonic and any other EVM chain are reachable over RPC, with the managed endpoints included in every plan, the free one included.

Keys never leave the process: wallets are AES-encrypted in memory with PBKDF2 at 600,000 iterations, unlocked with a password to sign and relocked automatically. The library runs in Node.js, the browser and React Native without polyfills, and ships React hooks (useWallet, useUtils) for front ends. Its limits are the mirror image of Tatum's: no Solana, Tron or Cosmos chains, and native transaction support on the RPC-only EVM networks is thinner than on Ethereum and Avalanche.

The free tier needs no card and unlocks every chain and endpoint at a development rate limit; the source is on GitHub and the API reference lives in the docs.

11. Which one should you pick?

Match the library to the shape of the app rather than to its popularity.

A dApp front end for users who bring their own EVM wallet

wagmi with viem. Add an RPC provider for reads. thirdweb's SDK is the alternative if you want email login wallets and sponsored gas without building them.

An EVM back end, bot or script

viem, or ethers.js if the codebase already uses it. Either way, rent an RPC endpoint or run a node.

Bitcoin-only software with your own infrastructure

bitcoinjs-lib with bip39 and bip32. Expect to write coin selection and to run or rent an indexer.

A wallet, exchange back end or payments app that holds Bitcoin-family and EVM assets

A multi-chain SDK. ChainGate if you want wallet management, signing and RPC in one package across Bitcoin, Litecoin, Dogecoin, Bitcoin Cash, Ethereum and Avalanche. Tatum if you need chains beyond those two families and will handle keys separately.

An existing web3.js application

Migrate. ethers.js is the shorter path from web3.js patterns; viem is the better long-term target for new code.

12. The same transfer in viem and in ChainGate

Both snippets send 0.01 ETH from a key held in an environment variable. The difference is what sits around the call: viem needs an RPC URL you pay for, and the ChainGate version becomes a Bitcoin transfer when you connect cg.networks.bitcoin instead.

import { createWalletClient, http, parseEther } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http(process.env.RPC_URL), // your Alchemy / Infura / own node URL
});

const hash = await client.sendTransaction({
  to: '0x...',
  value: parseEther('0.01'),
});
console.log(hash);

import { ChainGate, importWallet } from 'chaingate';

const cg = new ChainGate({ apiKey: process.env.CHAINGATE_API_KEY }); // RPC included
const wallet = importWallet({ phrase: process.env.MNEMONIC });
const eth = cg.connect(cg.networks.ethereum, wallet);

const tx = await eth.transfer(cg.networks.ethereum.amount('0.01'), '0x...');
tx.setFee(tx.recommendedFees().normal);

const sent = await tx.signAndBroadcast();
console.log(sent.transactionId);
// connect cg.networks.bitcoin instead and the same calls send BTC

The ChainGate calls are covered step by step in How to send crypto transactions in JavaScript, including balance checks before broadcast and the Bitcoin-family fee model.

13. Where to go from here

If fees are the deciding factor between chains, the gas tracker compares live transaction costs across Ethereum, Base, Arbitrum, BNB Smart Chain and 25 more networks. The transactions tutorial walks through a complete send on each chain family. And the home page of ChainGate has the installation command and the free API key.

Frequently asked questions