Real-time blockchain apps should not have to behave like batch jobs.
If you are building a trading interface, wallet activity feed, alerting system, analytics dashboard, bot, indexer, or AI agent, you need fresh on-chain data as soon as it lands. But the default path is often painful: poll RPC endpoints, fetch blocks or logs repeatedly, decode raw events, normalize data across chains, track cursors, handle reconnects, and pay for a lot of throwaway requests along the way.
Today, we are opening the beta for Pinax WebSockets: a new real-time data service powered by the Pinax API.
Pinax WebSockets lets developers stream decoded blocks, swaps, transfers, and exchange events over a single persistent WebSocket connection, with simple usage-based pricing at $0.50 per 10,000 delivered messages. Instead of polling for updates, your application subscribes to the streams it cares about and receives structured data as new activity confirms on-chain.
Push, don’t poll.
Why we built this
Polling is one of the most common workarounds in blockchain development.
Need to show a live swap feed? Poll.
Need to detect token transfers? Poll.
Need to trigger alerts when wallet activity happens? Poll.
Need to keep a bot or agent aware of market activity? Poll again.
Polling works, but it comes with tradeoffs:
- Higher request volume
- Added latency from polling intervals
- Repeated reads of data that may not have changed
- Client-side decoding and normalization
- More infrastructure to manage cursors, retries, and reconnects
- More complexity when scaling across multiple chains
For many real-time products, polling becomes a tax on both infrastructure and developer time.
Pinax WebSockets replaces that pattern with a persistent stream. Open one connection, subscribe to one or more channels, and receive decoded on-chain data as it becomes available.
What Pinax WebSockets gives you
The beta provides real-time streams for common on-chain activity, including DEX swaps and token transfers across Solana and major EVM networks.
At launch, supported streams include:
- Solana DEX swaps with normalized trade data across venues such as Raydium, Orca, Meteora, Pump.fun, and more
- Solana transfers for SPL, SPL-2022, and native SOL movement
- EVM DEX swaps across Ethereum, Base, and other supported EVM networks
- EVM ERC-20 transfers across the same EVM network set
Subscriptions use a simple network@table format.
For example, to stream Solana swaps:
wscat -c "wss://ws.pinax.network/ws/solana@swaps?token=<API_KEY>"
To stream Ethereum ERC-20 transfers:
wscat -c "wss://ws.pinax.network/ws/mainnet@erc20_transfers?token=<API_KEY>"
To subscribe to multiple streams from one connection:
wscat -c "wss://ws.pinax.network/ws/solana@swaps/mainnet@erc20_transfers?token=<API_KEY>"
And to subscribe to swaps across multiple networks:
wscat -c "wss://ws.pinax.network/ws/solana,base,mainnet@swaps?token=<API_KEY>"
No custom client protocol is required. Use a standard WebSocket client, authenticate with your Pinax API key, and start reading messages.
Built for live products
Pinax WebSockets is designed for teams building real-time product experiences on top of blockchain data.
Use it for:
- Live swap feeds
- Wallet activity streams
- Token transfer notifications
- DEX dashboards
- Trading bots
- Alerting systems
- Reorg-aware indexers
- AI agents that react to on-chain activity
Because streams are decoded server-side, your application can consume structured events directly instead of starting from raw logs or block payloads.
That means less glue code, less duplicated decoding logic, and a shorter path from chain activity to product experience.
One connection, many streams
A single WebSocket connection can carry multiple subscriptions.
You can subscribe to one stream, several specific streams, or use selectors to capture broader activity. Pinax supports path-based subscriptions, multi-channel streams, and wildcard selectors for teams that need broader coverage.
Every wrapped payload includes the stream identifier, so your application can route events by source while still consuming them from the same connection.
That makes it easier to build products that span chains or combine different types of activity, such as swaps and transfers, without opening and managing a separate connection for every data source.
Server-side filtering and reconnect replay
Real-time data is only useful if it is reliable and manageable.
Pinax WebSockets supports server-side filtering so you can reduce the number of delivered messages and focus on the activity your application actually needs. Instead of receiving a broad stream and discarding most of it client-side, you can push filtering closer to the edge.
The service also supports replay on reconnect, helping clients recover after interruptions without manually rebuilding cursor logic from scratch.
These features are especially important for production systems like alerting pipelines, bots, and indexers, where missed events can create real user impact.
Simple usage-based pricing
Pinax WebSockets is priced at $0.50 per 10,000 delivered messages.
You’re not charged for idle connections, heartbeats, or protocol frames. Billing is based on the WebSocket messages your application actually receives.
That distinction matters because one delivered message can contain multiple underlying swaps, transfers, or events. Combined with server-side filtering, this gives developers a predictable way to control both data volume and cost.
For teams replacing RPC polling, the model is straightforward: subscribe to the streams you need, filter down to the activity that matters, and pay for delivered real-time data.
Powered by Pinax data infrastructure
Pinax WebSockets is built on the same data foundation behind the Pinax API.
The goal is simple: give developers a cleaner path to production-grade blockchain data, whether they are querying historical data, building APIs, streaming chain activity, or connecting data to AI agents.
With WebSockets, that data becomes available as a real-time stream.
Try the beta
Pinax WebSockets is now available in beta.
Start here:
Open a connection, subscribe to a stream, and start building real-time blockchain experiences without the polling tax.
Push, don’t poll.
We’re building this with you
Pinax WebSockets is in beta, and we’re actively looking for feedback from teams building real-time blockchain applications.
If you’re building live trading interfaces, wallet activity feeds, alerting systems, dashboards, bots, indexers, research workflows, or AI agents, we’d love to hear what streams, filters, payloads, and replay behavior you need.
Reply or reach out directly at info@pinax.network.
We’ll respond to everyone.
No Comments