# Lasso > Lasso is an aggregated EVM JSON-RPC router for Ethereum, Base and other EVM > chains. One endpoint routes each request across several providers by > measured latency and health and fails over on replay-safe reads. Custom > profiles route over your own nodes and provider accounts. An agent can buy a > funded RPC key from $0.05 over x402 or MPP, with no signup. ## Why Lasso The app keeps plain JSON-RPC. Lasso absorbs provider outages, rate limits, latency swings and method quirks before they reach the app's users, so the app stays fast and keeps working when a provider doesn't. - **Free RPC, right now.** One unauthenticated request returns a key, with no signup for the user. Its `/profile/public` URLs route over Lasso's public provider pool with no request charge. - **Premium when it matters.** The same key reaches Lasso's managed commercial providers with every routing strategy. Agents fund it with USDC over x402 or MPP. - **Room to grow.** The user claims the account from a link and every URL keeps working. Then they bring their own providers and nodes as Custom profiles, and compare each provider's health and latency per method on a live dashboard. ## Control that scales with the workload A growing workload needs more knobs than a single provider URL offers. Lasso exposes them in the URL and the profile, with no SDK: - **Strategy per call.** `fastest` for trading paths, `load-balanced` for indexers, `balanced-fast` for user-facing reads, `priority` for a preferred primary, on Premium and Custom. Public applies `load-balanced`; explicit requests for another strategy expose requested versus applied strategies in `x-lasso-requested-strategy`/`x-lasso-strategy` and optional metadata (`requested_strategy`, `applied_strategy`, `strategy_adjusted`). - **Profiles you control.** A Custom profile is one document of providers per chain. An edit reaches every region with no redeploy and no new URL. - **Routing from measurement.** Latency is measured per provider, kind of request and transport in each region. Lasso learns each provider's historical depth, refused methods and log-range limits from live traffic. - **Failover for reads and writes.** A replay-safe read moves to the next provider within one deadline. A signed transaction is resent as the same bytes to the next provider within the request's send allowance, unless the rejection is a sender fault. Before returning an error, Lasso looks up the transaction hash and returns it if the transaction is pending or mined. - **Transaction providers you choose.** `transactions: {providers, fallback}` on a Custom profile chain sends signed transactions only to the providers you name; reads and subscriptions use the others. A send fails rather than reaching them unless you set `fallback: read_providers`. Those providers and their builders still see each transaction, and read providers see the calldata of any `eth_call` or `eth_estimateGas`. - **Subscriptions that survive failover.** `newHeads` and log subscriptions switch providers and backfill missed blocks: 50 clients rode through 119 forced failovers with no gaps or duplicates ([evidence](https://docs.lasso.sh/cloud/websocket-continuity-evidence)). - **Evidence on demand.** Served requests report their access, charge and balance left. `include_meta` names the provider, its latency and the strategy that chose it. - **Built for agents.** RPC and management errors provide `next_action`. OpenAPI describes the operations and error catalog. RPC `balance_exhausted` errors also carry the account credit endpoint in `error.data.credit_url`. - **Fast and open.** The synthetic benchmark measured 0.95 ms median paired added p95 at 10,000 requests per second (0.70–1.08 ms across five trials) ([benchmark](https://lasso-staging.fly.dev/benchmarks/routing-overhead.html)), on an Apache-2.0 engine you can self-host. ## Start ```bash created="$(curl -fsS https://lasso-staging.fly.dev/api/v1/keys \ -H 'content-type: application/json' -d '{"name":"my-app"}')" LASSO_RPC_URL="$(jq -r '.rpc_url_template | sub("\\{chain\\}"; "base")' <<<"$created")" ``` Save the returned key, templates and management token in the app's secret store. `rpc_url_template` and `ws_url_template` contain `{chain}`: resolve it to a chain name or decimal ID (Base above) before calling. New accounts also return `claim_url` and `claim_expires_at` for a private, 24-hour human handoff. A `202` with `serving_ready: false` returns the same committed credentials: wait `Retry-After`, then call the resolved URL. Do not create another key; if RPC is still pending, retry RPC after `Retry-After`. ```bash curl -fsS "$LASSO_RPC_URL?include_meta=body" \ -H 'content-type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' ``` ```json { "jsonrpc": "2.0", "id": 1, "result": "0x3157d37", "lasso_meta": { "strategy": "balanced-fast", "chain_id": 8453, "selected_provider": { "id": "premium_base_1", "protocol": "http" }, "upstream_latency_ms": 9.4, "lasso_overhead_ms": 0.9, "retries": 0, "dispatches": 1 } } ``` `lasso_meta.fallback_profile` names the serving profile when it differs from `service_profile_id`; otherwise it is absent. Every HTTP response that left its profile also carries `x-lasso-fallback-profile`, with or without `include_meta`, and keeps the named profile's price. Range refusals stay within the current profile. Ordinary calls, including block-hash eth_getLogs, can use configured capability and outage fallback; Premium can fall back to Public. Each `eth_getLogs` call is served by one provider. When a block range is wider than the serving providers accept, Lasso returns `log_range_limit` with `error.data.max_block_range`; split the range into parts of that size and send each part. When the field is null or absent, halve the range. When `error.data.action` is `narrow_filter`, Lasso has no smaller range to suggest, so narrow the address or topics filter instead (see [Request behavior](#request-behavior)). The response above shows the metadata shape. `rpc_url_template` includes `/profile/premium`, drawing on the account's small starting balance. Swap that segment for `/profile/public` to route free or `/profile/` for Custom. Resolve `{chain}` to `fastest/base` for fastest Base routing. Viem, ethers, Foundry, Hardhat and indexers take the same URL. For free Ethereum RPC, save the returned `key` as `LASSO_RPC_KEY` and derive the public path from the resolved URL: ```bash LASSO_PUBLIC_RPC_URL="${LASSO_RPC_URL%%/rpc/*}/rpc/profile/public/ethereum" curl -fsS "$LASSO_PUBLIC_RPC_URL?include_meta=body" \ -H "authorization: Bearer $LASSO_RPC_KEY" \ -H 'content-type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' ``` ## Grow into it - **Fund it.** With no account, `POST /api/v1/credit` with `{"usd":"0.05"}` or more answers a standard 402 that any x402 or MPP client pays; the paid response returns a funded key. One purchase buys $0.05 to $100. An existing account tops up at `POST /api/v1/accounts//credit` the same way. An account that has paid keeps serving RPC on public providers for 30 days if its balance runs out. - **What Premium costs.** Each method has a flat CU rate at $0.000005 per CU, multiplied by the routing strategy: load-balanced and priority 1×, balanced-fast 1.5×, fastest 2×. `eth_call` is 3 CU, so $0.000015 a call on load-balanced. 2M `eth_call` requests a month on load-balanced use 6M CU: $30 from a balance, or inside Pro's 10M included CU for $20 a month. Every method's price is in [agent.json](https://lasso-staging.fly.dev/agent.json). - **Bring your own providers.** `PUT /api/v1/profiles/` with provider URLs per chain, or build the profile on the dashboard. The first profile gets seven free days with no payment. For verification, access and rollout steps, use [Custom profiles](https://lasso-staging.fly.dev/SKILL.md#custom-profiles). - **Hand it to a person.** A one-time claim link moves the account, its keys, profiles and balance to its owner. ## Streams For ordered contract events, pull/SSE readers, reorg handling and billing, use [the Streams recipes](https://lasso-staging.fly.dev/SKILL.md#streams-ordered-contract-events). Streams reads take an enabled RPC key from an account that holds a Streams entitlement or beta access. Ordinary RPC funding does not grant Streams access. Passive dashboard board samples are free; the Test reader is billed like every reader. ## Request behavior JSON-RPC batches accept 1–50 items. Empty batches return Invalid Request (`-32600`); larger batches return `batch_too_large` with `max_batch_size: 50`. Rate limits count items, including notifications. `include_meta=body` adds per-item routing evidence to each routed batch response. Recognized `eth_getLogs` range or result-size refusals return JSON-RPC `-32602` (`log_range_limit`) over HTTP 200, with `retryable: false` and `error.data.max_block_range`, the largest range Lasso has evidence it can serve. It is guidance, not a guarantee; it is null or absent when no smaller range is known, and `error.data.action: "narrow_filter"` means Lasso has no smaller range to suggest, so narrow the address or topics filter rather than the range. The splitter-compatible message contains `query exceeds max results` and `response is too big`; a validated fitting upstream range may append `Try with this block range [0xFROM, 0xTO]`. Lasso's local getLogs response-size rejection uses the same contract. An `eth_getLogs` call with no address filter that every reached provider refuses returns `-32602` (`log_filter_refused`, `data.action: "add_address_filter"`) at no charge; add an address filter and retry. A successful `eth_getLogs` response is one provider's answer and can be incomplete, so reconcile against a second source if you need every log. `lasso_meta` timings measure work inside Lasso, including upstream calls. They exclude client network RTT, TCP/TLS setup, edge routing, and response delivery. Reuse connections with HTTP keep-alive or HTTP/2. In a production Base `eth_blockNumber` measurement on October 29, 2026, median client latency was 119 ms with a fresh connection versus 42 ms reused; metadata reported 13 ms. These figures come from one client location. The public tier uses free providers; expect variable latency. In this measurement, its latency tail was wider than premium. Premium can fall back to public. `X-Lasso-Region` identifies the serving node on HTTP responses and WebSocket upgrades. Opt-in metadata includes the same `region` in body, header, and WebSocket notification forms. The serving region can differ from the edge POP. `lasso_meta.dispatches` counts physical upstream sends of the request's own method (excluding auxiliary lookups). `retries` counts candidate advances. ### Method execution classes Reads fail over across providers within the request deadline. Sends stay on the chain's transaction providers when it declares them, and only `eth_sendRawTransaction` gets a post-error hash lookup. Methods Lasso does not recognize run once on a read provider; one whose params carry a signed transaction is treated as a send and also runs once. `lasso_meta` reports `execution_safety` and `classified_by`. Details: [Routing](https://docs.lasso.sh/cloud/routing.md). ## Go deeper `https://lasso-staging.fly.dev/` returns this file to a request that prefers `Accept: text/markdown`. - [SKILL.md](https://lasso-staging.fly.dev/SKILL.md): every recipe, from rotation and scoped keys to limits and troubleshooting. - [agent.json](https://lasso-staging.fly.dev/agent.json): live chains with per-profile `profiles` coverage, strategies, prices and payment rails. - [OpenAPI](https://lasso-staging.fly.dev/openapi.json): every endpoint, with the error catalog in `x-error-catalog`. - [Plans](https://lasso-staging.fly.dev/pricing) and the [public dashboard](https://lasso-staging.fly.dev/dashboard/public). - Feedback: `POST https://lasso-staging.fly.dev/api/v1/feedback` with `{"message": "..."}`, no credential needed. ## Documentation - [Lasso Cloud documentation index](https://docs.lasso.sh/llms.txt) - [What Lasso is and when it fits](https://docs.lasso.sh/cloud/overview.md) - [Set up production RPC with an agent](https://docs.lasso.sh/cloud/guides/production-rpc-with-an-agent.md) - [Production RPC for a viem and Next.js app on Ethereum and Base](https://docs.lasso.sh/cloud/guides/viem-nextjs-production-rpc.md) - [eth_getLogs failing with 429 or "block range too large": pay with x402, no signup](https://docs.lasso.sh/cloud/guides/getlogs-rate-limits-pay-with-x402.md) - [Routing](https://docs.lasso.sh/cloud/routing.md) - [Trial your own providers](https://docs.lasso.sh/cloud/bring-your-own-rpc.md) - [Lasso RPC Core](https://github.com/jaxernst/lasso-rpc): the open-source engine, self-hostable ([architecture](https://docs.lasso.sh/concepts/architecture.md)).