DEV Community: ScopeBots

Best RPC and data APIs for Xahau (2026)

ScopeBots — Thu, 22 Oct 2026 23:00:43 +0000

Documentation based guide: compiled from each maker's own docs on Oct 20, 2026. We have not load-tested these endpoints, and the guide contains no code we ran.

For most Xahau projects, the answer is short: build against the free public nodes the Xahau docs list (wss://xahau.network for Mainnet, wss://xahau-test.net for Testnet), use the Bithomp API when you need indexed data such as account history, NFTs or token lists, and run your own xahaud node once you go to production. Unlike the XRP Ledger, Xahau has no big managed RPC market yet: none of the four large multichain providers we checked names Xahau on its network list.

This guide goes deeper than our Xahau developer tools page: what each option gives you, the limits the makers publish, and the gotchas that trip up XRPL developers moving to Xahau. It is a summary of what each maker says, not a ranking.

Quick answer
Are there managed RPC providers for Xahau?
Xahau public nodes
Xahau Data API
Bithomp API (via Xahau Explorer)
Running your own xahaud node
Tools that sit on top of the RPC
How to choose

Quick answer

Option	What you get	Networks named	Cost and limits	Source
Xahau public nodes	WebSocket and HTTP POST RPC	Mainnet, Testnet, JSHooks Testnet	Free; no limits or rules stated	Source: Xahau docs
Xahau Data API	DEX trade and ledger info data	Not stated beyond Xahau	No numbers stated; limits sent in response headers	Source: Xahau docs
Bithomp API	Indexed accounts, NFTs (URI Tokens), transactions, tokens	Xahau Mainnet, Xahau Testnet	Free on test networks; mainnet free tier is non-commercial (10 req/min, 2K/day); paid from 30 EUR/month	Source: Bithomp docs
Your own xahaud node	Full control over ports, limits and access	Mainnet (network ID 21337)	Your server costs; hardware needs not stated on the setup page	Source: Xahau docs

Are there managed RPC providers for Xahau?

Not among the big ones. On Oct 20, 2026 we searched the network lists of QuickNode, Chainstack, GetBlock and NOWNodes. All four name the XRP Ledger, and none names Xahau. Xahau is a separate network with its own network IDs, so an XRPL endpoint from one of these providers will not serve Xahau.

If you came here from our XRP Ledger RPC guide, this is the main difference: on Xahau, the free public nodes and your own node are the realistic choices, with Bithomp covering the indexed-data side.

Xahau public nodes

The Xahau docs list free public endpoints for three networks (Source: Xahau public nodes):

Mainnet (network ID 21337): wss://xahau.network and https://xahau.network, plus xahau.org as an alias for both. The docs note the alias exists because "some ad-blockers block .network", which is worth knowing if your app calls the endpoint from a browser.
Testnet (21338): wss://xahau-test.net and https://xahau-test.net.
JSHooks Testnet (31338): wss://jshooks.xahau-test.net and https://jshooks.xahau-test.net, for Hooks written in JavaScript.

Trade-offs. The page names no operator and states no rate limits, history depth or uptime commitment. That is fine for development and light reads. For a production app, treat a public node as shared infrastructure you don't control: add a fallback (the .org alias, or your own node) and handle disconnects. The same docs page lists the Testnet faucet and explorers (Source: Xahau faucet and explorers); there is no Mainnet faucet.

Gotcha: NetworkID. Xahau transactions must carry a NetworkID field. The transaction reference says the field is required on networks with an ID of 1025 or higher, which includes Xahau Mainnet (21337) and Xahau Testnet (21338), and must be omitted on XRPL Mainnet (Source: Xahau transaction common fields). If you reuse XRPL code and transactions fail on Xahau, check this first.

Xahau Data API

The Xahau docs list a Data API at data.xahau.network as the primary data API (Source: Xahau data APIs). The current version "offers live Xahau DEX (IOU trades) and ledger info data", and its navigation shows endpoints for DEX rates, trades, volume and tickers, plus XAH supply and ledger-index-to-time conversions (Source: Xahau Data API).

Trade-offs. No API key or numeric rate limit is documented. Each response carries headers with the limit, the requests remaining and the reset time, so read those rather than guessing. Responses use a wildcard CORS policy, so browser apps can call it directly. Pagination uses an x-has-more-data header and a skip parameter. It is not a general account or transaction history API; for that, look at Bithomp or your own node.

Bithomp API (via Xahau Explorer)

Bithomp API is the indexed-data option. Its docs list a separate base URL per network, including Xahau Mainnet at xahauexplorer.com/api/v2/ and Xahau Testnet at test.xahauexplorer.com/api/v2/, each with its own API key (Source: Bithomp API docs). Its endpoints cover addresses, NFTs, transactions, tokens and more, and its changelog includes Xahau-specific additions such as URI Token remarks.

Pricing and limits (all from the same docs page):

Test networks: "Bithomp API is FREE on the test networks."
Mainnet free tier: non-commercial use only, 10 requests per minute and 2,000 per day.
Paid tiers: Basic is 30 EUR/month for 100 requests per minute and 30,000 per day; Standard is 100 EUR/month (400/min, 120,000/day). Prices are in euros.
On-demand: pay per request instead of a subscription; the Basic on-demand rate is listed as 0.003 XAH per request on Xahau.
Some endpoints (historical rates, for example) are available only on Standard and higher.

Trade-offs. The free mainnet tier rules out commercial apps, so budget for a paid tier before launch. It is a third-party indexer, not a raw node, so use it for lookups and history, and a node for submitting transactions and live subscriptions.

Running your own xahaud node

The Xahau docs describe two install paths for a Mainnet node: a Docker setup (the mainnet-docker repository with build and up scripts) and a binary build for Ubuntu 22.04 run with a xahaud.cfg config file. Once running, the node serves WebSocket on port 16006 and HTTP RPC on 16007 locally, and peers on network ID 21337 (Source: running a Mainnet node).

The interaction guide explains how ports are opened in the [server] section of xahaud.cfg, how to restrict admin requests to specific IPs, how to cap clients per port with limit, and how to enable TLS. It also documents UDP RPC on port 16008 for read-only queries, and says transaction submission should use WebSocket or HTTP RPC (Source: interacting with xahaud).

Trade-offs. The setup page does not state hardware requirements or how to configure history depth, so size the server from your own testing. You also take on uptime, upgrades and amendment changes yourself. In return you get no third-party rate limits and full control over who can call admin methods.

Tools that sit on top of the RPC

These are not RPC providers, but most Xahau builders will pair one with the endpoints above:

xahau.js: the Xahau GitHub organization's fork of the xrpl.js client library (Source: xahau.js repo). Its README is still the xrpl.js text, so point it at a Xahau endpoint yourself.
Hooks Toolkit: its getting-started example generates testnet accounts and sets the WebSocket to wss://jshooks.xahau-test.net (Source: Hooks Toolkit docs). Testnet example only in the docs we checked.
xahau-mcp: an MCP server that lets AI agents read Xahau ledger state and simulate Hooks. Its README says it is read-only toward the network, has no submit or sign function, and its transaction builders default to testnet (Source: xahau-mcp README).
Evernode SDK: Evernode is a hosting network whose host registry is a Hook on Xahau (Source: Evernode). If you are building an Evernode app, you will still read Xahau through one of the options above.

How to choose

Prototyping or a hackathon: Testnet public nodes plus the Testnet faucet. Use the JSHooks Testnet if you write Hooks in JavaScript.
Reading balances and submitting transactions in production: public Mainnet node with the xahau.org alias as fallback, then your own xahaud node once traffic matters.
Account history, NFTs (URI Tokens) or token lists: Bithomp API; check that your use is non-commercial before relying on the free tier.
DEX prices or XAH supply data: Xahau Data API, reading its rate-limit headers.
Porting XRPL code: add NetworkID to every transaction and change every endpoint; XRPL providers do not serve Xahau.
Before you commit: confirm limits on each maker's page. They change, and the public nodes publish none.

For every Xahau tool we list, with the chain evidence for each, see Xahau developer tools.

Originally published on ScopeBots, a free directory of Web3 developer tools with chain support checked against each maker's own docs. Prices and support change often: see the latest version.

This article was researched and written with AI assistance; every factual claim links to the maker's own page.

Best RPC and node providers for the XRP Ledger (2026)

ScopeBots — Sun, 18 Oct 2026 23:00:41 +0000

Documentation based guide: compiled from each provider's own docs on Oct 16, 2026. We have not load-tested these endpoints.

Most RPC providers list dozens of chains, but only some of them name the XRP Ledger. This guide covers six managed providers whose own pages name XRPL, plus the free public servers listed on xrpl.org. It is a summary of what each provider says about itself, not a ranking, and not financial advice.

What to look for

Mainnet vs testnet. Some providers name only XRPL Mainnet. If you need a hosted Testnet or Devnet endpoint, check that it is named. XRPL's own public servers page lists free Testnet and Devnet servers either way.
WebSocket support. XRPL's subscription methods run over WebSocket, so check that a WSS endpoint is offered on the plan you will use. For example, NOWNodes lists no WebSocket connection on its free Start plan (pricing).
History depth. XRPL servers keep a limited window of recent ledgers unless they are full-history servers. Providers differ a lot here, from about two weeks (Ankr) to full history from genesis (QuickNode). If you query old transactions, this matters more than price.
Free tier. Free options range from a one-month trial to a permanent free plan with daily or monthly limits. Units differ by provider (credits, request units, compute units, requests), so the numbers below are not directly comparable.
XRPL vs XRPL EVM. Several providers also list the XRPL EVM Sidechain as a separate network. This guide is about the XRP Ledger itself.

Comparison

Provider	XRPL networks named	Free option	Paid from	Source
QuickNode	Mainnet, Testnet	1-month free trial, 10M API credits	$49/mo Build ($34/mo billed annually)	Chains, pricing
Chainstack	Mainnet, Testnet	Free Developer plan, 3M request units/mo	$49/mo Growth	Networks, pricing
GetBlock	Mainnet	Free plan, 50K compute units/day	$49/mo Starter ($39/mo billed annually)	XRPL docs, plans
NOWNodes	Mainnet	Free Start plan, 100K requests/mo	Not stated	Nodes, pricing
Blockdaemon	Mainnet, Testnet	Free Plan with limited units (limits not stated)	Not stated	XRP RPC docs, quick start
Ankr	Mainnet, Testnet	Free public and Freemium tiers	Pay-as-you-go, $10 minimum deposit	XRPL launch post, service plans
XRPL public servers	Mainnet, Testnet, Devnet	Free (non-commercial)	Not applicable	xrpl.org

Prices change often. Confirm on each provider's page before you buy.

Provider notes

QuickNode

QuickNode lists the XRP Ledger as a non-EVM L1 with Mainnet and Testnet, with its Core RPC API and Streams/Webhooks (chains page). Its XRPL docs list Archive as "Yes" for both networks, with Mainnet history starting from ledger 32570, and show a WSS field for each network (XRPL docs). There is no permanent free plan: the free trial lasts one month with 10M API credits and 15 requests per second, no card required. The cheapest paid plan is Build at $49/mo billed monthly or $34/mo billed annually, with 80M API credits and 50 requests per second (pricing). QuickNode is also the only managed provider named in the Commercial section of XRPL's public servers page.

Chainstack

Chainstack lists the XRP Ledger with Global Node and Dedicated deployments on Mainnet, plus Testnet, using what it calls Extended nodes (protocols and networks). Its XRPL tooling page describes JSON-RPC over HTTPS and the WebSocket API over WSS. It also says the node keeps between 750,000 and 1,500,000 recent ledgers (roughly 33 to 66 days), not full history, and points to a full-history server for older queries (XRPL tooling). The free Developer plan includes 3M request units a month, 25 requests per second, one node and WebSockets. Growth is $49/mo ($40/mo billed annually) with 20M request units. Chainstack lists archive data only on paid plans (pricing).

GetBlock

GetBlock names XRP Ledger Mainnet only, with no testnet, and supports JSON-RPC and WebSocket (XRPL docs). Its docs do not say whether shared XRPL nodes are full or archive. Its XRP node page says full historical data and archive lookups come through Dedicated Nodes (XRP nodes). The free plan gives 50,000 compute units per day, renewed daily with no rollover, at 20 requests per second. The cheapest shared plan is Starter at $49/mo ($39/mo billed annually) for 90M compute units (plans and limits, pricing). Dedicated nodes start at $1,000 a month for most protocols.

NOWNodes

NOWNodes lists XRP with a Mainnet entry only and a WSS endpoint (nodes). It does not mention archive access for XRP. The free Start plan includes 100,000 requests a month and one API key, but no WebSocket connection. Paid plans go from Pro (1M requests a month) up to Enterprise (100M), but the pricing page did not show monthly prices when we checked, so the paid starting price is not stated (pricing).

Blockdaemon

Blockdaemon is not yet listed on ScopeBots. Its docs name XRP Mainnet and Testnet and describe JSON-RPC 2.0 POST requests. That page does not mention WebSocket (access XRP RPC). New accounts are enrolled in a Free Plan with a free API key and "limited unit usage", but the docs do not give the limits. Paid prices are not stated in its docs, and its API pricing page routes to a sales form (quick start).

Ankr

Ankr is not yet listed on ScopeBots. Its August 2026 launch post names XRPL Mainnet and Testnet and a free public tier (Ankr blog). Its XRP API docs say its XRP Ledger nodes are full nodes, not archive. They keep about the last two weeks of history, so older ledgers and transactions are unavailable. Those docs describe JSON-RPC but do not mention WebSocket (XRP API docs). The free Public and Freemium tiers both list about 1,800 Node API requests per minute. Paid access is pay-as-you-go with a $10 minimum deposit, and a non-EVM HTTPS request costs 200 credits ($0.00002) (service plans).

When the free public servers are enough

XRPL's public servers page lists free JSON-RPC and WebSocket endpoints. They are a reasonable choice for:

Learning and prototyping. Ripple, Honeycluster and XRPL Labs run free Testnet servers, and Ripple and Honeycluster also run Devnet servers.
Occasional full-history lookups. Honeycluster (with Clio), xrplcluster.com and Ripple's s2.ripple.com are listed as full-history Mainnet servers.
Browser apps in development. xrplcluster.com and the XRPL Labs testnet server are listed with CORS support.

They are not meant for production. The same page says Ripple's public servers are not for ongoing or commercial use and may go offline at any time. It recommends running your own server or hiring someone you trust to run one for regular use. It also warns that the xrpl.ws alias may be unsuitable for production. The page does not state rate limits.

Once you depend on uptime, a WebSocket subscription or a specific history window, use a managed provider or your own node, and check its history depth first.

How we checked

On Oct 16, 2026, we read each provider's own chain list, XRPL docs and pricing page, linked above. We counted a network only if the provider's own pages named it, and we wrote "not stated" where a provider's pages did not give a figure. We did not sign up, send requests or measure performance. ScopeBots listings for QuickNode, Chainstack, GetBlock and NOWNodes carry the same chain evidence with dates.