Klaviyo segment not updating — what to check

---

title: "Klaviyo segment not updating — what to check" description: "Why Klaviyo segments stop refreshing on schedule — relative-time lag, negative-condition processing, stalled rebuilds, and stale profile properties — with diagnostic steps." slug: "klaviyo-segment-not-updating" publishedAt: "2026-05-19" updatedAt: "2026-05-19" painCluster: 5 intent: 8 tier: 2 faq:

• q: "Why is my Klaviyo segment not updating?" a: "Klaviyo segments built on relative-time conditions (for example, 'opened email in the last 30 days') only re-evaluate once every 24 hours, not continuously. If the segment looks stale, it may be working as designed. Segments built on event-based conditions update within minutes; segments with relative-time logic refresh on a daily cron."
• q: "How long does it take for a Klaviyo segment to update?" a: "Event-based segments (placed order, opened email a specific time) update within minutes of the underlying event. Relative-time segments rebuild once per 24 hours. Profile-property segments update whenever the property changes, but custom-property updates from imports or APIs can lag by hours depending on payload size."
• q: "Why is my engaged segment shrinking?" a: "Three usual causes: list growth has slowed so fewer profiles are entering the engaged window; existing profiles aren't engaging at the previous rate (a deliverability or content issue); or a definition change excluded profiles that were previously included. Compare the segment's daily snapshot count over the trailing 30 days to see which pattern fits."
• q: "Can I force a Klaviyo segment to recalculate?" a: "No — Klaviyo doesn't expose a manual rebuild action. Edits to the segment definition trigger a rebuild, so duplicating the segment and re-saving its definition will force a fresh evaluation. For relative-time segments, that's the fastest path to a forced refresh."
• q: "Why does my segment count differ from what the preview shows?" a: "The preview runs against a sample of recently-evaluated profiles, while the live segment count reflects the last full evaluation. If a relative-time segment was last evaluated 18 hours ago, the live count won't include the last 18 hours of events. The preview is a sanity-check, not a real-time count."
• q: "Will Klaviyo tell me if a segment stops updating?" a: "No. Klaviyo's UI shows the most recent count regardless of when that count was last calculated. There is no UI surface for 'this segment hasn't refreshed in N hours.' Detecting segment staleness is one of the patterns external monitoring tools watch for."
• q: "Do custom profile properties update segments in real time?" a: "Updates from the Profile API update segments within minutes. Bulk imports of profile properties can take hours to fully propagate, particularly on lists with millions of profiles. If you've just imported a CSV and the segment isn't reflecting the new properties, wait 4-6 hours before assuming something is broken." related:
• klaviyo-engagement-segment-shrinking
• klaviyo-flow-not-sending-emails
• klaviyo-open-rate-dropped

---

A Klaviyo segment that has stopped updating sits in the same uncomfortable category as a Klaviyo flow that has stopped firing: the UI looks fine, the count looks plausible, and the only way to notice the problem is to compare today's number against last week's and ask whether it should have moved more.

Most of the time, when a segment "stops updating," it isn't actually broken — it's working as designed, but the design has a slower refresh cadence than the operator expected. Relative-time segments rebuild once every 24 hours. Profile-property updates from imports take hours to propagate. Negative conditions ("hasn't opened in 90 days") have evaluation lag that compounds over the size of the list.

This page walks through the failure modes in order of likelihood. If the segment is feeding a flow whose entries have dropped, start with the diagnostic checklist below — the segment may be fine, and the flow filter may be the culprit.

Quick diagnosis checklist

• Read the segment definition carefully. Note every condition. Flag any that reference "in the last X days/hours" — those are relative-time conditions and refresh only once per 24 hours.
• Check the segment's "Members over time" chart. A flat line at the bottom means the segment isn't gaining new members. A flat line at any value means it isn't losing them either. A typical healthy engaged segment shows daily noise of a few percent.
• Duplicate the segment, save it, and check the new copy's count. If the duplicate's count differs materially from the original's, the original is showing a stale evaluation.
• Check whether you've imported profile properties recently. Bulk imports can take 4-6 hours to propagate to segment membership.
• Verify the segment isn't blocked by a stalled account-level operation. If you switched accounts mid-import or mid-segment-build, Klaviyo can leave the segment in a stuck state.
• Look at the segment's underlying events. If the events the segment depends on (Opened Email, Placed Order) have stopped firing, the segment will silently stop gaining members.

1. Relative-time conditions only refresh once per 24 hours

This is the single most common reason a Klaviyo segment "isn't updating" — it is updating, just on a slower schedule than operators expect.

The pattern. A segment with a condition like "Opened Email in the last 30 days zero times" looks like it should evaluate continuously. It doesn't. Klaviyo runs a once-daily job that recomputes every segment with relative-time conditions and updates membership. Between runs, the segment's count is frozen, regardless of what events fired in the meantime.

How to verify. Open the segment. Look for any condition using "in the last X days," "more than X days ago," or similar. If you see one, the segment is on the daily-rebuild cadence.

How to work around it. If you need a faster refresh for a downstream flow, restructure the condition to use an event-based filter inside the flow itself rather than relying on segment membership. Event filters evaluate at flow-entry time, not on the daily segment cadence.

The trap. Operators sometimes build flows that trigger on "added to a segment" where the segment uses relative-time logic. The flow then fires in daily batches when the segment rebuilds, not continuously as profiles cross the threshold. If your "engaged in last 7 days" flow is sending huge bursts once a day and nothing in between, this is why.

2. Negative conditions create evaluation lag at scale

Negative segment conditions ("has not done X") are computationally expensive — Klaviyo has to evaluate every profile against every event in the relevant window, then exclude profiles that match. On lists over a few hundred thousand profiles, this evaluation can lag.

How to verify. Look at the segment's definition. Count the negative conditions ("has not done," "is not," "zero times"). If you have more than two, or if the negative conditions reference very large event volumes, the segment is in slow-evaluation territory.

How to fix. Where possible, rewrite negative conditions as positive ones. Instead of "has not opened in 90 days," consider "last opened more than 90 days ago" — same logical result, faster evaluation. Klaviyo's segment engine handles "last X event timestamp" comparisons more efficiently than universal-quantifier "zero times" checks.

Why it matters. Slow evaluation isn't a bug — but it does mean the segment's count can lag behind reality by 12-24 hours on large lists. If you're using the segment to trigger time-sensitive flows, that lag becomes a real revenue gap.

3. Profile-property imports take hours to fully propagate

If you update profile properties via a CSV import, an API push, or a third-party integration, the segment counts that depend on those properties don't update instantly. On small lists the lag is invisible. On large ones it can be material.

How to verify. Note the time you started the import. Wait six hours. Recheck the segment count. If it has moved meaningfully, the lag was the cause and you can recalibrate expectations. If it hasn't moved, the issue is elsewhere — check whether the import actually completed (Klaviyo's data feed page shows in-progress and completed imports).

Why this happens. Property updates are processed in a separate pipeline from event ingestion. The pipeline batches updates for efficiency, which introduces latency. For most segments, the lag is acceptable. For segments that need to react quickly to property changes, consider event-based triggers instead.

4. The underlying events have stopped firing

A segment that depends on Opened Email, Placed Order, or any other event will silently stop gaining new members if the underlying event stops being recorded. The segment doesn't break — it just doesn't grow.

How to verify. For each event referenced in the segment definition, open Analytics → Metrics → [event name]. Check the recent-events chart. If the right edge is flat and the previous week shows steady volume, the event has stopped firing. The segment is healthy; the data feeding it is not.

Where this comes from. This is the cluster 4 failure mode bleeding into segments. A broken Shopify integration stops Placed Order events. A dropped tracking snippet stops Viewed Product events. The segment depending on those events looks fine — it just stops growing.

5. The segment is stuck in a stalled rebuild

This is rare but real. If you switched accounts in the middle of a segment build, or if an underlying account-level operation timed out, Klaviyo can leave a segment in a state where its definition is saved but the membership calculation never completed.

How to verify. Duplicate the segment. Save the duplicate. Check whether the duplicate's count matches what you'd expect. If the duplicate has a very different count from the original — particularly if the original count has been static for days while the duplicate moves — the original is stuck.

How to fix. Replace the stuck segment with the duplicate. Anywhere the stuck segment is referenced (flows, campaigns), swap in the new one. Then archive the broken segment. There is no "rebuild this segment" button in Klaviyo; the practical fix is to recreate it.

How to verify the fix

After any change, here's the confirmation sequence:

1. Note the current count. Write it down. You'll need it tomorrow.
2. Wait 24 hours. If the segment uses relative-time conditions, this is the minimum refresh window.
3. Compare counts. Healthy segments show daily noise of at least a few percent. A flat count over 48 hours on a list with meaningful activity is suspicious.
4. Cross-check with a manual count. Build a temporary segment with the same conditions in a separate view. Compare. If the temporary segment has a materially different count, the original is still stale.

If after 48 hours the segment still hasn't moved meaningfully, the issue is upstream — almost always an event or integration that has stopped firing.

Why this keeps happening

Segment staleness is structural. Klaviyo's segment engine has to balance accuracy with performance, and the compromise it lands on is a multi-tier refresh schedule — events propagate fast, properties propagate medium, relative-time evaluations propagate slow. Each tier is reasonable in isolation. In combination, they produce a system where "stale" is a continuum, not a binary, and the operator has no UI signal for where any particular segment sits on that continuum.

That gap is what always-on monitoring closes. We track segment membership counts daily, flag segments whose count hasn't moved when you'd expect it to, and surface the upstream metric drift that's usually the real cause. The segment isn't broken — the data feeding it is, and the time between break and detection is what we shorten.