Early access

Real-time for your apps, without running WebSockets yourself.

Thuum.dev connects your users, devices and services live. Publish events, share state and get notified the moment something changes. Built for frontends, just as good in the backend.

← [{"op":"message","topic":"room:7","type":"message","data":{"from":"Alice","text":"Hi Bob! Did the new build go out?"}}]

WebSockets are easy. Real-time apps are not.

Opening a socket takes one line. Running one for real users takes a whole system. Here is what Thuum.dev already does for you.

Doing it yourself

With Thuum.dev

Run a socket server: heartbeats, idle timeouts, message size limits.

One endpoint per broker, with keepalive and limits built in.

Fan messages out across servers with a backplane and sticky sessions.

Broadcast to every subscriber, handled for you.

Authenticate the handshake, and keep secrets out of the browser.

App Keys are exchanged for short-lived tokens.

Decide who may publish to, or listen on, what.

Claims with Publish, Write, Subscribe and Read flags, per topic.

Recover the messages a client missed while it was offline.

Every topic keeps a recent history; catch up over REST.

Keep shared state consistent under concurrent updates.

JSON states with merge patches (RFC 7396) and versions.

Clean up old data before it piles up.

Automatic retention and expiry.

Keep customers and environments apart.

Every Domain is a fully isolated tenant.

Two brokers. Everything real-time.

Most real-time features are either something that happened, or how things are right now. Thuum.dev has a broker for each.

Event Broker

Something happened.

Streams of events on topics: chat messages, moves, alerts, finished jobs. Subscribers get them live; anyone who missed some catches up from the topic's recent history.

Publish and subscribe over one WebSocket
Recent history per main topic, kept by count and age
Publish from a backend with a single POST

State Broker

This is how things are now.

Live JSON values, organized by topic and key: presence, cursors, a document, a scoreboard. Change one, and everyone subscribed gets the new value.

Set, merge (JSON Merge Patch) or delete a value
Versions to drop out-of-order updates
Ask for the current value, or broadcast it to everyone

Built for apps people use together

If your users should see something the moment it happens, Thuum.dev is a fit.

Chat and comments

Rooms, threads and replies, delivered to every participant at once.

Event Broker

Collaborative tools

Whiteboards, live cursors and shared documents that stay in sync.

Event BrokerState Broker

Multiplayer games

Moves, turns and game state, shared between players in real time.

Event BrokerState Broker

Live dashboards

Metrics and statuses that update themselves. No refresh button.

State Broker

Notifications and feeds

Tell a user, a team or everyone that something just happened.

Event Broker

Presence

Who's online, who's looking, who's typing.

State Broker

IoT and telemetry

Devices report readings; screens and services react.

Event BrokerState Broker

Live polls and Q&A

Votes and questions that appear as the audience sends them.

State Broker

Order and delivery tracking

Status changes reach the customer the moment they happen.

Event BrokerState Broker

Frontend-first. Backend-ready.

Connect straight from the browser with a typed TypeScript client, or from any server language over plain REST and WebSocket. Same brokers, same permissions.

In the browser

Exchange a key for a token, connect, subscribe, publish. A chat on the Event Broker and a live cursor on the State Broker:

import { ThuumClient } from '@thuum/client';

const thuum = new ThuumClient({ baseUrl: 'https://api.thuum.dev' });
const { token } = await thuum.exchangeToken('acme', appKey);
const acme = thuum.domain('acme', token);

const chat = acme.eventBroker.connect();
await chat.ready;
chat.onMessage((event) => show(event.data));
await chat.sub('room:7');
await chat.pub('room:7', 'message', { text: 'Hello!' });

const board = acme.stateBroker.connect();
await board.ready;
board.onChange(({ key, value }) => draw(key, value));
await board.sub('board:42');
await board.merge('board:42', 'cursor:alice', { x: 120, y: 80 });

On your servers

No SDK needed: get a token, then publish an event (or set a state) with one HTTP request, from any language.

TOKEN=$(curl -s -X POST https://api.thuum.dev/api/acme/token \
  -H 'content-type: application/json' \
  -d '{"key":"<your App Key>"}' | jq -r .data.token)

curl -X POST https://api.thuum.dev/api/acme/event/data/orders \
  -H "authorization: Bearer $TOKEN" \
  -H 'content-type: application/json' \
  -d '{"type":"order.shipped","data":{"id":1042}}'

Start with the Quickstart Try it in the Playground →