Pusher-Style Channels

The Free, Pusher-Style Realtime API

A Pusher-style alternative — free to use, no plan tiers to outgrow.

Apinator follows Pusher's channel model — keep your channel names, your auth flow, and your event design; swap the SDKs. And it is free to use: no monthly plan, no connection tiers, no upgrade to buy when traffic spikes. Migrate in minutes.

Pusher-Style Channel Model

Same channel types, auth signature format, and event model as Pusher. Swap the SDKs — the concepts map 1:1.

No Plan Tiers

Pusher sells monthly plans capped on daily messages and concurrent connections, from $49 to $1,199 a month. Apinator is free to use, with no metered fees, no peak-connection overage, and no surprise invoices when traffic spikes.

Free Tier Built for Production

Presence, private channels, client events, and multi-region are included — not gated behind a paid plan. No credit card required.

Multi-Region (EU + US)

Choose the region for your app — EU or US — so connections stay close to your users and sensitive data stays in its jurisdiction.

The Core Pusher Feature Set

Public, private, presence, and cache channels. Client events. HMAC auth. Signed webhooks for channel occupancy and presence. The core Pusher primitives, without the monthly plan. Encrypted channels are not offered.

Straightforward Migration

Replace pusher-js with @apinator/client and update the constructor; channel names, event names, and bind() handlers map across. Most teams migrate in under 30 minutes.

Apinator vs Pusher

FeatureApinatorPusher
Pricing modelFreeFixed monthly plan tiers
Free-tier connections500100
Free-tier messages / day500,000200,000
Paid plansNone$49–$1,199/mo, custom above
Private channels
Presence channels
Client events
Cache channels
WebhooksOccupancy + presence events
Multi-region9 clusters, one per app
EU data residencyEU cluster (Ireland)

Client Migration

Replace pusher-js with @apinator/client — a different constructor and an explicit connect(), then subscribe() and bind() work the same way.

migration.js
// Before — pusher-js
import Pusher from 'pusher-js'
const pusher = new Pusher('APP_KEY', { cluster: 'us2' })
const ch = pusher.subscribe('orders')
ch.bind('update', (data) => renderOrder(data))

// After — @apinator/client (same channel model, fully managed)
import { Apinator } from '@apinator/client'
const client = new Apinator({ appKey: 'APP_KEY', cluster: 'eu' })
const ch = client.connect().subscribe('orders')
ch.bind('update', (data) => renderOrder(data))

Pusher Pricing in 2026 (and What Apinator Costs)

Pusher's plan tiers next to Apinator's free tier, and where the cost difference actually comes from.

PlanPrice / monthMessages / dayConcurrent connections
Pusher Sandbox$0200,000100
Pusher Startup$491 million500
Pusher Growth Plus$1,19990 million30,000
Apinator$0500,000500

Pusher Channels' free, first paid and largest listed plans. The tiers in between step up in price and limits.

Pusher sells fixed monthly plans, each capped on messages per day and concurrent connections. The free Sandbox allows 200,000 messages a day and 100 connections; paid plans run from $49/month (Startup: 1 million messages a day, 500 connections) to $1,199/month (Growth Plus: 90 million a day, 30,000 connections), with custom plans above that. Messages count in both directions — one event published to 50 subscribers is 51 messages — so a busy channel uses up a cap quickly. Outgrow a tier — a product launch, a viral moment, a seasonal spike — and you move up to the next plan.

Apinator has no tiers to climb. The platform is free to use, with no per-message overage and no peak-connection charge. The current free tier covers 500 concurrent connections, 500,000 messages per day, 100 channels, and presence tracking up to 500 members per channel. Presence, private channels, client events, and EU/US regions are all included — so the same workload that moves you up Pusher's plans leaves your Apinator bill at zero.

If you just need an endpoint to point a client at, the free WebSocket server overview covers the basics. If region and data residency matter, see managed WebSocket infrastructure, and the how WebSockets scale guide explains what runs underneath.

Step-by-Step Migration from Pusher

Most teams move over in under 30 minutes. The client swap above is step one — here is the server side and channel auth.

1. Point your server SDK at Apinator

Server-side publishing maps directly onto Pusher's. Apinator takes a single options object — trigger({ name, channel, data }) — and data is a JSON string. The channel names, event names, and payloads stay identical.

publish.js
// Before — pusher (server SDK)
import Pusher from 'pusher'
const pusher = new Pusher({ appId, key, secret, cluster: 'us2' })
await pusher.trigger('orders', 'update', { id: 1042 })

// After — @apinator/server
import { Apinator } from '@apinator/server'
const apinator = new Apinator({ appId, key, secret, cluster })
await apinator.trigger({ name: 'update', channel: 'orders', data: JSON.stringify({ id: 1042 }) })

2. Update the private & presence channel auth endpoint

Private and presence channels authorize through an HMAC-signed endpoint on your backend — the same scheme Pusher uses. Swap the helper; the request fields and response shape are the same. One difference: pusher-js posts the auth request form-encoded, while @apinator/client sends JSON by default, so either parse a JSON body on your endpoint or set authEncoding: 'form' on the client.

auth.js
// Before — pusher.authorizeChannel
app.post('/auth', (req, res) => {
  const auth = pusher.authorizeChannel(req.body.socket_id, req.body.channel_name)
  res.send(auth)
})

// After — apinator.authenticateChannel (same HMAC scheme)
app.post('/auth', (req, res) => {
  const auth = apinator.authenticateChannel(req.body.socket_id, req.body.channel_name)
  res.send(auth)
})

3. Set the cluster and deploy

Choose your region (EU or US) when you create the app, set cluster to it in the client — the SDK derives the ws-{cluster}.apinator.io host — and deploy. Channel names and event bindings carry over; presence code moves to getMembers() and memberCount. There is no data to migrate because realtime events are transient.

When to Choose Pusher vs. Apinator

An honest read. Both are hosted realtime platforms with the same core primitives; the decision usually comes down to billing model and ecosystem maturity.

Stick with Pusher when

  • You depend on a Pusher-specific add-on or dashboard integration that has no Apinator equivalent yet.
  • Your organization already has procurement, SLAs, and support contracts in place with Pusher and switching cost outweighs the savings.
  • You need a region Apinator does not currently offer (today Apinator runs EU and US data planes; Pusher has nine clusters, from Ohio to Sydney).

Switch to Apinator when

  • Your traffic is pushing you up Pusher's plan tiers and you want a predictable $0 instead of a $49–$1,199 monthly plan.
  • You have outgrown Pusher's free Sandbox (100 connections, 200,000 messages a day) — Apinator's free tier gives you 500 connections and 500,000 messages a day at no cost.
  • You want a short migration path: keep your channel and event names, swap the client and server SDKs — see the migration steps above.

Frequently Asked Questions

Ready to get started?

Completely free, no credit card required. Deploy in minutes.