High-performance node RPC that YOU control

What Lasso does

1. 01

   Unifies your RPC providers behind one drop-in endpoint for any EVM chain

   Standard Ethereum JSON-RPC behind a geo-distributed proxy. Each region measures every provider by method and transport and routes each request on its own measurements, steered by the URL you call.

   lasso.sh/rpc/profile/premium/fastest/base?include_meta=body

   lasso.sh/rpc/profile/premium/fastest/base?include_meta=body

   lasso.sh Nearest region

   Answered by the Lasso region closest to your app, ranking providers on its own measurements.

   premium Profile

   Which providers serve the request. One key reaches every profile.

   public premium your-app

   fastest Strategy

   How healthy providers are ranked, on latency measured live per method.

   fastest balanced-fast load-balanced priority

   base Chain

   Any chain the profile serves, each with its own provider pool.

   ethereum base arbitrum tempo

   include_meta=body Evidence

   Opt in and each response names the route it took and where the time went.

   strategy selected_provider retries upstream_latency_ms

2. 02

   Shows you what every provider is doing and how it performs

   The dashboard draws each chain with its providers attached and shows every routing decision as it happens. Open the live dashboard

   Robinhood ID 4663 102,738,879

   Ethereum ID 1 26,314,349

   Base ID 8453 53,339,865

   Arbitrum ID 42161 520,057,219

   Measured from every region

   Each Lasso region ranks providers on its own latency, so a request goes to what is fastest from where it arrived.

   Ranked per method

   Latency is tracked per kind of request and transport. The fastest provider for eth_call often isn't the fastest for eth_getLogs.

   Held to the chain head

   Every provider's block height is tracked against the others. One that falls behind is set aside until it catches up.

3. 03

   Gives you the keys to the nodes serving your users, tuned for your app

   A profile is a pool of providers for every chain it serves. Route through Lasso's public and premium profiles, or build a Custom profile from your own nodes and provider keys. The URL picks one per request.

   /profile/public

   Public

   Public endpoints, made dependable by spreading load across many and routing around the ones that fail.

   /profile/premium

   Premium

   Commercial providers alongside public ones, with higher rate limits and every routing strategy.

   /profile/your-app

   Custom

   Your own nodes and provider keys. Paste a URL and Lasso confirms its chain, probes the methods, limits and WebSocket support it offers, and builds the profile from what it finds.

   profiles/your-app.yml

   A Custom profile is one document. Put your node first and paid capacity behind it, set head tracking for each provider, and declare what one can't serve or let Lasso learn it. Changes reach every region with no redeploy and no new URL.

   base:  selection:    max_lag_blocks: 1  providers:    - id: your-node      priority: 1      url: http://10.0.4.12:8545      ws_url: ws://10.0.4.12:8546      heads: live    - id: alchemy      priority: 2      heads: standby    - id: publicnode      priority: 3      capabilities:        unsupported_categories: [debug, trace]

4. 04

   Reconciles every provider's quirks into one consistent JSON-RPC

   The same failure comes back in different words from each client, chain and provider, often under the same error code. Lasso reads what each one means for routing, so your app sees the same behavior on any EVM chain.

   The provider returns Lasso reads What happens

   execution reverted

   Your call reverted

   Returned as is. Never retried.

   header not found

   This provider is behind

   Retried on another provider, without counting against its health.

   missing trie node

   This node pruned that state

   Retried on another provider. How much history the node keeps is learned.

   this range of parameters is not supported

   A range limit on this provider

   Retried on another provider. The limit is learned.

   Learned facts carry their evidence and expire unless traffic confirms them. Custom profiles route on them, and the dashboard shows each one.

5. 05

   Keeps serving when providers, processes or its database fail

   Lasso runs on the BEAM, the Erlang virtual machine built around small isolated processes and the supervisors that restart them.

   Contained failures

   Every provider connection, circuit breaker and subscription runs as its own process. One crashing touches nothing else.

   Supervised restarts

   A crashed process is replaced by its supervisor while everything around it keeps serving.

   Preemptive scheduling

   A heavy request can't hold a CPU core and stall everyone else's.

   Routing from memory

   Each node routes from local state, so requests keep flowing through a database outage.

   Bounded failover

   A failed read moves to the next provider within one deadline. A signed transaction is sent once.

   Gap-free subscriptions

   When a WebSocket provider drops, the missed range is backfilled over HTTP: 119 forced failovers, no gaps