Managed WebSocket Infrastructure

Realtime infrastructure in minutes — not weeks.

Build chat, live dashboards, and notifications without managing WebSocket complexity.

Start building instantly with ApexStream Cloud.

Start free View examples

No credit card required
2-minute setup
Works locally and in production

Live · All systems operational

Active connections

1,593

+12.5% vs last 5m

Messages / min

8,742

+8.1% vs last 5m

P95 latency

42 ms

-9.3% vs last 5m

Delivery

99.98%

+0.02% vs last 5m

user:connectedmessage:senttyping:startpresence:update

WebSocket-first

Low latency, high throughput real-time communication.

Built for production

Scale horizontally with strong isolation and reliability.

Developer friendly

Small SDK, simple APIs, clear documentation.

Secure by default

TLS everywhere, key hygiene, and tenant isolation.

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.

Why now

Realtime is no longer a feature — it's a baseline expectation.

Users now assume instant updates; even small delays feel like broken UX.
Polling doesn't scale — it increases latency, infrastructure cost, and operational load.
Building realtime infrastructure slows teams down when they should be shipping product.

ApexStream abstracts this away: one production-ready layer for connections, channels, and metering.

At a glance

Three reasons teams choose ApexStream

Ship realtime features faster

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

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

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

Positioning

Compared to typical realtime stacks

Dimension	ApexStream	Typical vendor approach
Product model	Organization → project → application → API keys with a unified control plane	Pusher/Ably: channels + keys only · Firebase: database-centric model (Auth + Firestore/RTDB as core abstraction)
Hosting	Cloud or self-hosted (Docker / Kubernetes) — both first-class	Firebase: cloud-only (Google-managed) · Pusher/Ably: managed SaaS-first
Data & accounting	MongoDB for metadata, usage tracking, and billing + realtime pipeline via gateway (optionally NATS-backed)	Firebase: document model with security rules · Others: proprietary usage/limits layer
Protocol layer	WebSocket-first with explicit channel events and predictable semantics	Mixed REST/WebSocket abstractions, SDK-heavy integrations, vendor-specific behavior

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.

See live pipeline Quick start code

Live dashboards

Replace polling with push updates and reduce API load instantly.

See live pipeline Quick start code

Notifications

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

Try it live Quick start code

Collaboration

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

Try it live Quick start code

Get started

Go from zero to realtime in 3 steps

Create your first app

Set up a project in ApexStream to isolate your realtime environment (chat, dashboards, or events).

You instantly get a scoped workspace for keys, channels, and usage tracking.

Generate your API key

Create a secure key pair for your application.

Use it to authenticate clients and control access to realtime channels.

Connect in minutes

Install the SDK and establish your first WebSocket connection.

Start publishing and subscribing to events immediately — no backend glue required.

Need full control?

Run ApexStream in your own infrastructure with Docker or Kubernetes.

See it in action

From app key to live connection in minutes

Cloud-first flow: create an app in the dashboard, install the SDK, and connect to wss://api.apexstream.org. Every step below feeds directly into the live realtime pipeline.

01 — Create your app & API key

Open dashboard

02 — Install the SDK

03 — Connect to the realtime gateway

2-minute setup

From signup to live connection in minutes.

No infrastructure to manage

We run the gateway and the control plane.

Production-ready

Built for scale, reliability, and real workloads.

Secure by default

TLS, key hygiene, and tenant isolation.

Stay vigilant with API keys — store them only in secure, trusted places.

apexstream · session_livehealthy

sdk · npm package apexstreamchannel · orders

import { ApexStreamClient } from "apexstream";

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();

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

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

Live pipeline

socket.openGET /v1/ws · 101 Switching Protocols
ok
channel.subscribechannel="orders" · ack
ok
channel.publishchannel="orders" · kind=placed
ok
external.projectsGET /external/v1/projects · 200
ok
metrics.gatewayGET /external/v1/metrics/gateway-workers · 200
ok

Pricing

Plans that grow with your traffic

Start free, ship realtime, and scale naturally as your usage grows — no surprises, no hidden pricing logic.

Free

For prototyping, experiments, and early-stage projects

Up to 100 concurrent connections
1M messages / month
1 project
WebSocket pub/sub
Community support

Start free

Popular

Pro

$29

For production apps and growing teams

Up to 2,000 concurrent connections
10M messages / month
Unlimited projects
Webhooks + event replay (short window)
Email support

Start trial

Scale

$199

For high-traffic and business-critical systems

Up to 10,000 concurrent connections
100M messages / month
Advanced replay + guaranteed delivery
Full analytics & usage insights
Priority support

Start trial

Enterprise

Custom

For large teams, compliance-heavy or regulated environments

Unlimited scale
Self-hosted or dedicated cloud
RBAC + audit logs
Private networking / VPC support
SLA + dedicated engineering support

What teams like about this model

✓You scale on real usage (connections + messages) — not opaque bundled pricing
✓Same product works in cloud or self-hosted environments — no migration penalty
✓Clear upgrade path between engineering needs and business decisions
✓Free tier is fully usable — not a "demo sandbox"

Not sure which plan fits?

Start free, observe real traffic, and upgrade only when your system actually needs more capacity.

No credit card required.

Migration

Move off Pusher or Firebase without a ground-up rewrite

Migrate incrementally using the same mental model your team already knows — channels, explicit events, and a lightweight JavaScript SDK.

No architectural reset required.

Keep what already works

Your existing concepts still apply.

→subscribe / publish model
→app-based authentication
→client SDK for browser and Node.js

You can integrate ApexStream alongside your current stack and migrate step by step.

No forced platform lock-in

Deploy where you want, when you want.

Run ApexStream in our cloud today and move to your own infrastructure later — without changing client code or event semantics.

Same APISame behaviorDifferent deployment

Transparent usage model

Pay for what your system actually does.

Billing is based on measurable system activity:

→active connections
→message volume

No bundled abstractions or opaque usage categories.

Start safely

Validate, then scale with confidence.

Begin with a single service or namespace, validate behavior, and expand gradually as confidence grows.

Built for teams who ship to production.

Ready to migrate?

Start free and migrate at your own pace.

Start free Read documentation

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";

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.

Safety & reliability

Guardrails for production WebSocket traffic

ApexStream is designed to run multi-tenant realtime systems with predictable isolation, secure transport, and observable behavior.

Tenant isolation by design

Your infrastructure boundaries are enforced through a clear hierarchy:

Organizations → Projects → Applications → API Keys

Each layer is isolated, so traffic, access, and configuration never leak across tenants.

Secure transport everywhere

All control-plane and gateway communication is encrypted in transit using TLS.

API keys are never exposed in the browser directly — access is mediated through server-side authentication or short-lived tokens.

Operational transparency

System state is exposed through documented APIs:

connection status
throughput metrics
authentication failures

No hidden channels. No opaque internal dashboards.

Deployment flexibility

Run ApexStream in managed cloud environments or fully private deployments.

The same primitives apply regardless of where it runs.

Security model (summary)

Server-side API keys by default
Fully auditable API surface
Support for private / isolated deployments

Get started

Ready to build realtime systems?

Start in minutes. Scale when you need.

ApexStream runs your WebSocket infrastructure so you don't have to think about clusters, scaling, or message delivery plumbing.

Start small, validate your use case, and grow into production traffic without changing your integration.

Get started in one flow

01Create an application in the dashboard
02Copy your API key and WebSocket URL
03Install the SDK
04Connect and start publishing events

No infrastructure setup required.

Or explore first

No lock-in by design

Run in our cloud or move to your own infrastructure at any time — the API stays the same.

Start free