Add a Multi-Chain Wallet to Your App Without Holding Keys

Your product needs a wallet. You don't want to build one.

That's the position most teams end up in, and both exits are bad. Build it yourself and you spend a quarter on seed phrase storage, encryption at rest, key derivation across chains, recovery flows, fee estimation, and swap routing. Get any of it wrong and it isn't a bug, it's a headline. Or take the custodial shortcut, hold user funds, and inherit a regulatory surface you never wanted.

There's a third option: use threshold signatures so the keys stay with the user, and let an SDK handle the rest.

What you'd otherwise be building

Before writing your first feature, a wallet means owning all of this:

• Key material. Generation, encryption at rest, seedless recovery, backup, and the support burden when a user loses a device.
• Address derivation. Different curves and formats per chain. Bitcoin is not Ethereum is not Cosmos.
• Swap routing. Finding the best path, comparing quotes, handling failures mid-route.
• Token data. A registry that knows what a contract address means, plus on-chain discovery for what it doesn't.
• Pricing. Real-time fiat values that don't fall over when a feed does.
• Transaction safety. Simulation, phishing checks, and a way to show users what they're actually signing.

None of that is your product. All of it is table stakes.

Three ways in

The Vultisig SDK ships as two npm packages covering three integration shapes:

• Programmatic SDK (@vultisig/sdk). TypeScript, full type safety. Import it, initialize once, call methods. Best for apps, bots, dashboards, and any long-running process where you want to load WASM a single time and keep it alive.
• CLI one-shot (@vultisig/cli). vultisig agent ask "what is my ETH balance?" --json. Natural language in, machine-parseable JSON out. Built for AI coding agents like Claude Code and Cursor, and for shell scripts.
• CLI pipe mode. vultisig agent --via-agent gives an orchestrator a long-running NDJSON pipe instead of one command per call.

Most teams building a product want the first one. Most teams wiring up an autonomous agent want one of the other two.

The quick version

Create a vault, derive addresses, send, swap, read a portfolio:

import { Vultisig, Chain } from '@vultisig/sdk'


 


const sdk = new Vultisig()
await sdk.initialize()


 


const vaultId = await sdk.createFastVault({
  name: "My Wallet",
  email: "[email protected]",
  password: "secure-password",
})
const vault = await sdk.verifyVault(vaultId, "1234")


 


const btcAddress = await vault.address(Chain.Bitcoin)
const ethAddress = await vault.address(Chain.Ethereum)


 


await vault.send({ chain: Chain.Ethereum, to: "0x...", amount: "0.1" })


 


await vault.swap({
  fromChain: Chain.Ethereum, fromSymbol: "ETH",
  toChain: Chain.Bitcoin,   toSymbol: "BTC",
  amount: "0.5",
})


 


const portfolio = await vault.portfolio("usd")

Amounts are human-readable. No wei math, no decimals lookup, no per-chain unit conversion. send, swap, signMessage, portfolio and allBalances are single calls, and send and swap both take a dryRun flag so you can preview fees and output before anything gets signed.

What comes with it

Included, so you don't write it:

• 40+ chains spanning UTXO, EVM, and Cosmos. Bitcoin, Ethereum, Solana, Cosmos, and the rest.
• Cross-chain swaps with automatic routing through THORChain, 1inch, KyberSwap, and LiFi.
• Token registry with fee coin lookup and on-chain discovery for unknown tokens.
• Portfolio and pricing with real-time balances and fiat values via CoinGecko.
• Security scanning. Transaction validation and simulation through Blockaid, plus site phishing detection.
• Fiat on-ramp. Banxa buy URLs across 23+ chains.
• Dry-run mode on sends and swaps.
• Full TypeScript types and IntelliSense throughout.

Two custody models, pick per use case

The SDK supports both vault types. Pick per use case:

• Fast Vault. Server-assisted 2-of-2 MPC. One share on the user's device, one on VultiServer, which co-signs and can never sign alone. Setup takes under a minute, signing is instant, and there's still no seed phrase anywhere. The right default for consumer onboarding.
• Secure Vault. Multi-device N-of-M threshold signing with configurable thresholds, paired by QR with Vultisig mobile apps. No server in the signing path at all. This is what you want for treasuries, team wallets, and anything running unattended.

In both cases the keys are split and never fully reconstructed, and neither you nor Vultisig can move funds alone. That's the part that changes your liability: a wallet where you never hold the keys is a wallet where you're not holding user funds.

One thing to get right

Storage is the sharp edge. The SDK auto-configures persistent storage per platform (file storage on Node, browser storage in the browser), but MemoryStorage exists and it is not persistent. Ship it by accident and every keyshare dies with the process, which means permanent loss of funds. Use the platform default, and give users a real path to vault.export() for backups.

We'd rather say that in the docs and in an article than have you find it in production.

Who this is for

Not just agent builders. The same integration covers:

• A DeFi frontend that needs wallets, swaps and balances without a browser extension dependency.
• A treasury tool signing across chains with multi-device approval.
• A trading bot that runs unattended and shouldn't hold a hot private key.
• A game or consumer app where the wallet needs to disappear into the product.
• A dashboard that reads portfolios and never needs signing at all.

If you are specifically evaluating wallets for autonomous agents, the custody question gets sharper and the field looks different. We compared Coinbase, Cobo, MetaMask and Vultisig on that basis.

Start

npm install @vultisig/sdk      # apps, bots, dashboards
npm install -g @vultisig/cli   # coding agents, shell scripts

Source and docs are public: SDK repo, agent integration guide, developer documentation. Open source, end to end, so you can read exactly what signs before you ship it.