Saltar al contenido

Si tu app cuenta el webhook carts/update, tus números cambiaron

Actualización/ 17 min de lectura

Shopify dejó de enviar carts/update cuando una operación no cambia el carrito. Qué cambió el 12 de octubre, cómo mueve tus métricas y un handler idempotente probado.

  • Shopify
  • Apps de Shopify
  • Analítica
En este artículo (8)
  1. Qué cambió en el webhook carts/update
  2. Antes y ahora: un webhook por petición contra uno por cambio real
  3. Cómo afecta tus métricas
  4. Cómo ajustar reportes y comparativos
  5. Cómo probarlo en una tienda de desarrollo
  6. Errores comunes
  7. Preguntas frecuentes
  8. Checklist

Desde el 12 de octubre de 2026, Shopify ya no envía el webhook carts/update cuando una operación deja el carrito igual, por ejemplo al reenviar valores que ya tiene. Antes llegaba uno por cada petición; ahora llega uno por cada cambio real. Si tu app contaba esas entregas, el conteo pudo bajar sin que cambiara nada en tu tienda.

Aquí tienes qué dice el aviso, qué pasa con tus métricas, cómo recalcular reportes para que los comparativos de noviembre no mezclen dos reglas, un handler idempotente probado en local y cómo verlo en una tienda de desarrollo. Consultamos la documentación de Shopify citada el 11 de noviembre de 2026.

Qué cambió en el webhook carts/update

La entrada del changelog de Shopify del 12 de octubre de 2026 se titula «Cart updates that result in no changes to the cart no longer trigger carts/update webhooks». Son cuatro frases. Las operaciones de carrito que lo dejan igual, «por ejemplo, reenviar los mismos valores que el carrito ya tiene», ya no disparan carts/update. Shopify envía un webhook cada vez que cambian el contenido o las propiedades del carrito. Antes, cada operación producía uno. Y el cambio elimina esas notificaciones duplicadas: las apps reciben un carts/update por cada cambio, no uno por petición.

Tres datos de la entrada importan para tus reportes:

  • Fecha y hora. Entró en vigor el 12 de octubre de 2026 a las 10:00 hora del Este (UTC-4): las 14:00 UTC y las 08:00 en la Ciudad de México. La entrada se publicó a las 12:00 hora del Este, dos horas después.
  • Sin versión de la API. La entrada da una fecha y una hora de efecto, no una versión: los datos de la página dejan vacía la versión efectiva. Nada en ella indica que fijar una versión anterior en tu suscripción conserve el comportamiento de antes.
  • Sin acción requerida. Shopify no la marca como «Action required». Tu código no se rompe; lo que cambia es cuántas entregas recibes.

La entrada etiqueta el cambio con la Ajax API y la Storefront API, y enlaza a la referencia del carrito de la Ajax API. La referencia de webhooks, versión 2026-10, y el enum WebhookSubscriptionTopic describen el tema así: ocurre cuando se actualiza un carrito de la tienda online, no cubre carritos actualizados en un storefront personalizado y requiere el scope read_orders. La entrada solo habla de carts/update; no menciona carts/create.

el cambio de carts/update en el tiempoantes · uno por peticiónahora · uno por cambio real12 oct 2026 · 10:00 ET08:00 en CDMX · entra en vigornov–dic 2026comparativos vs. 202512 oct · 12:00 ETsale el changelogbarra clara: entregas · oscura: cambios realesbajan las entregas, no los cambios realesbarras ilustrativas, sin datos reales · fuente: changelog de Shopify

Desliza la figura para verla completa

Antes y ahora: un webhook por petición contra uno por cambio real

El tema de una tienda modifica el carrito con la Ajax API: /cart/add.js agrega productos, /cart/update.js cambia cantidades, la nota, los atributos o el descuento, y /cart/change.js cambia la cantidad o las propiedades de una línea. Hasta el 12 de octubre, cada una de esas peticiones generaba un carts/update, cambiara algo o no. Ahora, si la petición deja el carrito como estaba, no llega nada.

Un ejemplo ilustrativo, con un carrito que ya tiene un artículo:

Petición¿Cambia el carrito?Antes del 12 octDesde el 12 oct
/cart/change.js, quantity de 1 a 2Sí1 webhook1 webhook
/cart/update.js, nota «regalo» (estaba vacía)Sí1 webhook1 webhook
/cart/update.js, nota «regalo» otra vezNo1 webhookNinguno
/cart/change.js, quantity 2 otra vezNo1 webhookNinguno
/cart/change.js, quantity de 2 a 3Sí1 webhook1 webhook
Total53

Las filas 3 y 4 son lo que el changelog llama reenviar los mismos valores. Pueden venir, por ejemplo, de un tema que vuelve a mandar la nota o la cantidad al cerrar el cajón del carrito. Cuántas de esas peticiones tiene tu tienda depende de tu tema y de tus apps; Shopify no publica una proporción.

cinco peticiones al carrito, webhooks antes y ahorapetición al carrito¿cambia?antesahorachange.js · quantity 1 → 2sí1 webhook1 webhookupdate.js · note "" → "regalo"sí1 webhook1 webhookupdate.js · note "regalo"no, igual1 webhookningunochange.js · quantity 2no, igual1 webhookningunochange.js · quantity 2 → 3sí1 webhook1 webhooktotal5 webhooks3 webhooksantes cada petición; ahora solo los cambiosejemplo ilustrativo con la Ajax Cart API, carrito con 1 artículo

Desliza la figura para verla completa

El payload no cambia de forma. Según la referencia, carts/update trae el id y el token del carrito, las line_items (con key, quantity, properties, precios y descuentos), la note, updated_at y created_at. Lo que cambia es cuántas veces llega.

Tampoco cambiaron los duplicados. Según Verify webhook deliveries, la misma entrega puede llegar más de una vez tras un timeout o un reintento (Shopify reintenta hasta ocho veces en cuatro horas, según Troubleshoot webhooks), y se detecta con X-Shopify-Webhook-Id. Tu handler tiene que seguir descartándolos.

Cómo afecta tus métricas

El cambio no toca a tus compradores: el carrito funciona igual. Toca lo que tu app calcula a partir de contar entregas. Revisa cuatro casos:

  • Conteos. Si una métrica es «cuántos carts/update recibimos» (actividad de carrito, eventos por sesión, volumen por tienda), desde el 12 de octubre deja fuera las peticiones sin cambios. Ejemplo ilustrativo: si una tienda recibía 10,000 entregas al día y 2,500 eran peticiones sin cambios, con el mismo tráfico ahora recibe 7,500. La gráfica muestra una caída de 25 % que no corresponde a menos compradores.
  • Tasas. Si carts/update está en el denominador, la tasa sube por la misma razón. En el mismo ejemplo ilustrativo, 300 pedidos entre 10,000 entregas daban 3 %; entre 7,500 dan 4 %.
  • Señales de actividad. Si tu app toma la llegada de un carts/update como «el comprador sigue aquí», por ejemplo para reiniciar un temporizador de carrito abandonado, una petición sin cambios ya no reinicia nada. Revisa si tus esperas dependían de esas señales.
  • Alertas. Un umbral calculado con el volumen de septiembre puede dispararse en falso con el de noviembre. Si vigilas el embudo en temporada alta, recalibra antes: lo vemos en alertas de conversión del checkout para el Buen Fin.

Lo que no se mueve: tus pedidos y los eventos que el tema manda desde el navegador, como el add_to_cart de GA4 (cómo medir add_to_cart en GA4), que no pasan por webhooks. Si un reporte compara eventos del navegador con entregas de webhooks, recuerda que solo una de las dos fuentes cambió el 12 de octubre. Si esas cifras ya no te cuadraban antes, empieza por por qué GA4 y Shopify no cuadran en ventas.

qué revisar en tu app tras el cambio de carts/updatesi tu app…desde el 12 octqué hacercuenta entregas de carts/updateel conteo bajaanota el cortedivide entre carts/updatela tasa subedivide entre cambiosusa el webhook como actividadsin cambio, sin señalrevisa temporizadoresdeduplica por X-Shopify-Webhook-Idlos reintentos siguenmantenloguarda la huella del payloadcasi sin repetidosrecalcula el históricocompara contra 2025mezcla dos reglascompara cambios realesrevisa cada uso de carts/update en tu applos duplicados por reintento no dependen de este cambio

Desliza la figura para verla completa

Cómo ajustar reportes y comparativos

Primero, marca el corte en cada tablero: 12 de octubre de 2026, 10:00 ET (14:00 UTC, 08:00 en la Ciudad de México). Ese día mezcla las dos reglas: las primeras horas cuentan como antes y el resto como ahora. Después, decide qué mides, entregas o cambios reales. Si guardas cada entrega con una huella del carrito, puedes recalcular el histórico con la regla nueva y comparar meses sin mezclar reglas.

Guarda cada entrega una sola vez

La tabla guarda una fila por entrega. La clave primaria es X-Shopify-Webhook-Id, que la estructura de entrega define como una clave única por entrega para identificar y deduplicar. Es la tabla que el artículo sobre verificar el HMAC de los webhooks de Shopify dejaba pendiente para producción. 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);
  1. webhook_id es la clave primaria: no pueden existir dos filas con el mismo id.
  2. event_id guarda X-Shopify-Event-Id, que comparten las entregas de una misma acción: sirve para correlacionar, no para deduplicar.
  3. shop y cart_token identifican la tienda y el carrito.
  4. fingerprint es un hash del carrito sin updated_at: la misma huella es el mismo carrito.
  5. triggered_at viene de X-Shopify-Triggered-At: según About webhooks, Shopify no garantiza el orden y recomienda ordenar por ese encabezado o por updated_at. received_at queda para depurar.
  6. El índice sirve al reporte de más abajo.

El handler verifica la firma, toma el id de la entrega y la guarda solo si es nueva. Es la misma idea que usamos para evitar cobros dobles con una clave de idempotencia, con el id de la entrega en el papel de la clave. 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 };
}
  1. verifyShopifyWebhook es la verificación del artículo de HMAC: HMAC-SHA256 del cuerpo crudo con el client secret de la app, en base64, comparado con timingSafeEqual después de comparar el largo.
  2. Los encabezados van en minúsculas, como los entrega Node; la documentación pide tratarlos sin distinguir mayúsculas.
  3. Firma inválida: 401. Sin X-Shopify-Webhook-Id: 400. En los dos casos no se guarda nada.
  4. Separa updated_at y calcula la huella con el resto del carrito.
  5. ON CONFLICT (webhook_id) DO NOTHING: si el id ya existe, PostgreSQL no inserta ni lanza error, y RETURNING solo devuelve filas insertadas, según la documentación de INSERT. Si falta X-Shopify-Triggered-At, usa el updated_at del payload.
  6. Un duplicado también recibe 200, como pide Shopify; counted dice si la entrega era nueva.

db es cualquier objeto con query(sql, params) que devuelva { rows }; nosotros lo probamos con PGlite. Para conectarlo a una ruta que recibe un Request estándar, como un Route Handler de Next.js, 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 });
  };
}
  1. makeRoute recibe la base y el secreto una vez y devuelve la función POST.
  2. request.text() lee el cuerpo crudo, sin parsear: la firma se calcula sobre esos bytes.
  3. Object.fromEntries(request.headers) convierte los encabezados en un objeto con nombres en minúsculas.
  4. La respuesta lleva solo el código. Todo cabe en una inserción, así que contesta dentro de los cinco segundos que da Shopify. Si tu proceso es más pesado, encólalo: cola de trabajos en Postgres con SKIP LOCKED.

Entregas contra cambios reales

Con la huella guardada, un reporte puede contar las dos cosas. Una entrega es un cambio real si su huella es distinta de la entrega anterior del mismo carrito, en el orden en que Shopify las disparó. 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;
  1. deliveries cuenta entregas únicas: lo que tu app veía.
  2. real_changes cuenta las que cambian el carrito. La primera entrega de cada carrito cuenta como cambio, porque no tiene anterior.
  3. AT TIME ZONE 'America/Mexico_City' agrupa por día de la Ciudad de México. Cámbiala por la zona de tus reportes.
  4. lag(fingerprint) OVER (...) trae la huella de la entrega anterior del mismo carrito, ordenada por triggered_at, no por hora de llegada.

Antes del 12 de octubre, las dos columnas difieren; después coinciden, salvo cambios que el payload no muestra. real_changes es la serie que puedes comparar a través del corte, y es una aproximación: el payload de ejemplo no trae los atributos del carrito, así que un cambio solo en atributos se vería como «sin cambio».

Si no guardabas los payloads

Sin huella no hay forma de separar, en el histórico, las entregas sin cambios. Te quedan tres opciones: comparar solo periodos posteriores al 12 de octubre, anotar el corte en la gráfica y en el reporte que mandas al cliente, o apoyarte en métricas que no dependen de contar entregas, como los pedidos. Contar carritos distintos (por token) en vez de entregas reduce el efecto, pero no lo elimina: un carrito cuya única actividad del día fue una petición sin cambios aparecía antes y ya no. Y empieza a guardar la huella hoy: en unas semanas tendrás una serie limpia.

Comparativos contra el año pasado

Noviembre es el mes en que más se compara contra el año anterior: Buen Fin, Black Friday, Cyber Monday. Tus datos de 2025 se contaron con la regla vieja y los de 2026, desde el 12 de octubre, con la nueva. Si comparas conteos crudos de carts/update, parte de la diferencia puede ser del cambio y no de tu tienda. Recalcula 2025 con real_changes si guardaste los payloads; si no, compara pedidos y conversión con fuentes que no cambiaron y deja la actividad de carrito fuera del comparativo.

Cómo probarlo en una tienda de desarrollo

Primero, en local

Probamos el handler, la ruta y el reporte con node --test en Node 22.22.3, contra PGlite 0.5.10 (PostgreSQL 18.6 compilado a WebAssembly), con el payload de ejemplo de carts/update de la referencia 2026-10 y firmas hechas con un secreto de prueba. No llamamos a Shopify: las entregas son simuladas. Esta es la salida, sin las líneas de duración:

$ 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. 1 y 2: la misma entrega, cinco veces seguidas o cinco a la vez, deja una sola fila; todas reciben 200. Como control, una tabla sin clave primaria guardó las cinco.
  2. 3 y 4: una firma con otro secreto, o un cuerpo cambiado después de firmar, da 401; sin X-Shopify-Webhook-Id, 400. Ninguna guarda nada.
  3. 5: la ruta, con un Request de Node 22 y encabezados con mayúsculas, funciona igual.
  4. 6: llegan desordenadas cuatro entregas del 11 de octubre (un reintento y una sin cambios) y dos del 13 (un reintento). Datos de prueba: 3 entregas y 2 cambios reales el 11; 1 y 1 el 13.
  5. 7: las 05:30 UTC del 12 de octubre caen todavía en el 11 en la Ciudad de México.

Un límite: PGlite ejecuta una consulta a la vez, así que la prueba 2 no demuestra concurrencia real. En un PostgreSQL de verdad, lo que garantiza que solo una inserción gane es la clave primaria.

Después, con un carrito real

Para ver el cambio de Shopify necesitas una tienda de desarrollo con tienda online y tu app instalada. Esta parte no la corrimos: requiere una tienda y una cuenta reales. El comando shopify app webhook trigger no sirve para esto: según su documentación, siempre envía el mismo payload de ejemplo, no reintenta y no valida tus suscripciones. Sirve para probar el handler, no el cambio. Suscribe la app en shopify.app.toml:

[access_scopes]
scopes = "read_orders"

[webhooks]
api_version = "2026-10"

[[webhooks.subscriptions]]
topics = ["carts/update"]
uri = "/webhooks/carts"
  1. read_orders es el scope que pide carts/update.
  2. api_version fija la versión con la que Shopify serializa el payload, según Manage webhook subscriptions. No cambia este comportamiento, que va por fecha.
  3. topics y uri definen la suscripción. La ruta es relativa porque la URL del túnel de shopify app dev cambia en cada arranque, como recomienda la guía de verificación. Los cambios a shopify.app.toml se aplican solos durante app dev en la tienda de desarrollo elegida, según la configuración de la app.

Con shopify app dev corriendo, abre la tienda online, agrega un producto al carrito y pega esto en la consola del navegador, en una página de la tienda:

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
  1. window.Shopify.routes.root es la raíz que usan los ejemplos de la Ajax API; respeta el idioma de la tienda.
  2. /cart.js devuelve el carrito, y tomamos su primera línea.
  3. change llama a /cart/change.js con la key de la línea, que la referencia recomienda sobre el id de variante.
  4. La primera llamada manda la misma cantidad: desde el 12 de octubre no debería llegar ningún carts/update.
  5. La segunda sube la cantidad en uno: debería llegar exactamente uno.

Mira las entregas en el log de tu handler o en el Dev Dashboard: Apps, tu app, Logs, con el filtro del tema carts/update. Según la guía de problemas con webhooks, ese log puede tardar varios minutos. Repite la prueba con /cart/update.js y la misma nota. El fragmento lo corrimos contra un fetch falso para revisar la sintaxis y las peticiones que hace; contra una tienda, no.

Errores comunes

  • Leer la caída del 12 de octubre como menos compradores. Es una regla de conteo distinta. Mira pedidos y conversión antes de concluir nada.
  • Quitar la deduplicación porque «ya no hay duplicados». El cambio quitó las entregas sin cambios, no los reintentos. Sigue guardando X-Shopify-Webhook-Id.
  • Tener dos suscripciones a carts/update que escriben en la misma tabla. Cada entrega trae su propio Webhook-Id y las dos comparten Event-Id: contarías doble. Usa una suscripción por tema o cuenta por event_id.
  • Ordenar por hora de llegada. Shopify no garantiza el orden. Usa X-Shopify-Triggered-At o updated_at.
  • Intentar reproducir el cambio con shopify app webhook trigger. Siempre manda el mismo payload de ejemplo. Para el cambio necesitas un carrito real.
  • Cambiar api_version o include_fields sin pensar en la huella. Si el payload cambia de forma, cada carrito mostrará un cambio extra en ese momento. Anótalo como anotas el corte.

Preguntas frecuentes

¿Tengo que cambiar algo en mi código?

No es obligatorio. La entrada no pide ninguna acción y el payload sigue igual. Lo que debes revisar son las métricas, tasas, alertas y temporizadores que dependan de contar entregas de carts/update, porque desde el 12 de octubre llegan menos con el mismo tráfico.

¿Puedo volver al comportamiento anterior?

La entrada no ofrece ninguna forma. El cambio tiene fecha y hora de efecto y no está atado a una versión de la API. Si necesitabas registrar cada petición al carrito, incluidas las que no cambian nada, carts/update ya no es la fuente para eso.

¿Afecta a carts/create o a los checkouts?

La entrada solo menciona carts/update. No dice nada de carts/create ni de checkouts/update, así que no asumas un cambio que Shopify no publicó. Si cuentas esos temas, revisa sus series por separado.

¿Siguen llegando webhooks duplicados?

Sí. Shopify avisa que la misma entrega puede llegar más de una vez tras un timeout o un reintento. Para descartarlas, guarda X-Shopify-Webhook-Id con una restricción única y responde 200 cuando ya exista, como el handler de este artículo.

Checklist

  • Sabes en qué métricas, tasas, alertas y temporizadores usas carts/update.
  • Cada tablero marca el corte: 12 de octubre de 2026, 10:00 ET (08:00 en la Ciudad de México).
  • El handler verifica la firma y guarda cada entrega una vez, con X-Shopify-Webhook-Id como clave primaria.
  • Guardas la huella del carrito y X-Shopify-Triggered-At en cada entrega.
  • Tus reportes ordenan por triggered_at, no por hora de llegada.
  • Los comparativos contra 2025 usan cambios reales o dejan fuera la actividad de carrito.
  • Recalibraste las alertas que usaban el volumen de septiembre.
  • Probaste el cambio en una tienda de desarrollo con la misma cantidad y con una cantidad nueva.
  • Avisaste a tus clientes por qué sus tableros cambiaron el 12 de octubre.

Si tu endpoint todavía no valida la firma, empieza por cómo verificar el HMAC de los webhooks de Shopify; para entender por qué guardar el id de la entrega basta para no contar dos veces, lee cómo evitar cobros dobles con idempotencia. Y si tus reportes de temporada mezclan GA4 y Shopify, revisa por qué tus ventas en GA4 y Shopify no cuadran antes del Buen Fin.

¿Viste esto en Instagram? Comenta CARTS en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 11 de noviembre de 2026

← Blog