Ledger® Live Wallet – Getting Started™ | Developer Portal

Overview

Ledger Live is a cross-platform wallet application that provides secure storage and transaction signing for multiple blockchains using Ledger hardware devices. This guide focuses on the developer's perspective: installing Ledger Live, connecting devices, automating common flows, and following security best practices when building integrations or tools that interact with Ledger Live.

1. Install & initial setup

1.1 Download and verify

Get Ledger Live for your platform (Windows, macOS, Linux) from the official download page. Always verify signatures when possible and confirm checksums. Never download Ledger Live from third-party sites.

1.2 First-run flow

On first run, you will:

• Create or restore a Ledger device (seed phrase setup happens on the device, not in Ledger Live).
• Set a PIN on the device.
• Install the Ledger Live Manager to add blockchain apps to the device.

2. Add accounts & manage assets

2.1 Install apps on the device

From the Ledger Live Manager tab, install the blockchain-specific apps (e.g., Bitcoin, Ethereum). Each app allows signing of transactions for that ledger/chain.

2.2 Add accounts

Use the Accounts tab to add accounts for supported blockchains. Ledger Live will derive addresses from the hardware device using standard derivation paths (BIP32/BIP44/BIP44-legacy for certain chains).

// Example: derive a single Ethereum address (conceptual)
// Actual derivation and signing happens on the hardware device.
m/44'/60'/0'/0/0
      

Developer note

If your app or tool imports Ledger-derived addresses, ensure you match the derivation path your users expect and provide clear UI to let users confirm addresses on their device.

3. Sending & receiving transactions

3.1 Standard send flow

When sending, Ledger Live builds the unsigned transaction, then asks the hardware device to sign. The device displays transaction details (amount, destination, fees) for the user to approve.

3.2 Best practices for building send flows

• Show exact transaction details and gas/fee breakdown before invoking the device.
• Do not pre-fill or hide important details—users must visually confirm them on their device display.
• Use deterministic serialization formats (e.g., RLP for Ethereum) so the device verifies exactly what you intend to sign.

// Pseudo-example: high-level signing call (conceptual)
const unsignedTx = buildUnsignedTx(...);
const signature = await ledgerDevice.signTransaction(unsignedTx);
broadcast(signature);
      

4. Integrations & developer APIs

4.1 Integrate safely with dApps

If you're building a dApp that supports Ledger devices, prefer using established adapters and WalletConnect-style bridges rather than custom transport layers. Respect user consent flows and always require an on-device confirmation for signing.

4.2 Using the Ledger SDKs & libraries

Ledger provides libraries and SDKs for communicating with devices (APDUs over USB/BLE). When possible, use maintained libraries rather than reimplementing transport logic. Keep native USB and BLE permissions secure and minimal.

Example: high-level flow

1. Discover device via USB/BLE.
2. Negotiate transport and protocol version.
3. Request public keys / addresses.
4. Build unsigned transaction locally.
5. Send signing command to the device; device displays details.
6. Collect signed payload and broadcast to network.

5. Security & compliance

5.1 Never expose private keys

Ledger devices keep private keys isolated — they never leave the device. Your software must never attempt to read or transmit seed phrases. Prompt users to confirm transactions only on-device.

5.2 Protect user flows

• Use HTTPS for all endpoints and verify TLS certificates.
• Validate addresses and display full addresses for user confirmation (don’t truncate in the device-confirm step).
• Rate-limit and log developer keys; detect unusual patterns.

6. Troubleshooting & common issues

6.1 Connection problems

If the Ledger device does not connect:

• Check USB cable and permissions (macOS security dialog, Linux udev rules).
• Ensure Ledger Live is allowed to access the device (no blocking apps).
• Try reconnecting the device and confirming the PIN on-device.

6.2 Signing errors

Signing will fail if transaction format is invalid or the device rejects details. Log the exact APDU/responses (without exposing private data) and surface clear error messages to users so they can re-check amounts and destinations on the device screen.

7. Advanced topics

7.1 Batch signing & performance

For batch operations, present users with a summarized confirmation list and allow per-item inspection on the device where feasible. Avoid sending long, complex payloads that the device UI cannot render properly.

7.2 Integrating with backend services

Backend systems should not perform signing—delegate signing to the client device. Use backends for indexing, broadcasting transactions, and analytics only. Ensure any backend that stores non-sensitive metadata is secured and that access tokens expire.

8. Conclusion & resources

Ledger Live combined with Ledger hardware devices offers a robust, user-verified signing model. As a developer, prioritize on-device confirmations, follow Ledger's published SDKs and security recommendations, and design clear UX for address and amount verification. That approach keeps user funds safer and reduces support overhead for your product.

Further reading

• Ledger Developer Portal
• Ledger Support
• Ledger Security