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
| Feature | Apinator | Pusher |
|---|---|---|
| Pricing model | Free | Fixed monthly plan tiers |
| Free-tier connections | 500 | 100 |
| Free-tier messages / day | 500,000 | 200,000 |
| Paid plans | None | $49–$1,199/mo, custom above |
| Private channels | ||
| Presence channels | ||
| Client events | ||
| Cache channels | ||
| Webhooks | Occupancy + presence events | |
| Multi-region | 9 clusters, one per app | |
| EU data residency | EU 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.
// 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.
| Plan | Price / month | Messages / day | Concurrent connections |
|---|---|---|---|
| Pusher Sandbox | $0 | 200,000 | 100 |
| Pusher Startup | $49 | 1 million | 500 |
| Pusher Growth Plus | $1,199 | 90 million | 30,000 |
| Apinator | $0 | 500,000 | 500 |
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.
// 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.
// 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
Related
From the blog
Next.js WebSockets (2026): Does Vercel Support Them? 4 Ways That Work
Vercel Functions and Route Handlers can't hold a WebSocket open. The 4 setups that work with the App Router and Pages Router, with full code for each.
WebSockets vs HTTP Polling
Polling gets the job done until it doesn't. Here's an honest comparison of WebSockets and HTTP polling — latency, server load, complexity, and when to use each.
How to Add Realtime to a Laravel App
Add WebSocket-powered realtime features to your Laravel application — publishing events from controllers and subscribing from the frontend with a few lines of code.
How to Build Slack with WebSockets
Slack's realtime features — channel messages, typing indicators, online presence, and notifications — can all be built with WebSockets. Here's how the architecture works.
How to Build Realtime Chat in Node.js
A step-by-step guide to building a working realtime chat app with Node.js and Apinator — from server setup to client subscription in under 50 lines of code.
Ready to get started?
Completely free, no credit card required. Deploy in minutes.