Your nodes, your apps, your ERPC account. One command line.
Run RPC nodes across 18 chains, validators on supported networks, and your own apps on ERPC VPSs or servers you manage. Use the commands directly, automate them in scripts, or work with ERPC AI in your terminal.
Quick start Β· Choose your workflow Β· Documentation Β· Complete usage guide
For mainnet validators, follow the verified installation guide to check the signed release manifest before running a binary.
macOS and Linux
curl -fsSL https://install.erpc.global | shWindows (PowerShell)
irm https://install.erpc.global/ps1 | iexThese installers select the latest stable release, or the newest published prerelease when no stable release exists. See the installation details for supported platforms, version pinning and source builds.
erpc version
erpc --helpValidator and RPC node lifecycle commands are free and need no ERPC account. The node guides cover the server, key-management and network requirements for each chain.
Sign in to use account services, then make a Solana mainnet RPC read:
erpc login
erpc whoami
erpc rpc call getSlotNeed an account? Run erpc signup. Prefer a conversation? Run erpc ai and
describe what you want to do. The assistant presents server changes and paid
operations for your approval by default; see ERPC AI.
| What you want to do | Start here |
|---|---|
| Run a validator or RPC node | Node lifecycle and supported chains Β· Chain guides |
| Build and deploy an app | Worker guide: create a Rust app, import an existing app, or deploy a Linux binary |
| Connect an app to Solana data | Worker data lines: Geyser gRPC, Shreds, UDP Forwarding and Unlimited RPC |
| Call RPC or deliver events to an API | RPC calls and webhooks |
| Work with an AI assistant or scripts | ERPC AI and agent skills Β· Command reference Β· machine-readable --json output |
| Store files and back up a machine | Storage encryption Β· Backups |
1Password holds the node inventory and managed signing-key backups, so teams can manage shared nodes from their own machines. Operator credentials can also use the OS keychain. Worker apps receive their secrets through the worker's memory; node key storage and recovery requirements vary by chain. See where keys are kept and the worker secrets guide.
ERPC CLI is in pre-release. RPC node workflows cover 18 chains; validator workflows cover the supported subset. Live acceptance is still in progress for most chains. Check the chain source map and each chain's guide before choosing a deployment.
Node operations, ERPC AI, workers, RPC, storage and command reference.
erpc uses 1Password for node inventory and managed signing-key backups, and supports the operating system's keychain for operator credentials. A node process needs its runtime secrets, so what stays on a server depends on the chain: Running nodes has the table.
- Solana validators. Original identities are retained in 1Password. A new native validator syncs under a separate non-voting identity; voting needs explicit registration and history checks. The withdrawal authority is not imported into the node. Other chains have their own custody and admission rules in the node guides.
- Trading bots and Web3 apps. An
erpc workerapp gets its wallet key on a pipe when it starts. The worker holds it in memory only, locked and undumpable; there is nowallet.json, no.env, no copy on the server's disk. After a reboot the app stays locked until you send the key again. On your own machine the key is kept in 1Password or the OS keychain. On a machine with neither (a Linux server or WSL without a desktop keyring) it goes into erpc's keystore: a file encrypted under a passphrase you choose, which you back up yourself (what that protects). - Secrets. API tokens and RPC keys are kept the same way and named in
erpc.tomlby reference (op://β¦,keychain:β¦,keystore:β¦), never by value. The values reach the server over standard input, never on a command line. - Your team. The node inventory lives in 1Password too. Share the vault and everyone on the team manages the same nodes from their own machine, with 1Password deciding who can do what.
- Keys that stay on a server. Many nodes hold a key on the host. An Ethereum validator's keystores and unlock password live on it, and a Solana node on the solv backend keeps a throwaway identity in plain text. Those hosts need backups of their own.
Node recovery must preserve the original identity and signing history. Follow the chain's recovery procedure before replacing a server or restoring its data; a key backup alone does not establish safe validator recovery.
macOS and Linux
curl -fsSL https://install.erpc.global | shWindows (PowerShell)
irm https://install.erpc.global/ps1 | iexThese URLs select the latest stable release. While the project has only
prereleases, they select the most recently published prerelease. To pin a
version, use https://install.erpc.global/v0.1.0-rc.7 or
https://install.erpc.global/v0.1.0-rc.7/ps1. The release workflow updates the selected version after publication and approval
of the protected installer deployment. Edge and client caches may delay what
clients see.
The installer puts erpc in ~/.erpc/bin and writes the assistant's skills
to ~/.erpc/skills. Builds are published for Linux (x86_64, arm64), macOS
(Intel, Apple silicon) and Windows (x86_64). Running a mainnet validator? Use the
high-assurance path, which checks the signed manifest
before anything runs.
Build from source
git clone https://github.com/elsoul/erpc-cli
cd erpc-cli
cargo build --release
./target/release/erpc --helpSolana |
Ethereum |
Base |
Avalanche |
Bitcoin |
Polygon |
BNB Chain |
Kaia |
Arbitrum |
Optimism |
Hyperliquid |
Monad |
TRON |
Sui |
NEAR |
Arc |
Robinhood |
Soneium |
init prepares a server and deploy installs and starts the node; every chain
uses the same verbs. An Ethereum RPC node starts from a bare Ubuntu server
(24.04 or later):
# check the server, pin the client releases, store the node in 1Password
erpc rpc --chain ethereum -n mainnet --name eth1 init --host <address> --vault <vault id> --ssh-key ~/.ssh/id_ed25519.pub
# install, fetch a snapshot, apply the firewall, start
erpc rpc --chain ethereum -n mainnet --name eth1 deploy --ssh-key ~/.ssh/id_ed25519.pub
# both layers, sync and head
erpc rpc --chain ethereum -n mainnet --name eth1 status --ssh-key ~/.ssh/id_ed25519.pubSome chains need more in place first, and each chain's guide says what. A new Solana validator or RPC node needs three filesystems mounted and its keys already in 1Password: see native Solana nodes. A Solana node whose server an earlier erpc recorded keeps the commands it was set up with.
| Chains | |
|---|---|
RPC node (erpc rpc) |
all 18 |
Validator (erpc validator) |
Solana, Ethereum, Avalanche, Sui, TRON, Polygon, BNB Chain, Kaia, Monad, Hyperliquid, NEAR, Arbitrum One, Robinhood Chain |
Every deploy logs in over SSH with your key, from the 1Password SSH agent or
SSH_AUTH_SOCK, and pins the host key. Most chains run the client as its own
user that cannot log in, check each release against a pinned checksum, and
apply an nftables firewall that uses a timed rollback and requires a fresh
management connection to confirm access. Not all of them do: a new Solana node
is built on the server from a pinned source commit; a Solana node recorded on
the earlier solv backend runs as a login user with passwordless sudo and
fetches some tools without a checksum; and solv Solana validators, Ethereum
validators and Bitcoin nodes get no firewall from erpc.
Running nodes has the details. Retain an independent way to
reach the host during network changes.
init, deploy, status, logs, start, stop, restart, update,
update-config, plan and destroy work the same on every chain, except
that a Solana validator on the solv backend has only init, deploy and
status of them, besides list, keys, vote-account, registration and
migration. Live acceptance on real hosts is still under way for most chains.
Running nodes has the clients, networks and guides for each
chain, and the chain source map where each one stands.
βΊ I want to run a Solana testnet validator
erpc ai opens a conversation with the ERPC assistant. Say what you want in
your own words; it knows every chain above and every erpc command, and runs
them for you.
- It asks before it acts. Anything that spends money or changes a server is shown first, with the cursor on Stop. Choices are picked with the arrow keys. You can allow every command for one conversation, behind a second question, and then nothing is asked until it ends.
- It prefers erpc to improvised scripts. The assistant drives the same commands you would type, and can run other commands and scripts only as you allow them. What erpc enforces on a chain is enforced by its code every time, not left to what a model writes. What that covers differs by chain: the node guide lists it.
- It sets up the server too. It can start an hourly VPS, wait for it, install your SSH key, turn off password logins and allow SSH only from your address.
- It remembers you. Your hosts, chains and preferences carry over from one
conversation to the next, and
erpc resumepicks up an old one.
erpc skills install --agent claude gives the same knowledge to Claude Code
or another agent. What the assistant can see, and what it never sees, is in
the assistant guide and SECURITY.md.
Use your signed-in ERPC account to call Solana or Ethereum mainnet. The CLI selects the shared endpoint from the method, or you can select the network.
erpc login
erpc rpc call getSlot
erpc --json rpc call eth_getBlockByNumber '["latest", false]' --network ethereum-mainnet
erpc rpc call eth_call --params-file params.json
printf '%s' '["finalized", false]' | erpc rpc call eth_getBlockByNumber -
erpc rpc call getHealth --endpoint-url http://127.0.0.1:8899For pay-per-call access without an account, request an x402 quote. To pay,
run the command without --quote at a terminal. The CLI shows the amount,
asks for confirmation and signs the quoted Base EURC payment with the wallet
configured by erpc wallet create. Keep EURC on Base in that wallet.
erpc rpc call getSlot --network solana-mainnet --x402 --quote
erpc rpc call eth_blockNumber --x402A local webhook subscribes to the RPC WebSocket and POSTs events to your URL. Start a receiver, create the subscription, then run the ID returned by create in a terminal or under your process supervisor.
erpc webhook create --name slots --network solana-mainnet \
--url http://127.0.0.1:8080/events --method slotSubscribe
erpc webhook create --name heads --network ethereum-mainnet \
--url http://127.0.0.1:8080/events --method eth_subscribe --params '["newHeads"]'
erpc webhook list
erpc webhook run 1For wallet activity on Solana, use --template solana-wallet --wallet ADDRESS
in place of --method. For Ethereum contract logs, use
--template evm-contract-events --address CONTRACT.
Each POST contains webhook_id, network and the original JSON-RPC
notification. Return HTTP 2xx to accept it. Delivery starts at the current
live subscription. A disconnect or failed callback ends the runner with a
nonzero status. Restarting subscribes to new events. Use --once to test a
single delivery or --endpoint-url on run to supply your own WebSocket RPC.
webhook show ID, list and enabled-count inspect local configuration.
pause ID disables delivery, activate ID enables a later run, and
delete ID removes the definition. Pass --yes for these changes in scripts.
Generate shell completions with erpc completions zsh (also bash, fish,
powershell and elvish).
erpc worker init # a HelloWorld API in Rust, a pump.fun bot, ... or `erpc worker import` for an app you have
erpc worker run # build it and run it here first
erpc worker deploy --new-vps # a new hourly VPS, its price shown first, your app on it
erpc worker status # running? which release? what it costs per hour, how long your credit lastserpc worker compiles your app to a native Linux binary and runs it on a
latest-generation ERPC VPS, or a server of your own. No Docker and no runtime
in between: the binary runs under a hardened systemd unit with the whole
machine to itself, which is what a trading bot's latency budget asks for. A
release that does not come up healthy is rolled back to the one before, and
several apps can share one server, each on a port of its own. You can also
build one by talking to erpc ai.
| π Start from HelloWorld | erpc worker init makes a small HTTP API in Rust that deploys with one command and needs no key. The pump.fun trading bot is the next template up. |
| π¦ Bring the app you already have | erpc worker import reads your directory (a Cargo package, .env.example, a Dockerfile) and writes its erpc.toml without changing your code. A Linux binary built anywhere, in any language, deploys the same way: erpc worker import --binary <PATH>. |
| β‘ ERPC's lines, one flag each | deploy --grpc (Geyser gRPC), --shreds (the Shreds stream), --udp (the leader's raw shreds over UDP), --unlimited (an Unlimited RPC). Each starts by the hour from ERPC Credit, lets your server in (or, for UDP, opens its port to ERPC's senders only; when ERPC names none, the port stays closed unless --udp-any-source opens it to any IPv4 address), and reaches the app as a setting. Nothing to copy from a dashboard. |
| π‘οΈ A WAF in front of your API | Add [waf] to erpc.toml and deploy puts a filtering proxy in front of the app: only the methods and paths you allow, size limits, a request rate per address, bans for addresses that keep being blocked, scanner probes refused. Around it the firewall drops everything else. |
| π Keys that never touch the server's disk | The trading key and the secrets go from 1Password, your keychain or erpc's encrypted keystore straight into the worker's memory. No wallet.json, no .env. |
| π€ Made for scripts and agents | --yes accepts the price a start shows, --prepare does everything but hand over the key, --json is on every command. erpc ai runs the same commands when you ask it to. |
| πΆ Costs in plain sight | Every start shows its price first. status shows what each server and line costs per hour, your credit and how long it lasts. erpc worker delete --release-server ends all of it. |
A zero-block buy lands in the very block the pool it buys is created in. The pump.fun template goes for it by reading a token's migration as the leader sends it out, before any node has run it, and buying at once. Whether the buy makes that block comes down to two things: how early the bot sees the migration, and how fast its buy reaches the leader. Each line that changes either is one flag:
| Step | Flag | What the bot gets |
|---|---|---|
| Geyser gRPC | --grpc |
The pool, once a node has run the migration |
| Shreds | --shreds |
The migration in the leader's shreds, before anyone has run it |
| UDP Forwarding | --udp |
The same shreds as raw UDP on a port of your server's own, from an ERPC node in its region: no gRPC stream in between |
| Unlimited RPC | --unlimited |
A send route of its own, in the server's region |
erpc worker deploy --udp # Standard: β¬0.69 an hour, from one ERPC node
erpc worker deploy --udp --udp-plan <PREMIUM_PRODUCT_ID> # Premium: β¬1.39 an hour, the first copy of each shred from a regional mesh
erpc worker api /api/timing # how much sooner the UDP shreds came, how late each buy landeddeploy --udp checks what it would be refused for before it buys anything,
then starts the line, points it at the server's IPv4 address and port
10001 (or --udp-port, 1024 and up), opens that port in the server's
firewall to the addresses ERPC sends from and to no one else (when ERPC
names none the port stays closed, unless --udp-any-source opens it to any
IPv4 address), and gives the app SHREDS_UDP_BIND. The bot reads
migrations from the UDP shreds and the Shreds stream alike, and acts on
whichever shows one first; /api/timing says by how much the UDP shreds
led (udp_before_shreds_ms). Each datagram is checked against its slot's
leader before the bot believes it. In ERPC's
own measurement (Frankfurt, 2026-10-30), Premium was first for 98% of the
shreds both plans carried, by a median of 1.78 ms
(ERPC's announcement). Prices are the
catalogue's on 2026-11-13; deploy shows the current one before it asks.
When it helps. UDP Forwarding makes the bot see sooner; it does not make
its buy arrive sooner. On ERPC's test bot (a Standard VPS in Frankfurt) the
shared Shreds stream showed migrations a median of 2 ms before Geyser: a
lead that short is what a faster stream improves. When /api/timing shows
the stream well ahead and the buys still late, the send is what holds the
bot back: raise the priority fee first, which costs nothing by the hour,
then --unlimited. A buy sent that early can land before the pool exists
and fail, paying its fee; every bot aiming at the same pool competes for
the same block, and nothing guarantees a place in it. Measure before and
after each step; erpc worker delete --release-server ends the line with
the server (the bot's guide,
the line in detail).
[waf]
port = 8080 # the public port: the app itself stays on loopback
allow_paths = ["/api/*", "/healthz"] # default: every path
rate = { per_second = 50, burst = 100 } # per client address$ erpc worker status --env prod
api-prod on 203.0.113.10: running, release 20261101T093000Z-1a2b3c4d, pid 4217, up 2h 14m
current 20261101T093000Z-1a2b3c4d, previous 20261028T171500Z-9f8e7d6c, 2 releases kept
WAF: listening on port 8080, forwarding to 127.0.0.1:3000, since 2026-11-01T09:30:12Z; requests 5120, forwarded 5043, blocked 71, connections refused 12, app errors 6, addresses banned now 1
Charged by the hour, from ERPC Credit:
VPS 100001 β¬0.07 per hour
The account has β¬12.00 of credit and spends β¬0.07 per hour on all it runs: about 171 hours.
`erpc worker delete --release-server --env prod` ends what this app is charged for.
It answers a request the app should never see itself (405, 404, 403, 413,
429, and 408 for a head or a body that takes too long to arrive), closes
the connections of an address it has banned, and refuses requests shaped to
confuse a proxy and an app about where one request ends. The firewall in
front of it limits new connections per address as well. When you change
[waf], the port is not opened to anyone new until a deploy has put the
new rules in place. erpc worker firewall list shows what was blocked, by
rule, and erpc worker logs --waf each refusal. It speaks plain HTTP/1.1:
no TLS, no HTTP/2 and no WebSocket, and it does not inspect request bodies
(all of it).
-
The firewall lets SSH in only from the address you deploy from and drops every other inbound connection, but for the app's port when
firewall.app_allowopens it and the port of a UDP Forwarding line (--udp), open to ERPC's senders only (to any IPv4 address when ERPC names none and--udp-any-sourceasks). If your address changes, add every fixed address your admins use:erpc worker firewall allow --to ssh 203.0.113.10 198.51.100.7
-
A package update does not restart your app.
deploytells the server'sneedrestartto leave the worker alone, so an unattended security update does not stop a trading bot. After a reboot, or when its agent fails and systemd starts it again, an app with a key waits, locked, until you send the key again. -
Lost access? If the server may have been taken over, first run
erpc worker backup offto revoke its backup access key, and move funds off its trading key and replace its secrets.offdoes not undo what the server already read: the worker guide has the limits. Then rebuild it from the dashboard and deploy again. If the rebuild changed its SSH host key, erpc refuses it until you update the pinned key. A deploy brings back the code, not the app's state, which only a backup can restore. -
App state can be backed up daily to ERPC Global Storage, encrypted on the server, once you run
erpc worker backup on. Redis and PostgreSQL data are not covered.
Everything about an app is in erpc.toml, which holds no secret and can be
committed. docs/worker.md has the full guide.
erpc storage buy 5 # an ERPC Global Storage plan
erpc backup init # back this machine up with restic, on a schedule if you likeFiles are encrypted on your machine before they leave it, and each machine
gets an append-only key that cannot delete its own backups. The machine where you
ran erpc backup init also holds the keys that can.
See storage encryption and backups.
Validator and RPC node lifecycle commands are free and need no account. Install and go.
An account at dashboard.erpc.global unlocks the rest:
| Command | No account | With an account |
|---|---|---|
| Validator and RPC node lifecycle | β | β |
erpc ai |
β | |
erpc worker |
β | |
erpc storage, erpc backup |
β |
erpc signup # opens the sign-up page
erpc login # signs this machine in; the session goes to the keychain or 1Password
erpc whoamiRun any command group without a verb (erpc validator, erpc worker) to
list its verbs. erpc --json <command> gives machine-readable output. On node
commands the flag has to go before the command.
| Command | What it does |
|---|---|
validator (v), rpc (r), node (n) |
Validators and RPC nodes |
ai, resume, memory, skills |
The assistant, its saved conversations, memory and skills |
worker (w) |
Your own apps on a server |
storage (st), backup |
ERPC Global Storage and machine backups |
wallet |
The Base wallet that buys ERPC Credit with EURC (details) |
signup, login, logout, whoami |
Your ERPC account |
doctor |
Report how this machine stores your session |
config |
Read and change ~/.erpc/config.toml (public settings only) |
version |
Version, build and component information |
Errors and exit codes
A failure reads the same everywhere: an error: line saying what went
wrong, and a hint: line saying what to do next when there is one. With
--json it is one object on standard output,
{"error": {"code", "exit", "message", "hint"}}.
| Exit | Code | Meaning |
|---|---|---|
| 0 | it worked | |
| 1 | failed |
it could not do what was asked |
| 2 | usage |
the command line was not usable |
| 3 | needs_terminal |
a person must answer; pass --yes or run it in a terminal |
| 4 | not_signed_in |
run erpc login |
| 5 | problems_found |
a check (status, doctor) found problems; its report says which |
| 6 | declined |
you said no; nothing was changed |
| 7 | network |
ERPC or another service could not be reached |
The rules for these, and for writing a message, are in docs/errors.md.
Files erpc keeps
| Path | What it holds |
|---|---|
~/.erpc/config.toml |
Public settings (erpc config) |
~/.erpc/state/ |
The session and locks (erpc doctor says how the session is stored) |
~/.erpc/conversations/ |
Saved conversations |
~/.erpc/memory.json |
What the assistant remembers |
~/.erpc/vps_hosts.json |
Host keys of VPSs the assistant logged in to |
~/.erpc/skills/ |
Skills written by erpc skills install |
~/.erpc/storage-key |
The storage encryption key, when erpc login keeps the session in a file |
~/.erpc/backup-password, ~/.erpc/backup-admin-key |
The backup master password and read_write key, when erpc login keeps the session in a file |
~/.erpc/keystore/ |
The worker keystore: an app's secrets and trading key, each in a file encrypted under your passphrase, on a machine with neither 1Password nor a keychain that lasts (back it up) |
~/.erpc/backup.env |
This machine's backup credentials (0600) |
~/.erpc/bin/restic-0.19.1 |
The pinned restic erpc backup installs |
Repository layout
| Path | Purpose |
|---|---|
crates/erpc |
The binary: commands, the terminal UI, the node flows |
crates/erpc-core, erpc-auth, erpc-api, erpc-secret |
Shared types, sign-in, the ERPC API client, 1Password |
crates/erpc-ssh, erpc-ops, erpc-chain* |
SSH, server operations, and each chain's specifics |
crates/erpc-ai, erpc-skills |
The assistant and its skills |
crates/erpc-worker, erpc-worker-agent |
erpc worker, its app templates, and the agent that holds keys on the server |
crates/erpc-mcp-server |
An MCP server for AI agents (placeholder) |
crates/erpc-wallet, erpc-x402 |
The EURC wallet and buying credit with it |
crates/erpc-release |
Release manifests and verification |
installer/ |
Cloudflare Worker for install.erpc.global |
scripts/ |
Hygiene and release helpers |
docs/ |
Guides, release verification, compliance, public hosts, incident response |
Pre-release (v0.1.0-rc.7). The commands above exist and pass their offline
checks; acceptance on real hosts is still under way for most chains, and each
chain's guide says where it stands. erpc is the Rust successor of
SLV.
See CONTRIBUTING.md, SECURITY.md and
GOVERNANCE.md. Every URL in this repository must name a
host declared in crates/erpc-core/src/endpoints.rs, as
docs/public-hosts.md explains.
lefthook install sets up the pre-commit checks for this, along with
clippy, the tests and a secret scan. The checks only help: review is what
enforces these rules. If a secret ever lands in the repository, follow
docs/secret-exposure-response.md and
rotate it before rewriting any history.
Apache-2.0. See LICENSE and NOTICE. Chain logos come
from web3icons (MIT); each is a
trademark of its own project. The ERPC header and CLI key visual
(header, CLI key visual)
are ELSOUL LABO B.V.'s brand material and are not under the Apache License: see
LICENSES/LicenseRef-ELSOUL-LABO-Brand.txt.
