Skip to content

RPC Node Hosting for Full and Archive Nodes on Your Own Domain

Protofire hosts full and archive nodes behind one dedicated RPC endpoint on your own domain, for chains, protocols and custodians. Under a written scope, we run the nodes and write down method limits and failover. Filecoin's newsletter thanked us for running Glif Nodes RPC, which we built.

Arsenii Petrovich

Reviewed by Arsenii Petrovich, Offer Owner at ProtofireLast reviewed: November 2026

On this page
  1. Overview
  2. Why it matters
  3. Why Protofire
  4. What you get
  5. Who runs it
  6. How it runs
  7. How work starts
  8. Not the right fit
  9. Related guides and services
  10. FAQ

Work shipped for 60+ networks and 95+ protocols, including

  • Chainlink
  • Ethereum
  • Solana
  • Safe
  • Ripple
  • Aave

RPC node hosting on a domain in your DNS zone

Each RPC plan sets its own eth_getLogs block cap, so code that works on one provider can fail on the next. For example, your indexer's backfill ran clean against one provider, and on the next it returns an error. Your wallet, your backend and your oracle nodes all hold the vendor's URL, so changing provider means a release in each of them.

With RPC node hosting, Protofire runs the endpoint and the full and archive nodes behind it, on a domain in your DNS zone. We write the limit per method, the history each consumer reads and the failover rule into the scope. Replacing an operator then becomes a DNS change.

Who owns each hop of one RPC request

You keep the domain, the configs and the snapshots. Protofire runs the gateway, the router and the nodes under the scope.

Client

Consumers

Wallets, backends, indexers and oracle nodes call one URL over HTTPS or WebSocket.

Domain and TLS

The endpoint name is a record in your DNS zone, and a CNAME points it at the gateway.

Snapshots

Snapshot copies are written to storage you can read, and a restore is rehearsed before anyone needs it.
Protofire runs

Gateway

The gateway checks API keys, applies a limit per method and block range, and handles WebSocket connections.

Router

The router compares each node's head number and block hash with the group's. It drops laggards and forks and sends trace methods to the clients that serve them.

Client pool

The pool runs two execution clients where the network has two. Full nodes serve recent reads, and an archive tier serves old state.

Monitoring

Monitoring tracks head lag, the error rate by method class and the figures from the measurement point that the scope names.

Shared and public RPC endpoints set their own limits

Whoever runs an RPC endpoint sets its limits, and the limits differ from one vendor and plan to the next.QuickNode caps eth_getLogs at 5 blocks on its Free Trial and 10,000 on paid plans (QuickNode). Alchemy allows spans of 10 blocks on its free tier and caps a response at 150 MB (Alchemy).

Public RPC URLs have tighter limits. Filecoin's docs warn that "most publicly hosted endpoints only guarantee recent state, i.e. 2000 of the latest blocks (last 16.67 hours)" (Filecoin). OP Mainnet's public URLs are "rate limited and do not support websocket connections" (OP docs). So an explorer, an indexer or an oracle node that reads old state has to find another provider.

While your callers use a vendor's URL, the vendor's plan decides what they can read. Moving to another vendor then costs a code change in each integration instead of a DNS change.

We do not recommend exposing API endpoints publicly, and any user who wishes to do so should carefully consider setting up proxies, WAFs, application level filtering, rate limiting, logging, tls terminator and monitoring to improve resilience.
go-ethereum, Security documentation, Ethereum execution client team · Security documentation, read November 2026

Our record: Glif Nodes, the public Filecoin RPC service

Protofire built Glif Nodes, a public RPC service for Filecoin, and we run it.The records below are the evidence.

  • Filecoin's own pagesFilecoin's newsletter of 29 May 2024 reported an average of 3 billion RPC requests a month on Glif Nodes. The newsletter recorded the service's top place in the Fil-RetroPGF round and thanked "the Protofire team for running Glif Nodes RPC". Filecoin's mainnet documentation lists Glif Nodes among its RPC providers. Protofire's Filecoin case study covers the build.
  • LotusProtofire engineers contributed gateway methods to Lotus, the Filecoin reference node. The merged pull requests show this, and the earliest dates from March 2023. Protofire also publishes Lotus gateway builds and an Ethereum-RPC gateway for the Glif nodes on its GitHub.
  • Tooling and archiveFrom 2020 to 2022 Protofire wrote open-source Filecoin node tooling, including a caching RPC proxy. In June 2023 we published how we handled a 37 TB Filecoin archive.

What RPC node hosting on your domain gives you

A change of operator is a DNS change

Wallets, backends and oracle nodes call a URL on your domain. So none of them needs a wallet or SDK update when the operator changes. Protofire serves the CNAME target and terminates TLS at the gateway. When we exit, we revoke the certificate for your hostname.

One published limit for each method

Your docs state one limit per method, and a caller that exceeds a limit gets an error that names the limit. Protofire sets API keys and a per-IP limit for public traffic. We also set block-span and response caps on eth_getLogs, and a lower class for wide logs and traces.

History as far back as your consumers read

You pay for the history depth your callers use, from a recent window to a full archive. Protofire sizes the node tier from your query mix and sends trace methods to the clients that serve them. A team that reads events alone can often skip archive, and indexing may serve that team better.

Failover on head number and block hash

A node that lags the group or is on another fork leaves rotation instead of answering. The router compares each node's head number and block hash with the group's. Protofire runs two execution clients behind the URL where the network has two, and we upgrade them one at a time.

Snapshots on storage you can read and a rehearsed restore

A successor operator starts from your copy, so it does not depend on the outgoing operator's goodwill. Snapshot jobs write to storage you can read, and a restore is rehearsed on a fresh node.

Figures in the agreement name their measurement point

A figure in the scope names its measurement point and the tool that reports it. The measurement point is the gateway, your consumers or a synthetic probe. Failures are counted by method class. A span rejected for exceeding the published limit counts as correct behavior, but a timeout inside the limit counts against the target.

Shared RPC provider, self-hosted nodes or an operator on your domain

A shared RPC provider is the fastest way to start.Your own nodes give full control, but your team then staffs its own on-call rota. With an operator on your domain, you keep the URL and the limits while someone else runs the nodes.

Endpoint URL

Shared RPC provider: The vendor's URL and API key

Self-hosted nodes: Yours

An operator on your domain: Yours, through a CNAME the operator serves

Method and range limits

Shared RPC provider: Set by the vendor's plan

Self-hosted nodes: Set by your client flags

An operator on your domain: Agreed with you and published per method

Archive and trace

Shared RPC provider: Where the plan offers them

Self-hosted nodes: Full control, on your disks and your sync time

An operator on your domain: Sized to your query mix

Incidents

Shared RPC provider: The vendor's status page and support terms

Self-hosted nodes: Your on-call rotation

An operator on your domain: On-call hours named in the scope

Leaving

Shared RPC provider: A new URL in each integration

Self-hosted nodes: Your nodes, so you decide

An operator on your domain: A DNS change, once the next operator has synced from your snapshots and loaded TLS and API keys

How Protofire sets up and runs your RPC endpoint

  1. Step 1

    Readiness review of your traffic

    Protofire reads the methods your callers use and the history each caller needs. We also check which clients are available on the network and which parent-chain dependencies it has. The output is a written plan that names the node types and the clients. The plan also names the method limits and the hosting account.
  2. Step 2

    Config review before the first node syncs

    The plan fixes the client mix for each pool, the sync strategy and the rollout order for forks and releases. Helm charts, Terraform and client flags go to your repository as reviewed commits.
  3. Step 3

    Gateway and limits table go live

    API keys, limits by method class and WebSocket handling go in front of the nodes at the gateway. The router starts to route on head lag and block hash, and it routes trace methods. Your developers get the limits table to publish in your docs.
  4. Step 4

    Archive tier restored once before it is needed

    Archive and trace nodes cover the history in the plan, and snapshot jobs write to storage you can read. A restore on a fresh node closes the step.
  5. Step 5

    DNS cutover once the new nodes are ready

    The DNS record changes once the new nodes are synced and a certificate for your hostname is in place. The API keys must also be loaded at the gateway first. Consumers keep the same URL.
  6. Step 6

    On exit you keep the domain, the configs and the runbook

    You own the domain, the deployment configs and the snapshots. The exit runbook lists the DNS change, the repositories and the snapshot location. It also lists the API keys and the credentials to revoke. If the nodes run in your own cloud account, you can remove Protofire's role. If the nodes run in a Protofire account, the scope lists what moves on exit: node data, snapshots and monitoring history.

How work with Protofire starts

To start, you send Protofire the network and your query mix per method.You also say how far back history must reach and where the endpoint domain is hosted. Protofire's first proposal fixes the hosting account, the on-call hours and the readiness review. The readiness review then sets the node types, clients and method limits. An EU financial entity records a hosted endpoint in its DORA register as ICT operation management (type S14 in Annex III to Implementing Regulation 2024/2956). The entity's risk team and counsel decide the entry. The full process is on how we work.

Proposal
In writing, one business day after the discovery call: findings, a plan in phases and the first step we recommend.
Price
Fixed per phase when you commission it, against written acceptance criteria. Overruns inside them are ours to absorb, invoices follow delivered milestones, and you can stop at any phase boundary. Anything we operate after launch is priced in the proposal as its own recurring line, with the notice to end it.
Ownership
Code we write for you, contracts, the keys and credentials this work creates and the accounts your infrastructure runs in are yours by contract, within the license of any third-party software involved. Keys that a custody platform or a staking provider holds under its own key model stay with it under your contract; every other custody key stays with you or the custodian you appoint. Where the scope places something on servers we rent, it says what moves to you and when. An NDA is available from your first message, and we sign a data processing agreement (DPA) together with it.
After launch
Delivery closes with a hypercare window and a defect warranty, with their terms written into the proposal. A service we operate continues under its written scope until that scope ends.
Access
Read-only by default. A role that can start requests only if your written scope names one; never a signer, approver, administrator, key holder or recovery role on your contracts, wallets or custody platform. Services we build call each platform on credentials your staff issue and keep in your vault. Anything that approves or moves funds runs in your environment, and a scope under which we operate a service lists every write call it makes. Where the scope has us operate nodes, validators, monitors, explorers or indexers, it names the role and any key we hold on those servers, and in your own cloud account you can remove it.
Licenses
Protofire is an engineering firm and holds no financial or crypto-asset license; licensed activity stays with you and your providers.

How we work shows a worked proposal.

When a hosted RPC endpoint from Protofire does not fit

  • Your traffic is ordinary reads on a major chain. Alchemy's Pay As You Go plan has no eth_getLogs block-range cap on such a chain, and a shared provider is the better purchase.
  • You need service credits for downtime from day one. With Protofire, service credits exist only if the scope creates them, so a vendor with a published SLA fits better.
  • You need one node for a staging environment or a hackathon, or you need events alone. Self-hosting the node covers the first case, and indexing covers the second.
  • You need block signing. Block signing involves keys and slashing, and our validator operations service covers it.

Hosted RPC on Filecoin

Glif Nodes
Public RPC endpoint

Protofire built and runs the Glif public RPC endpoint and node infrastructure for Filecoin.

FAQ

What is RPC node hosting?
RPC node hosting means running the JSON-RPC endpoint that wallets, apps and backends call, together with the full and archive nodes behind it. Protofire hosts such endpoints on a client's own domain. In the scope, we write which methods are open and how far back logs and traces reach. The scope also states how requests move between nodes.
Who can host a dedicated RPC endpoint for our chain or protocol?
Protofire can host a dedicated RPC endpoint for a network whose client runs from published releases. The node must also be able to bootstrap from genesis or from a snapshot we can verify. We built and run Glif Nodes, the public Filecoin RPC service. For a network other than Filecoin, Protofire reads its client docs first. We host no light clients, because Geth "offers no EL light client at the moment as a sync mode" (Geth).
Do we need an archive node to read old events?
Usually you do not need an archive node to read old events. Events come from logs, and a full node keeps logs. What matters is how far back the logs are indexed. By default, Geth indexes about one year of blocks, and --history.logs=0 extends the index to the whole chain (Geth). An archive node pays off when callers read state at old blocks, such as a balance or a storage slot.
Do you commit to an uptime number?
Protofire commits to an uptime figure only in a scope that names the measurement point and the reporting source. Without those two facts, neither side can check the number.
What do Chainlink's RPC requirements ask of an endpoint?
Chainlink's network integration requirements, read on 9 November 2026, call for three separate independent RPC providers. Chainlink also asks for no rate limit, configurable log lookbacks and an archive node from genesis. The requirements set thresholds for availability, throughput, latency and incident response too. One operator fills one of the three provider seats. Protofire's oracle integration page covers the rest of the list.
How many clients should run behind one endpoint?
Two clients should run behind one endpoint on a network that has two production clients. On 11 November 2020, a consensus bug in Geth v1.9.9 and v1.9.13 caused what Infura called its most severe service interruption (Infura, archived). A second client keeps answering through such a bug when the router can tell which fork is correct. So the scope names the reference that the router checks.
Do RPC nodes hold validator keys?
No, RPC nodes hold no validator, multisig or contract admin keys. The credentials on an RPC node are the JWT secret between the execution and consensus clients, plus the gateway's own credentials. Signing is a separate job with slashing risk.

Get a proposal

Tell us what you are building. An engineer reads it, we have a short call, and the written proposal follows within one business day.

Arsenii PetrovichOffer Owner, reads every request · LinkedIn

A demo or repository link also works.