---
title: "The Wavelength system"
description: "How Wavelength turns self-custodial Bitcoin and Lightning payments into a few API calls, and where Wavelength, the client you run, fits into the larger system."
canonical: https://wavelength.lightning.engineering/introduction/the-wavelength-system/
---

> Docs index: https://wavelength.lightning.engineering/llms.txt

# The Wavelength system

## What Wavelength is

Wavelength adds self-custodial Bitcoin and Lightning payments to any app with a handful of API calls. Your users get a real wallet that can send and receive over the Lightning Network, and you never run a Lightning node, open channels, or source liquidity to make it work. If you can call an API, you can accept Bitcoin. (Stablecoin support is on the way through Taproot Assets, over the same wallet surface.)

The value is in what you do **not** have to run. Accepting Lightning payments has traditionally meant operating a node, balancing channels, sourcing liquidity, and keeping all of that healthy around the clock. Wavelength runs that machinery and gives you a small, friendly wallet surface in its place, so the capability (instant, global, low-fee payments) is available without the operational burden.

> **This does not replace running your own node**
>
> Lightning has always offered a fully self-sovereign path where you run your own node and channels, and that path is not going anywhere. Wavelength is for everyone who would rather not run infrastructure at all, without giving up control of their funds.

## What you run vs. what is managed

You run **Wavelength**, the self-custodial client (compiled from [wavelength](https://github.com/lightninglabs/wavelength)). It holds the user’s keys, tracks their balance, and builds and signs their payments. Everything the wallet talks to is managed for you.

Your app

wallet API

Wavelengththe client you run · holds keys, signs paymentswebnativeserverMCP

exit

BOLT 11

Bitcoin on-chainyours anytime, no permission

Wavelength Operatormanaged for you · coordination + settlementdeep liquidity via Loop

Lightning Network

| Piece                         | Who runs it         | What it does                                                                                                                                                    |
| ----------------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Wavelength** (the client)   | You                 | Holds keys, tracks balances, builds and signs payments. Runs as an embedded SDK in a web or mobile app, as a standalone server, or as an MCP server for agents. |
| **Coordination + settlement** | Wavelength Operator | An Ark-like layer that batches off-chain transfers instantly and cheaply. It settles between users but never takes unilateral control of anyone’s funds.        |
| **Liquidity via Loop**        | Wavelength Operator | Deep Lightning liquidity through Loop, so payments route reliably without you sourcing, funding, or managing channels.                                          |
| **The Lightning Network**     | Open network        | Everything speaks BOLT 11, so you can pay and be paid by any wallet, exchange, or app already on Lightning.                                                     |

## Self-custodial, exit anytime

Users hold their own keys. The coordination service settles transfers but never has unilateral control of anyone’s money, and a user can always move their balance back to the Bitcoin blockchain on their own, at any time, without anyone’s cooperation. The wallet exposes this directly through an `exit` command. You get the convenience of a managed payments experience with the trust guarantees of holding your own Bitcoin. See [Leaving Ark](/concepts/leaving-ark/) for how exits work in practice.

## One invoice for everything

Every payment you send and receive is a BOLT 11 invoice, the standard Lightning format. There is a single payment format to learn, and your wallet works with the entire Lightning Network the moment you integrate it. A normal Bitcoin address only shows up at the edges, when funding a wallet or moving funds back to the chain. See [Lightning payments are swaps](/concepts/lightning-payments-are-swaps/) for how a Lightning payment maps to an Ark swap under the hood.

## Ways to integrate

Wavelength meets you where you build:

- **Embedded SDK** - pull the SDK into your app to put a wallet directly inside it. It runs on web (compiled to WebAssembly, in a browser tab) and on mobile (compiled into the app binary), on React Native or on native Kotlin and Swift. Start with the [Web quickstart](/web/get-started/quickstart/), the [React Native quickstart](/react-native/get-started/quickstart/), or the [Native iOS & Android quickstart](/native-ios-android/quickstart/).
- **As a standalone client** - a single self-contained process driven over a gRPC and REST API.
- **For agents** - run the MCP server so an AI agent can drive the wallet as typed tool calls. Wallet creation and unlock stay off the agent channel, so seeds and passwords are never exposed to a model.

These docs focus on the SDK (web, React Native, and native iOS and Android). The other surfaces share the same wallet commands and are documented separately.

## Networks

Wavelength runs on signet and testnet by default, and both are open to everyone. These test networks let you build and exercise the full payment flow with coins that have no real value. Mainnet access is gated to an approved allowlist and requires an explicit opt-in. See [Networks and config](/concepts/networks-and-config/) for the details.

## Where to go next

- [What is Wavelength?](/introduction/what-is-wavelength-sdk/) - the client you run, and the packages it ships as.
- [Web quickstart](/web/get-started/quickstart/), [React Native quickstart](/react-native/get-started/quickstart/), or [Native iOS & Android quickstart](/native-ios-android/quickstart/) - a running wallet in a few minutes.
- [System architecture](/introduction/system-architecture/) - how the embedded daemon connects to the backend gateways.
