Relying on public RPC providers—Alchemy, Infura, QuickNode—means depending on someone else's uptime, rate limits, and pricing. Ethereum nodes and clients recommends running your own infrastructure for production workloads. At volumes over 100k requests/day, the economics of a private node become compelling: a typical configuration pays for itself in 3–6 months, reducing infrastructure spending by 50–70% compared to public provider plans. Beyond cost, a private node gives you full access to debug_* and trace_* namespaces that public providers often disable or charge separately for. The cost of a private solution is 2–3 times lower than public RPC at workloads above 500k requests/day.
Recently, a DeFi project came to us when their public RPC provider disabled debug methods right in the middle of testing a new AMM contract. Changing providers would have taken weeks, but the deadline was tomorrow. In two days we spun up a private node using Reth + Lighthouse, and the team continued debugging without restrictions. Contact us for a consultation on choosing the right configuration for your load.
We have been setting up private RPC nodes for 5+ years, with 50+ projects on Ethereum and sidechains. Our engineers test each node under real load and guarantee 99.9% uptime given the proper environment.
Which client to choose for Ethereum?
Two main execution clients:
Geth (go-ethereum) — the most widespread, largest documentation, stable. Archive mode takes ~16 TB. Slowest on eth_getLogs over large block ranges.
Reth (Paradigm) — written in Rust, significantly faster than Geth on historical queries. Archive mode ~2.5 TB (better compression). We recommend it for new installations.
Erigon — archive node ~3 TB, fast historical queries, but more complex to set up and update.
| Client | Disk (archive) | Sync time | Historical queries |
|---|---|---|---|
| Geth | ~16 TB | 2–4 weeks | Slow |
| Reth | ~2.5 TB | 3–7 days | Fast |
| Erigon | ~3 TB | 3–7 days | Fast |
Why set up a private node?
Public RPCs have rate limits (typically 100–300 req/s), lack debug/trace methods, and cost extra when you exceed limits. Compare for yourself:
| Parameter | Public RPC | Private Node |
|---|---|---|
| Rate limit | 100-300 req/s | Unlimited |
| debug/trace methods | Unavailable or paid | Full access |
| Savings at 1M req/day | - | Up to 70% of budget |
| Archive sync time | Instant | 3-7 days (one-time) |
| Version control | No | Yes |
A private node gives you:
- Full control: any
eth_*,debug_*,trace_*methods without surcharges. - No rate limits: you pay only for hardware.
- Fast historical queries: archive node is not throttled.
- Independence: if a provider fails, your node keeps running.
Detailed hardware specifications
For an Ethereum mainnet archive node we recommend:
- CPU: AMD EPYC 64 cores (or similar Intel Xeon)
- RAM: 256 GB DDR4 ECC
- Disk: 2x 3.84 TB NVMe SSD (RAID1) for Reth, 4x 3.84 TB for Geth
- Network: 10 Gbps
Final configuration is tailored to your RPS and number of chains.
How to set up a private RPC node: step-by-step
The setup process includes:
- Install execution and consensus clients.
- Create a JWT secret for client communication.
- Start the execution layer (Reth).
- Start the consensus layer (Lighthouse) with checkpoint sync.
- Configure Nginx reverse proxy with SSL and rate limiting.
- Set up monitoring and alerts.
Installing Reth + Lighthouse (Ethereum mainnet)
Ethereum PoS requires two clients: execution layer (Reth) + consensus layer (Lighthouse/Prysm):
# Reth curl -L https://github.com/paradigmxyz/reth/releases/latest/download/reth-x86_64-unknown-linux-gnu.tar.gz | tar xz sudo mv reth /usr/local/bin/ # Lighthouse (consensus client) curl -L https://github.com/sigp/lighthouse/releases/latest/download/lighthouse-x86_64-unknown-linux-gnu.tar.gz | tar xz sudo mv lighthouse /usr/local/bin/ # JWT secret for Engine API communication openssl rand -hex 32 > /etc/ethereum/jwt.hex Start execution layer (Reth):
reth node \ --chain mainnet \ --datadir /data/reth \ --http \ --http.addr 127.0.0.1 \ --http.port 8545 \ --http.api eth,net,web3,txpool,debug,trace \ --ws \ --ws.addr 127.0.0.1 \ --ws.port 8546 \ --authrpc.addr 127.0.0.1 \ --authrpc.port 8551 \ --authrpc.jwtsecret /etc/ethereum/jwt.hex \ --full # use --full=false for archive Start consensus layer (Lighthouse):
lighthouse beacon_node \ --network mainnet \ --datadir /data/lighthouse \ --execution-endpoint http://127.0.0.1:8551 \ --execution-jwt /etc/ethereum/jwt.hex \ --checkpoint-sync-url https://mainnet.checkpoint.sigp.io \ --disable-deposit-contract-sync --checkpoint-sync-url enables syncing the consensus client from a finalized checkpoint instead of genesis, reducing time from weeks to hours.
Configuring Nginx as reverse proxy
Exposing the RPC port directly is bad practice. Use Nginx with auth and rate limiting:
upstream ethereum_rpc { server 127.0.0.1:8545; keepalive 32; } server { listen 443 ssl; server_name rpc.yourdomain.com; ssl_certificate /etc/letsencrypt/live/rpc.yourdomain.com/fullchain.pem; ssl_certificate_key /etc/letsencrypt/live/rpc.yourdomain.com/privkey.pem; satisfy any; allow 10.0.0.0/8; deny all; location / { proxy_pass http://ethereum_rpc; proxy_http_version 1.1; proxy_set_header Connection ""; proxy_set_header Host $host; proxy_read_timeout 300s; limit_req zone=rpc_limit burst=100 nodelay; } } limit_req_zone $binary_remote_addr zone=rpc_limit:10m rate=100r/s; WebSocket for subscriptions — separate location:
location /ws { proxy_pass http://127.0.0.1:8546; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "upgrade"; proxy_read_timeout 3600s; } Other EVM networks: BSC, Polygon and their setup
Most EVM networks are forks of Geth. The principle is the same, with their own clients. For BSC we use BSC Geth, for Polygon — Bor (execution) and Heimdall (consensus), similar to the Reth+Lighthouse pair. They are launched with similar parameters, only with configs matching the respective network. For Polygon, two consensus layers are required: Heimdall (Cosmos SDK based) and Bor (Geth fork). This increases setup time, but we provide ready-made scripts.
Node monitoring
Checking sync is simple: the eth_syncing request returns status and lag. Alerts: a node is healthy if lag < 5 blocks and peers >= 5. If peers = 0, the node is isolated from the network—worse than simply being behind.
Prometheus + Grafana for long-term monitoring: Reth and Geth expose metrics natively (--metrics.port 9001). Ready dashboards are in the respective client repositories.
What's included in turnkey setup
- Installation and configuration of execution + consensus clients for the selected network.
- Nginx reverse proxy with SSL, rate limiting, and IP whitelist.
- Monitoring (Prometheus + Grafana) with alerts to Telegram/Slack.
- Load testing (up to 1000 rps) and optimization.
- Maintenance and recovery documentation.
- Training for your team (1 hour online).
Timelines and cost
Estimated timeline: from 2 to 7 days depending on the network and archive requirements. Cost is calculated individually after load analysis: contact us for a free project estimate. Order a private RPC node setup and gain full control over your infrastructure. Our engineers will help you pick the optimal configuration for your budget and load.
Get in touch—we have already set up nodes for 50+ projects, including high-load DeFi and NFT marketplaces.