Descriptor Wallets Compared: Output Descriptor Support
Compare Bitcoin wallets by output descriptor support, import/export compatibility, miniscript policies, and hardware signer integration.
Which Wallets Support Output Descriptors?
Output descriptors are the modern standard for defining how a Bitcoin wallet derives and constructs its addresses. Unlike a bare xpub, a descriptor bundles the script type, derivation path, master key fingerprint, and child key range into a single portable string. This makes wallet backup, recovery, and cross-wallet migration deterministic rather than guesswork.
Not every wallet supports descriptors equally. Some wallets are built entirely around them, while others lack import or export capabilities altogether. The following comparison covers the most widely used Bitcoin wallets and signing devices, evaluated across descriptor format support, miniscript compatibility, and interoperability.
| Wallet | Type | Descriptor Import | Descriptor Export | Miniscript | Taproot (tr) |
|---|---|---|---|---|---|
| Bitcoin Core | Full node | Yes | Yes | Yes (wsh + tr) | Yes |
| Sparrow | Desktop | Yes | Yes | Partial | Yes |
| Liana | Desktop | Yes | Yes | Yes (native) | Yes |
| Nunchuk | Desktop / Mobile | Yes | Yes (descriptor + BSMS) | Yes | Yes |
| Specter Desktop | Desktop | Yes | Yes | Partial | Yes |
| Electrum | Desktop | No | No | No | Yes |
| BlueWallet | Mobile | No | No | No | Yes |
For a broader look at how wallet backup formats compare, see our wallet backup format comparison. For the full descriptor syntax reference, see the output descriptors reference guide.
Descriptor Format Support by Wallet
Bitcoin output descriptors use function-like expressions to specify script types. The most common descriptor functions are pkh() for legacy P2PKH, wpkh() for native SegWit P2WPKH, sh(wpkh()) for wrapped SegWit, wsh() for witness script hash (used in multisig and miniscript), and tr() for Taproot P2TR outputs.
| Wallet | pkh() | sh(wpkh()) | wpkh() | wsh(multi()) | tr() | Multipath (BIP-389) |
|---|---|---|---|---|---|---|
| Bitcoin Core | Yes | Yes | Yes | Yes | Yes | Yes |
| Sparrow | Yes | Yes | Yes | Yes | Yes | Yes |
| Liana | No | No | No | Yes | Yes | Yes |
| Nunchuk | No | No | Yes | Yes | Yes | Yes |
| Specter Desktop | Yes | Yes | Yes | Yes | Yes | No |
| Electrum | Yes | Yes | Yes | Yes | Yes | No |
Bitcoin Core is the reference implementation for descriptors and supports every standardized descriptor function. Liana intentionally omits legacy script types (pkh, sh(wpkh)) because it is built around miniscript spending policies that require wsh() or tr(). Electrum supports all address types natively but lacks descriptor-based import and export, meaning you cannot paste a raw descriptor string into Electrum to restore a wallet.
Hardware Signer Compatibility
Descriptor wallets become most useful when paired with hardware signing devices for air-gapped signing. Each device has its own level of descriptor and miniscript support, which constrains what your coordinator wallet can do.
| Signing Device | Descriptor Export | Miniscript (P2WSH) | Miniscript (Taproot) | BIP-388 Policies |
|---|---|---|---|---|
| Ledger (Nano S+/X) | Via companion app | Yes | Yes | Yes (native) |
| Coldcard (Mk4/Q) | Yes (file/QR) | Yes (Edge fw) | Yes (fw 5.5.0+) | No |
| BitBox02 | Yes | Yes | Yes (fw 9.21.0+) | Yes |
| Blockstream Jade | Yes | Yes (fw 1.0.30+) | Partial | No |
| Foundation Passport | Yes | No | No | No |
| Trezor (Model T/Safe) | No | No | No | No |
Ledger's implementation of BIP-388 wallet policies is the most complete among hardware signers. The device stores an HMAC proof-of-registration for each policy, so the user only needs to verify and approve a descriptor once. BitBox02 added Taproot miniscript (MiniTapscript) in firmware 9.21.0 (October 2024), making it the second device with production Taproot-miniscript support. Coldcard offers miniscript through its Edge firmware channel, with Taproot descriptor signing available in standard firmware from version 5.5.0. Foundation Passport supports Taproot addresses (firmware v2.3.0) but does not yet support miniscript signing. Trezor has no descriptor or miniscript support as of late 2026.
Miniscript and Timelock Descriptor Support
Miniscript is a structured subset of Bitcoin Script that enables composable spending policies: timelocked recovery paths, decaying multisig thresholds, and inheritance conditions. When embedded in a descriptor, these policies become portable across any wallet that supports the same miniscript fragments.
Liana is the only wallet built entirely around miniscript descriptors. Every Liana wallet includes at least one timelock recovery path using OP_CSV (relative timelocks), so if the primary key is lost, a backup key can sweep funds after a configurable delay. Nunchuk added miniscript support with a focus on programmable spending conditions and allows users to import custom miniscript policies. Bitcoin Core has supported miniscript in wsh() descriptors since v24.0 and extended it to tr() descriptors in v26.0.
Sparrow and Specter Desktop can parse and display miniscript descriptors but do not offer a policy editor or compiler. If you need to construct a miniscript policy from scratch, you would typically use a tool like the Sipa miniscript compiler or Liana's setup wizard, then import the resulting descriptor into your coordinator wallet.
For a deeper technical explanation, see our research article on miniscript spending policies and the miniscript fragment glossary entry.
Import and Export Interoperability
The practical value of descriptors depends on whether you can move them between wallets without data loss. Interoperability has improved significantly since Bitcoin Core standardized the format, but gaps remain.
Bitcoin Core uses importdescriptors and listdescriptors RPCs for import and export. These commands accept and produce raw descriptor strings with checksums. Sparrow supports both raw descriptor text files and Specter-format JSON, making it one of the most flexible coordinators for cross-wallet migration. Nunchuk exports wallets as either a raw descriptor file or a BSMS (Bitcoin Secure Multisig Setup) file, which wraps the descriptor with metadata like the wallet's first receive address for verification.
Liana added explicit descriptor export in v10.0 and supports whole-wallet backup. Because Liana uses miniscript descriptors, its exports may include fragments that simpler wallets cannot parse. Recovering a Liana wallet in Bitcoin Core is straightforward since Core supports the same miniscript subset, but importing into a wallet without miniscript support will fail.
Electrum remains a notable gap: it does not support descriptor-based import or export. While you can derive descriptors from an Electrum wallet externally using tools like pubport, this is a one-way conversion that requires technical proficiency. A GitHub issue requesting native descriptor import in Electrum has been open since 2023.
For related research on wallet portability, see Output Descriptors: The Standard That Makes Bitcoin Wallets Portable.
Why Use Descriptors Over a Bare xpub?
A bare xpub tells another wallet which public keys can be derived, but it says nothing about how those keys are used. If you export an xpub from a native SegWit wallet and import it into software that defaults to legacy addresses, the derived addresses will not match and your funds will appear missing. Descriptors solve this by encoding the script type alongside the key material.
The gap is even wider for multisig setups. Recovering a multisig wallet requires every cosigner's xpub, the exact key ordering, each derivation path, and the quorum threshold. A descriptor captures all of this in a single string. Losing any piece makes recovery difficult or impossible.
Bitcoin Core removed legacy (non-descriptor) wallets entirely in v30.0 (October 2025). Every new Bitcoin Core wallet is now a descriptor wallet by default, signaling that the ecosystem considers descriptors the standard going forward.
Choosing a Descriptor Wallet
The right wallet depends on your use case and technical comfort level:
- For full descriptor control and advanced scripting: Bitcoin Core gives you the complete descriptor toolkit, including miniscript in both
wsh()andtr(). It requires running a full node. - For multisig coordination with hardware signers: Sparrow and Nunchuk both offer descriptor import/export and work with Ledger, Coldcard, and BitBox02. Nunchuk adds BSMS support and a guided multisig setup flow.
- For inheritance and timelock policies: Liana is purpose-built for miniscript spending conditions with automatic recovery paths. It integrates with Ledger, Coldcard, Jade, and BitBox02.
- For simple single-sig with hardware: Sparrow or Specter Desktop handle standard
wpkh()andtr()descriptors with minimal complexity.
Wallets built on the Bitcoin Development Kit (BDK) are descriptor-first by design. BDK-based wallets accept descriptors as a primary input, which means any BDK wallet inherits full descriptor and multipath descriptor (BIP-389) support automatically.
Frequently Asked Questions
Why should I use descriptors over xpub for wallet backup?
An xpub stores only the extended public key. A descriptor adds the script type (wpkh, wsh, tr), the derivation path, the master fingerprint, and the child key range. This means any compliant wallet can reconstruct the exact same addresses from a descriptor without guessing the script type or path. For multisig wallets, descriptors also capture the quorum threshold and all cosigner keys, which are essential for recovery.
Can I use descriptors with my hardware wallet?
Yes, but support varies by device. Ledger and BitBox02 have the most complete descriptor and miniscript support, including Taproot policies. Coldcard supports descriptor export and Taproot signing in firmware 5.5.0+, with miniscript available through its Edge firmware channel. Blockstream Jade supports P2WSH miniscript. Trezor and Foundation Passport do not currently support miniscript descriptors, though Passport does support standard Taproot addresses.
What is the difference between a descriptor and a BSMS file?
BSMS (Bitcoin Secure Multisig Setup) is a wrapper format defined by BIP-129 that includes an output descriptor plus additional metadata such as the wallet's first receive address. The first address serves as a checksum: if the importing wallet derives the same address, the import is correct. Nunchuk supports both raw descriptor and BSMS export. BSMS is particularly useful for multisig setups where you need to verify that all cosigners are using the same wallet configuration.
Can I import a Liana wallet descriptor into Bitcoin Core?
Yes. Liana uses standard miniscript fragments within wsh() or tr() descriptors, and Bitcoin Core supports both since v26.0. Nunchuk provides a recovery guide that walks through importing miniscript descriptors into Bitcoin Core using the importdescriptors RPC. You will need to derive the matching private key (xprv) from your seed before importing.
What is BIP-388 and why does it matter for hardware wallets?
BIP-388 defines "wallet policies," a compact representation of output descriptors designed for devices with limited screen space and memory. Instead of displaying a full descriptor string, the device shows a simplified policy that the user can verify. Ledger implements BIP-388 natively and stores an HMAC proof-of-registration so the user only needs to verify each policy once. BitBox02 also supports wallet policies. This standard makes it practical to use complex multisig and miniscript setups on hardware signers.
Does Electrum support output descriptors?
As of late 2026, Electrum does not support importing or exporting wallets via raw output descriptor strings. Electrum uses its own internal wallet format and derivation conventions. A feature request for descriptor import has been open on Electrum's GitHub since 2023 (issue #8657) but remains unimplemented. If you need to move from Electrum to a descriptor-based wallet, you can use the same seed phrase and manually configure the correct derivation path and script type in the target wallet.
What are multipath descriptors (BIP-389)?
BIP-389 multipath descriptors use the notation /<0;1>/* to encode both the receive (index 0) and change (index 1) address chains in a single descriptor string. This halves the number of descriptors you need to back up. Bitcoin Core, Sparrow, Liana, and Nunchuk all support multipath descriptors. When exporting from Nunchuk, the default format is a multipath descriptor that Bitcoin Core can import directly.
How do descriptors relate to Taproot and Tapscript?
The tr() descriptor function defines a Taproot output with an internal key and an optional script tree. Each leaf of the tree can contain a Tapscript spending condition, including miniscript policies. This enables complex spending logic (timelocks, threshold signatures, hash locks) while keeping the common spending path efficient and private. Bitcoin Core added miniscript support in tr() descriptors starting with v26.0.
This tool is for informational purposes only and does not constitute financial advice. Wallet features, firmware versions, and descriptor support change with each release. Always verify current capabilities against each project's official documentation before making custody or backup decisions.
Build with Spark
Integrate bitcoin, Lightning, and stablecoins into your app with a few lines of code.
Read the docs →
