If your app counts carts/update webhooks, your numbers changed
Update/ 17 min read
Shopify stopped sending carts/update when a cart operation changes nothing. What changed on October 12, how it moves your metrics, and a tested idempotent handler.
- Shopify
- Shopify apps
- Analytics
In this article (8)
Since October 12, 2026, Shopify no longer sends the carts/update webhook when a cart operation leaves the cart unchanged, such as resubmitting values it already holds. You used to get one per request; now you get one per real change. If your app counts those deliveries, the count may have dropped with nothing changing in the store.
Below: what Shopify announced, what it does to your metrics, how to rebuild reports so November comparisons don't mix two counting rules, an idempotent handler we tested locally, and how to see the change on a development store. We read the Shopify docs cited here on November 11, 2026.
What changed in the carts/update webhook
The Shopify changelog entry from October 12, 2026 is titled "Cart updates that result in no changes to the cart no longer trigger carts/update webhooks." It runs four sentences. Cart operations that leave the cart unchanged, "for example, resubmitting the same values a cart already has," no longer trigger carts/update. Shopify sends a webhook every time a cart's contents or properties change. Previously, every cart operation produced one. And the change removes those duplicate notifications, so apps get one carts/update per change instead of one per request.
Three details from the entry matter for your reports:
- Date and time. It took effect on October 12, 2026 at 10:00 a.m. Eastern (UTC-4), which is 14:00 UTC. The entry itself was posted at 12:00 p.m. Eastern, two hours later.
- No API version. The entry gives an effective date and time, not a version: the page data leaves the effective API version blank. Nothing in it suggests that pinning an older version on your subscription keeps the old behavior.
- No action required. Shopify does not flag it as "Action required." Your code does not break; what changes is how many deliveries you receive.
The entry is tagged Ajax API and Storefront API, and it links to the Ajax API cart reference. The webhooks reference, version 2026-10, and the WebhookSubscriptionTopic enum describe the topic this way: it fires when a cart is updated in the online store, it does not cover carts updated in a custom storefront, and it requires the read_orders scope. The entry only covers carts/update; it does not mention carts/create.
Scroll the figure sideways to see all of it
Before and now: one webhook per request vs. one per real change
A storefront theme edits the cart through the Ajax API: /cart/add.js adds products, /cart/update.js changes quantities, the note, attributes or the discount, and /cart/change.js changes one line's quantity or properties. Until October 12, each of those requests produced a carts/update, whether it changed anything or not. Now a request that leaves the cart as it was produces nothing.
An illustrative example, starting from a cart that already holds one item:
| Request | Changes the cart? | Before Oct 12 | Since Oct 12 |
|---|---|---|---|
/cart/change.js, quantity 1 to 2 | Yes | 1 webhook | 1 webhook |
/cart/update.js, note "gift" (was empty) | Yes | 1 webhook | 1 webhook |
/cart/update.js, note "gift" again | No | 1 webhook | None |
/cart/change.js, quantity 2 again | No | 1 webhook | None |
/cart/change.js, quantity 2 to 3 | Yes | 1 webhook | 1 webhook |
| Total | 5 | 3 |
Rows 3 and 4 are what the changelog calls resubmitting the same values. They can come, for example, from a theme that sends the note or the quantity again when the cart drawer closes. How many of those requests your store makes depends on your theme and your apps; Shopify does not publish a share.
Scroll the figure sideways to see all of it
The payload keeps its shape. Per the reference, carts/update carries the cart's id and token, its line_items (with key, quantity, properties, prices and discounts), the note, updated_at and created_at. What changes is how often it arrives.
Duplicate deliveries did not change either. Per Verify webhook deliveries, the same delivery can arrive more than once after a network timeout or a retry (Shopify retries up to eight times over four hours, per Troubleshoot webhooks), and you catch it with X-Shopify-Webhook-Id. Your handler still has to drop those.
How this affects your metrics
Shoppers will not notice anything: the cart works the same way. What moves is anything your app derives from counting deliveries. Check four cases:
- Counts. If a metric is "how many
carts/updatewe received" (cart activity, events per session, volume per store), since October 12 it leaves out requests that change nothing. Illustrative example: a store that received 10,000 deliveries a day, 2,500 of them unchanged-cart requests, now receives 7,500 on the same traffic. The chart shows a 25% drop that does not reflect fewer shoppers. - Rates. If
carts/updatesits in a denominator, the rate goes up for the same reason. In the same illustrative example, 300 orders over 10,000 deliveries was 3%; over 7,500 it is 4%. - Activity signals. If your app treats an incoming
carts/updateas "the shopper is still here," for example to reset an abandoned cart timer, a request that changes nothing no longer resets anything. Check whether your delays relied on those signals. - Alerts. A threshold set on September's volume can fire falsely on November's. If you watch the funnel during peak season, recalibrate first; we cover that in checkout conversion alerts.
What does not move: your orders, and events your theme sends from the browser, such as the GA4 add_to_cart event (how to track add_to_cart in GA4), which never go through webhooks. If a report compares browser events with webhook deliveries, remember that only one of those sources changed on October 12. If those numbers already disagreed, start with why GA4 and Shopify sales don't match.
Scroll the figure sideways to see all of it
How to adjust reports and year-over-year comparisons
First, mark the cutoff on every dashboard: October 12, 2026, 10:00 a.m. ET (14:00 UTC). That day mixes both rules: the early hours count the old way and the rest the new way. Then decide what you measure, deliveries or real changes. If you store each delivery with a fingerprint of the cart, you can rebuild history under the new rule and compare months without mixing rules.
Store each delivery exactly once
The table keeps one row per delivery. Its primary key is X-Shopify-Webhook-Id, which the delivery structure page defines as a unique key per delivery, for identifying and deduplicating. It is the table that our guide to verifying Shopify webhook HMAC signatures left for production. schema.sql:
CREATE TABLE cart_events (
webhook_id text PRIMARY KEY,
event_id text,
shop text NOT NULL,
cart_token text NOT NULL,
fingerprint text NOT NULL,
triggered_at timestamptz NOT NULL,
received_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX cart_events_by_cart ON cart_events (shop, cart_token, triggered_at);
webhook_idis the primary key, so two rows with the same id cannot exist.event_idstoresX-Shopify-Event-Id, shared by every delivery from the same action: use it to correlate, not to deduplicate.shopandcart_tokenidentify the store and the cart.fingerprintis a hash of the cart withoutupdated_at: same fingerprint, same cart.triggered_atcomes fromX-Shopify-Triggered-At. Per About webhooks, Shopify does not guarantee order and recommends sorting by that header or byupdated_at.received_atis there for debugging.- The index serves the report further down.
The handler verifies the signature, reads the delivery id and stores the delivery only if it is new. It is the same idea behind preventing double charges with an idempotency key, with the delivery id playing the key. cart-events.mjs:
import { createHash, createHmac, timingSafeEqual } from "node:crypto";
export function verifyShopifyWebhook(rawBody, hmacHeader, secret) {
if (!secret || typeof hmacHeader !== "string") return false;
const expected = Buffer.from(createHmac("sha256", secret).update(rawBody).digest("base64"));
const received = Buffer.from(hmacHeader);
return expected.length === received.length && timingSafeEqual(expected, received);
}
// headers: lowercase names, as Node and the Fetch API give them.
export async function handleCartsUpdate(db, headers, rawBody, secret) {
if (!verifyShopifyWebhook(rawBody, headers["x-shopify-hmac-sha256"], secret)) return { status: 401 };
const webhookId = headers["x-shopify-webhook-id"];
if (!webhookId) return { status: 400 };
const { updated_at, ...cart } = JSON.parse(rawBody);
const fingerprint = createHash("sha256").update(JSON.stringify(cart)).digest("hex");
const { rows } = await db.query(
`INSERT INTO cart_events (webhook_id, event_id, shop, cart_token, fingerprint, triggered_at)
VALUES ($1, $2, $3, $4, $5, $6)
ON CONFLICT (webhook_id) DO NOTHING
RETURNING webhook_id`,
[
webhookId,
headers["x-shopify-event-id"] ?? null,
headers["x-shopify-shop-domain"],
cart.token,
fingerprint,
headers["x-shopify-triggered-at"] ?? updated_at,
],
);
return { status: 200, counted: rows.length === 1 };
}
verifyShopifyWebhookis the check from the HMAC guide: an HMAC-SHA256 of the raw body with the app's client secret, base64-encoded, compared withtimingSafeEqualafter a length check.- Header names are lowercase, the way Node hands them over; the docs say to treat them as case-insensitive.
- A bad signature gets
401and a missingX-Shopify-Webhook-Idgets400. Neither stores anything. - It sets
updated_ataside and hashes the rest of the cart. ON CONFLICT (webhook_id) DO NOTHING: if the id already exists, PostgreSQL skips the insert without an error, andRETURNINGonly returns inserted rows, per the INSERT documentation. IfX-Shopify-Triggered-Atis missing, it falls back to the payload'supdated_at.- A duplicate still gets
200, as Shopify asks;countedtells you whether the delivery was new.
db is any object with a query(sql, params) method that returns { rows }; we tested it with PGlite. To wire it into a route that receives a standard Request, such as a Next.js Route Handler, route.mjs:
import { handleCartsUpdate } from "./cart-events.mjs";
export function makeRoute(db, secret) {
return async function POST(request) {
const rawBody = await request.text();
const headers = Object.fromEntries(request.headers);
const { status } = await handleCartsUpdate(db, headers, rawBody, secret);
return new Response(null, { status });
};
}
makeRoutetakes the database and the secret once and returns thePOSTfunction.request.text()reads the raw body, unparsed, since the signature is computed over those bytes.Object.fromEntries(request.headers)turns the headers into an object with lowercase names.- The response carries only the status code. The work is a single insert, so it answers well within Shopify's five-second limit. If your processing is heavier, queue it: a Postgres job queue with SKIP LOCKED.
Deliveries vs. real changes
With the fingerprint stored, one report can count both. A delivery is a real change when its fingerprint differs from the previous delivery for the same cart, in the order Shopify triggered them. report.sql:
SELECT day,
count(*) AS deliveries,
count(*) FILTER (WHERE prev IS DISTINCT FROM fp) AS real_changes
FROM (
SELECT (triggered_at AT TIME ZONE 'America/Mexico_City')::date AS day,
fingerprint AS fp,
lag(fingerprint) OVER (PARTITION BY shop, cart_token ORDER BY triggered_at) AS prev
FROM cart_events
) e
GROUP BY day
ORDER BY day;
deliveriescounts unique deliveries: what your app used to see.real_changescounts the ones that change the cart. Each cart's first delivery counts as a change, since there is nothing before it.AT TIME ZONE 'America/Mexico_City'groups by calendar day in Mexico City. Swap in the time zone your reports use, such as'America/New_York'.lag(fingerprint) OVER (...)fetches the previous fingerprint for the same cart, ordered bytriggered_atrather than arrival time.
Before October 12 the two columns differ; after it they match, except for changes the payload does not show. real_changes is the series you can compare across the cutoff, and it is an approximation: the sample payload does not include cart attributes, so a change to attributes alone would look like no change.
If you were not storing payloads
Without a fingerprint there is no way to pull the unchanged-cart deliveries out of your history. That leaves three options: compare only periods after October 12, annotate the cutoff on the chart and in the report you send the merchant, or lean on metrics that don't depend on counting deliveries, such as orders. Counting distinct carts (by token) instead of deliveries softens the effect but does not remove it: a cart whose only activity that day was an unchanged-cart request used to show up and no longer does. And start storing the fingerprint today; in a few weeks you will have a clean series.
Year-over-year comparisons
November is when everyone compares against last year: Black Friday, Cyber Monday, and in Mexico the Buen Fin. Your 2025 data was counted under the old rule and your 2026 data, from October 12 on, under the new one. If you compare raw carts/update counts, part of the gap may come from the change and not from the store. Rebuild 2025 with real_changes if you kept the payloads; if not, compare orders and conversion from sources that did not change, and leave cart activity out of the comparison.
How to test it on a development store
First, locally
We tested the handler, the route and the report with node --test on Node 22.22.3, against PGlite 0.5.10 (PostgreSQL 18.6 compiled to WebAssembly), using the carts/update sample payload from the 2026-10 reference and signatures made with a test secret. We made no calls to Shopify; the deliveries are simulated. This is the output, minus the duration lines:
$ node --test cart-events.test.mjs
ok 1 - the same delivery sent 5 times is stored once
ok 2 - 5 concurrent copies of one delivery are stored once
ok 3 - a bad signature gets 401 and stores nothing
ok 4 - a missing X-Shopify-Webhook-Id gets 400
ok 5 - the Request route lowercases mixed-case header names
# │ (index) │ day │ deliveries │ real_changes │
# │ 0 │ '2026-10-11' │ 3 │ 2 │
# │ 1 │ '2026-10-13' │ 1 │ 1 │
ok 6 - report: deliveries vs real changes per day, out-of-order arrival
ok 7 - report day boundary uses Mexico City time (UTC-6)
# tests 7
# pass 7
# fail 0
- 1 and 2: the same delivery, sent five times in a row or five times at once, leaves a single row, and every call gets
200. As a control, a table without the primary key stored all five. - 3 and 4: a signature made with another secret, or a body changed after signing, gets
401; a missingX-Shopify-Webhook-Idgets400. Neither stores anything. - 5: the route, called with a Node 22
Requestand mixed-case header names, behaves the same. - 6: four deliveries from October 11 (one retry, one unchanged cart) and two from October 13 (one retry) arrive out of order. On this test data: 3 deliveries and 2 real changes on the 11th, 1 and 1 on the 13th.
- 7: 05:30 UTC on October 12 still falls on October 11 in Mexico City.
One limit: PGlite runs one query at a time, so test 2 does not prove real concurrency. On a real PostgreSQL server, the primary key is what guarantees only one insert wins.
Then, with a real cart
To see Shopify's change you need a development store with an online store and your app installed. We did not run this part, because it needs a real store and account. shopify app webhook trigger won't help here: per its documentation, it always sends the same sample payload, does not retry, and cannot validate your subscriptions. It tests your handler, not the change. Subscribe the app in shopify.app.toml:
[access_scopes]
scopes = "read_orders"
[webhooks]
api_version = "2026-10"
[[webhooks.subscriptions]]
topics = ["carts/update"]
uri = "/webhooks/carts"
read_ordersis the scopecarts/updaterequires.api_versionsets the version Shopify uses to serialize the payload, per Manage webhook subscriptions. It does not affect this behavior, which is date-based.topicsanduridefine the subscription. The path is relative because theshopify app devtunnel URL changes on every start, as the verification guide recommends. Changes toshopify.app.tomlare applied automatically duringapp devon the development store you picked, per the app configuration docs.
With shopify app dev running, open the online store, add a product to the cart, and paste this into the browser console on a storefront page:
const root = window.Shopify.routes.root;
const cart = await (await fetch(root + "cart.js")).json();
const item = cart.items[0];
const change = (quantity) =>
fetch(root + "cart/change.js", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ id: item.key, quantity }),
});
await change(item.quantity); // same quantity: no carts/update expected
await change(item.quantity + 1); // real change: one carts/update
window.Shopify.routes.rootis the root the Ajax API examples use, and it respects the storefront's locale./cart.jsreturns the cart, and we take its first line.changeposts to/cart/change.jswith the line'skey, which the reference recommends over the variant id.- The first call sends the same quantity: since October 12, no
carts/updateshould arrive. - The second raises the quantity by one: exactly one should arrive.
Watch the deliveries in your handler's log or in the Dev Dashboard under Apps, your app, Logs, filtered to the carts/update topic. Per the troubleshooting guide, that log can lag by several minutes. Repeat the test with /cart/update.js and the same note. We ran the snippet only against a stubbed fetch, to check its syntax and the requests it makes, not against a store.
Common mistakes
- Reading the October 12 drop as fewer shoppers. It is a different counting rule. Check orders and conversion before concluding anything.
- Removing deduplication because "there are no more duplicates." The change removed unchanged-cart deliveries, not retries. Keep storing
X-Shopify-Webhook-Id. - Running two
carts/updatesubscriptions that write to the same table. Each delivery has its own Webhook-Id and both share the Event-Id, so you would count twice. Use one subscription per topic, or count byevent_id. - Sorting by arrival time. Shopify does not guarantee order. Use
X-Shopify-Triggered-Atorupdated_at. - Trying to reproduce the change with
shopify app webhook trigger. It always sends the same sample payload. You need a real cart. - Changing
api_versionorinclude_fieldswithout thinking about the fingerprint. If the payload changes shape, every cart shows one extra change at that moment. Annotate it the same way you annotate the cutoff.
Frequently asked questions
Do I have to change my code?
It is not required. The entry asks for no action and the payload is the same. What you should review are the metrics, rates, alerts and timers that depend on counting carts/update deliveries, because since October 12 fewer of them arrive for the same traffic.
Can I get the old behavior back?
The entry offers no way to. The change has an effective date and time and is not tied to an API version. If you needed a record of every cart request, including the ones that change nothing, carts/update is no longer the source for that.
Does it affect carts/create or checkouts?
The entry only mentions carts/update. It says nothing about carts/create or checkouts/update, so do not assume a change Shopify has not published. If you count those topics, check their series separately.
Do duplicate webhooks still arrive?
Yes. Shopify warns that the same delivery can arrive more than once after a network timeout or a retry. To drop them, store X-Shopify-Webhook-Id under a unique constraint and return 200 when it already exists, as the handler in this post does.
Checklist
- You know which metrics, rates, alerts and timers read
carts/update. - Every dashboard marks the cutoff: October 12, 2026, 10:00 a.m. ET (14:00 UTC).
- The handler verifies the signature and stores each delivery once, with
X-Shopify-Webhook-Idas the primary key. - Each delivery is stored with the cart fingerprint and
X-Shopify-Triggered-At. - Reports sort by
triggered_at, not arrival time. - Comparisons against 2025 use real changes or leave cart activity out.
- Alerts tuned on September volume have been recalibrated.
- You tested the change on a development store with the same quantity and with a new one.
- Your merchants know why their dashboards shifted on October 12.
If your endpoint does not verify signatures yet, start with how to verify Shopify webhook HMAC signatures. To see why storing the delivery id is enough to avoid counting twice, read how idempotency keys prevent double charges. And if your peak-season reports mix GA4 and Shopify, check why GA4 and Shopify sales don't match before Black Friday.
Saw this on Instagram? Comment CARTS on the Reel and I'll send you the guide.
Written by

Published November 11, 2026