Pusher, Soketi or Thunderclap? Choosing a realtime backend in 2026

Prices and project status checked on 1 November 2026.

If you're adding live updates to a product (chat, notifications, dashboards, presence, a live score), you'll end up choosing between three shapes of the same idea: channels you publish to from your backend, and clients that subscribe over a WebSocket. Pusher made that model popular. Soketi made it self-hostable. Thunderclap rebuilds it to scale on its own and cost nothing while it's quiet.

This article compares the three the way you'd evaluate them for a real product: how they're built, what they cost for typical workloads, how they scale, and where each one is the better choice. Including where it isn't us.

The short version

If you remember one thing: Pusher bills you for each delivery, Thunderclap bills you for each message you publish. One message to a 30-person room is 31 messages on Pusher and 1 on Thunderclap. The more your messages fan out, the wider the gap.

Three ways to build the same thing

Pusher: a managed cluster in one region

You create an app in a cluster (mt1, eu, ap1…), and every client and your backend talk to that region. It's simple and it's been reliable for over a decade. The trade-off is geography: a user in Sydney connected to a US app crosses the Pacific for every frame, and serving several regions means several apps, with your backend publishing to each.

Soketi: your own cluster, glued together with pub/sub

Soketi is an open-source server that speaks Pusher's protocol, so Pusher's client and server libraries work against it unchanged. A single node is fast: it's built on uWebSockets.js. To run several, nodes share messages through Redis or NATS, and that's where its scaling model shows:

• Every node receives every message. A publish goes to one shared pub/sub topic; each node decodes it and delivers to its own subscribers, if it has any. Adding nodes adds connection capacity, but not publish capacity: every node still processes the whole cluster's stream.
• Cluster-wide questions are asked of every node. How many people are in this channel? Who's in this presence room? Each answer means a request to all nodes, waiting for the slowest (up to a 5-second timeout). Joining a presence channel runs one of these.
• You run it. Load balancer, Redis, autoscaling, TLS, monitoring, upgrades, multi-region if you need it.

It's also worth knowing where the project stands: the last release, 1.6.1, is from March 2024, and it depends on a 2022 version of uWebSockets.js, so running it on a current Node.js may mean rebuilding it yourself.

Thunderclap: an actor mesh at the edge

Thunderclap is a managed service built from two kinds of small, stateful actors, running in edge locations around the world:

• Shards hold your users' WebSockets, a few thousand each, in the location nearest to them. A shard exists the moment it's first used and costs nothing before that. When its sockets are quiet, it sleeps, and their keepalives are answered without waking it.
• Channels are one actor each. A channel doesn't know about individual sockets, only which shards have subscribers. It assigns every event a sequence number and sends it once to each of those shards, which deliver it locally.

Three consequences matter to you as a user:

1. A message only travels where it's needed. Unlike a pub/sub cluster, a shard with no subscribers to a channel never sees its messages, so publish capacity grows with the number of channels instead of being capped by one node.
2. Big rooms don't create big storms. If 100,000 people join one channel, the channel hears from the shards they land on (dozens, not 100,000). Shards absorb the subscribe storm.
3. Clients know what they missed. Because one actor orders each channel, every event carries a sequence number. After a network drop, thunderclapJS tells you exactly which range to fetch from your own database:

room.onGap((gap) => {
  if (gap.reset) reloadRecentHistory();
  else fetchMissed({ from: gap.from, to: gap.to });
});

Neither Pusher nor Soketi can do this: a reconnecting client simply doesn't know whether it missed anything.

What it costs

Two different ways of counting

At the two prices both sell a plan at, the difference in connections is more than tenfold:

Pusher's published tiers go from Sandbox (free, 100 connections) to Growth Plus ($1,199: 30,000 connections, 90M messages a day), then Enterprise. Thunderclap's go from Spark (free, 200 connections, 2M messages) to Business ($499: 150,000 connections, 120M messages), then Enterprise, and paid plans are never capped.

Soketi is free software, so its cost is infrastructure plus the people who run it. A minimal highly available setup (two nodes, Redis, a load balancer) is roughly $20–40 a month on budget cloud providers. The people cost is the bigger number: even a tenth of an engineer's time spent on upgrades, scaling and on-call is worth far more than any plan in the examples below.

Three real workloads

Monthly bills, 30 days, at list prices. For each one we picked the cheapest Pusher tier and the cheapest Thunderclap plan (plus overage) that fit.

Notifications: one recipient per message. 2,000 peak connections, each user getting a notification every 5 minutes on their own private channel. That's 17.3M messages published a month.

• Pusher counts each one twice (publish + delivery): 1.15M a day, which needs Pro, $99.
• Thunderclap: Starter plus 9.3M messages of overage, $66.

Team chat: 30-person rooms. 10,000 peak connections, each user receiving one message a minute. 14.4M messages published, 432M deliveries.

• Pusher counts 14.9M a day: Premium, $499.
• Thunderclap: Starter plus 5,000 connections and 6.4M messages of overage, $65.

Live broadcast: one channel, many viewers. 50,000 viewers around the clock, one update a second. 2.6M messages published, 130 billion deliveries.

• Pusher: past every public tier on connections alone, and about 4.3 billion counted messages a day. Enterprise.
• Thunderclap: Starter plus 45,000 connections of overage, $119. The messages fit in the plan: 2.6M publishes are 2.6M messages, however many people watch.

The pattern: the more your messages fan out, the more you save against Pusher, from about 1.5× with one recipient per message to 7–8× for rooms, and a public price instead of a sales call for broadcasts. Against Soketi, Thunderclap costs more in raw infrastructure once traffic is steady, and less once you count the time it takes to run Soketi well.

How they scale

Our capacity numbers, how we measured them and what they imply for your workload are in a companion article: How far does Thunderclap scale?

Features side by side

Choosing

Pick Pusher if

• you need native iOS or Android SDKs, or Pusher's push-notification product, today;
• you want a vendor with a long track record and an enterprise sales relationship;
• your traffic is small and one-to-one, where counting deliveries costs you little.

Pick Soketi if

• your team already runs infrastructure and your traffic is steady and predictable: raw server cost is the lowest of the three;
• you need to run on your own premises or in a specific jurisdiction, which a managed service can't offer;
• you need the lowest possible latency within one region: one process, no hops;
• you send very high rates of tiny messages with almost no fan-out (game ticks, telemetry at tens of thousands of messages a second). Per-message pricing isn't designed for that, and a VM running flat out is cheaper;
• you're comfortable with a project that hasn't shipped a release since March 2024.

Pick Thunderclap if

• your traffic is spiky, growing or unknown, and you don't want to size anything: it goes from zero to large and back to nearly free on its own;
• your messages fan out, to rooms, teams, dashboards, live audiences: you pay once per message, not per recipient;
• your users are spread around the world: they connect to the nearest edge location, not to one region;
• clients must not silently miss events: sequence numbers and gaps tell you exactly what to backfill;
• you want generous connection counts on a managed service: 5,000 for $29, 25,000 for $99.

What we're honest about

• Latency is good, not the lowest. A publish crosses the edge, the channel and the shard: in our tests the median from your backend's request to the client's screen was 55–74 ms, with a longer tail. A single Soketi process next to your users will beat that; for chat, notifications and live dashboards nobody will notice.
• Connections get recycled. Edge networks restart servers, and a WebSocket on any of them lives hours, not weeks. thunderclapJS reconnects with jitter and reports any gap, so your app stays correct, but you should treat reconnects as routine.
• SDKs are JavaScript-first. Server libraries for PHP, Python, Ruby and Go are where we're heading next.

Switching

From Pusher or Soketi, the first step is a configuration change: Thunderclap understands Pusher's protocol and REST API, so your existing client and server libraries work by changing the host. Then you move to thunderclapJS and @thunderclapjs/server at your own pace, page by page if you like, because clients on both share the same channels. The migration guide walks through both steps.

Starting fresh, it's two packages:

import { Thunderclap } from "@thunderclapjs/client";

const thunderclap = new Thunderclap({ key: process.env.NEXT_PUBLIC_THUNDERCLAP_KEY });
thunderclap.subscribe("room-42").bind("message", (data, meta) => show(data, meta.seq));

import { ThunderclapServer } from "@thunderclapjs/server";

const thunderclap = new ThunderclapServer({
  appId: process.env.THUNDERCLAP_APP_ID,
  secret: process.env.THUNDERCLAP_SECRET,
});
await thunderclap.publish({ channel: "room-42", data: { text: "Hello!" } });

The free plan, Spark, includes 200 connections and 2 million messages a month, with no card. The quickstart gets you to a first event in a few minutes.

Pusher's prices are from pusher.com/channels/pricing and Soketi's status from its GitHub repository, both read on 1 November 2026. Self-hosting costs are approximate. Thunderclap's figures come from our own load tests, described in How far does Thunderclap scale?