ApexStream logoApexStream

ApexStream

Product

ApexStream realtime infrastructure: WebSocket gateway, control plane, and dashboard for chat, live dashboards, and notifications.

One stack for connections, channels, and operations — run in ApexStream Cloud or on your own infrastructure without changing client code or event semantics.

What problems we solve

Realtime is easy to demo — hard to run in production

Building realtime features sounds simple — until you hit production.

  • Connections drop and users miss updates
  • Messages get lost without proper delivery guarantees
  • Scaling WebSockets across nodes becomes complex
  • Debugging realtime issues is painful without visibility
  • Pricing from Firebase or Pusher grows unpredictably
  • You lose control over data and infrastructure when it matters

ApexStream solves this out of the box.

Run on our cloud or your own infrastructure — with reliable delivery, replay, and full operational control built in.

At a glance

Three reasons teams choose ApexStream

Ship realtime features faster

01

Launch chat, dashboards, notifications, and live updates without stitching together multiple third-party services or building infrastructure from scratch.

Cloud or self-hosted, same experience

02

One consistent model for organizations, projects, applications, and API keys — whether you run in our cloud or your own cluster.

Scale the gateway, not your codebase

03

Start with a single node and grow to distributed gateways without rewriting clients or changing your architecture.

Use cases

Same transport — outcomes that matter

The hands-on cloud flow is in See it in action below — dashboard, SDK, and wss://api.apexstream.org.

Realtime chat

Production-ready chat in minutes with rooms, presence, and delivery semantics — without owning an entire messaging stack.

Notifications

Deliver instant alerts to users without bolting complex backend logic onto your core API.

Collaboration

Sync user state, cursors, and actions for co-editing, ops dashboards, and multiplayer-light UX.

From client connection to operations

One product story: gateway, control plane, and dashboard

ApexStream for you

Operate live systems without custom admin tooling

Status pages, gateway metrics, and External API controls live in one dashboard so teams can debug and operate realtime services from a shared view.

  • Control-plane inventory: organizations, projects, applications, keys
  • Gateway workers and operational metrics from `/external/v1/metrics/...`
  • Health checks for API and WebSocket gateway from your Next.js server
deployment · self-hosted-prod
workers: 2 · open_connections: 42 · status: healthy
ApexStream platform

SDK primitives that match the real gateway

Install `apexstream`, set `VITE_APEXSTREAM_WS_URL` and `VITE_APEXSTREAM_API_KEY` in `client/.env` (same names as github.com/apexstream/examples), then `connect()`, `subscribe()`, `publish()`, and `disconnect()` — the same primitives you run against the gateway in the browser or Node.

import { ApexStreamClient } from "@apexstream/client";

const wsUrl = import.meta.env.VITE_APEXSTREAM_WS_URL!;
const apiKey = import.meta.env.VITE_APEXSTREAM_API_KEY!;

const client = new ApexStreamClient({
  url: wsUrl,
  apiKey,
  allowInsecureTransport: wsUrl.startsWith("ws://"),
});

client.connect();

const unsubscribe = client.subscribe("orders", (payload) => {
  console.log("orders event", payload);
});

client.publish("orders", { kind: "placed", id: "ord_123" });

unsubscribe();
client.disconnect();

Be careful with keys — store them only in secure, trusted places.

Built for production

Ship traffic you can operate — not a demo you hope will scale

ApexStream is designed for systems that are already in production, with visibility, control, and operational safety built in from day one.

  • Scale without client changes

    Add gateway replicas horizontally and optionally enable fan-out between nodes.

    Your client code and event model stay unchanged.

  • Same system in cloud or self-hosted

    Run in our managed cloud or deploy via Docker and Kubernetes using the same runtime components.

    No forked versions. No "enterprise edition" rewrite path.

  • Secure by default

    Secrets never leave your servers.

    Clients receive app-scoped keys or short-lived tokens depending on your security model.

  • Operational visibility built-in

    Monitor connections, throughput, and authentication failures through the same API surface used by the platform itself.

    Your on-call sees issues before users do.

Architecture (optional transparency)

WebSocket gateway with a centralized control plane and MongoDB-based metadata layer.

Optional NATS-based fan-out for multi-node deployments.