Web3 Pi Arkiv RPC Proxy — Many nodes. One endpoint.

01 Live load balancer

One endpoint in.
Healthy nodes out.

Every node in this view is a real Arkiv node in the running proof of concept. The proxy checks each one every 2 seconds and sends requests only to the nodes that pass.

Load 120 req/s

Simulation on the live fleet state. Health checks are real.

Your appJSON‑RPC over HTTPS

Web3 Pi RPC ProxyLoad balancer

Request
Health check
Ready
Lagging · syncing
Offline
Paused

Eligible — Routed in this view 0

Tip: click a node to take it offline in the simulation — the proxy routes around it.

02 The problem

Public RPC has
a ceiling.

Every Arkiv app reaches the chain through RPC. Shared public endpoints have to ration their capacity — sooner or later, your app hits a rate limit.

Access keys

Sign up, get a key, keep an eye on your quota.

Rate limits

Throttled just when your app starts to grow.

Shared capacity

Everyone’s traffic hits the same backends.

A black box

No view of which node answers — or how healthy it is.

public Arkiv RPC · test log

# anonymous access · stage 2 · 10 req/s
→ arkiv_query       200 OK
→ arkiv_getEntity   200 OK
→ arkiv_query       429 Too Many Requests
  ratelimit:   limit=10000, remaining=0, reset=3573
  retry-after: 3573

Excerpt from our test log, 16 October 2026: anonymous access to the public Arkiv RPC (selected headers). The next request is allowed in about an hour.

03 Two ways to run it

Start with one Pi.
Grow into a fleet.

Two ways to run Arkiv RPC on your own hardware — both built on Web3 Pi.

Model 01 · Single node

Arkiv node on one Raspberry Pi 5

Run an Arkiv node with a local RPC endpoint. A compact starting point for your application, on infrastructure you own.

1 × Raspberry Pi 5
Local RPC
No third‑party limits

Model 02 · Fleet

Arkiv RPC Proxy / Load Balancer

Many small devices behind one endpoint. The Web3 Pi proxy load‑balances every request across healthy nodes for high throughput.

Many nodes
One endpoint
Load balancing

04 How it works

One proxy.
A whole fleet.

The Web3 Pi Arkiv RPC Proxy load‑balances requests across the nodes. Monitoring runs on its own, separate path.

Apps & services

HTTP JSON‑RPC clients

dApps
Backends
Indexers & agents

Web3 Pi RPC Proxy

Load balancer · health-aware

GO

Eligibility · checked every 2 s

Correct chain ID7738577
Fully synced
Fresh block · max 30 s old
At most 2 blocks behind the head

Load balancing

Selection considers in‑flight load, node weight and observed latency. Pool and rules reload live.

Arkiv node fleet

Raspberry Pi 5 · NVMe · execution + consensus clients

Raspberry Pi 5 A1Ready
Raspberry Pi 5 A2Ready
Raspberry Pi 5 A3Ready
x86 node optionalReady

Add a node — no restart

Web3 Pi Control Center live traffic · node health · hardware & client telemetry · routing rules — on a separate, read‑only monitoring path

One endpoint

Apps connect to a single URL. The fleet stays behind it.

Load balancing

Each request goes to the least busy healthy node.

Scale out

Designed to scale by adding nodes — no restart.

Your infrastructure

Your capacity. No third‑party rate limits.

Careful by design

The proxy is conservative about what it repeats and where it sends traffic.

Reads recover. A transport error on a known read method may be retried once on another healthy node.
Writes never repeat. Signed transactions are forwarded once and never retried automatically.
No hidden state. Stateful filters are refused over HTTP — use eth_getLogs instead.
No downtime to change. Add, pause or remove nodes and edit rules while the proxy keeps serving.

Angled view of the Web3 Pi Cluster Edition board with Raspberry Pi 5 nodes in Web3 Pi cases, UPS battery modules and gigabit switches — Real build

05 Hardware platform

Ten nodes.
One board.

Web3 Pi Cluster Edition puts ten Raspberry Pi 5 nodes, NVMe storage, battery backup and a dedicated network on a single board — one you can carry by the handle.

10: Raspberry Pi 5 nodes
40: Cortex‑A76 cores at 2.8 GHz
160GB: RAM in total
20TB: NVMe storage
13: Web3 Pi UPS modules
1Gb/s: per node, on its own network

Cluster Edition hardware platform. RPC tests: 8 Raspberry Pi 5 + 3 x86 nodes.

Explore the Cluster Edition

Web3 Pi Cluster Edition node case with a status display showing execution, node and consensus state, disk, CPU and RAM — Status display on every node

Web3 Pi UPS module with battery charge display — Web3 Pi UPS — battery backup

Gigabit network switches mounted along the top of the board — On‑board gigabit network

Live

The proof‑of‑concept fleet, right now

Raspberry Pi 5 and x86 nodes, read from the monitoring path.

Clients running: —
CPU cores: —
Memory: —
NVMe capacity: —
Avg. CPU temperature: —

06 Control center

Everything
in view.

One Web3 Pi dashboard for the whole fleet — live, with real data from the running proof of concept.

1
Live traffic
Requests per second, latency and errors as they happen.
2
Cluster map
Only nodes that are ready receive traffic.
3
Chain status
Head block and lag, checked against the network.
4
Fleet telemetry
CPU, temperatures, memory, NVMe, network, execution and consensus clients.

The public dashboard is read‑only. Operators manage nodes and routing rules in a separate, authenticated panel.

Open the public dashboard

Web3 Pi · Arkiv RPC · public dashboardlive

RPC traffic · last 60 s

07 Status

Not a render.
It’s running.

The proof of concept is live on Arkiv Tiramisu testnet, serving real HTTPS traffic through one public endpoint.

1

public HTTPS RPC endpoint

live on Arkiv Tiramisu testnet

13

nodes in one pool

10× Raspberry Pi 5 + 3× x86

100%

valid responses in the latest demo run

28,800 of 28,800 requests
40 / 80 / 120 RPS · 120 s per stage
p95 217–221 ms

0

restarts to change the node pool

Add, pause or remove a node. Changes apply live.

Demo run, 16 October 2026: historical Arkiv read workload (replay) sent through the public HTTPS endpoint from the local network. A bounded demonstration, not a maximum‑capacity test.

Indicative performance

More throughput.
Your capacity.

In our tests, the mixed Web3 Pi fleet served more Arkiv RPC traffic than the official endpoint used with an access key. No third‑party rate limits.

Official public RPC · shared · access‑gated

Your app Rate limit Official RPC

Access policy and capacity belong to the provider.

Web3 Pi RPC fleet · 8 Raspberry Pi 5 + 3 x86 nodes

Your app

Web3 Pi RPC Proxy Pi 5Pi 5Pi 5Pi 5Pi 5Pi 5Pi 5Pi 5x86x86x86

Your nodes, your capacity.

Internal tests on Arkiv Tiramisu, 16 October 2026. 8 Raspberry Pi 5 + 3 x86 versus the official endpoint with an access key, using the same historical read workload. Local‑origin HTTPS for the proxy, WAN for the reference. Indicative results under tested conditions, not an SLA.

08 Why it matters

Built for builders.
Valuable to Arkiv.

For builders

Own your endpoint.

Keep control of access and infrastructure capacity as your application grows.

One URL for your app

For node runners

Put compact hardware to work.

Operate Arkiv nodes with routing and telemetry in one Web3 Pi stack.

Your nodes, in one fleet

For the Arkiv ecosystem

More independent RPC capacity.

A practical reference for community‑operated infrastructure alongside public RPC.

Community infrastructure

09 The presentation

The whole story.
Thirteen slides.

The Web3 Pi Arkiv RPC Project deck. Browse it here or take the PDF with you.

Download PDF9.8 MB Open PDF

Slide 1 of 13: Many nodes. One endpoint. Web3 Pi Arkiv RPC proxy and load balancer

01 / 13

10 For developers

Standard
JSON‑RPC.

Plain JSON‑RPC 2.0 over HTTPS — single calls and batches. Arkiv query and entity methods, public Ethereum read methods and signed transactions. Point your app at one URL.

Arkiv

arkiv_query
arkiv_getEntity
arkiv_getEntityCount
arkiv_getBlockTiming

Ethereum

eth_blockNumber
eth_call
eth_getLogs
eth_getBlockByNumber
eth_getTransactionReceipt
eth_sendRawTransaction
+ more public read methods

Not exposed: account management, debug_*, admin_*, engine_* and stateful filters over HTTP.

curl $ARKIV_RPC \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

# first five entity keys, at the head
curl $ARKIV_RPC \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"arkiv_query","params":["*",{"limit":"0x5"}]}'

const res = await fetch(ARKIV_RPC, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0', id: 1,
    method: 'arkiv_getEntityCount', params: [],
  }),
});
console.log((await res.json()).result);

The examples use $ARKIV_RPC — set it to your Web3 Pi proxy endpoint. Chain ID 7738577 (Tiramisu testnet).

11 Roadmap

From proof of concept
to plug‑and‑play.

Now
Proof of concept
- RPC proxy & load balancer
- Web3 Pi control center
- Fleet & client monitoring
- Live on Tiramisu testnet
Next
Prove it at scale
- Scaling curve from one to many Pi nodes
- Long‑run endurance and thermals
- Node failure and recovery
Then
Production‑ready
- High‑availability proxy
- Persistent metrics
- WebSocket subscriptions
Vision
Plug‑and‑play RPC
- Arkiv on a single Pi in minutes
- Cluster Edition as a turnkey RPC appliance
- Power on, join the fleet

Indicative roadmap — scope and timing will follow validation results.

Many nodes.One endpoint.

One endpoint in.Healthy nodes out.

Public RPC hasa ceiling.

Access keys

Rate limits

Shared capacity

A black box

Start with one Pi.Grow into a fleet.

Arkiv node on one Raspberry Pi 5

Arkiv RPC Proxy / Load Balancer

One proxy.A whole fleet.

Apps & services

Web3 Pi RPC Proxy

Arkiv node fleet

One endpoint

Load balancing

Scale out

Your infrastructure

Careful by design

Ten nodes.One board.

The proof‑of‑concept fleet, right now

Everythingin view.

Live traffic

Cluster map

Chain status

Fleet telemetry

Not a render.It’s running.

public HTTPS RPC endpoint

nodes in one pool

valid responses in the latest demo run

restarts to change the node pool

More throughput.Your capacity.

Built for builders.Valuable to Arkiv.

Own your endpoint.

Put compact hardware to work.

More independent RPC capacity.

The whole story.Thirteen slides.

StandardJSON‑RPC.

From proof of conceptto plug‑and‑play.

Proof of concept

Prove it at scale

Production‑ready

Plug‑and‑play RPC

Many nodes.One endpoint.Your capacity.

Many nodes.
One endpoint.

One endpoint in.
Healthy nodes out.

Public RPC has
a ceiling.

Start with one Pi.
Grow into a fleet.

One proxy.
A whole fleet.

Ten nodes.
One board.

Everything
in view.

Not a render.
It’s running.

More throughput.
Your capacity.

Built for builders.
Valuable to Arkiv.

The whole story.
Thirteen slides.

Standard
JSON‑RPC.

From proof of concept
to plug‑and‑play.

Many nodes.
One endpoint.
Your capacity.