Global real-time infrastructure
that ships in minutes.

Zokai lets you build globally distributed, low-latency systems without running NATS, WebSockets, or multi-region infra yourself.

Start for free See how it works

Low latency

global routing

1M+

concurrent connections

99.99%

uptime SLA

          
          network · live
        
          Your Server
          REST API

          Zokai
          NATS mesh
          
          client
          
          client
          
          client

          3 regions · live fanout · <3ms

We run the hard parts:
you just publish events.

Global routing, presence, fanout, scaling — all handled. No clusters to operate, no WebSocket servers to maintain, no multi-region infra to configure.

client.js

import Zokai from '@zokai/client';

// Connect with your app key
const client = new Zokai({ appKey: 'zk_live_…' });

// Subscribe to a channel
const ch = client.subscribe('notifications');

// React to events instantly
ch.on('new-order', ({ orderId, total }) => {
  showToast(`Order #${orderId} — $${total}`);
});

import Zokai from '@zokai/server';

const zokai = new Zokai({
  appKey:    process.env.ZOKAI_KEY,
  appSecret: process.env.ZOKAI_SECRET,
});

// Publish from your backend — reaches clients instantly
await zokai.publish('notifications', 'new-order', {
  orderId: 'ORD-7821',
  total:   149.99,
});

import zokai, os

client = zokai.Client(
    key=os.environ["ZOKAI_KEY"],
    secret=os.environ["ZOKAI_SECRET"],
)

# Push an event to all subscribers instantly
client.publish(
    channel="notifications",
    event="new-order",
    data={"orderId": "ORD-7821", "total": 149.99}
)

Connected · 3ms · 1 subscriber

Live in production

What you get

Everything you need.
Nothing you have to build.

From a simple notification badge to full collaborative presence — Zokai handles the realtime layer so you can focus on your product.

Events reach users with low latency

No polling, no refreshing. Messages are pushed the instant they happen — users see updates before they can blink.

Organize events without designing your own model

Channels give you a ready-made abstraction — built on NATS subjects — for public feeds, private rooms, or per-user streams. No modeling required.

Know who's online without writing backend logic

Presence is one of the hardest parts of realtime to build correctly. Zokai tracks joins, leaves, and member lists — you just subscribe to the channel.

Lock down channels with one server endpoint

Private channel auth is a single callback on your server. Zokai calls it before letting anyone subscribe — you approve or reject, we enforce.

Zero infrastructure work as your traffic grows

Your first 100 users and your first million use exactly the same code. Capacity, routing, and connection management are Zokai's problem, not yours.

Publish from any backend with a single call

One HTTP request from your server pushes an event to every connected client. Official SDKs for Node.js, Python, and Go — or hit the REST API directly.

The full picture

What Zokai actually gives you

This replaces weeks or months of building on top of raw infrastructure.

Realtime API

Publish and subscribe over WebSockets. REST for your server.

Channel abstraction

Built on NATS subjects. Public and private, out of the box.

Presence system

Who's online, when they joined, when they left.

Private channel auth

Your backend approves. Zokai enforces.

Multi-region routing

Users connect to the nearest region automatically.

SDKs (JS, Node, Python)

Drop in one import, connect with your key, done.

Dashboard

Create apps, manage keys, and monitor connections in one place.

Built for every product

What will you build?

Zokai fits wherever your users need to see things happen in real time.

In-app chat

Support, team, or customer messaging with typing indicators and read receipts — without managing WebSocket state yourself.

Live dashboards

Sales metrics, analytics, and KPIs that update the moment data changes on your server. No polling, no stale numbers.

Order tracking

Push status updates the instant something changes on your backend. Users see it happen in real time, no refresh required.

Collaboration

Live cursors, shared editing, and co-presence. Subscribe to a presence channel and Zokai handles who's online and where.

support · 3 online

Hey, my order hasn't shipped yet?

Let me check that for you right now.

Thank you!

Sarah is typing

It shipped this morning! Tracking #ZK-4812

Live metrics Streaming

Revenue today

Active users

—

Uptime

Order #ORD-7821 Picked

Placed

Picked

Shipped

Delivered

Preparing shipment...

Updated just now via Zokai

Q3 Roadmap · presence channel

3 online

Marco

Jana

How it works

Up and running in minutes.

Three simple steps from sign-up to live events in your app.

Create your app

Register and create an app in the dashboard. You'll get an API key and secret — that's all you need to start sending events.

Add the client SDK

Install the SDK, connect with your key, and subscribe to a channel. One line of code per event type — no boilerplate, no config files.

Publish from your backend

Call the REST API or use an SDK from your server. Events arrive at every connected client in milliseconds — automatically, at any scale.

The honest answer

Why not build it yourself?

WebSockets are easy to prototype. The rest is not.

WebSockets are easy to start

A basic server accepts connections in an afternoon. The next part is where the work begins.

Scaling is hard

A single-node WebSocket server doesn't share state. Scaling horizontally means solving message fanout across every node.

Presence is complex

Tracking who's connected, handling tab duplication, and broadcasting join/leave events correctly takes real coordination logic.

Multi-region is painful

Low latency globally means routing connections to nearby infrastructure and syncing state across regions — a full distributed systems problem.

Reconnection logic is messy

Clients drop connections. Handling exponential backoff, resubscription, missed events, and auth re-validation adds up fast.

Zokai solves all of this for you — out of the box.

Ship your realtime feature this week instead of building the infrastructure for it.

Pricing

Simple, honest pricing.

Start for free. Upgrade when you grow. No hidden fees, no surprise bills.

Starter

$0 / month

Single-region. No credit card required. Always free.

100 concurrent connections
200k messages / day
3 apps
Community support

Start for free

Global real-time infrastructure that ships in minutes.

We run the hard parts: you just publish events.

Everything you need.Nothing you have to build.