When something changes, everyone sees it.

PushCaster is managed realtime infrastructure for applications. Publish an update once and every connected browser, phone and dashboard has it in the same moment — no polling, no refresh button, and no connection servers for you to run.

Start building Read the docs

browser

phone

dashboard

Two calls, and it is live

One line in the browser to listen, one on your server to send. No SDK of ours to learn — the libraries below are the ones you already use, pointed at PushCaster.

In the browser — listen for the event

client.js

import Pusher from 'pusher-js'// The same library you already use. One host override points it at PushCaster.const pusher = new Pusher('APP_KEY', {  wsHost: 'ws-eu1.pushcaster.io',  wsPort: 443,  forceTLS: true,})const channel = pusher.subscribe('presence-room')channel.bind('message', (data) => {  render(data.body)})

On your server — send it

server.js

import Pusher from 'pusher'const pusher = new Pusher({  appId: 'APP_ID',  key: 'APP_KEY',  secret: 'APP_SECRET',  host: 'api-eu1.pushcaster.io',  useTLS: true,})await pusher.trigger('presence-room', 'message', {  body: 'Deployed to production',})

Your app id, key and secret come from the dashboard; the cluster you pick is part of the host.

What you get to build with

A realtime feature is a little product code on a lot of delivery machinery: who is subscribed, who is allowed, who is still there. This is that second part, already running.

Four kinds of channel

Public, private, presence, and private-encrypted when the payload should be opaque to us as well.

Publish once, reach everyone

One call from your server reaches every subscriber, without your code tracking who is listening.

Presence as a channel

Who is in the room is answered by the channel, not by a store you keep in sync.

Client events

Typing indicators and cursors travel between subscribers directly, rate-limited, with no round trip through you.

Webhooks on lifecycle

Occupancy and membership are posted back to you with signed headers, so your backend can react to what the connection sees.

You choose where it runs

An application is created in a cluster and its connections terminate there. The current list is on the status page.

Where your messages actually go

Delivery and billing run on separate tiers. A control-plane outage degrades the dashboard; it does not interrupt delivery.

Clusters are highly available for messaging and not for presence. If a presence store is lost, presence and occupancy degrade while public and private channels keep delivering — better read here than discovered later.

The same thing, wearing different clothes

Chat, dashboards, notifications, shared documents. Under each is one idea: something changed, and everyone watching should know.

presence-room-42

presence

Chat and collaboration

Presence tracks who is in the room; client events carry typing and cursors. Messages land the moment they are published.

private-metrics

private

Live dashboards

Push metrics and order flow to every open dashboard as they change — no polling interval to tune, no window where the number is already wrong.

private-user-1e9

private

Notifications

One server-side event reaches every device a user has open, in the same round trip that triggered it.

presence-game

presence

Multiplayer and live state

Shared state with presence-tracked membership — canvases, live scores, anything where two people must see the same thing.

All use cases

Already using Pusher
Channels libraries?

Existing clients connect with a small configuration change — the same protocol on the wire, the same library, a different host. Three to six lines per application — no application rewrite, only connection configuration changes.

Credentials do not carry over, and there are a few genuine differences worth reading first. Both are listed in full on the comparison page.

Compatibility and migration in detail

src/realtime.tsunified diff

  const pusher = new Pusher(APP_KEY, {
-   cluster: 'eu',
+   wsHost: 'ws-eu1.pushcaster.io',
+   wsPort: 443,
+   forceTLS: true,
  })

Pay-as-you-go against a prepaid wallet

One rate card. No plans, no tiers, no seats, no monthly commitment — you pay for what you send, hold open and transfer.

Rate card

USD · effective Sep 1, 2026

Messages published
$0.1per million messages
Messages delivered
$0.1per million messages
Connection time
$0.2per million connection-minutes
Connection milliseconds
$0.2per million connection-minutes

Published live from the pricing API. Allowances are inclusions inside the one rate card, not a free plan.

How billing works

Published state, not a promise

Read live from the platform. We publish component and per-region state and a full incident history — and no uptime figure we cannot substantiate.

Documentation
Channel types, authentication, webhooks and the full error-code reference.
Status page
Component and per-region state, latency, and the incident history.
Support
Open a ticket from your account. Engineering questions reach people who work on it.

Platform status

All systems operational

WebSocket service
Client connections, subscriptions and event delivery.
All systems operational
Publish API
Publishing events from your servers to PushCaster.
All systems operational
Dashboard
Signing in and managing your applications.
All systems operational
Control plane
Application configuration, billing and account management.
All systems operational

eu1 · Europe West
eu2 · Europe Central

$ export PUSHER_HOST=ws-eu1.pushcaster.io

Change a host.
Keep your code.

Same protocol, same SDKs, same auth handshake. Create an app, point the libraries you already ship at PushCaster, and your realtime features are live in minutes.