API Overview

The Stash Cloud API lets applications manage the full lifecycle of a dedicated RGB Lightning node over a standard HTTP interface — create, query, start, stop, destroy and export node data — without self-hosting servers. Log in with a wallet to get an API Key; no account application is required.

The node runtime is powered by the RGB Lightning Node (rgbldkd, developed by Bitlight Labs). Each node has a dedicated domain, and the runtime API is accessed directly on that domain.

Responsibility boundary

The interfaces covered by the Stash Cloud documentation are split into two clearly separated, non-overlapping layers:

Layer	Provider	Responsibility	Docs
Node Management API	Stash Cloud	Create, query, start, stop and destroy nodes; lifecycle and quota; multi-tenant isolation	This documentation (Authentication, Node Management)
Node Runtime API	RGB Lightning Node	In-node capabilities such as opening channels, sending/receiving payments and RGB asset operations	RGB Lightning Node API; request/response format follows the OpenAPI spec in rgb-ldk-api-public

After creating a node, use the dedicated domain returned by the management API (public_dns / api_base_url) to reach the runtime API. Runtime endpoints use the node's own credentials; the management API Key is not a runtime credential and cannot call native node interfaces. See Runtime API for the boundary.

Core design

• Deterministic quota model: each tenant has a hard node cap, applied per network; the public create endpoint accepts no resource-spec selector, and the exact quota follows the service agreement.
• Tenant isolation: each tenant's nodes and resources are physically isolated from one another; even on the internal network, cross-tenant operations are not possible.
• One instance, one network: each API endpoint is bound to a single network (regtest / testnet / mainnet); the network is selected with the X-Network header and never sent in the request body, avoiding cross-environment mistakes.
• Differentiated node roles: the platform differentiates lifecycle policies by role such as user (default) and hub; the public API exposes no role selector.
• Dedicated domain: each node has its own domain, and the runtime API is accessed directly on that domain.

Node types & lifecycle

Nodes are differentiated by role on the platform, and each role has its own resource reclamation and keep-alive policy. The public management API exposes no role selector; creation accepts only an optional name:

Role	Description	Lifecycle and storage
User node	The default role, produced by wallet registration	Compute resources are reclaimed after the deployment's idle window; storage is persisted with platform backups. After reclamation the node wakes on a later access per the deployment policy — do not assume any request wakes the node or extends activity
Hub node	A platform-level node, usually enabled by contacting Stash Labs	Runs persistently and is published to the public hub directory and P2P peers (see GET /v3/public/hubs, GET /v3/public/peers/{ln_pubkey})

Idle reclamation, on-demand wake-up and backup retention are deployment policies, not create-request parameters, and are not capability promises of the public API. LSP keep-alive protection is a separate product capability; see LSP.

Integration paths

Log in with a wallet in the official console to obtain an API Key — no account application required. The official Stash Wallet and third-party apps / custom clients share the same underlying node capabilities:

• Official products (Stash Wallet, RGB Dex, and so on): reach nodes through the wallet session and node access authorization, and use official capabilities such as export and keep-alive.
• Third-party developers: create an API Key in the official console and use the public management API (/v3) documented here to manage nodes within their own tenant.

Both paths share the same node infrastructure, but their credentials, permissions and callable endpoints are independent and must not be mixed.

Architecture

Wallet login / application
    │
    ▼
Stash Cloud API
    ├── Auth + quota check
    └── Node lifecycle management
            │
            ▼
    RGB Lightning Node (dedicated domain)
            │
            ▼
    Node runtime API (open channels, send/receive, RGB assets…)

Documentation navigation

• Quickstart — complete a full node management flow with an API Key.
• Authentication — scopes, network selection, secure storage, request UUIDs and errors.
• Node Management — creation, pagination, start/stop, deletion and P2P allocation.
• LSP — LSP keep-alive protection and its boundary.
• Node Data Export — node archive export, retention and recovery boundary.
• Runtime API — how and within what boundary to reach native node interfaces on the dedicated domain.

Further reading

• Node Compute Engine — node lifecycle, async creation and runtime policies.
• Storage Backup — export, self-custody and recovery boundary.
• Security & Access — API Key security, node isolation and funds safety.
• RGB Lightning Node API — grouped runtime endpoint index; full spec in rgb-ldk-api-public.