Lexe Public Launch: App Store Releases, New Features, New SDKs

By Max Fang – March 26th, 2026

Lexe is next-generation Bitcoin infrastructure: self-custodial wallets and SDKs that are easy to use, always online, and hosted for free. Today, we are excited to announce the first ever public release of Lexe Wallet on the App Store and Google Play. This beta release comes with new features and fresh SDKs for creating and controlling your own self-custodial Lightning node running inside a TEE.

Lexe Wallet: Self-Custody Mobile Wallet

Built on Lexe's state-of-the-art infrastructure, Lexe Wallet is a self-custodial mobile Bitcoin wallet with a cutting edge Lightning UX. Use Lightning the way it was meant to be used: with real Lightning channels that allow you to reliably send and receive payments 24/7, and infinite just-in-time liquidity that ensures you never miss a payment.

Lexe Wallet is now available on the App Store and Google Play:

New Feature: Human Bitcoin Address (BIP 353)

Every Lexe user now gets their own Human Bitcoin Address (HBA), which resembles an email address but is used to receive Bitcoin: for example ₿awesome-zebra1@lexe.app. Human Bitcoin Addresses are defined in the BIP 353 open standard: they can be paid to by any Lightning wallet which implements it. Lexe also supports paying Human Bitcoin Addresses linked to any 3rd party Bitcoin wallets which support the standard.

Soon, Lexe will allow you to claim a custom username for use with your Human Bitcoin Address, for example: ₿satoshi@lexe.app.

Usernames as short as four characters and first names will be distributed first-come-first-serve, so join our community on Discord, X, or email if you would like to be first to hear when custom usernames are available.

New Feature: Lightning Address

Lexe is also excited to announce support for Lightning Address. Your Lightning address is based on the same username as your Human Bitcoin Address, and looks almost exactly like your Lexe HBA, except by the Lightning Address standard, it doesn't include the leading Bitcoin ₿. For example: awesome-zebra1@lexe.app.

Lexe also supports paying Lightning Addresses linked to 3rd party wallets. If you use Lexe Wallet to pay an address that looks like a Human Bitcoin Address or Lightning Address, Lexe will first try to pay using the more secure Human Bitcoin Address protocol, then fall back to paying with Lightning Address if HBAs are not supported by the receiver.

Lexe SDKs

Lexe is launching the first of a series of native language SDKs, making it easy to create wallets and control them programmatically.

Python SDK

The Python SDK provides a simple interface that makes it easy to integrate a self-custodial Lightning wallet into any Python application, or create and manage a wallet interactively via a Python REPL. It is published to PyPI as lexe-sdk.

To try it out, open a Python shell with lexe-sdk installed:

$ pip install lexe-sdk
$ python

Or if using uv:

$ uv run --with lexe-sdk python

Then paste the following:

from lexe import Credentials, LexeWallet, RootSeed, SeedFileError, WalletConfig

# Create a mainnet wallet config
config = WalletConfig.mainnet()

# Load seed from ~/.lexe/seedphrase.txt, or create a fresh one
try:
    seed = RootSeed.read(config)
except SeedFileError.NotFound:
    seed = RootSeed.generate()
    seed.write(config)

# Load or create wallet (data stored in ~/.lexe)
creds = Credentials.from_root_seed(seed)
wallet = LexeWallet.load_or_fresh(config, creds)

# Signup and provision the node (idempotent)
wallet.signup(root_seed=seed, partner_pk=None)
wallet.provision(creds)

# View node info
info = wallet.node_info()
print(f"Balance: {info.balance_sats} sats")

# Create a Lightning invoice
resp = wallet.create_invoice(
    expiration_secs=3600,
    amount_sats=1000,
    description="Initial deposit",
)
print(f"Invoice: {resp.invoice}")

# Pay a Lightning invoice - fill in an invoice below
# payment = wallet.pay_invoice(
#     invoice="lnbc1pjlue...",
#     fallback_amount_sats=None,
#     note="Personal note for my records",
# )

For more details, see the Python quickstart and API reference. Or watch the demo - from a Python shell, we create a mainnet Lightning wallet, fund it, and make payments, all hand-typed, in just 3 minutes:

Rust SDK

The Rust SDK is our most advanced SDK, ideal for building secure, reliable, high-performance applications. It is published to crates.io as lexe.

Cargo.toml:

[dependencies]
lexe = "0.1"

main.rs:

use std::str::FromStr;
use lexe::{
    config::WalletEnvConfig,
    types::{
        auth::{CredentialsRef, RootSeed},
        bitcoin::Invoice,
        command::{CreateInvoiceRequest, PayInvoiceRequest},
    },
    wallet::LexeWallet,
};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create a mainnet wallet config
    let env_config = WalletEnvConfig::mainnet();

    // Create a fresh root seed and persist to ~/.lexe/seedphrase.txt
    let root_seed = RootSeed::generate();
    root_seed.write(&env_config.wallet_env)?;

    // Create a mainnet Lexe wallet (data stored in ~/.lexe)
    let credentials = CredentialsRef::from(&root_seed);
    let wallet = LexeWallet::fresh(env_config, credentials, None)?;

    // Signup and provision the node (idempotent)
    let partner_pk = None;
    wallet.signup(&root_seed, partner_pk).await?;

    // View node info
    let info = wallet.node_info().await?;
    println!("Balance: {} sats", info.balance);

    // Create a Lightning invoice
    let invoice_req = CreateInvoiceRequest {
        expiration_secs: 3600,
        amount: None,
        description: Some("Initial deposit".to_string()),
        payer_note: None,
    };
    let invoice_resp = wallet.create_invoice(invoice_req).await?;

    // Pay a Lightning invoice - fill in an invoice below
    // let invoice = Invoice::from_str("lnbc1pjlue...")?;
    // let pay_req = PayInvoiceRequest {
    //     invoice,
    //     fallback_amount: None,
    //     note: Some("Personal note for my records".to_string()),
    //     payer_note: None,
    // };
    // let pay_resp = wallet.pay_invoice(pay_req).await?;

    Ok(())
}

For more details, see the Rust quickstart and rustdocs.

Building with Lexe

If you would like to learn more about building with Lexe, please get in touch! Developers building on Lexe will get access to a direct support channel (groupchat) with the Lexe team, and additional developer resources. Fill out this short form or contact us at hello@lexe.app.