A Self-Hosted Pusher and Ably Alternative: Tako Channels

A Self-Hosted Pusher and Ably Alternative: Tako Channels

Tako-kun·

Updated November 15, 2026: Tako now includes Presence, params-scoped channel streams, and shared WS subscriptions. The Tako examples below have been updated. Competitor pricing is a historical April 2026 snapshot; check the linked pricing pages before choosing a plan.

Most apps need realtime eventually. A chat pane, a live dashboard, a presence indicator on a doc. The default answer is to reach for Pusher or Ably — both excellent products that have been doing this since long before “realtime” was a checkbox on every framework’s homepage. Sign up, add an SDK, ship.

The catch is the bill. Connection and usage charges add up as more browsers stay on a dashboard. The tables below record the plans compared when this article was first published, rather than current price quotes.

Tako Channels are the self-hosted version of that shape: WebSocket and SSE routes served by the same proxy already running your app. Durable publishes are stored in a bounded replay log before delivery, so reconnecting clients can catch up without the backend checking whether a browser is connected. You pay for server capacity; socket count, fanout, and message sizes still consume its resources.

At a glance

Pusher ChannelsAblyTako Channels
HostingSaaSSaaSSelf-hosted (your VPS)
Free tier100 conns / 200k msg/day200 conns / 6M msg/moWhatever the box can hold
Next paid tier$49/mo — 500 conns$29/mo + usage — 10k conns$0 extra
5k concurrent$299/mo (Business)Pro tier $399/mo + usage$0 extra
Live transportWebSocketWebSocket, SSE, MQTTWebSocket, SSE
Replay / historyAdd-on (Storage)24h-72h replay (longer paid)Bounded channel replay, 10 minutes by default
PresenceYes (built-in)Yes (built-in)Yes — scoped membership and expiring metadata
Per-channel authAuth endpoint in your appToken request in your appauth callback in your app
Server publishREST APIREST or realtime SDKDirect module import through the Tako SDK
Routing shapeNamed channelsNamed channelsNamed channels with typed params

Sources: Pusher pricing, Ably pricing (April 2026).

SDK code, side by side

Pusher’s API is the canonical realtime SDK shape — server triggers, client subscribes:

// Server (Node)
import Pusher from "pusher";
const pusher = new Pusher({ appId, key, secret, cluster: "us2" });
await pusher.trigger("chat-room-42", "typing", { userId: "u_123" });

// Client (browser)
import Pusher from "pusher-js";
const channel = new Pusher(key, { cluster: "us2" }).subscribe("chat-room-42");
channel.bind("typing", (data) => console.log(data));

Tako’s channel name and validated roomId select a separate stream with its own subscribers and replay. The authorization callback must still verify access to that room; params alone grant no permission. See channel parameter semantics.

The Tako shape is file-based. Channel definitions live next to your app code and the proxy discovers them at deploy time:

// src/channels/presence.ts
import { defineChannel } from "tako.sh";

export default defineChannel("presence", {
  paramsSchema: (t) => t.Object({ roomId: t.String({ minLength: 1 }) }),
  auth: {
    headerName: "authorization",
    verify: async ({ header, params }) => {
      const session = await readSession(header);
      if (!session || !(await canReadRoom(session.userId, params.roomId))) return false;
      return { subject: session.userId };
    },
  },
  transport: "ws",
}).$messageTypes<{ typing: { userId: string } }>();
// Server-side publish — typed, imported directly
import presence from "../channels/presence";
await presence({ roomId: "42" }).publish({
  type: "typing",
  data: { userId: "u_123" },
});
// Client (React)
import { useChannel } from "tako.sh/react";

export function TypingEvents({ token }: { token: string }) {
  const { messages, status } = useChannel("presence", {
    transport: "ws",
    params: { roomId: "42" },
    authorization: token,
  });
  return <p>{status}: {messages.length} typing events received</p>;
}

readSession and canReadRoom are app-owned helpers; token is the current session’s bearer credential. There is no separate auth service to stand up. The callback runs inside your app for every logical subscription and can query your existing permission model. The channel named presence above carries typing events; for current online membership, use definePresence and usePresence instead.

Where replay belongs

Pusher and Ably bundle live delivery and replay into one product surface. Tako does the same at the channel level, but keeps the replay window intentionally short by default:

// src/channels/chat.ts
import { defineChannel } from "tako.sh";

export default defineChannel("chat", {
  paramsSchema: (t) => t.Object({ roomId: t.String({ minLength: 1 }) }),
  replayWindowMs: 10 * 60 * 1000,
}).$messageTypes<{ msg: { text: string; userId: string } }>();

This definition uses the default SSE transport. Its dedicated HTTP stream supports both live delivery and resume:

GET /_tako/channels/sse/chat?roomId=42

That window is for delivery, not product history. A collaborative cursor can be replayed after a laptop wakes. Write canonical chat messages to your app database through an app route before publishing them.

How the request actually flows

Diagram

The browser SDK shares /_tako/channels/ws between WS channels and Presence with the same origin, credentials, and transport configuration in one tab. connection: "dedicated" selects /_tako/channels/ws/<name> instead. SSE always uses a separate request at /_tako/channels/sse/<name>. Your app answers auth and publishes events without hosting another socket gateway.

Leaving a page unsubscribes its topics and presence memberships while layout subscriptions remain connected. The last subscription closes the socket. Call resetChannelConnections() after cookie-session changes so subsequent subscriptions get fresh handshake credentials. Shared connections have limits of 32 subscriptions, 64 KiB client commands including envelopes, and 1 MiB delivered events. See shared ownership and recovery; low-level connect() callers own reconnection, while React hooks reconnect automatically.

Presence now supplies server-maintained member snapshots, trusted subjects, and expiring typing/cursor metadata. Each hook call owns a distinct membership, even when several memberships share a physical socket.

What Tako does not do yet

Long-term message history is still app-owned. Tako Channels give you delivery and short reconnect replay; your database remains the source of truth for messages that must survive beyond the channel window.

Pricing reality check

For a typical indie or small-team app, the connection math goes like this:

Concurrent usersPusher tierAbly tier (per-minute)Tako on a $5 VPS
100Sandbox (free)Free$5/mo
1,000Pro — $99/moStandard — ~$30/mo + usage$5/mo
5,000Business — $299/moPro — $399/mo + usage$5/mo
20,000Plus — $899/moPro — $399/mo + usageA bigger VPS — maybe $40/mo

A single modest VPS can hold many idle WebSocket connections. The bottleneck is usually message throughput and fanout design, not the connection count itself. If you outgrow one box, add another — same tako.toml, same app model.

When each makes sense

Pick Pusher or Ably if you need managed global fanout, MQTT bridging, enterprise SLAs, or you simply want someone else to operate realtime for you.

Pick Tako Channels if you already run a VPS, do not want to pay per connection, and want durable realtime as a primitive of the same server that is serving your HTTP traffic, holding your secrets, and running your workflows.

tako init, drop a file in src/channels/, tako dev, and you have a realtime feature running locally over real HTTPS in about a minute. Start with the docs ->