Skip to content

Flow Lifecycle

Also called: WhatsApp Flow status · Flow statuses · Flow status lifecycle

The Flow lifecycle is the set of statuses a WhatsApp Flow moves through — Draft, Published, Throttled, Blocked, Deprecated — and what you can do in each.

Reviewed

What is the Flow lifecycle?

The Flow lifecycle is the sequence of statuses a WhatsApp Flow passes through from creation to retirement, together with the rules for what can be edited, sent and opened in each. There are five: DRAFT, PUBLISHED and DEPRECATED, which the business controls, and THROTTLED and BLOCKED, which WhatsApp sets on its own when it detects that a Flow's endpoint or screen navigations are unhealthy.

A new Flow starts as a draft. In DRAFT its Flow JSON and settings can change freely, it can be deleted, and it can be sent only for testing, with mode: "draft" in the message. Publishing moves it to PUBLISHED, after which it can never be deleted. Meta's lifecycle guide lets you edit a published Flow's metadata or Flow JSON, but the edit returns it to Draft until you publish again, and only messages sent after that carry the new version — Flows already delivered keep the one they were sent with. Some older Flows don't support editing and must be cloned with clone_flow_id instead. When a Flow is no longer wanted, deprecating it retires it for good: it can no longer be sent to real customers, it can't be restored, and Meta warns that copies already on customers' phones may still send responses.

The two system statuses protect customers from broken Flows. When endpoint error rate, latency or availability deteriorate, a published Flow becomes THROTTLED — it still opens and sends, but only 10 messages an hour — and if health keeps getting worse it becomes BLOCKED: the business cannot send it and customers cannot open copies they already received. Recovery is automatic and runs back the same way: once the endpoint is healthy again, a blocked Flow moves to Throttled and then to Published. The lifecycle describes the Flow's state over time, separate from its content (the Flow JSON) and from the status of any template used to send it.

Key takeaways

  • Every WhatsApp Flow is in one of five statuses: DRAFT, PUBLISHED, THROTTLED, BLOCKED or DEPRECATED.
  • Drafts can be deleted and sent only for testing; once published, a Flow can never be deleted, only deprecated for good.
  • Editing a published Flow returns it to Draft until you publish again, and messages already sent keep the old version.
  • WhatsApp sets THROTTLED (10 sends an hour) and BLOCKED automatically when a Flow's endpoint is unhealthy.
  • Status changes arrive as FLOW_STATUS_CHANGE events on the flows webhook field.

See InfiQ pricing

Interactive stop

Follow a Flow from draft to retirement

3 / 3
  • Draft to Published: publish
  • Draft to Deleted: delete
  • Published to Draft: edit
  • Published to Throttled: health drops
  • Throttled to Published: recovers
  • Throttled to Blocked: gets worse
  • Blocked to Throttled: improves
  • Published to Deprecated: deprecate
  1. Draft
  2. Published
  3. Deprecated

Step 3 of 3 · end of walk

Deprecated

Retired by the business, from Published, Throttled or Blocked. It can no longer be sent to real customers and the change is one-way; late responses from delivered copies may still arrive.

Arrived from Published via deprecate.

Can move to

Nothing — this is a final state.

Walk a Flow through the statuses it can hold. Switch paths to see an edit and re-publish, the endpoint-health detour WhatsApp applies automatically, or a draft that never ships.

Happy path, step 3 of 3: Deprecated (via deprecate). Retired by the business, from Published, Throttled or Blocked. It can no longer be sent to real customers and the change is one-way; late responses from delivered copies may still arrive.

How does the Flow lifecycle work?

  1. Create: DRAFT

    POST /{WABA_ID}/flows creates the Flow as a draft. Upload Flow JSON, clear the validation_errors, and send test messages with mode: "draft".

  2. Publish: PUBLISHED

    POST /{FLOW_ID}/publish makes it sendable to every customer. Meta expects a verified business with high message quality and no open validation errors or publishing checks; from then on the Flow can't be deleted.

  3. Change it: edit or clone

    Uploading new Flow JSON or metadata to a published Flow returns it to Draft; test it and publish again, and only new sends carry the change. For a big change, or an older Flow that doesn't support editing, create a new Flow with clone_flow_id, test the draft, publish it and switch your sends to the new flow_id while the original keeps running.

  4. React to THROTTLED and BLOCKED

    If the endpoint degrades, WhatsApp limits the Flow to 10 messages an hour (sends beyond that fail with error 132069), then blocks it (error 132068). Fix the endpoint; the status recovers on its own.

  5. Retire: DEPRECATED

    POST /{FLOW_ID}/deprecate stops the Flow being sent to real customers once a replacement is live. It can't be undone, and only drafts can be deleted outright. Keep handling its responses for a while — copies already delivered may still be submitted — before you retire its endpoint.

The Flow lifecycle: key facts and limits

Statuses
DRAFT, PUBLISHED, THROTTLED, BLOCKED, DEPRECATED
Set by the business
Draft (on create), Published, Deprecated
Set by WhatsApp
Throttled and Blocked, on unhealthy endpoint or navigations
Throttled
Opens and sends, but only 10 messages an hour (error 132069 beyond)
Blocked
Can't be sent or opened (error 132068)
Edit or delete
Delete drafts only; editing a published Flow returns it to Draft
Deprecated
Can't be sent to real customers; terminal, can't be restored
Webhook
flows field, event FLOW_STATUS_CHANGE

The Flow lifecycle in code

# Publish a draft (fails while validation_errors remain)
curl -X POST "https://graph.facebook.com/v26.0/{FLOW_ID}/publish" \
  -H "Authorization: Bearer {ACCESS_TOKEN}"
 
# Check status, validation errors and health before a campaign
curl "https://graph.facebook.com/v26.0/{FLOW_ID}?fields=name,status,validation_errors,health_status" \
  -H "Authorization: Bearer {ACCESS_TOKEN}"
 
# Small change: upload new Flow JSON (a published Flow returns to DRAFT; publish again)
curl -X POST "https://graph.facebook.com/v26.0/{FLOW_ID}/assets" \
  -H "Authorization: Bearer {ACCESS_TOKEN}" \
  -F "file=@flow.json;type=application/json" -F "name=flow.json" -F "asset_type=FLOW_JSON"
 
# Big change or an older Flow: clone it into a new draft (the original keeps running)
curl -X POST "https://graph.facebook.com/v26.0/{WABA_ID}/flows" \
  -H "Authorization: Bearer {ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{ "name": "admission_enquiry_v2", "categories": ["LEAD_GENERATION"], "clone_flow_id": "{FLOW_ID}" }'
 
# Retire the old version (one-way)
curl -X POST "https://graph.facebook.com/v26.0/{FLOW_ID}/deprecate" \
  -H "Authorization: Bearer {ACCESS_TOKEN}"
 
# Delete: drafts only
curl -X DELETE "https://graph.facebook.com/v26.0/{FLOW_ID}" \
  -H "Authorization: Bearer {ACCESS_TOKEN}"

Common mistakes with the Flow lifecycle

  • Expecting an edit to reach Flows already sent

    Customers who already received the Flow keep the version they were sent, and the edited Flow sits in Draft until you publish again. Keep your webhook tolerant of both versions' payloads for a while, and resend the Flow if everyone needs the new one.

  • Launching with draft settings

    Drafts can only be sent in test mode. If production code still sends mode: "draft" or a draft flow_id, real customers won't receive the Flow. Publish first and drop the draft flag.

  • Deprecating too early

    Deprecation is permanent and stops every new send. Check that no template, campaign or bot path still references the old flow_id before you deprecate it, and keep handling its responses afterwards — Meta warns they can still arrive from copies already delivered.

  • Missing a throttle

    A throttled Flow still sends — just ten an hour — so campaigns degrade quietly. Subscribe to the flows webhook, alert on THROTTLED and BLOCKED, and watch endpoint health before it gets that far.

Example: A clone release and a throttle in Lucknow

A Lucknow coaching institute publishes an admission-enquiry Flow in March. In June it needs a new "preferred batch" field. Rather than editing the live Flow mid-admissions, the developer clones it so the current version keeps taking enquiries, adds the field to the draft, has two counsellors test it with mode: "draft", publishes the clone and points the website's click-to-chat handler at the new flow_id. The original is deprecated a week later, once no campaign still uses it, and the webhook keeps accepting its older payload shape for late submissions. In July the institute's endpoint slows down during results week: a FLOW_STATUS_CHANGE webhook reports PUBLISHED → THROTTLED, the on-call engineer scales the endpoint, and a second event reports THROTTLED → PUBLISHED forty minutes later — before the Flow ever reached Blocked.

— A clone release and a throttle in Lucknow

Why does the Flow lifecycle matter?

Status decides whether a Flow works for customers right now. Teams get caught out in predictable ways: they edit a live Flow and expect customers who already received it to see the fix, they forget that testers were using a draft real customers cannot receive, or they miss a throttle until a campaign mysteriously sends ten an hour. Tracking status through the webhook and the API, and treating every change as a tested release with a version number, keeps Flows dependable.

Best practices for the Flow lifecycle

  • Put the version in the Flow name (admission_enquiry_v2) so clones are easy to tell apart.
  • Keep the live flow_id in configuration, not code, so switching versions is a config change.
  • Check health_status before a large campaign that uses a Flow with an endpoint.
  • Keep the old version published until the new one is proven, then deprecate it.

Flow Lifecycle FAQs

Can I edit a WhatsApp Flow after publishing it?+
Yes, but editing a published Flow's metadata or Flow JSON returns it to Draft until you publish it again. Only messages sent after re-publishing carry the new version. Some older Flows don't support editing; clone those with `clone_flow_id`, publish the clone and switch your sends to its `flow_id`.
Why is my WhatsApp Flow throttled?+
WhatsApp throttles a Flow when its endpoint or screen navigations look unhealthy — a rising error rate, high latency or low availability. Sending is limited to 10 messages an hour; fix the endpoint and the Flow returns to Published automatically.
What happens to Flows customers already received when a Flow is blocked?+
They can't be opened. While a Flow is Blocked the business cannot send it and customers cannot open it, including earlier messages, until health improves and the Flow steps back to Throttled and then Published.
Can I delete a WhatsApp Flow?+
Only while it is a draft. Once a Flow has been published it can't be deleted; deprecate it instead, which stops it being sent to real customers and can't be reversed.

Talk to InfiQ

From definition to your first message

InfiQ is an official Meta Business Partner. Start a 7-day free trial — no card needed — and see this running on your own number.

Start free trialBrowse all 550 terms