Most of the web just sits there. Our crawler, scheduler, and change-detection engine turn it into one live, deduplicated feed, streamed to you over plain HTTPS, for you to build anything on.
Early access, opening soon. No credit card. Be first to stream the static web live.
Speaking natively to the open web
We speak the open web's real protocols natively: ATProto and Jetstream, RSS, Atom and JSON feeds, WebSocket streams, SSE endpoints. Those carry every kind of source, whether it's an always-on push source, a feed we poll, or a feed-less HTML page we diff. Each source has a purpose-built connector that normalizes into one shared event shape.
We speak ATProto natively. Bluesky's Jetstream is the primary source: no DAG-CBOR, no CAR decoding, no ceremony. Any app built on the AT Protocol flows through the same connector.
Universal parsing across RSS 2.0, Atom 1.0, and JSON Feed, polled on a polite adaptive schedule. Hot feeds get checked often; quiet ones back off. You never see the same item twice.
Plenty of the web's most valuable pages have no feed and no API at all. We extract the main content, fingerprint it, and surface genuinely new content, so the sources that matter most aren't the ones you miss.
One-way server push over plain HTTP. Reconnects resume exactly where you left off, no gaps. Wikimedia EventStreams is wired in by default. Point us at any SSE endpoint and it flows.
Bidirectional streaming from any WebSocket-based API. Mastodon instances, financial data streams, live dashboards. If it speaks WebSockets, we can listen. Backfill polling closes any gaps a disconnect leaves.
Add an entire domain and we'll crawl it politely, learn its shape, and surface genuinely-new content across every page as one stream.
Build straight on the raw feed. Subscribe to the filtered, normalized stream over plain HTTPS and ship whatever you want on top, no app in the middle.
The engine turns every source into one normalized stream. How you consume it is up to you: pull it live over plain HTTPS, have it pushed as signed webhooks, drop it into the chat your team already lives in, or wire it into anything you build yourself.
This is the flagship: one HTTP call opens the live, normalized stream over plain HTTPS. Filter to the slice you want, and if you drop off, reconnect with your cursor and resume with nothing lost. It is the raw feed itself, no app in the middle.
Prefer to be pushed to? We deliver each event to your endpoint with an HMAC signature you can verify, automatic retries with backoff, and dead-lettering so a bad endpoint never silently loses events.
Deliver straight into Slack, Teams, or Discord as native destinations, with richer formatting than a bare webhook. Matches land where your team already works, so nobody has to watch another dashboard.
Every channel is just an adapter over the same stream. Subscribe to the raw feed and pipe it into a queue, a database, Notion, Linear, or anything you build yourself. The stable boundary is yours to extend, today.
The hard parts of making the static web live: change detection, durability, politeness, and a clean consumption boundary. Solved once, for every source.
We fingerprint extracted content, not raw HTML, so you get news, not the same page with a new timestamp.
Durable buffering and backpressure mean events survive crashes, restarts, and slow consumers. Reconnect and resume from your cursor.
Per-source adaptive polling respects robots.txt, rate limits, and conditional requests. Good for the open web, good for you.
Subscribe with one HTTP call, filter to the slice you want, and backfill from any point. Auto-reconnect built in.
HMAC-signed deliveries with retries, scoped API keys, per-key rate limits, TLS everywhere, and SSRF protection on every URL you give us.
Copy-paste quickstart, a clean versioned schema, predictable errors, and an obvious mental model. Integration that stays out of your way.
# Authenticate with one header. That's it, you're streaming.
curl -N https://api.hypeline.io/v1/stream?match=acme \
-H "Authorization: Bearer sk_live_..."import { Hypeline } from "@hypeline/sdk";
const ls = new Hypeline("sk_live_...");
for await (const evt of ls.stream({ match: "acme" })) {
console.log(evt.title, evt.url); // it's live ✨
}from hypeline import Hypeline
ls = Hypeline("sk_live_...")
for evt in ls.stream(match="acme"):
print(evt.title, evt.url) # it's live ✨ls := hypeline.New("sk_live_...")
stream, _ := ls.Stream(ctx, hypeline.Match("acme"))
for evt := range stream.Events() {
fmt.Println(evt.Title, evt.URL) // it's live ✨
}One key. One header. One unified stream across every source you add. No setup to fight and nothing to learn twice, just a clean live stream you can build on from the very first request.
Authorization header and you're streaming. No OAuth dance, no handshakes, no SDK required.# An example event on the wire
{
"id": "evt_01J9X3K7QF",
"source": { "type": "html_diff", "name": "reuters.com/markets", "tier": "minutes" },
"kind": "content.new",
"title": "Fed holds rates steady",
"url": "https://www.reuters.com/markets/fed-holds-rates-steady",
"detected_at": "2026-06-30T08:14:09Z",
"cursor": "c_8f2a91d4"
}A cursor is just a bookmark in the stream. Disconnected? Reconnect with ?cursor=c_8f2a91d4 and pick up exactly where you left off. Nothing dropped.
Security is first-class, not bolted on. The boring guarantees that let you build on us without worrying.
Least-privilege access, rotate anytime, per-key rate limits.
Verify every delivery is really from us, with retries and replay protection.
Encrypted everywhere, and every user-supplied URL is fetched safely.
Careful secret handling and a data stance built for European reality.
Join the waitlist and we will reach out with an API key the moment early access opens.
No credit card. No spam. Just one email when your access is ready.