ERPC Adds Jet Analytics to Solana RPC | Buidlers Collective (BDLC)

ELSOUL LABO B.V. (Headquarters: Amsterdam, Netherlands; CEO: Fumitake Kawasaki) and Validators DAO, the operators of ERPC, are pleased to announce the launch of Jet Analytics & Indexed RPC on Solana RPC. This update introduces new supported methods that make it easier to retrieve historical data, perform backfilling, recover after incidents, and build analytics infrastructure through ERPC’s Jetstreamer implementation.

With this update, developers using ERPC Solana RPC can work not only with data collected from the present onward, but also with historical data retained in ERPC indexes. This makes it easier to develop applications, backfill missing data, recover after incidents, analyze past activity, monitor systems, and validate historical behavior.

The supported methods are getTransactionsForAddress, getTransfersByAddress, jetTopPrograms, jetSlotStats, jetTpsTimeseries, jetEpochSummary, and jetProgramStats. These are Jet Analytics & Indexed RPC methods provided through ERPC’s Jetstreamer-derived self-hosted indexes and gateway.

This update is available across all ERPC Solana RPC plans. Existing users can try Jet Analytics & Indexed RPC from their current ERPC API key and Solana RPC endpoint without subscribing to a separate dedicated plan.

ERPC Dashboard: https://dashboard.erpc.global/ ERPC Official Website: https://erpc.global/

Jet Analytics Can Be Tried Directly From Docs Inside the ERPC Dashboard

In the ERPC Dashboard, developers can manage Solana RPC usage and plans while also opening Solana RPC Documentation through the Docs flow to review each Jet Analytics & Indexed RPC method. Request formats, parameters, response structures, and usage notes can be checked from the documentation, allowing developers to start testing immediately.

Jet Analytics adds historical data access and index-backed analytics to the existing Solana RPC workflow. Developers can check their ERPC Solana RPC endpoint and use the same API key, dashboard, and documentation flow to retrieve historical transactions, token transfers, program statistics, slot statistics, TPS trends, and epoch summaries.

This makes it easier to use historical data from the ERPC Solana RPC platform for early-stage application development, analytics infrastructure, existing indexer supplementation, recovery after incidents, past-period verification, user-facing history views, and monitoring system resynchronization.

Strengthening Historical Data Access Through the Jetstreamer Implementation

Solana RPC is widely used as infrastructure for retrieving current state and recent information. However, in real-world application development and analytics operations, current state alone is often not enough. Developers frequently need to retrieve past transactions, address-level history, token transfers, execution activity for specific programs, per-slot transaction counts, and epoch-level activity after the fact.

When starting a new application, developers need not only “data collected from now on,” but also “data that already happened before development started.” Wallets, explorers, trading applications, analytics platforms, monitoring systems, bots, and AI agents cannot fully understand prior user activity, transaction history, token movement, program usage, or comparison data for anomaly detection if they only begin collecting data from the present moment.

Traditionally, this kind of backfilling has carried a large operational burden. General RPC usage is centered on current state and recent data retrieval, so retrieving older archive data quickly and shaping it into an application-friendly format often requires a dedicated indexer, archive node, custom database, and long-running re-fetch process. As a result, many teams could begin collecting data from the present, but had difficulty starting application development with past data already available.

ERPC has now integrated a Jetstreamer-based self-hosted index into its Solana RPC infrastructure to improve the practicality of historical data retrieval. This allows developers to use historical data retained in ERPC indexes for backfilling, re-fetching, recovery, and analytics, rather than relying only on newly collected data from the current point in time.

Access to Historical Data Changes the Starting Point of Application Development

Faster historical data access does not simply mean that older information can be viewed. The ability to begin development with past data already available affects application design, analytics quality, user experience, and operational recovery.

For example, wallets and explorers need to retrieve past transactions and token transfers for an address and display prior activity to users. Analytics platforms need to understand which programs were heavily invoked during a given period, how many transactions were processed in each slot, and how TPS changed over time, not only for the present but also for past periods.

Historical data access is also important when an indexer or internal database suffers an unexpected incident. If data is lost because of database corruption, ingestion downtime, deployment bugs, storage failure, or an incorrect migration, being able to re-fetch past data makes it easier to fill the missing period and restore the service to its previous state.

For Solana applications, real-time data arrival is only one part of the data pipeline. The subsequent steps of confirmation, storage, supplementation, re-fetching, analytics, and monitoring are also critical. ERPC’s Jet Analytics & Indexed RPC is an extension designed to support these downstream historical data workflows and operational recovery.

Address-Level Historical Transaction Access With getTransactionsForAddress

getTransactionsForAddress is an Indexed RPC method for retrieving transactions related to a specific address. By specifying the target address and combining conditions such as slot, blockTime, signature, and status, developers can retrieve address-level historical data.

This method supports two retrieval modes: transactionDetails: "signatures" and transactionDetails: "full". In signatures mode, it returns index rows such as signature, slot, transactionIndex, err, memo, blockTime, and confirmationStatus. In full mode, it performs the same index lookup and combines it with transaction detail retrieval to also return transaction, meta, and version.

For wallets, explorers, monitoring systems, user support, transaction history checks, and internal reconciliation, fast access to past transactions related to a specific address is important. This method is also useful when a new product needs to display past history, when an existing indexer needs supplementation, or when address history needs to be reconstructed after an incident.

The response includes paginationToken, which can be used to retrieve the next page. It also includes windowStart, allowing clients to check the oldest slot currently retained in the index. This helps client applications design historical data retrieval while understanding which range is available from the endpoint.

Historical Token Transfer Data With getTransfersByAddress

getTransfersByAddress is an Indexed RPC method for retrieving SPL Token v1 transfer data related to a specific owner address. By combining inbound, outbound, or any direction, counterparty address, mint, amount, blockTime, and slot conditions, developers can retrieve historical token transfer data required by wallets and analytics systems.

Each row includes fields such as signature, slot, blockTime, type, fromUserAccount, toUserAccount, fromTokenAccount, toTokenAccount, mint, amount, decimals, uiAmount, feeAmount, feeUiAmount, transactionIdx, instructionIdx, and innerInstructionIdx. If a single transaction includes multiple Token program calls, each call is treated as a separate row.

The solMode option allows developers to choose between merged mode, where wSOL is treated similarly to native SOL, and separate mode, where the wSOL mint remains distinguishable. Merged mode may be easier for wallet and portfolio display, while separate mode is useful for analytics use cases that need to distinguish SOL and wSOL flows.

Token transfer data is important for wallets, portfolios, transaction histories, accounting, monitoring, alerts, fund-flow analysis, bot verification, and user support. This method is also useful when reconstructing asset movement for a specific period or filling gaps in an indexer.

Understanding Program Usage With jetTopPrograms

jetTopPrograms retrieves a ranking of programs by invocation count within a specified time window. By specifying since, until, includeVotes, and limit, developers can retrieve invocations, errors, and total_cus for each program.

On Solana, understanding which programs were heavily used during a given period is useful for network analysis, application analysis, load trend investigation, bot and trading application target selection, and monitoring target discovery. Transaction counts alone do not show which programs were actually invoked, how many compute units were consumed, or how many errors occurred.

With jetTopPrograms, developers can inspect Solana program activity for a specific period at a higher level of detail. It can be used to research new application areas, discover notable programs, identify programs with heavy load, compare past periods, and understand overall network activity trends.

Time-Series Program Analysis With jetProgramStats

jetProgramStats retrieves time-bucketed invocations, errors, and total_cus for a specific program ID. By specifying programIdBase58, since, until, and bucketSec, developers can review usage trends for a target program over time.

This method is useful for checking program usage growth, error increases, compute unit consumption changes, activity before and after an event, post-release usage, and abnormal invocation spikes. Viewing program-level activity as a time series makes it possible to understand changes that are not visible from a single aggregate number.

For trading applications, DeFi, NFTs, games, DePIN, AI x Crypto, monitoring systems, and analytics dashboards, it is important to know when activity around a specific program increased, during which period errors rose, and how compute unit consumption changed. jetProgramStats makes this kind of program-level analytics easier to access through the ERPC Solana RPC workflow.

Per-Slot Processing Visibility With jetSlotStats

jetSlotStats retrieves transaction_count, vote_transaction_count, non_vote_transaction_count, and block_time for a single slot or slot range. It supports both single-slot lookup by slot and range lookup using fromSlot and toSlot.

In Solana analysis, it is important to understand how many transactions were processed per slot and how many were vote transactions versus non-vote transactions. Looking only at total transaction counts does not distinguish application-driven activity from consensus-related vote activity.

With jetSlotStats, developers can inspect processing conditions for a specific slot or period at slot-level granularity. It can be used for incident investigation, performance analysis, per-slot activity analysis, backfill range checks, missing-data verification, and monitoring system baseline data collection.

TPS Trend Retrieval With jetTpsTimeseries

jetTpsTimeseries retrieves total_tps and non_vote_tps per bucket for a specified time window. By specifying from, to, and bucketSec, developers can review Solana transaction throughput as a time series.

TPS can be misleading when viewed as a single point-in-time number. It fluctuates depending on time of day, network load, application activity, vote transaction ratio, and congestion conditions. jetTpsTimeseries separates total TPS and non-vote TPS, making it easier to understand application-driven activity more realistically.

For analytics dashboards, network monitoring, research, infrastructure load analysis, application activity comparison, and traffic verification for specific periods, handling TPS as a time series is important. jetTpsTimeseries allows developers to retrieve historical throughput trends through the ERPC RPC workflow.

Epoch-Level Aggregation With jetEpochSummary

jetEpochSummary retrieves aggregate information for a specified epoch, including slots, non_vote_txs, vote_txs, total_txs, first_block_time, last_block_time, distinct_programs, and program_invocations.

Epoch-level aggregation is useful for understanding Solana network activity over a larger time unit than individual slots or transactions. Developers can check how many slots are present in the index for an epoch, how many vote and non-vote transactions were processed, and how many distinct programs were invoked.

This is useful for research, reporting, network analysis, long-term usage trend review, application activity comparison over time, and infrastructure load forecasting. jetEpochSummary makes this kind of large-scale analysis easier to start without retrieving massive numbers of individual transactions.

From getTransaction Speed Improvements to Expanded Historical Data Access

ERPC recently improved historical transaction retrieval performance around Solana RPC’s getTransaction. getTransaction is a fundamental method for retrieving details for a single transaction signature and is frequently used by explorers, wallets, indexing systems, analytics platforms, monitoring systems, backend APIs, and transaction history workflows.

Jet Analytics & Indexed RPC expands this direction further. The getTransaction speed improvement supports detailed retrieval for a specific transaction. By contrast, Indexed RPC allows developers to search, aggregate, and paginate across multiple kinds of historical data, including address-level data, token transfers, program activity, slot stats, TPS timeseries, and epoch summaries.

Solana applications need not only to inspect a single transaction in detail, but also to retrieve activity over past periods and feed that data into application databases, dashboards, monitoring systems, analytics platforms, and AI agents. ERPC combines improvements to fundamental methods such as getTransaction with index-backed methods such as Jet Analytics & Indexed RPC to improve the practicality of historical data access.

Use the Currently Retained Index Range While Checking Availability

Jet Analytics & Indexed RPC is provided through ERPC-operated self-hosted indexes. Therefore, the historical data range available from each endpoint depends on the range currently retained in the index. getTransactionsForAddress and getTransfersByAddress return windowStart, which indicates the oldest slot currently retained in the index.

Developers can use windowStart to determine which range is available from the endpoint. When designing historical data backfilling, re-fetching, and recovery flows, it is important to combine the target period, paginationToken, sortOrder, limit, filters, and windowStart to retrieve the necessary range in stages.

Jet Analytics is an extension for making historical transactions, token transfers, program execution statistics, slot statistics, TPS trends, and epoch aggregations easier to handle. Applications should combine standard RPC, getTransaction, Indexed RPC, WebSocket, Geyser gRPC, and Shredstream according to their use case.

Use Cases for Explorers, Wallets, Indexers, Analytics Platforms, Monitoring, and AI Agents

Jet Analytics & Indexed RPC can be used across many Solana application scenarios.

Explorers and wallets can use it for address-level historical transactions, token transfers, past transaction checks, and user-facing history views. Trading applications and DeFi systems can use it to inspect historical fund flows for specific addresses or mints, program activity, transaction success and failure trends, and operational verification.

Indexers and analytics platforms can use it for initial backfilling, filling missing periods, re-aggregating past periods, reconciling against existing databases, and recovering after incidents. Monitoring systems can use slot stats, TPS timeseries, program stats, and epoch summaries to establish baselines, detect anomalies, analyze load trends, and monitor activity changes for specific programs.

Historical data is also important for AI agents and automated operations systems. When an AI agent retrieves current state from Solana RPC and combines it with past activity, transaction history, token transfers, program stats, and TPS trends from Jet Analytics & Indexed RPC, it can provide reports, monitoring, notifications, investigation, and development support with better context.

Solana RPC, WebSocket, Geyser gRPC, Shredstream, and Indexed RPC in the Same Workflow

ERPC provides Solana RPC, WebSocket, Geyser gRPC, Shredstream, VPS, and bare metal servers as Solana-specialized operational infrastructure. With the addition of Jet Analytics & Indexed RPC, not only real-time data delivery but also historical data, aggregated data, and analytics data can be handled more easily through the same Solana RPC workflow.

Solana applications cannot rely on real-time subscriptions alone. They also need getTransaction to confirm events detected in real time, Indexed RPC to backfill past periods, historical data for user-facing screens, slot stats and TPS timeseries for monitoring baselines, and program activity analytics.

ERPC treats these not as fragmented standalone features, but as data paths actually required by Solana applications. Developers can check their Solana RPC endpoint from the ERPC Dashboard and use Docs to test each method while validating the data retrieval path required by their workload.

Available Across All ERPC Solana RPC Plans

Jet Analytics & Indexed RPC is available across all ERPC Solana RPC plans. Existing users can try the new methods from their current Solana RPC endpoint without subscribing to a separate dedicated plan.

The ERPC Dashboard allows users to check Solana RPC usage, plan management, API keys, and documentation flows. The Jet Analytics & Indexed RPC methods have been added to the Jet Analytics & Indexed RPC section of the Solana RPC Documentation, where developers can review request formats, parameters, and response structures while testing the methods.

ERPC Dashboard: https://dashboard.erpc.global/

Expanding Historical Data Access and Analytics as Solana-Specialized Infrastructure

ERPC improves Solana RPC not as a simple API endpoint, but as infrastructure supporting the execution quality of Solana applications. In Solana, HTTP RPC, WebSocket, Geyser gRPC, Shredstream, SWQoS, server placement, validator quality, network routes, processing node performance, indexing, and historical data access directly affect application speed, stability, recoverability, and analytical capability.

The addition of Jet Analytics & Indexed RPC expands the range of data retrieval available to Solana applications. By making current state, real-time events, historical transactions, token transfers, program activity, slot stats, TPS timeseries, and epoch summaries available within the same development workflow, ERPC helps developers reduce the initial burden of combining multiple infrastructure services and focus more directly on application design, validation, and operational recovery.

ELSOUL LABO has received approval for five consecutive years since 2022 under the Dutch government’s WBSO research and development support program. The company continues research and development across Solana RPC infrastructure, validator operations, real-time data delivery, historical data access, and AI agent-based operations and development support. These results are reflected across ERPC, SLV, SLV AI, and the AS200261 Solana-specialized data center.

With ERPC Jet Analytics & Indexed RPC, developers using Solana RPC can handle not only current data, but also historical data, aggregated data, analytics data, and recovery data within the same workflow. By combining real-time data access, historical data retrieval, backfilling, recovery, and analytics on the same platform, developers can more easily build and operate wallets, explorers, trading applications, DeFi products, indexers, analytics platforms, monitoring systems, and AI agents.

Contact

For questions about Jet Analytics & Indexed RPC, Solana RPC, getTransactionsForAddress, getTransfersByAddress, jetTopPrograms, jetSlotStats, jetTpsTimeseries, jetEpochSummary, jetProgramStats, historical data access, backfilling, recovery, analytics infrastructure, existing plans, or configuration consultation, please create a support ticket on the Validators DAO official Discord.

ERPC Dashboard: https://dashboard.erpc.global/ ERPC Official Website: https://erpc.global/ Validators DAO Official Discord: https://discord.gg/C7ZQSrCkYR

ERPC Adds Jet Analytics to Solana RPC — Strengthening Historical Data Access, Backfilling, Recovery, and Analytics Through Jetstreamer Implementation