Best Bittensor RPC Providers 2026: Pricing, Archive Access and WebSocket Support Compared

A validator script pulls the subnet 64 metagraph from 30 days ago to compare weights, and the public endpoint answers with State discarded ... This indicates the block is too old, and you should instead make this request using an archive node. The call was fine. The node was a lite node, and a lite node keeps about 300 blocks of state, one hour on Bittensor.

That error sorts the provider list more than price does. Bittensor is a Substrate chain, so several large providers do not serve it: QuickNode and Ankr have no Bittensor endpoint, and Chainstack sells it as a dedicated node only. Of the four shared-plan providers compared here, two serve archive state, one is a full node only, and one does not say. Pricing runs from $1.96 to about $22 per million calls on entry plans.

This comparison covers those four, plus the free public endpoints and three partial options. Pricing is a list-price snapshot from October 12, 2026, normalized to dollars per million calls.

What Makes Bittensor Different for RPC

Bittensor runs on Subtensor, a Substrate (Polkadot SDK) chain. Blocks come every 12 seconds from Aura, and GRANDPA finalizes them about 2-3 blocks behind the head. The runtime upgrades often: it reported specVersion 477 on October 12, 2026, after four runtime releases between October 5 and 8.

Lite nodes keep about 300 blocks of state

Subtensor nodes come in two kinds. A lite node warp-syncs and keeps recent state only, so it uses about 128 GB. An archive node keeps every state since genesis, and it needed at least 3.5 TB at block 7,929,000 in March 2026. The chain passed block 9,269,000 in October.

The Bittensor docs recommend an archive node for any data "older than the previous 300 blocks". In our probes, the public lite pool always returned state from 256-270 blocks back, sometimes from 280-310, and never from 1,000. Block hashes and headers stay available everywhere. Only the state goes. So chain_getBlockHash(1000000) works on a lite node, and state_getStorage at that hash fails with error 4003.

Reads that need archive:

• Metagraph, stake, emission or weights at a past block
• Any state_call runtime API (SubnetInfoRuntimeApi, NeuronInfoRuntimeApi) pinned to an old block hash
• Indexers, dashboards, tax and accounting exports, and subnet backtests

The SDK and extrinsic watching need WebSocket

Three of the methods Bittensor apps use most are subscriptions: author_submitAndWatchExtrinsic (submit a signed extrinsic and stream its status until it is in a block and finalized), chain_subscribeNewHeads, and state_subscribeStorage. Subscriptions only work over WebSocket. Over plain HTTPS you get author_submitExtrinsic, which returns a hash and nothing else.

The bittensor Python SDK v11 (11.3.0, released October 7, 2026) goes further: its transport is WebSocket-only for every call, and it keeps one long-lived connection per endpoint. An HTTPS-only provider cannot serve the SDK or btcli at all.

Validators and miners load RPC in bursts

Most subnets run a 360-block tempo (72 minutes), and the default weight-setting rate limit is 100 blocks (20 minutes). The official subnet template re-syncs the metagraph every 100 blocks. A validator therefore holds a head subscription open, pulls a full metagraph (up to 256 neurons with weights and bonds) every 20 minutes, and submits a set_weights or commit-reveal extrinsic in each window. Across 128 subnets and 29,600 registered UIDs, that load lands on whichever endpoint operators configure.

Custom RPC namespaces and the EVM on one URL

Subtensor adds its own RPC methods on top of the Substrate set: subnetInfo_* (for example subnetInfo_getMetagraph, subnetInfo_getAllDynamicInfo), neuronInfo_* and delegateInfo_*. A provider that runs a stock Substrate proxy in front of the node must pass these through.

The Bittensor EVM (chain ID 964, testnet 945) runs inside the same node through Frontier. On most providers the same URL answers eth_chainId with 0x3c4, and Solidity contracts reach staking, metagraph and neuron state through precompiles at 0x801-0x808.

Dynamic TAO, the Halving and 128 Subnets

Dynamic TAO went live on February 13, 2025, giving each subnet its own alpha token and pool. The first halving landed in December 2025 and cut issuance to 0.5 TAO per block, about 3,600 TAO a day. On October 12, 2026 the chain had 128 subnets, its current cap, and TAO traded at $283.91 for a market cap of about $3.2B (CoinGecko).

What to Look for in a Bittensor RPC Provider

Archive state on the shared plan. Without it, every historical read fails. Some providers list archive only on dedicated nodes or on higher plans, so check the plan you will buy.

WebSocket on your plan. The SDK needs it, and author_submitAndWatchExtrinsic needs it. Also check idle timeouts: a validator that sleeps between epochs will see dropped connections on a provider that closes idle sockets after 30 seconds.

How subscription pushes are billed. A head subscription delivers 300 pushes an hour. Some providers bill each push as a response, others charge only for the subscribe call. On a per-push biller, one watched extrinsic that streams ready, in-block and finalized updates costs about four units.

Bittensor RPC namespaces. Confirm that subnetInfo_getMetagraph and neuronInfo_getNeuronsLite work, not only state_* and chain_*.

EVM on the same endpoint. If you run contracts on chain 964 and a Substrate backend, one URL and one key is simpler than two.

Testnet. Subnet owners and validators test on testnet first. Not every provider offers it.

How to Compare Bittensor Pricing Across Unit Systems

Bittensor providers quote their rates in requests, response units, RU and compute units. To compare them, convert each one to dollars per million calls for the Substrate methods a subnet or wallet backend actually makes, using the weight each provider gives the method.

Per-request billing. One request or response is one unit, whatever the method. Dwellir, OnFinality and NOWNodes bill Bittensor this way on every method in the mix. Dwellir's Developer plan works out to $1.96 per 1M calls included, with overage at $2-5 per 1M. OnFinality Growth is $2.45 per 1M included and $6.00 overage, and OnFinality bills system_health at zero. NOWNodes Business is about $7.45 per 1M included and about $11.18 overage.

Compute units. The provider charges per million units and gives each call a weight.

• GetBlock charges $0.544 per 1M CU on Starter. Bittensor is not named in GetBlock's multiplier groups, so it falls into the default group of 10 CU per call, which is $5.44 per 1M calls. This is an inference we could not confirm on a published price list. If the dashboard shows 20 CU, every figure doubles.
• dRPC assigns a flat $6.00 per 1M calls, but on Bittensor it serves the EVM only, so Substrate methods are not priced.

Method by method, in dollars per 1M calls at each plan's included rate:

Overage runs $2-5 per 1M at Dwellir, $3.75-6.00 at OnFinality and about $5.59-11.18 at NOWNodes. GetBlock publishes overage only on Pro and Premium ($3.50-4.00 per 1M calls); lower plans top up at an unpublished price. Subscription billing is the variable that can move a bill: OnFinality bills every pushed response, and the others do not say.

The monthly totals later in this post use the same mostly-reads mix as our other provider comparisons, mapped to Substrate methods: 40% state_getStorage or state_queryStorageAt, 25% state_call runtime API reads, 15% chain_getHeader and chain_getBlockHash, 10% chain_getBlock, 5% system_accountNextIndex and 5% author_submitExtrinsic or author_submitAndWatchExtrinsic, all on recent blocks. On that mix every call is one unit at Dwellir, OnFinality and NOWNodes, so 1M calls cost the per-call rate above. On GetBlock every call is 10 CU, so Starter's 90M CU cover 9M calls and Pro's 1B CU cover 100M calls at $499.

1. Dwellir

Dwellir serves Bittensor mainnet and testnet from archive nodes on its shared plans, over HTTPS and WSS, with one RPC response billed as one API credit. The endpoint is https://api-bittensor-mainnet.n.dwellir.com/<your-api-key>, with wss:// on the same host. The same URL serves the Bittensor EVM (eth_chainId returns 0x3c4) and the Subtensor namespaces (subnetInfo_*, neuronInfo_*, delegateInfo_*). See the Bittensor network page and the Bittensor API docs.

On October 12, 2026 the endpoint returned System.Number at block 1,000,000 (0x40420f00), streamed chain_subscribeNewHeads at 12-second intervals, and served a 30-day-old subnet 64 metagraph through the v11 SDK. The same read failed on the public lite endpoint.

Key features:

• Archive state on the shared endpoint, mainnet and testnet
• WebSocket for author_submitAndWatchExtrinsic and storage subscriptions (method docs)
• Substrate, Subtensor RPC namespaces and Bittensor EVM on one URL and key
• Unlimited Node for flat, unmetered billing on the same URL and key
• 150+ networks; crypto payment on every paid plan

Pricing:

A dedicated Bittensor node cluster lists at $3,048 per month, with isolated nodes, regions of your choice, a 99.99% uptime SLA and no request counting.

Considerations: OnFinality's $249 Accelerate plan includes 100M responses where Dwellir's metered bill at 100M is $299. The shared Bittensor nodes run in Europe, so teams with validators in Asia or the US should test latency from their own region on the free plan first.

Best for: Validators, subnet owners and backends that need archive reads, WebSocket and the EVM on one endpoint with one-credit-per-response billing, plus testnet on the same account.

2. OnFinality

OnFinality is a long-running Substrate specialist with a shared Bittensor Finney endpoint, archive on every plan, and dedicated full, archive and validator nodes in Northern Virginia and Hong Kong. The public endpoint bittensor-finney.api.onfinality.io/public also answered EVM calls with 0x3c4 in our probe, though EVM is not marketed on the Bittensor page.

Key features:

• Archive access on all plans, including Free
• HTTPS and WebSocket
• Free plan with 400,000 responses a day
• Dedicated Bittensor nodes in two regions
• 130+ networks

Pricing:

Considerations: OnFinality bills every response, including each message pushed on a subscription. A chain_subscribeNewHeads stream is 300 response units an hour, about 216,000 a month per open subscription. The pricing page lists plans as "+ Node and API Usage Costs", and Bittensor testnet is not listed. At 50M calls Growth's $6.00 overage brings the bill to $229.

Best for: Teams already on OnFinality for Polkadot ecosystem chains, and free-tier development with archive reads.

3. GetBlock

GetBlock lists Bittensor with Substrate, WebSocket and EVM access. On its shared plans Bittensor is a full node in us-east-1, mainnet only. Substrate and EVM are separate endpoints, chosen per endpoint in the dashboard.

Key features:

• Substrate JSON-RPC, WebSocket subscriptions and EVM endpoints
• SOC 2 Type II
• Dedicated Bittensor full node from $1,000 per month in three regions
• 130+ networks

Pricing:

The calls column assumes 10 CU per Bittensor call, the default group. If the dashboard shows 20, every per-call figure doubles.

Considerations: No archive state on the shared endpoint and none listed for dedicated nodes either, so historical metagraph and stake reads fail. No shared testnet. GetBlock's Bittensor API reference lists the mainnet EVM chain ID as 945, which is testnet; mainnet is 964.

Best for: Recent-state reads and extrinsic submission from US East, for teams that already use GetBlock on other chains and need SOC 2 paperwork.

4. NOWNodes

NOWNodes serves Bittensor at https://tao.nownodes.io, with docs covering the Substrate methods, the Subtensor namespaces, eth_* and debug_trace* on the same host. Every request counts as one, whatever the method. Prices are in euros; dollar figures below use the October 12, 2026 ECB rate (1 EUR = $1.1181).

Key features:

• Substrate, Subtensor namespaces and EVM on one host
• Flat per-request billing, no RPS cap on paid plans
• 120+ blockchains

Pricing:

Considerations: Archive, testnet and a Bittensor WebSocket URL are not stated, and the Pro Plus and Business Plus prices did not render outside the browser. The entry plan's 1M requests is small for any validator.

Best for: Teams already on NOWNodes for other chains that want Bittensor on the same key.

Also Serving Bittensor

• Opentensor Foundation public endpoints. wss://entrypoint-finney.opentensor.ai:443 (lite state), wss://lite.chain.opentensor.ai:443, wss://archive.chain.opentensor.ai:443 and testnet wss://test.finney.opentensor.ai:443. Free, no SLA, no published limit; the lite endpoint returned HTTP 429 after roughly 60-80 calls in our testing. The SDK's finney and archive presets point here.
• dRPC. Bittensor EVM only (chain 964 and 945), HTTPS only, no archive, paid plans only, at a flat $6.00 per 1M calls. Substrate methods return -32601, so it cannot serve the SDK.
• Chainstack. Bittensor is dedicated-only ("Request deployment"), with no shared plan or public price.
• Taostats API. Indexed Bittensor data (metagraph history, staking, prices) from $9 a month, with an RPC passthrough to lite and archive nodes. Credits per RPC call are not published and the legacy /api/ paths retire on November 9, 2026, so it fits indexed data lookups better than RPC volume.

Provider Comparison

For reference, the Opentensor Foundation's public lite endpoint returned HTTP 429 after roughly 60-80 calls in a few minutes in our October 12, 2026 testing. It publishes no rate limit and no SLA, so treat it as a development endpoint.

Effective Price per Million Calls

One denominator for every provider: dollars per 1M Bittensor calls under the mix above, at the entry paid plan and at the best self-serve rate, with overage alongside.

What That Costs at Volume

Plans step at fixed tiers, so monthly bills differ from the per-million rates. Same mix, list prices.

Each figure uses the cheapest plan that covers the volume, plus overage where that is cheaper than the next plan. 100M calls a month averages about 39 requests per second, inside every plan shown.

At 10M requests, Dwellir's $49 ties OnFinality. At 50M, Dwellir is the lowest at $174, and at 100M OnFinality's Accelerate plan is $50 below Dwellir's metered bill. The Dwellir Unlimited Node at 50M is $119 if average traffic stays under 25 RPS and $479 for the 100 RPS tier. GetBlock and NOWNodes cost roughly two to five times as much as Dwellir or OnFinality, and GetBlock's shared endpoint has no archive.

Choosing the Right Provider

For most Bittensor workloads, choose Dwellir. Archive state, WebSocket and the EVM share one endpoint, so historical metagraph reads, author_submitAndWatchExtrinsic and chain 964 contracts use one URL and key, and testnet sits on the same account. Billing is one credit per response at $1.96 per 1M on entry. When traffic is steady, the Unlimited Node turns the same endpoint into a flat monthly price, and the same key covers 150+ other networks.

If you already use OnFinality for Polkadot ecosystem chains, or you need a larger free tier while developing, choose OnFinality. Model the cost of your subscriptions first, because every pushed head counts as a response.

For heavy validators running above 1,000 RPS, or for operators who need isolated hardware in a chosen region, compare dedicated clusters: Dwellir lists a Bittensor cluster at $3,048 a month.

Point the Bittensor SDK at a Provider

SDK v11 takes a WebSocket URL directly. Empty fallback and archive lists stop the client from silently routing reads to the Opentensor Foundation's public pools, so you know which provider served each call. The script below was run against Dwellir on October 12, 2026 with bittensor==11.3.0:

import os
import bittensor as bt

url = f"wss://api-bittensor-mainnet.n.dwellir.com/{os.environ['DWELLIR_API_KEY']}"

# Empty fallback and archive lists pin every read to this one endpoint
sub = bt.Subtensor(url, fallback_endpoints=[], archive_endpoints=[])

head = sub.block
print("head:", head, "finalized:", sub.finalized_block)

now = sub.subnets.metagraph(64)
print("SN64 neurons now:", len(now.neurons))

# 30 days back: the state is gone on a lite node, so this needs archive
past = sub.at(head - 216_000).subnets.metagraph(64)
print("SN64 neurons 30 days ago:", len(past.neurons))

Output on Dwellir:

head: 9269384 finalized: 9269382
SN64 neurons now: 256
SN64 neurons 30 days ago: 256

The same script against wss://lite.chain.opentensor.ai:443 fails on the last read:

bittensor.result.ChainError: State discarded for 0xf1760e97...ac61. This indicates the block is too old, and you should instead make this request using an archive node.

Run the same script against each provider you are evaluating. It checks WebSocket, the Subtensor runtime APIs and archive state at once. For btcli, pass the same URL with -n wss://.... The v10 flag --subtensor.chain_endpoint no longer exists in v11.

Getting Started

Dwellir's Bittensor endpoints serve mainnet and testnet from archive nodes, over HTTPS and WSS, with the EVM on the same URL:

• Free plan: 100,000 responses a day to test archive reads and subscriptions
• Developer: $49 a month for 25M responses, one response billed as one credit
• Unlimited Node: from $119 a month for 25 RPS with no request counting
• Dedicated cluster: $3,048 a month with a 99.99% uptime SLA

Bittensor endpoints: Bittensor network page

Documentation: Bittensor API docs, subnetInfo_getMetagraph, author_submitAndWatchExtrinsic

Contact: Talk to the Dwellir team

Related Resources

• RPC Providers Without Compute Units
• RPC Provider Rate Limits and RPS Compared

References

• Bittensor networks and public endpoints
• Subtensor nodes: lite vs archive
• Subtensor node requirements
• Bittensor EVM networks
• Chain rate limits
• bittensor 11.3.0 on PyPI
• Subtensor releases
• Taostats: TAO halving
• OnFinality pricing and response units
• GetBlock Bittensor and pricing
• NOWNodes pricing and TAO docs
• dRPC Bittensor
• Chainstack protocols and networks