EmitWave is the infrastructure layer for realtime: one WebSocket for channels and presence, HMAC-signed publishing, and per-application tenant isolation — behind one protocol and every SDK.
await emitwave.trigger(
"private-company.123",
"invoice.paid",
{
invoice_id: "INV-2026-0042",
amount: 250000,
currency: "USD"
}
)Most teams start by hand-rolling socket servers, presence tracking, auth, and fan-out. EmitWave gives you all of it as managed infrastructure — one protocol to subscribe, authorize, publish, and scale.
Subscribe the browser to public, private, cache, and encrypted channels over a single connection.
Private channels run your own authorization rules; encrypted channels get a per-channel key.
Track who is online with a live member set, join/leave events, and server-signed identity.
Publish from a trusted server with HMAC-signed requests through typed Node, Go, PHP, and Laravel SDKs.
Your server calls trigger(channel, event, data) with a server SDK, which HMAC-signs the request.
EmitWave verifies the signature, rate-limits, and validates the payload before accepting the event.
The channel name is scoped to your application so tenants never share a channel.
The event is pushed to every subscriber bound to that channel over their WebSocket.
Every publish surfaces in the live console and in your delivery metrics.
A signed entry point that accepts HMAC-signed publishes, verifies them, and fans them out to subscribers.
Owns your organizations, applications, and credentials, and authorizes every realtime connection.
Low-latency WebSocket streams for dashboards, chat, collaboration, and live workflows.
A live member set with join and leave events, backed by server-signed member identity.
End-to-end encrypted channels where only authorized subscribers hold the decryption key.
A live debug console plus connection, channel, and delivery metrics in your dashboard.
EmitWave is designed for teams that want a clean API, reliable SDKs, predictable payloads, helpful logs, and simple debugging tools.
import { Client } from "@emitwave/node"
const emitwave = new Client({
appId: process.env.EMITWAVE_APP_ID,
key: process.env.EMITWAVE_KEY,
secret: process.env.EMITWAVE_SECRET,
// gatewayUrl defaults to https://api.emitwave.com
})
await emitwave.trigger("orders", "order.shipped", {
order_id: "ORD-9042",
tracking_number: "DHL-829103",
})A channel's prefix decides how it is authorized and delivered. private- requires authorization, presence- adds a member set, cache- replays the latest event, and private-encrypted- adds a per-channel key.
EmitWave is built for applications where users expect events to arrive instantly and reliably. Signed publishing, rate limiting, health checks, self-healing workers, and tenant isolation are built in.
Every publish is verified; unknown, revoked, or stale requests are rejected.
Publishing is rate-limited and payload-capped with stable error codes.
Queue and scheduler workers carry a restart policy and recover on their own.
Every service exposes health and readiness so orchestration can route safely.
Channels are scoped as namespace:app_id.canonical, so tenants never collide.
New subscribers can receive the latest retained event to rehydrate state.
Push wallet credits, transfer status, and balance changes to private per-user channels in realtime.
Live dashboards, collaborative editing with presence, mentions, and activity feeds.
Sync cursors, comments, and edits across everyone viewing the same document or board.
Stream order status, inventory, and buyer–seller chat as events the moment they change.
Broadcast driver location and delivery status to customers and operations as it happens.
Multiplayer state, live scores, presence, and announcements over low-latency channels.
Subscribe from the browser with the JS, React, Next.js, and Vue SDKs, publish from your backend with the Node, Python, PHP, Laravel, Go, Ruby, Rust, and Java SDKs, or talk to the REST API and webhooks directly.
Skip running, scaling, and patching WebSocket servers, connection state, and fan-out.
Get connection tokens, channel authorization, and presence identity as managed primitives.
Channels are scoped per application automatically, so tenants never share a stream.
Watch publishes in a live console and track connection and delivery metrics in your dashboard.
EmitWave gives your application a managed WebSocket for channels and presence, HMAC-signed publishing, and typed client and server SDKs.