Skip to content
Realtime SSE

Millisecond push updates.

Server-Sent Events for instant flag and config changes. Your SDKs stay up to date without polling.

Get started for free Read the docs
Publish once✦ Stream changes✦ Reconnect safely✦ Fall back locally✦

See it live

Every change streams to connected clients the moment it happens.

SSE Stream
connected
event: flag_updated data: {"key":"new-checkout","value":true} 2ms ago
event: config_updated data: {"key":"pricing","value":"v2"} 850ms ago
event: flag_updated data: {"key":"dark-mode","value":false} 3s ago
event: ai_updated data: {"file":"agent.md","type":"agent"} 12s ago
flagdash.io/api/v1/sse
4 events

How realtime works

Industry-standard SSE protocol. The same approach used by LaunchDarkly and Flagsmith.

1

Toggle in dashboard

Flip a flag, update a config, or edit an AI prompt in the FlagDash dashboard.

new-checkout
Toggled ON just now
2

PubSub broadcasts

The server broadcasts the change to all connected SSE streams for that environment.

broadcasting...
3

Clients update instantly

Every connected SDK receives the update. No polling, no stale cache, no manual refresh.

event: flag_updated
data: {"key": "new-checkout"}
The Problem

Polling wastes bandwidth
and adds latency.

Traditional flag services require your app to poll for changes every few seconds. That means wasted requests, delayed updates, and unnecessary server load.

Polling every 30s = up to 30s of stale state
Thousands of clients = thousands of wasted requests
Kill switch toggles take seconds, not milliseconds
The Solution

Push, don't poll.
Millisecond updates.

Server-Sent Events stream changes the moment they happen. Toggle a flag in the dashboard and every connected client updates instantly — no round-trips.

Changes push in milliseconds, not seconds
One persistent connection per client
Auto-reconnect with exponential backoff
app.js
connected
const source = new EventSource(
"https://flagdash.io/api/v1/sse",
{ headers: {
"Authorization": "Bearer sk_your_api_key"
} }
);
// Flag changed in dashboard
source.addEventListener("flag_updated", (e) => {
const flag = JSON.parse(e.data);
console.log(flag.key, flag.value);
});
Realtime

Connect once, stay in sync.
Zero polling required.

Open an SSE connection and receive flag and config changes as they happen. Or use the SDK with realtime: true for automatic handling.

  • SSE push for flags, configs & AI configs
  • Auto-reconnect with exponential backoff
  • Polling fallback for server SDKs

Changes propagate instantly

Toggle a flag in the dashboard and every connected client updates in milliseconds.

Server-Sent Events

One-way server-to-client streaming over plain HTTP. No custom protocol for your team to learn.

Instant Propagation

Flag toggles, config changes, and AI config updates push to all connected clients within milliseconds.

Auto-Reconnect

Exponential backoff reconnection built into every SDK. Connections recover gracefully from network interruptions.

All SDKs Supported

Works with JavaScript, React, Node.js, Go, and Python SDKs. Enable with a single option: realtime: true.

No WebSocket Complexity

SSE is simpler than WebSockets. No bidirectional protocol, no upgrade handshake, no sticky sessions required.

HTTP-Compatible

Works through proxies, load balancers, and CDNs. Standard HTTP — no special infrastructure required.

Stop polling. Start streaming.

Real-time flag and config updates on every SDK. Set up in under 5 minutes.

Get started for free Read the docs