Coming Soon

Realtime infrastructure built for throughput. Binary-first. Kafka-backed. Priced honestly.

Celeris is a Rust-powered WebSocket platform for teams that need high-throughput pub/sub without JSON overhead, vendor lock-in, or billing surprises. Launching with two regions, five SDKs, and a free tier.

We're not live yet. Get early access when we launch.

p95 32ms
round-trip latency

Single c8g.large EC2.
Includes k6 client overhead.

SDKs:JavaScriptJavaRustPythonFlutter
THE PROBLEM

You've been here before.

Firebase worked, until it didn't.

No proper sharding. You hacked Firestore and RTDB together to handle throughput. The architecture got messy. The platform got flaky. A traffic spike shouldn't feel like a production incident.

The bill compounds fast.

Three meters. Four meters. Usage fees on top of base fees. Add a premium feature and watch it multiply. By the time you understand the invoice, you're locked in. You just needed messages to move, not a pricing puzzle.

PubNub is 60+ transaction types.

Average contract north of $80k/year. HTTP long-polling on the hot path. The pricing page requires a spreadsheet to understand. You just need messages to move fast.

Self-hosting means pager duty.

Rolling your own Kafka + WebSocket layer sounds attractive until your team is on-call at 2am for infrastructure that isn't your core product. Managed is faster. The math is obvious.

We built Celeris because we lived this.

Not as a market opportunity. As a solution to a real problem we had. The architecture decisions aren't clever. They're deliberate.

WHY CELERIS

Three things we refuse to compromise on

Every architecture decision exists for a reason. Here are the three that matter most.

01

Throughput without compromise

Binary-first. Kafka-backed. Built in Rust.

Native MessagePack and Protobuf support means no JSON serialization on the hot path. Messages flow through Kafka for per-channel ordering and multi-node fanout. In-memory delivery for local rooms. Cross-region replication only when you need it.

  • Native MessagePack & Protobuf
  • Per-channel Kafka ordering
  • In-memory local fanout
  • Rust-powered efficiency
96,114 msg/s
single node, 56% CPU, 102MB memory
02

Pricing that doesn't punish growth

Three dimensions. Clearly stated. No surprises.

Messages, connection minutes, channel minutes. You know exactly what you're paying for before you deploy. Monthly billing for teams still evaluating. 10-year one-time access for teams that hate recurring SaaS subscriptions.

  • Usage-based, 3 dimensions
  • No per-seat or per-region fees
  • Monthly or 10-year one-time
  • Free tier, no credit card required
$2 / M msg
plus connection and channel minutes
03

Your data stays yours

BYOD: Bring Your Own Destination.

Celeris delivers. You own the data. Connect write-only export connectors to Kafka, RabbitMQ, S3, or HTTP endpoints. Your database is never on the spike path. Consume from your own queue at your own pace.

  • Kafka, RabbitMQ, S3, HTTP
  • Write-only, post-acceptance
  • Protect DB from traffic spikes
  • No vendor lock-in
At-least-once
with deduplication via event_id
BENCHMARKS

Real numbers. Labeled honestly.

These are production benchmarks run on a single c8g.large EC2 instance. Round-trip latency includes k6 test-client overhead.

Message Throughput

96,114/s

Sustained 25 minutes · 44,000 KBps data transfer

p95 Latency

32ms

avg 13.85ms · med 12ms

Memory

102MB

56% CPU · single node

Uptime

99.95%

Reliability with automatic retries

Test methodology

  • Single AWS c8g.large EC2 instance
  • 25-minute sustained load test
  • Round-trip latency includes k6 client overhead
  • A second test at 90k msg/s ended early due to k6 server failure. Not Celeris.
HOW IT WORKS

From sign-up to productionin four steps.

You can test Celeris from the dashboard before writing a single line of code. When you're ready, integration takes minutes.

1

Create an app. Test from the dashboard.

Sign up, create an app, and send test messages directly from the dashboard. No code required to verify it works.

No credit card. No code. Just working WebSockets.

Dashboard message tester

Send a test message. See it arrive. No code.

2

Add a token endpoint to your backend.

Create a signing key in the dashboard. Add ~4 lines to your backend to issue scoped tokens for clients.

Works with any backend: Node, Java, Python, Rust, Go.

backend.js
const celeris = new Celeris(keys);

app.post("/token", (req) => {
  const token = celeris.createToken({ ...options });
  return { token };
});
3

Connect your client.

Point the SDK at your token endpoint. Connect to a channel. Send and receive messages.

Pure WebSocket underneath. Raw WebSocket also works.

client.js
const celeris = new CelerisClient({
  appId,
  tokenEndpoint: "/token",
});

const channel = celeris.connect({
  channel: "my-channel",
  onMessage: (msg) => console.log(msg.json()),
});

channel.send({ text: "hello" });
4

Watch metrics. Scale when you're ready.

Messages delivered, bytes transferred, connection health, all visible in the dashboard in real time. Add regions, increase limits, configure BYOD export when you need it.

US and EU live at launch, via AWS Global Accelerator.

US
Live
EU
Live
AP
Soon
PRODUCT MODEL

Four concepts. That's the model.

Celeris has a simple, composable hierarchy. Once you understand it, everything else follows naturally.

Top level

Account

Your organization. Contains all your apps and billing.

Isolated environments

Apps

Separate environments per product or deployment. Apps are fully isolated with different signing keys and different metrics.

WebSocket endpoints

Channels

Each WebSocket connection is to a Channel. Channels have their own auth rules and message ordering.

Virtual rooms

Segments

Virtual sub-divisions within a channel, like rooms. The default segment is always there. No extra code needed for simple cases.

Real-world mapping: live collaboration tool

Account
acme-corp
App
collab-tool-production
Channel
document-abc123
Segment
comments-thread
BYOD: BRING YOUR OWN DESTINATION

We deliver. You own.

Celeris is the delivery layer. Your data belongs to you. Configure write-only export connectors to pipe message data directly into your own infrastructure.

Why this matters: When traffic spikes, your application database shouldn't be the one absorbing it. Celeris writes to your queue. Your system consumes at its own pace. No dropped messages. No cascading failures.

Write-only. Celeris never reads from your infrastructure.
At-least-once delivery with deduplication via event_id
Post-acceptance: confirmed on Celeris side before export
Switching platforms doesn't require migrating your data
Available connectors
Celeris
write-only · at-least-once
Kafka
Available
RabbitMQ
Available

Deduplication via event_id. Post-acceptance delivery. Celeris confirms receipt before export. Your pipeline runs at your pace.

NO LOCK-IN

Pure WebSocket underneath. Always.

The Celeris SDK is a thin wrapper over a standard WebSocket connection. If you want to connect with raw WebSocket, no SDK or dependency needed, you can. We publish the protocol. We hide nothing.

Raw WebSocket works

The SDK is optional. Connect with any standard WebSocket client. The protocol is documented.

Data is already yours

BYOD export means your messages are in your infrastructure before you even think about switching.

Switching is a URL change

No proprietary message format. No SDK-specific state. Standard WebSocket frames, your data, your choice.

"If you want to leave, the door is open."

Your messages are in your BYOD destination. Your clients use standard WebSocket. Migrating away means updating a URL. We're confident you won't want to.

USE CASES

Built for real workloads

Celeris is a transport layer. What you build on top of it is up to you.

View all use cases
FEATURES

What ships in V1

Built and benchmarked. No vaporware. These are the features available today.

Binary-first messaging

Native MessagePack and Protobuf support. No JSON serialization on the hot path. Smaller payloads, faster transmission.

Kafka-backed ordering

Per-channel message ordering via Kafka. In-memory fanout for local rooms, Kafka for multi-node, bridge replication for cross-region.

Signed token auth

Issue scoped tokens from your backend using a signing key from the dashboard. Clients authenticate without touching your database.

BYOD data export

Write-only connectors to Kafka, RabbitMQ, S3, and HTTP. At-least-once delivery with deduplication via event_id. Your DB is never on the spike path.

Multi-region

US and EU live at launch. AWS Global Accelerator for global routing. Regional isolation. Cross-region replication only when configured.

Dashboard testing

Send test messages, view history, inspect metrics, and verify delivery from the dashboard, before writing a single line of client code.

Five SDKs

JavaScript, Java, Rust, Python, Flutter. Pure WebSocket underneath. Raw WebSocket also works if you prefer no abstraction.

Channels and segments

Each WebSocket connection is to a Channel. Segments are virtual sub-divisions within a channel, like rooms. The default segment requires no extra code.

Metered billing

Three transparent dimensions: messages, connection minutes, channel minutes. No per-seat fees, no per-region surcharges, no surprises.