Introducing: Next-Generation Enhanced WebSockets

Real-time data streaming is essential for building responsive applications on Solana. WebSockets have long been the go-to protocol for enabling persistent, bidirectional communication, replacing inefficient HTTP polling with a single connection.

While WebSockets are ideal over traditional HTTP polling, they introduce a host of challenges that can undermine reliability, which is detrimental in high-throughput environments such as Solana. Issues ranging from random disconnects to inadequate filtering have historically compelled developers to dedicate significant time and effort to custom mitigations, often at the expense of core product innovation.

At Helius, we’ve long recognized these pain points. In the past, we introduced Enhanced WebSockets, a faster and more customizable option for streaming transaction and account updates. Yet, as our infrastructure evolved, it became clear that even these enhancements still fall short of the resilience and performance possible with Helius.

We’re excited to announce that Enhanced WebSockets are now powered by the same infrastructure that powers LaserStream, our next-gen gRPC streaming service built for speed, simplicity, and fault-tolerance. 

This integration provides gRPC-level reliability to WebSocket streams in a JSON-native format, eliminates fragile connections, and enables frontend developers to focus on delivering the best UX possible.

The Challenges of WebSockets and Real-time Applications

WebSockets promise persistent, bidirectional magic—a single connection for push notifications in place of continually polling HTTP endpoints. While this sounds nice, WebSockets aren’t without issues:

1. Connection Fragility and Heavy Load

WebSockets maintain stateful, long-lived TCP connections. This makes them susceptible to interruptions due to network blips, proxy timeouts, or overloaded servers. 

Solana’s 400ms slot times and bursty traffic amplify WebSocket vulnerabilities. Thus, developers are forced to implement custom reconnection logic, such as exponential backoffs and heartbeat pings, to maintain uptime.

2. Data Flooding

WebSocket subscriptions often return too much data.

Native subscriptions, such as accountSubscribe, deliver unfiltered streams, overwhelming developers with noise. This forces developers to filter on the client side, which can increase bandwidth usage and introduce processing delays.

3. Scalability and Resource Overhead

Handling thousands of concurrent connections strains server resources, leading to memory leaks, CPU bottlenecks, increased load balancer complexity, and the need for sharding connections to manage load.

Scaling WebSockets horizontally is notoriously difficult, and not something most teams have the time, resources, or expertise to perfect. 

4. Developer Time Siphoned from Product Innovation

Collectively, these challenges take away cycles from building new, differentiated features and applications. This inefficiency is a hidden tax on progress in Solana’s fast-moving landscape.

These persistent challenges render standard Solana WebSockets inadequate for production-grade applications, where even the most brief disruptions can mean missed opportunities or stale UIs.

Next-Generation Enhanced WebSockets

We introduced Enhanced WebSockets—a Geyser-enhanced version of Solana’s standard WebSockets for better account and transaction subscriptions—to address these gaps. 

It introduced powerful filters (e.g., up to 50,000 addresses via accountInclude, accountExclude, and accountRequired) and faster response times than traditional WebSockets. However, our data streaming infrastructure has improved since its original launch.

Enhanced WebSockets are now powered by the same infrastructure as LaserStream—our next-generation gRPC streaming service, built for speed, reliability, and simplicity.

Now, experience gRPC reliability in a WebSocket wrapper.

Key enhancements include:

Best-in-Class Resilience

Enhanced WebSockets now stream from multiple aggregated nodes simultaneously with automatic failovers, increasing resilience by removing any single points of failure and ensuring maximum uptime.

High Performance

LaserStream is purpose-built for ultra-low-latency data streaming, and now, Enhanced WebSockets will benefit from our latest improvements for the fastest notifications possible.

Frontend-Optimized Streams

The JSON payloads of Enhanced WebSockets, backed by upgraded infrastructure, empower frontend developers to integrate high-fidelity streams directly into browsers, React apps, and mobile clients.

Choosing the Right Streaming Solution: A Comparison

At Helius, we have different data streaming services built for specific use cases, which we’ve outlined below. 

Enhanced WebSockets

Developers should use Enhanced WebSockets when:

1. Latency, continuity, and correctness do not affect PnL, fills, or risk
2. When you want JSON payloads
3. Your focus is on consumer UX without backend complexity

LaserStream

Developers should use LaserStream when:

1. Every millisecond matters
2. Latency, continuity, and correctness affect PnL, fills, and/or risk
3. You need more advanced filtering capabilities
4. You need gapless delivery with automatic replay
5. You need to receive transactions at various commitment levels

Shred Delivery

Developers should use Shred Delivery when:

1. You need raw signals
2. Have, or can build out, a custom deshredding pipeline

In summary:

• Use Enhanced Websockets for frontend-friendly, non-critical streams.
• Use LaserStream for backend decision loops where latency gaps or data continuity directly impact opportunities.
• Use Shred Delivery when you’re using a custom deshredding pipeline for the earliest signals from raw shreds.

Enhanced WebSockets Quickstart

Getting started with Enhanced WebSockets is straightforward. 

To start, sign up and get an API key in the “API Keys” section.

Simply connect to one of our endpoints, subscribe via transactionSubscribe or accountSubscribe, and start receiving filtered, resilient streams. 

Endpoints

• Mainnet: wss://atlas-mainnet.helius-rpc.com/?api-key=<YOUR_API_KEY>
• Devnet: wss://atlas-devnet.helius-rpc.com/?api-key=<YOUR_API_KEY>

Example: Monitor New Raydium Launchpad Pools

The following Node.js script is a straightforward example of how to use Enhanced WebSockets in a production setting to subscribe to Raydium’s Launchpad program using transactionSubscribe to filter for successful pool initializations via log parsing:

import WebSocket from 'ws';

const API_KEY = process.env.HELIUS_API_KEY; // Set your API key as an env var
const WS_URL = `wss://atlas-mainnet.helius-rpc.com/?api-key=${API_KEY}`;
const 
RAYDIUM_LAUNCHPAD_PROG
= '
LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj
';

const ws = new WebSocket(WS_URL);

ws.on('open', () => {
  console.log('Connected to LaserStream-Powered Enhanced WebSockets!');
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'transactionSubscribe',
    params: [
      { 
        failed: false, 
        accountInclude: [
RAYDIUM_LAUNCHPAD_PROG
]
      },
      {
        commitment: 'confirmed',         
        encoding: 'jsonParsed',            
        transactionDetails: 'full',        
        maxSupportedTransactionVersion: 0 
      }
    ]
  }));

  // Optional heartbeat ping
  setInterval(() => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method: 'ping' }));
    }
  }, 30000);
});

ws.on('message', (data) => {
  try {
    const payload = JSON.parse(data.toString());
    const result = payload.params?.result;
    if (!result) return;

    // Filter for init logs
    const logs = result.transaction.meta.logMessages || [];
    if (!logs.some(log => log.includes('Instruction: Initialize'))) return;

    
 const keys = result.transaction.transaction.message.accountKeys.map(k => k.pubkey);
    console.table({
      Signature: result.signature,
      Creator: keys[1],  // From IDL: accounts[1] is creator
      BaseMint: keys[7], // From IDL: base_mint is around index 7 in initialize accounts
      Slot: result.slot
    });

  } catch (err) {
    console.error('Message parse error:', err);
  }
});

ws.on('error', (err) => console.error('WebSocket error:', err));
ws.on('close', () => {
  console.log('Disconnected');
});

Run the code above with:

export HELIUS_API_KEY=your-api-key-here
node raydium-launchpad-stream.js

The following script will stream a table of newly launched pools to the console, ensuring gapless delivery, even under high load.

Pricing and Metering

As part of our continued investment in latency and reliability, starting October 16th, 2025, new plans meter Enhanced WebSockets at the same rate as LaserStream (i.e., 3 credits per 0.1 MB of streamed data).

Professional plans can purchase additional data at a fixed rate, which can be used for data streaming needs either for Enhanced WebSockets or LaserStream.

If you’re on an existing plan, your pricing, limits, and billing stay exactly the same. No action required. 

Standard WebSockets are unchanged and are available to both free and paid plans.

Elevate Your Streams Today

Reliability, performance, and simplicity—your streams are ready to scale with you. Start building with Enhanced WebSockets today. Sign up, grab an API key, and experience reliability on your frontends.

Stream smarter, innovate faster.