Pulse Feed
Some things have to show up on a screen the instant they happen — a live dashboard, an activity feed inside an app, a status that updates itself while someone watches. The old way to do that is polling: the browser asks "anything new?" every second, mostly hearing "no," wasting a request each time and still lagging behind reality by up to a second. Feed is the push instead of the poll. It holds a connection open to each viewer and sends updates the moment they occur, so what's on the screen matches what's true.
Feed is the last mile of Pulse's real-time story. Stream is the event bus where things happen; Feed is how those events reach a person watching. A viewer opens a subscription, and events flow to them live over Server-Sent Events — a standard, firewall-friendly one-way channel that every browser speaks natively, no special client needed.
In code, a stream is the log events are published to and a change feed is the one-way channel for a collection's row changes:
Create the client once
import { createClient, realtimeTopic } from "@k9o/core";
const k9o = createClient({
orgSlug: "acme",
projectSlug: "task-app",
apiKey: process.env.K9O_API_KEY,
});Pulse · Feed
// A stream is an ordered log you can publish to, replay and tail.
const { data: stream } = await k9o.streams.create({
displayName: "orders-feed",
maxBytes: 10_485_760,
});
const slug = stream.slug; // the other calls take the slug
try {
// 1. Publish three events. A subject is an optional routing label.
await k9o.streams.publish(slug, { id: 1, total: 42 }, { subject: "eu.new" });
await k9o.streams.publish(slug, { id: 2, total: 17 }, { subject: "eu.new" });
await k9o.streams.publish(slug, { id: 3, total: 99 }, { subject: "us.new" });
// 2. Subscribe from the start and use each event; stop after the third.
const controller = new AbortController();
let sum = 0;
for await (const event of k9o.streams.subscribe<{ id: number; total: number }>(slug, {
fromSequence: 0,
signal: controller.signal,
})) {
sum += event.data.total;
console.log(event.sequence, JSON.stringify(event.data));
if (event.data.id === 3) controller.abort();
}
console.log(`total of all orders: ${sum}`);
// 3. Replay: read a page of history again, from any position.
const { data: page } = await k9o.streams.replay(slug, { fromSequence: 1, limit: 10 });
console.log(`${page.events.length} events after #1, more: ${page.hasMore}`);
} finally {
// 4. Retire the stream when you are done with it.
await k9o.streams.delete(slug);
}1 {"id":1,"total":42}
2 {"id":2,"total":17}
3 {"id":3,"total":99}
total of all orders: 158
2 events after #1, more: false- A stream is ordered and replayable. Publishing needs the project admin role; subscribing and replaying need the admin or auditor role.
maxBytes(the storage ceiling) is at least 10485760 (10 MiB) and at most 64 GiB. Sizes step by 10 MiB up to 1 GiB, by 100 MiB up to 10 GiB and by 1 GiB up to 64 GiB. The stream'sslugis what the other calls take. A sequence is a string.fromSequenceis exclusive: events after it.subscribereopens its connection by itself from the last sequence it saw.- The tab creates a temporary stream and deletes it at the end.
What you're paying for, and why it's measured this way
Feed is metered on two things, and the pairing is deliberate — each guards against a different way live delivery gets expensive:
- Connection-minutes — how long connections stay open. A live feed's real cost isn't only the data; it's holding thousands of connections open at once, each consuming a slot whether or not much is flowing through it. This is what a dashboard left open on a wall display all day actually costs.
- Delivered events — how many events are actually pushed to a subscriber. One event published to a thousand watchers is a thousand deliveries, not one — that fan-out is the work, and it's what a broadcast to a large audience actually costs. Measuring the publish alone would let a message blasted to an unbounded crowd look free, which it very much isn't.
Together they price the two shapes of a live feed by what each demands: a few connections receiving a firehose, and a huge audience each receiving a trickle, cost what they respectively demand of the platform.
Kept separate from storage on purpose
It would be simpler to fold all of this into one number, but it would misprice almost everyone. What you store (a Stream's retention window, a Lakehouse dataset) and what you do (delivering events live, running a query) are genuinely different costs that don't move together — a stream with a thousand subscribers costs the platform very differently from the same stream with none, and that gap has nothing to do with how long the data is retained. Kilimanjaro keeps the two axes separate — storage priced by the gigabyte-month, activity priced by the work — so you pay for your actual usage shape rather than an average that fits nobody.
When a plan's connection or delivery allowance runs out, new connections are turned away at the door rather than quietly accepted and billed after the fact — enforcement happens when a connection is opened, not in a reconciliation later. Paying for overflow beyond your allowance is opt-in. Current rates and allowances are on the pricing page.