Back to Blog
Integration

Shopify Changed When Two Webhooks Fire. Your Payload Tests Didn't Notice.

In October 2026 Shopify stopped sending carts/update for cart operations that change nothing, and started sending customers/enable on a customer's first sign-in. Same payloads, new firing rules. Why trigger conditions belong to the webhook contract, and how to notice when they move.

WebhookVault Team · Webhook Infrastructure Experts10 min read
A person holding a bank card in one hand while typing on a silver laptop keyboard with the other, on a light wooden table

A quieter topic can still be a healthy one

Your abandoned-cart service has a chart of carts/update deliveries per hour. Sometime in the middle of October the line dropped and stayed down. No errors. No failed deliveries. Signature checks all pass. The handler code has not changed in months. And yet the reminder emails now go out to shoppers who were still browsing, because the timer that used to be reset every few minutes is no longer being reset.

Nothing broke on your side. Shopify changed when the webhook fires. The payload is identical. The topic name is identical. What changed is the rule that decides whether a delivery happens at all, and nothing in a typical webhook test suite looks at that rule.

What Shopify changed on October 12

On October 12, 2026, at 10:00 AM Eastern, Shopify changed how carts/update is triggered from the Ajax API and the Storefront API. Before that, every cart operation produced a carts/update webhook. A theme that posted to /cart/update.js with the same quantity it already had, a script that re-applied an attribute on every page load, a headless storefront that synced the cart on each route change: each of those requests produced a delivery, even when the cart came out of it exactly as it went in.

Now a cart operation that leaves the cart unchanged sends nothing. Shopify sends the webhook when the cart's contents or properties actually change. The changelog files it under "Update" with no action required, and describes it as removing redundant notifications.

For Shopify that is a sensible cleanup. For you it changed how many events arrive and what one of them means, and it came with no version bump.

The customers/enable change runs the other way

Sixteen days later Shopify published a second change that moves in the opposite direction. When a customer signs in to customer accounts for the first time, Customer.state now goes from DISABLED to ENABLED, and that transition fires both customers/enable and customers/update. It applies to every sign-in method. The changelog entry is dated October 28, 2026, but gives October 17 as the date the behaviour took effect, so for eleven days the new deliveries were arriving before the announcement existed.

There is a second detail in that entry worth reading twice. Customers who had already signed in between May 27, 2024 and the change were moved to enabled by an earlier one-time update, and that update sent no webhooks. So the same state transition now happens with a webhook for new customers and already happened without one for a large historical group.

One change removed deliveries your code may have relied on. The other added deliveries your code may never have seen. Neither touched the payload schema.

Firing conditions are part of the contract

When people talk about a webhook contract, they mean the payload: field names, types, the envelope, the signature header. Versioning schemes protect exactly that. Shopify ties payloads to an API version, Stripe pins them to your account's API version, and most other providers do some version of the same.

The trigger rules sit outside all of that. "When does carts/update fire?" is answered by provider code that runs before serialisation, and no API version pins it. It is documented in a sentence or two, if at all, and the sentence is usually vague enough to stay true while the behaviour underneath it changes.

That makes it the least protected part of the integration and, often, the part you depend on most. Your handler reads the payload, sure. It also assumes something about why the payload exists. "A carts/update arrived, so the shopper is active." "A customers/enable arrived, so an admin invited this person." Both are guesses based on the firing rule. When the rule moves, they quietly turn false.

Why your payload tests stayed green

Think about what a webhook test usually checks. You record a delivery, store it as a fixture, and assert that the handler parses it and does the right thing. Contract tests go a step further and validate fixtures against a schema. Both are good practice. Neither has any opinion on how many deliveries should exist.

A fixture is one event in isolation. It cannot tell you that the provider used to send forty of them per checkout and now sends six, or that a topic which only ever fired from the admin now fires from a storefront sign-in. Our post on a Shopify Events field changing from array to object was about a change your schema validation can catch if you bother to run it. This one is the class of change it can never catch, because every individual delivery is still perfectly valid.

Production metrics have the same blind spot when they are built around failures. A success rate of 100% on half the volume is still a success rate of 100%.

Who was quietly depending on the noise

Redundant deliveries look like waste until you find the code that was using them as a signal. With carts/update, start with your activity timers. Abandoned-cart flows that reset a countdown on every update treated each no-op cart sync as proof the shopper was still there. That proof is gone.

Then look for heartbeats. Some apps derive "last seen on storefront" from the most recent carts/update, because it was the only storefront signal reaching the server. Those timestamps now lag behind real activity.

Alerting is next. A "no carts/update for 30 minutes on a busy shop" alert was tuned against a baseline that included the no-op traffic. Without that traffic it fires on quiet afternoons.

Dedup windows are the harmless case. Handlers that collapsed bursts of identical updates now see fewer bursts. But if you sized a queue or a rate limit around the old burst shape, you are over-provisioned and you won't notice.

With customers/enable, the risk runs the other way. If your handler treats customers/enable as "a merchant invited this customer and they accepted", it now fires for something else entirely. A welcome email, a CRM lifecycle stage, a loyalty-points grant or a "new account" metric can all run for people who have been customers for years and just signed in once. Shopify's own guidance is to check that your app acts at the right moment. Read that as: the moment has changed.

The backfill that never comes

The quietest part of the customers/enable change is the historical cohort. If you built "all enabled customers" from webhooks alone, your table is now wrong in a way no future delivery will fix. Customers who signed in between May 2024 and the change were flipped to enabled with no event. Your database still says disabled, and it will say that until something reads the current state from the API.

This is the general rule, and it is why a webhook-only mirror always drifts. Providers run one-off migrations, bulk updates and data repairs that change state without emitting events, because emitting millions of events for a migration would be its own incident. We covered the structural version of this in why webhooks do not keep your state in sync. Shopify's changelog just happens to put it in writing. With dates.

If you keep customer state in sync from webhooks, run a one-time reconciliation of state against the Admin API now. Then keep a periodic one, because this will not be the last silent migration.

Measure topic volume per shop

You cannot read every provider's changelog every day, and as the customers/enable entry shows, reading it would not have warned you anyway. What you can do is watch for the symptom: a sudden, sustained step in delivery volume for one topic that does not match a step in the business.

Track deliveries per topic per shop, normalised against something the provider's trigger rules cannot touch, such as your own order count or page traffic. A ratio that steps and stays stepped means the rule moved.

-- carts/update deliveries per order, per shop, per day.
-- A step change that persists for days is a firing-rule change, not a traffic change.
SELECT
  d.shop_domain,
  date_trunc('day', d.received_at)              AS day,
  count(*) FILTER (WHERE d.topic = 'carts/update') AS cart_updates,
  count(DISTINCT o.id)                           AS orders,
  round(
    count(*) FILTER (WHERE d.topic = 'carts/update')::numeric
      / NULLIF(count(DISTINCT o.id), 0), 1
  )                                              AS updates_per_order
FROM webhook_deliveries d
LEFT JOIN orders o
  ON o.shop_domain = d.shop_domain
 AND date_trunc('day', o.created_at) = date_trunc('day', d.received_at)
WHERE d.received_at > now() - interval '45 days'
GROUP BY 1, 2
ORDER BY 1, 2;

Alert on the ratio. Raw counts move with Black Friday. A ratio that halves overnight on every shop at once is the provider. Your customers didn't all change their habits on the same Sunday. That simultaneity is the tell: a firing-rule change lands across all tenants on the same day, while real behaviour changes are staggered.

For topics that should rarely fire, watch the opposite. A topic that jumps from a few deliveries a week to dozens a day, as customers/enable can after October 17, deserves a look even when every one of those deliveries succeeds.

Derive meaning from state

The fix that lasts is in the handler. "This webhook arrived" is a hint that something may have changed. Decide what actually happened by comparing the current state with what you last recorded.

// customers/enable can mean "invite accepted" or "first sign-in".
// Decide from the transition you observe, not from the topic name.
async function onCustomerEnable(customerId: string) {
  const current = await shopify.getCustomer(customerId) // fresh read, not the payload
  const previous = await db.customers.find(customerId)

  if (previous?.state === current.state) return // nothing new for us

  await db.customers.upsert({ id: customerId, state: current.state })

  if (current.state === 'ENABLED' && !previous?.welcomedAt) {
    // Act once per customer, whatever triggered the transition.
    await sendWelcome(customerId)
    await db.customers.markWelcomed(customerId)
  }
}

The welcome email now depends on "this customer has never been welcomed". You own that fact. "Shopify sent this topic" is a rule Shopify owns, and Shopify can change it on a Thursday. The same thinking applies to the cart timer: base it on the cart's updated_at or line contents compared with the last value you saw, and accept that the absence of deliveries is not the absence of a shopper. It is the fetch-on-notify pattern again, used for meaning this time, where it is usually used against staleness.

Read changelogs for the verbs

When you do read a provider changelog, the entries that hurt are rarely the ones marked breaking. Breaking changes get a version, a deadline and an email. The ones to look for change a verb: "no longer triggers", "now sends", "now fires", "will also emit". Both Shopify entries here are written exactly that way, and neither was flagged as action required.

A cheap habit: subscribe to the webhook-filtered changelog feed for each provider you depend on, and grep the titles for topic names you handle. When one appears, ask a single question: does any code of mine depend on how often this fires, or why? If the answer is yes, that code should read state. Counting deliveries is how you got here. Sender-side behaviour you cannot see is the same trap as a filter in the sender's dashboard: the events that do not arrive never show up as failures.

Frequently asked questions

Does the carts/update change affect checkout or order webhooks? The changelog only covers carts/update triggered through the Ajax API and the Storefront API. Order, checkout and fulfilment topics are not mentioned. Treat them as unchanged, but put them on the same volume-ratio monitoring so you would see it if their rules moved too.

How do I find customers who were enabled without a webhook? Read state for your customers from the Admin API and compare it with what your database holds. Any customer the API reports as enabled while you still have them as disabled was changed without an event reaching you, most likely by the one-time update Shopify describes for sign-ins between May 27, 2024 and October 2026.

Should I subscribe to customers/update instead of customers/enable? It does not solve the meaning problem. Shopify sends both topics on a first sign-in, and customers/update fires for many other reasons as well. Pick whichever topic gets you notified, then decide what happened by comparing current state with your last recorded state.

Can a payload version pin protect me from trigger changes? No. Pinning an API version fixes the shape of the payload. The conditions that produce it are outside the pin. Neither changelog entry ties its change to an API version; both carry a date instead. The only protection is handlers that act on observed state and monitoring that watches delivery volume.

Related posts