RVO Typed JSON API for Faster Integrations
RVO is built around one principle: make infrastructure behavior explicit and predictable.
With this release, that philosophy extends directly into how developers integrate with blockchain data.
We are introducing a Typed JSON API layer alongside our existing JSON-RPC surface, designed to simplify common read workflows and provide stable, application-friendly contracts.
The Problem
Raw JSON-RPC is powerful, but noisy.
It provides full protocol control, but for most application use cases it introduces unnecessary complexity:
- verbose and inconsistent payloads
- varying response formats
- multiple calls required for simple data retrieval
- no standardized error handling
- no native batching abstraction
For many integrations, this leads to slower development and more fragile code.
The Solution
The RVO Typed JSON API introduces clean, predictable request and response contracts for common read operations.
It does not replace JSON-RPC. It complements it.
Key principles:
- stable schemas
- minimal payloads
- grouped execution
- consistent error handling
- short-TTL caching for read-heavy requests
Architecture
RVO now exposes two surfaces:
JSON-RPC
- route:
/ - full protocol-level access
- all standard Solana methods available
Typed JSON API
- route:
/v1/* - structured endpoints with validated input/output
- optimized for application integration
Authentication
All typed endpoints use:
X-API-Key:
Response Format
Success: { "ok": true, "data": { } }
Error: { "ok": false, "code": "ERROR_CODE", "message": "Readable error message" }
Grouped Operations
The /v1/group endpoint allows batching up to 20 operations in a single request.
Each operation is:
- validated independently
- executed independently
- counted independently for usage
This enables efficient batching without losing visibility or control.
Caching
Read-heavy queries are often repetitive.
To improve responsiveness:
- short-TTL caching is applied
- frequently requested data returns faster
- correctness is preserved through minimal cache lifetimes
Endpoint Overview
POST /v1/meta
Returns compact, aggregated data including:
- latest slot
- recent blocks
- recent transactions
POST /v1/transaction
Fetch parsed transaction data by signature.
POST /v1/address
Returns balance and recent signatures for an address.
POST /v1/block
Returns block data for a given slot.
POST /v1/slot
Returns the latest slot quickly.
POST /v1/balance
Returns account balance.
POST /v1/signatures
Returns recent signatures with optional limit.
POST /v1/latest-blockhash
Returns latest blockhash and context.
POST /v1/group
Executes multiple operations in one request.
Platform Updates
JSON API Console
The dashboard now includes a dedicated JSON API console:
- endpoint selection
- parameter input
- live execution
- snippet generation for:
- cURL
- JavaScript
- Node.js
- C#
Documentation
The documentation now includes:
- full JSON API section
- standardized schemas
- usage examples
When to Use What
Use Typed JSON API (/v1) for:
- backend integrations
- dashboards
- data aggregation
Use JSON-RPC (/) for:
- protocol-level control
- advanced method usage
Closing
The Typed JSON API is designed for how applications are actually built.
- predictable contracts
- fewer requests
- faster integrations
- cleaner code
Use the JSON API for stability and speed.
Use JSON-RPC when full flexibility is required.
See also
Reliable Solana RPC Integration in Production
Solana RPC is easy to start with but difficult to operate reliably at scale. This guide explains the fundamentals, common pitfalls like latency and provider instability, and how to build a production ready setup using RVO for predictable performance.
Designing a Production-Grade RPC Failover Layer
Adding multiple RPC endpoints is easy. Designing a production-grade failover layer with health scoring, stale node detection, latency tracking, and circuit breaking is not. This article breaks down what it actually takes.
Tracing a Web3 Request End-to-End: Where Latency and Failure Actually Come From
RPC performance issues rarely originate at the node itself. Latency, inconsistency, and failure are introduced across a chain of systems long before a request reaches a validator. This article traces a Web3 request end-to-end to show where delays accumulate, errors are masked, and reliability quietly degrades.