XRP Ledger tooling

Get started with a reliable XRP Ledger RPC endpoint to use the tools below. Your Chainstack XRP Ledger node serves the rippled API two ways: JSON-RPC over the HTTPS endpoint, and the WebSocket API over the WSS endpoint. The official SDKs — xrpl.js and xrpl-py — connect over WSS, and xrpl-py also connects over HTTPS. XRP Ledger has its own method set and does not implement the Ethereum eth_* interface, so EVM tooling — ethers.js, web3.py, Hardhat — does not apply here.

JSON-RPC over HTTPS

Every call is an HTTP POST carrying a method and a params array. The params array holds exactly one object, even when a method takes no arguments — a bare {} rather than an empty array.

curl YOUR_CHAINSTACK_ENDPOINT \
  -H 'Content-Type: application/json' \
  -d '{"method":"server_info","params":[{}]}'

The result object reports the client version, the ledgers this node holds, and its sync state:

{
  "build_version": "3.3.0",
  "complete_ledgers": "106106987-107266543",
  "server_state": "full"
}

Replace YOUR_CHAINSTACK_ENDPOINT with your node’s HTTPS endpoint. For the credential in that endpoint and the other ways to authenticate, see Authentication methods for different scenarios.

WebSocket API over WSS

The WSS endpoint serves the rippled WebSocket API, which frames requests differently from JSON-RPC: each message names the method in a command field and carries its arguments at the top level, with an optional id that the response echoes. A WebSocket connection also supports subscriptions, which push events such as closed ledgers and validated transactions as they happen.

wscat -c YOUR_CHAINSTACK_WSS_ENDPOINT
> {"id": 1, "command": "subscribe", "streams": ["ledger"]}

The node answers with the subscription result, then sends a ledgerClosed message for every new validated ledger:

{"id":1,"result":{"fee_base":10,"ledger_hash":"9FF17722348FDC9F54AC383A8EF40B62BD37B12153D77C611351FDD75C1CCF44","ledger_index":107266586,"ledger_time":843812440,"network_id":0,"reserve_base":1000000,"reserve_inc":200000,"validated_ledgers":"106106987-107266586"},"status":"success","type":"response"}
{"fee_base":10,"ledger_hash":"582D06B6C94C4F897F1B0F5411DD5FDF523EDA20B4D2895D2920D265FF9F2D9A","ledger_index":107266587,"ledger_time":843812441,"network_id":0,"reserve_base":1000000,"reserve_inc":200000,"txn_count":75,"type":"ledgerClosed","validated_ledgers":"106106987-107266587"}

Replace YOUR_CHAINSTACK_WSS_ENDPOINT with your node’s WSS endpoint, which carries the same auth token as the HTTPS endpoint.

How much ledger history your node holds

XRP Ledger Global Nodes are Extended — they keep more recent ledgers than a default rippled server holds, but not the full chain. The node deletes old ledgers in rotation and holds between 750,000 and 1,500,000 of the most recent ledgers. At the Mainnet close rate of about 3.8 seconds per ledger, that is about 33 to 66 days of history. Read complete_ledgers from server_info at runtime and work within it. The lower bound jumps forward each time the node rotates out old ledgers, so treat any specific depth as a moving target rather than a guarantee. Requesting anything below the window returns lgrNotFound:

{
  "result": {
    "error": "lgrNotFound",
    "error_message": "ledgerNotFound",
    "status": "error"
  }
}

The same floor applies to transaction history and to account state alike — account_tx clamps its search range to the retained window rather than reaching further back. For queries older than the window, use a full-history source such as an XRP Ledger public full-history server.

Python

Use the official xrpl-py SDK. Its JsonRpcClient talks to your node over HTTPS:

# pip install xrpl-py
from xrpl.clients import JsonRpcClient
from xrpl.models.requests import AccountInfo, ServerInfo

client = JsonRpcClient("YOUR_CHAINSTACK_ENDPOINT")

info = client.request(ServerInfo()).result["info"]
print("rippled", info["build_version"], "| ledgers on this node:", info["complete_ledgers"])

account = client.request(AccountInfo(
    account="rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
    ledger_index="validated",
)).result["account_data"]
print("balance (drops):", account["Balance"], "| sequence:", account["Sequence"])

This prints the node’s client version, its retained range, and the queried account’s balance in drops:

rippled 3.3.0 | ledgers on this node: 106106987-107266543
balance (drops): 56775133590 | sequence: 44196

For subscriptions, use AsyncWebsocketClient over the WSS endpoint. This script subscribes to the ledger stream and prints each closed ledger:

# pip install xrpl-py
import asyncio

from xrpl.asyncio.clients import AsyncWebsocketClient
from xrpl.models.requests import StreamParameter, Subscribe


async def main():
    async with AsyncWebsocketClient("YOUR_CHAINSTACK_WSS_ENDPOINT") as client:
        await client.send(Subscribe(streams=[StreamParameter.LEDGER]))
        async for message in client:
            if message.get("type") == "ledgerClosed":
                print("ledger", message["ledger_index"], "closed with", message["txn_count"], "transactions")


asyncio.run(main())

ledger 107266567 closed with 95 transactions
ledger 107266568 closed with 76 transactions
ledger 107266569 closed with 110 transactions

JavaScript

Use the official xrpl.js SDK. Its Client connects to your node over the WSS endpoint:

// npm install xrpl
import { Client } from "xrpl";

const client = new Client("YOUR_CHAINSTACK_WSS_ENDPOINT");
await client.connect();

const { result } = await client.request({ command: "server_info" });
console.log("rippled", result.info.build_version, "| ledgers:", result.info.complete_ledgers);

const { result: account } = await client.request({
  command: "account_info",
  account: "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
  ledger_index: "validated",
});
console.log("balance (drops):", account.account_data.Balance, "| sequence:", account.account_data.Sequence);

await client.disconnect();

rippled 3.3.0 | ledgers: 106106987-107266543
balance (drops): 56775133590 | sequence: 44196

Sign and submit a transaction

submitAndWait fills in Fee, Sequence, and LastLedgerSequence from the node, signs the transaction with the wallet locally, submits it, and resolves once a validated ledger contains it:

// npm install xrpl
import { Client, Wallet, xrpToDrops } from "xrpl";

const client = new Client("YOUR_CHAINSTACK_WSS_ENDPOINT");
await client.connect();

const wallet = Wallet.fromSeed("YOUR_SEED");

const { result } = await client.submitAndWait(
  {
    TransactionType: "Payment",
    Account: wallet.classicAddress,
    Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
    Amount: xrpToDrops("1"),
  },
  { wallet },
);
console.log(result.meta.TransactionResult, "in validated ledger", result.ledger_index);

await client.disconnect();

On Testnet, a successful payment prints:

tesSUCCESS in validated ledger 21087026

Track new ledgers

Subscribe to the ledger stream and handle the ledgerClosed event. The node pushes one message for every validated ledger, every few seconds:

// npm install xrpl
import { Client } from "xrpl";

const client = new Client("YOUR_CHAINSTACK_WSS_ENDPOINT");
await client.connect();

client.on("ledgerClosed", (ledger) => {
  console.log(`ledger ${ledger.ledger_index} closed with ${ledger.txn_count} transactions`);
});

await client.request({ command: "subscribe", streams: ["ledger"] });

ledger 107266544 closed with 87 transactions
ledger 107266545 closed with 86 transactions
ledger 107266546 closed with 115 transactions

To follow validated transactions instead, subscribe to the transactions stream and handle the transaction event.

Platform

Pricing

Core

Add-ons

Security

Migrate to Chainstack

Web3 [de]coded

MCP servers

Marketplace

Chainstack Compare

Chainstack ChatGPT plugin

Chainstack DLP browser extension

Protocols

Advanced APIs

Tooling

JSON-RPC over HTTPS

WebSocket API over WSS

How much ledger history your node holds

Python

JavaScript

Sign and submit a transaction

Track new ledgers

​JSON-RPC over HTTPS

​WebSocket API over WSS

​How much ledger history your node holds

​Python

​JavaScript

​Sign and submit a transaction

​Track new ledgers

JSON-RPC over HTTPS

WebSocket API over WSS

How much ledger history your node holds

Python

JavaScript

Sign and submit a transaction

Track new ledgers