Push events the moment they happen.
A free, hosted WebSocket layer for realtime apps — channels, presence, and webhooks on a generous free tier.
forever / free tier / no card / no catch
Channels with opinions.
Public, private, and presence channels with built-in authorization. The same primitive powers chat, dashboards, live carts, multiplayer lobbies — without you inventing a session machinery.
Open to anyone with the app key. Good for room lists, status, public feeds.
Know who's in the room.
Track members joining and leaving in realtime. The roster updates without you reaching for a session store, a Redis hash, or a cron job. Multi-tab is handled.
A POP near every socket.
Clients connect to the closest available node. Cross-region fan-out is handled by Redis Pub/Sub behind the scenes — your code publishes once, every region delivers.
One cluster string at the client. The router picks the right
socket. Add a region next month, your code doesn't change.
Lossy networks stop mattering.
Exponential backoff, state restoration, replay of queued messages. The kind of code you'd write twice and still get subtly wrong — already written, already in the SDK.
Server-side side-effects, signed.
Get notified when channels are occupied or vacated, when members join or leave, or when a client emits an event. HMAC-signed, retried, delivered at-least-once.
Drop-in for the protocol you already use.
Built on a Pusher-compatible client protocol — the same channels, events, and auth flow you already know. Swap the import, keep the rest of your code. Migrate when you want to, not when a billing email says so.
new Pusher('app_key', { cluster: 'mt1', forceTLS: true })
new Apinator('app_key', { cluster: 'eu', forceTLS: true })
Same constructor signature. Same event names. Same auth flow. Two lines of imports change; the rest of your code does not.
Three steps to live.
One install, one subscribe, one trigger. No servers to provision, no load balancers to tune, no Redis to babysit. Open the docs and you're shipping in five minutes.
Add the SDK
for your language.
Available on npm, pip, go get, Composer, Swift Package Manager and Gradle. One dependency, no config files.
// install npm install @apinator/client
Connect from the
client.
Open a connection and subscribe to channels. Public, private, or presence — all share the same API surface.
const ch = client .connect() .subscribe('chat-room') ch.bind('message', fn)
Publish from your
server.
Trigger events from any backend. Your server publishes — all subscribed clients receive instantly.
await realtime.trigger( 'chat-room', 'message', { text: 'hello' } )
Works everywhere
you do.
First-class SDKs in seven languages. Identical mental model on the client and the server. The example shifts to your stack — pick a row.
npm install @apinator/clientimport { Apinator } from '@apinator/client'
const client = new Apinator({
appKey: 'your-app-key',
cluster: 'us'
})
const channel = client.connect().subscribe('chat-room')
channel.bind('message', (data) => {
console.log('New message:', data)
})Why not run your
own?
Running WebSockets at scale is not "open a socket." Sticky sessions, Redis fan-out, file descriptor ceilings, connection draining on every deploy — the work compounds. So does the bill from commercial alternatives.
Pusher and Ably meter messages and connections and bill you by usage — we don't. Rolling your own takes days–weeks and a Redis you'll have to babysit on every deploy.
We're not mad about any of it — we're just shipping. One protocol-compatible endpoint, multi-region by default, open-source SDKs on GitHub, free forever.
- Sticky sessions, fan-out, multi-region
- Managed · default · zero config
- Open-source SDKs
- MIT-licensed · your client code stays portable
- Vendor lock-in
- None · leave any time · we don't have your data
You build features.
We keep the line open.
Multi-region deployment, automatic failover, cross-node fan-out and connection recovery — running quietly in the background while your team ships product. Here's the shape of it.
One tier.
Generous limits.
No paid plan hiding above it, no credit card, no upsells. A single free tier with limits big enough for almost any realtime app you can build.
- Concurrent connections
- 500
- Messages / day
- 500K
- Channels
- 100
- Presence members / channel
- 500
- Client events / second
- 500
- Max message size
- 256 KB
Public, private & presence channels, webhooks, multi-region, and HMAC auth are all included — not gated behind a tier. Need more headroom? Open an issue and tell us what you're building.
Reasonable
questions.
Quick answers to the things people ask before they pull the SDK. Anything missing? The docs go much deeper, or open an issue on GitHub.
WebSocket infrastructure manages the servers, scaling, and failover needed to run persistent WebSocket connections at scale — so you only write your app logic, not the plumbing.
Apinator is API-compatible with Pusher's client protocol and completely free, with open-source SDKs. You get channels, presence, and webhooks without per-message pricing.
Yes. Apinator is a free managed service maintained as a community project, with no paywalls, no upsells, and no credit card requirement.
SDKs for JavaScript, Node.js, Python, Go, PHP, and Swift. Kotlin support is coming. Framework guides for Next.js, React, Vue, SvelteKit, Laravel, and more.
Apinator uses Redis Pub/Sub fan-out across nodes, so any node can receive a publish and deliver it to all connected clients regardless of which server they're on.
The client and server SDKs are open source and MIT-licensed. The server that powers the managed service is proprietary — you use Apinator as a free hosted service rather than self-hosting it.
The free tier includes 500 concurrent connections, 500,000 messages per day, 100 channels, 500 presence members per channel, 500 client events per second, and a 256 KB maximum message size. Private and presence channels, webhooks, multi-region, and HMAC auth are all included.
Ship realtime,
start now.
Sign up takes about thirty seconds and you'll be sending your first event in under five minutes.