---
topic: developer-tools
author: Crashtech Editorial
published: Nov 18, 2026 · read: 4 min
---

GitHub Event Streams Replace Polling for Pull Requests, With a Reconnect Caveat

GitHub Event Streams send pull request updates over SSE, but clients must reconcile missed, repeated, or out-of-order events.

– –

A coding agent that checks for review feedback every few seconds spends most of its time asking a question whose answer is still no. Check too slowly and a useful review sits idle. GitHub Event Streams offers another pattern: subscribe to a pull request, leave a client connection open, and receive an event when selected state changes. GitHub announced the feature in public preview on November 17, saying a public webhook endpoint is not required. [1]

A pull-request event tube carries review and check slips toward a laptop, with a visible gap that signals a reconnect and state refresh.
Conceptual illustration of a client-side event stream and recovery fetch; it is not a GitHub product diagram.

A client subscribes, then listens

The documented flow is deliberately small. Create an event subscription for a pull request and selected event types, open its events_url as an HTTP stream, and handle each message. GitHub’s examples use a streaming client such as curl -N; the ordinary GitHub CLI API command waits for the entire response and is therefore not suitable for an open stream. When an event arrives, its api_url points to the review, check suite or pull request to fetch for current details. [2]

The public preview currently covers pull-request events. GitHub’s changelog lists review submission, new commits, merge conflicts, merged or closed state, and check-suite changes. The documentation adds the subscription model and event details. This is not a general-purpose stream for every repository activity, nor is it a durable replacement for the REST API. [1] [2]

For a broader comparison of asynchronous delivery choices, see API polling, webhooks and WebSockets. The transport is Server-Sent Events (SSE): the client opens an HTTP connection and receives a sequence of named events. That differs from a webhook, where GitHub makes an outbound request to a server endpoint you operate. A laptop agent can receive an SSE stream without making its machine publicly reachable, while a hosted system with an always-on endpoint may still find webhooks a better fit. [3]

The event tells you to look again

Events are notifications that something changed, not always a complete representation of the change. GitHub’s documentation advises fetching the api_url to read current state. For example, a review event does not necessarily contain the review’s final state, while check-suite events include a conclusion. This keeps the stream payload small and makes the API response the source of truth. [2]

A robust client should treat event delivery as a prompt to reconcile, not as a transaction log to apply blindly. Duplicate events can arrive; events can arrive out of order; and a disconnection can create gaps. Deduplicate when the event type provides an identity, then fetch current state and make the agent’s work idempotent. If the agent posts a comment or triggers a follow-up task, persist that action’s own identifier so a retry does not repeat a side effect.

GitHub explicitly says there is no replay for events that happened before a stream opened, in a short interval after subscription creation, or while disconnected. Its recommended recovery is to fetch the pull request after subscribing, and reconcile again after reconnecting. This initial read closes a race where a change happens between creating a subscription and opening the stream. [2]

Preview constraints shape the architecture

Subscriptions are tied to one pull request and expire 24 hours after creation. GitHub documents a limit of 100 active subscriptions per user, app or installation token. Unknown event types produce an error, so clients should not assume the event catalog is stable. The feature is a public preview and GitHub warns that APIs, event types and limits may change with short notice. [2]

That makes Event Streams useful for a bounded workflow such as a local coding session or one agent following a few active reviews, but it calls for operational handling: renew subscriptions, close streams cleanly, detect the server’s end event, and use backoff on reconnect. Do not leave one subscription per historical pull request indefinitely. A persistent service should track subscription expiry and active-stream health.

When it beats polling

For one agent watching a handful of pull requests, SSE can reduce idle API calls and make feedback arrive without a public receiver. If the workflow needs delivery after a process is offline, replay, broad repository event coverage or durable processing, this preview does not promise those properties. Use a webhook plus a queue or another durable event architecture where missed work is unacceptable, and reconcile with the GitHub API either way.

The right migration is to replace the polling loop only after designing recovery. Open the subscription, fetch current state, process notifications as hints, and fetch authoritative state again after every gap. That pattern gets the responsiveness benefit while keeping the pull request—not the transient stream—as the source of truth.

Advertisement

Frequently asked questions

Do GitHub Event Streams replay events after a disconnect?

No. GitHub documents that events are delivered only while the stream is open, with no replay for events before connection or during a disconnect. Fetch the pull request once after subscribing and again after reconnecting to reconcile current state.

Are Event Streams a replacement for GitHub webhooks?

They serve a different connection pattern. Event Streams use a client-opened Server-Sent Events connection and do not require a publicly reachable webhook receiver, which can suit a developer machine. Webhooks remain appropriate for server-side integrations that need GitHub to call a stable endpoint.

What do GitHub Event Streams currently support?

The public-preview documentation describes subscriptions for pull requests, with review, commit, merge-conflict, state and check-suite events. GitHub says the API and event types may change during preview.

Sources & further reading

/* Comments */