Waiting Room keeps a site available during traffic surges by diverting excess visitors into a customizable virtual queue and admitting them as capacity frees up. Until now, operators could only watch the status endpoint, which reports the number of queued users, the number of active users on the site, and the estimated wait time shown to the last person in line. That endpoint still gives a useful near real-time snapshot, but it cannot answer the questions that matter when tuning a configuration: how long visitors actually spent in the queue, what the peak visitor count was, how long a pre-queue for an online event lasted, or how a settings change affected wait times.

Waiting Room Analytics closes that gap. Available in the Waiting Room dashboard to all Business and Enterprise plans, it provides metrics on end-user experience and visualizations of waiting room traffic, so configuration choices can be based on observed behavior rather than guesswork while the site stays protected from overwhelming spikes.

BLOG-1865 Embedded Image - JD7PjV

Reading the metrics against your settings

The core of the feature is the feedback loop between what visitors experience and how the waiting room is configured. Because the analytics surface both end-user experience and traffic volume, a queue-length figure can be judged alongside the wait that visitors actually endured, and a change to settings can be evaluated by what happened to wait times afterward. The same data answers the operational questions above — queue duration, peak arrivals, pre-queue length for event scenarios — that the status endpoint could not address.

BLOG-1865 Embedded Image - 6Q19bM

Building analytics on a distributed network

Waiting Room itself runs on Cloudflare's Durable Objects, a design documented in a January 2021 behind-the-scenes look at how the product was built. Bringing analytics to that architecture presented a distinct engineering problem, which the following section examines.

From status checks to historical insight

The status endpoint remains the right tool for an at-a-glance view of current conditions, and the analytics feature does not replace it. What changes is that customers who previously had to infer performance from a single moment in time now have traffic visualizations and experience metrics covering the questions they were asking, on Business and Enterprise plans.

From queue times to origin dwell: reading the dashboard

Cloudflare's Waiting Room dashboard opens with pre-built visualizations of peak waiting room traffic over the last 24 hours. Selecting View more opens the full analytics view and extends history to 30 days. For a past event inside that window, the blue link in the events table opens the dashboard at the event's exact start and end times, pre-queueing period included.

To get data tied to a past event, simply select the link in the Waiting Room Events table.

The first two metrics describe users rather than infrastructure. Time in queue shows how long queued users waited before entering the site over the selected period; time on origin estimates the range of time users spend on the site before leaving. Both are reported for the typical user, as a range between the 50th and 75th percentiles, and for the top 5% of users with the longest waits or visits.

The Time in queue and Time on origin are given for the typical user as well as for the 95th percentile of users.

When session renewal is disabled, time on origin never exceeds the configured session duration, because users receive a new waiting room cookie once their session lapses and the timer restarts. A typical time on origin that sits close to session_duration therefore suggests users may need more time to finish their journey before being sent back to the line.

Further down, charts compare observed traffic against the room's two thresholds: Total active users caps concurrent users on the site, and New users per minute caps the influx rate. In the Active users chart, each bar stacks the peak number of queued users on top of the peak number of active users for that moment, so the full bar height shows everyone either on the site or waiting, with the split visible where the active-user threshold engaged. Hovering a bar reveals exact values. A finer-grained view comes from dragging across a time range, which rescales the other graphs and insights to match.

BLOG-1865 Embedded Image - GsZhRD

The New users per minute chart plots incoming rate against the configured limit and is the place to spot surges that triggered queueing.

BLOG-1865 Embedded Image - 8wSBlu
BLOG-1865 Embedded Image - wXZRW9

Because either threshold can start a queue, both charts need review before concluding which setting caused a given wait.

Tuning settings against observed traffic

A frequent complaint is wait times longer than expected during peaks. The analytics support a repeatable workflow: pick the peak, judge the waits, then change one setting at a time.

First, zoom out to a window that contains a known high-traffic event—up to 30 days—and drag across the peak so every other panel updates to that period. Then check Time in queue for that window. If waits were worse than anticipated, three options exist.

  • Shorten session duration while renewal is enabled. This opens spots faster as users go idle without raising allowed load. It suits request-heavy journeys such as checkout, but not video streaming or long-form reading, where users are active without making frequent requests.
  • Disable session renewal. Also load-neutral, this gives each user session_duration minutes before rejoining the queue—popular for high-demand events like product drops where fairness and limits on inventory hoarding matter. Set the duration from analytics: if it stands at 10 minutes while even the longest visitors leave after about 5, cutting it to 5 frees capacity with little disruption.
  • Raise Total active users or New users per minute. The surest lever, but the riskiest. Change limits in small steps and watch origin CPU and memory plus any rise in 5xx errors, visible in Web Analytics. Past surges handled without instability are a strong signal that higher limits are safe. The two traffic charts show which limit is actually driving queueing, so adjust that one and keep monitoring.
BLOG-1865 Embedded Image - AVirtB

Inside the analytics pipeline

Waiting Room runs on Workers and Durable Objects, with every request passing through a Worker; isolates let the platform spin up hundreds or thousands of them within 5 milliseconds at little overhead. Rather than track each visitor, the system buckets users by the timestamp of their first request: anyone arriving between 00:00:00 and 00:00:59 lands in bucket 00:00:00. Each user gets an encrypted cookie on that first request that is updated as their queue status changes, holds the join timestamp used to compute queue wait, and receives an expiry of session_duration minutes from the last request once the user is accepted to the origin.

Collecting metrics across a distributed system leaves two designs: have every worker write raw per-request data, or reuse the aggregation path. Because Waiting Room configurations are minute- and user-based, while per-request writes are not tied to either, Cloudflare chose the existing routing pipeline. Workers report to their data center coordinator, which aggregates and forwards to a global Durable Object; that aggregated stream serves routing decisions and analytics alike, so what customers see matches how the room actually behaves, and writing one pre-processed log per minute costs less space and is less noisy.

The Waiting Room is a distributed system that receives requests from multiple locations around the globe

Counts such as new users per minute and total active users can simply be summed, but durations cannot: adding a user who waited four minutes to one who joined two minutes ago gives a meaningless six. Time on origin and total time waited in queue are therefore stored as histograms, which allows accurate quantiles for the typical (50th percentile) and near-worst (95th percentile) cases. Cloudflare uses Hdr Histogram, recording a value in 3–6 nanoseconds in constant time, adding histograms together, and compressing them to base64 for transport. Memory stays constant at a 32-bit bucket size and three significant digits, with auto-resizing; a cap of 5,000 recorded points per minute keeps storage efficient and has proven adequate.

Histograms travel from workers to the per-data-center Durable Object, merge there, then merge again at the global Durable Object, which computes quantiles and hands off to a reporting worker that reads configurations from Workers KV. One aggregated message per minute goes to Clickhouse through an internal version of Workers Analytics Engine, written as blobs and doubles against a schema; a Clickhouse view with ABR keeps queries fast at any timescale from 30 minutes to 30 days. Data lives in the table for 30 days, so older periods are unavailable in the dashboard.

Sampling handles large queries at consistent latency. Data is indexed on waiting room id, and ABR stores it at 100%, 10%, 1% and other resolutions, reading the best one that returns in reasonable time. Thanks to pre-aggregation, windows up to 7 days are expected to read at full resolution; longer ranges are sampled.

Querying the data yourself

The same Clickhouse data is exposed through the GraphQL API for custom dashboards, explorable with a client such as GraphiQL. Two datasets under Zones Viewer hold it: waitingRoomAnalyticsAdaptive and waitingRoomAnalyticsAdaptiveGroups, the latter also the place to find groupable dimensions such as time and waiting room id, with the schema under ZoneWaitingRoomAnalyticsAdaptive. Filter by zone, waiting_room_id and request period; order by any metric ascending or descending. The max, min, avg and sum functions aggregate metrics over a period, and avgWeighted computes the weighted mean used for histogram-backed metrics—total active users weights time on origin, since periods with more active users are more representative, and new users per minute weights total time waited, since that instant's arrivals are the users who queued and proceeded to the origin. Dropping the datetime dimension returns per-minute logs instead of a breakdown; sample queries are in the developer documentation.

{
 viewer {
   zones(filter: {zoneTag: "example-zone"}) {
     waitingRoomAnalyticsAdaptiveGroups(limit: 10, filter: {datetime_geq: "2023-03-15T04:00:00Z", datetime_leq: "2023-03-15T04:45:00Z", waitingRoomId: "example-waiting-room-id"}, orderBy: [datetimeHour_ASC]) {
       avgWeighted {
         timeOnOriginP50
         totalTimeWaitedP90
       }
       dimensions {
         datetimeHour
       }
     }

The response arrives as JSON.

{
  "data": {
    "viewer": {
      "zones": [
        {
          "waitingRoomAnalyticsAdaptiveGroups": [
            {
              "avgWeighted": {
                "timeOnOriginP50": 83.83,
                "totalTimeWaitedP90": 994.45
              },
              "dimensions": {
                "datetimeHour": "2023-05-24T04:00:00Z"
              }
            }
          ]
        }
      ]
    }
  },
  "errors": null
}