How Direct Works

Overview

Direct replaces the single central endpoint of a traditional RPC provider with two things working together: a peer-to-peer network of RPC nodes, and a client that connects your app to it. This page explains what that means and the features you get because of it.

The traditional model

Most RPC providers put one endpoint — a load balancer — in front of their nodes. Every request goes through that single point.

   ┌──────────┐      ┌───────────────┐      ┌──────┐
   │ Your app │ ───> │ Load balancer │ ───> │ Node │
   └──────────┘      └───────────────┘      └──────┘

                     one endpoint —
                  one point of failure

If that endpoint is slow, far away, or down, every request feels it. Throughput is capped by that one path, and you’re trusting a single provider for every answer.

The Direct model

Direct gives your app a client that connects straight to many nodes at once, with no central endpoint in the middle.

   ┌──────────────────┐         ┌──────┐
   │ Your app         │ ──┬───> │ Node │
   │ + Direct client  │   ├───> │ Node │
   └──────────────────┘   ├───> │ Node │
                          └───> │ Node │
                                └──────┘

   direct connections to many nearby nodes —
   no central endpoint, no single point of failure

Because requests spread across a mesh of nodes, there’s no single point of failure, throughput scales with the network, and the node closest to you answers fastest.

Direct works at both ends of every request: the client sits close to your app, and the network sits close to the RPC nodes. Local-first architecture follows a single request through both. The next two sections cover each.

The network

Direct routes your requests across a peer-to-peer network of RPC nodes instead of one central endpoint.

  • Made up of independent node runners, third-party RPC providers, and Direct’s own infrastructure.
  • Direct pays providers per request and routes each one to the best node by performance, reliability, price, and region.
  • The network is continuously monitored, so requests always reach healthy, fast, well-priced nodes.
  • No central controller sits in the middle — so there’s no single point of failure.

→ The Network covers how this works in detail, including wholesale access.

The client

The client connects your app to the network and exposes everything as plain JSON-RPC, so your existing code works unchanged.

  • Drop-in— plain JSON-RPC, two lines in the browser or a local endpoint on your backend.
  • Two clients— a Browser SDK for frontend apps and a CLI client for backends.
  • Resilient— requests spread across many nodes for automatic failover and high throughput.
  • Instant reads— local-first syncing serves popular data without a round trip.
  • Optional data integrity— quorum checks across multiple providers when you need them.

→ Using Direct covers both clients and their features.

Read next