Cosmo Streams

Real-time GraphQL for your federated graph

Five subscription protocols with connection multiplexing, plus event-driven subscriptions via Kafka, NATS, and Redis.

Protocol-based subscriptions and Cosmo Streams (EDFS). Choose what your architecture needs.

Overview

Two approaches to real-time GraphQL

Cosmo Router provides subscription support out of the box. GraphQL Subscriptions handles multiple protocols and connection multiplexing. Cosmo Streams (EDFS) connects the Router directly to message brokers, making subgraphs completely stateless.

Both approaches work within the same federated graph. Use protocol subscriptions for existing WebSocket subgraphs. Use Cosmo Streams when moving to serverless, working with Kafka or NATS, or reducing connection overhead at scale.

Why it matters

Why GraphQL subscriptions at scale are hard

Real-time features should not require stateful subgraphs, three WebSocket connections per client, or weeks of custom infrastructure work.

Four problems that arise with traditional GraphQL subscriptions.

WebSocket subscriptions require stateful subgraphs.

Every active subscription lives in memory somewhere. Serverless platforms usually limit request length, which makes long-lived subscription connections in subgraphs difficult or impossible.

Three connections per client adds up fast.

Client to Router, Router to Subgraph, internal subgraph state. At 10,000 clients, connection overhead alone can consume substantial memory resources.

Protocol mismatches block real-time features.

Legacy Apollo clients, modern web clients, and Phoenix (Absinthe) clients all use different protocols. Without a translator, each protocol requires a separate implementation.

Federated subscriptions require inter-subgraph coordination.

Classic Federation forces one subgraph to own the subscription root field. When other subgraphs contribute fields to the entity, triggering an update means coordinating across subgraphs.

Cosmo Router handles all four. Protocol translation, multiplexing, and event-driven stateless subscriptions.

Real-time capabilities

GraphQL Subscriptions

Five subscription protocols from clients to the Router, and WebSockets or SSE from the Router to each subgraph. Connection multiplexing routes subscriptions with the same authentication headers over a single upstream connection.

All plans, including self-hosted

Use cases

Streams use cases

Real-time dashboards, serverless deployments, and high-scale notifications.

Real-time dashboard

Live dashboards with multiplexed WebSocket connections

Scenario

A fintech application displays real-time prices and portfolio values to thousands of concurrent users.

How Cosmo handles it

Clients connect via graphql-ws. The Router routes subscriptions that share the same forwarded authentication headers over a single connection to the pricing subgraph.

Outcome

Upstream connections grow with the number of distinct forwarded header sets, such as authentication, not with the number of clients.

Serverless real-time

Serverless subgraphs with real-time subscription support

Scenario

An engineering team wants to deploy subgraphs on AWS Lambda or Cloud Run but cannot because subscriptions require persistent connections.

How Cosmo handles it

Subgraphs publish events to NATS when data changes. The Router subscribes to topics and fetches current state via HTTP when events arrive. Lambda handles only stateless HTTP requests.

Outcome

Full serverless deployment with real-time subscription support.

High-scale notifications

Push updates to large numbers of concurrent users

Scenario

A platform needs to push updates to many concurrent users without overwhelming infrastructure.

How Cosmo handles it

Backend services publish notifications to Redis. The Router handles all client connections with efficient I/O. Subscriptions on the same Redis channel share a single trigger, so the Router does not open a broker subscription per client.

Outcome

Subgraphs hold no subscriber connections, so subscriber growth lands on the Router, not your services.

Which capability do you need?

If you are…	Start here
Needing WebSocket support with multiple protocol options	GraphQL Subscriptions
Moving subgraphs to serverless deployments	Cosmo Streams
Integrating Kafka, NATS, or Redis as the event source	Cosmo Streams
Supporting legacy clients alongside modern clients	GraphQL Subscriptions
Reducing memory and connections at high client counts	Cosmo Streams

How Cosmo Streams compares

	Cosmo Streams	Traditional GraphQL Subscriptions	Custom Event Gateway
Subgraph state	Stateless (HTTP only)	Stateful (WebSockets)	Varies
Serverless compatible	Yes	Limited	Requires custom work
Message broker integration	Native (Kafka, NATS, Redis)	None	DIY
Subscription deduplication	Automatic	Manual	DIY
Protocol options	5 client protocols	Varies by framework	Custom

Why teams use Cosmo for real-time

Five subscription protocols, automatic translation. graphql-ws, SSE (GET and POST), Multipart HTTP, subscriptions-transport-ws, and Absinthe from clients. The Router translates between client and subgraph protocols automatically.
Event-driven subscriptions for stateless subgraphs. Kafka, NATS, and Redis connect directly to the Router. Subgraphs publish events and serve plain HTTP. No WebSocket servers in subgraphs.
Connection multiplexing reduces upstream connections. The Router groups subscriptions with matching authentication headers into shared upstream connections, reducing backend connection count.

Get started

Add real-time to your federated graph

Start Free Read the Docs