Build an abandoned cart flow with Klaviyo and n8n

01/The build

How to build it

1. 01

   Decide the trigger, the timing, and whether you even need n8n

   Needs a human

   Settle three things before wiring anything, and be honest about the third. First, the trigger: an abandoned cart means a Started Checkout (the customer reached checkout and gave an email or phone) with no order placed inside your window — not a bare add-to-cart, which has no identity to email. Second, the cadence: a common shape is the first email ~1 hour after abandonment, a second at ~24 hours, an optional third at ~72 hours. Third, and most important: if you're on Shopify's standard checkout and Klaviyo's onsite tracking is reliably firing Started Checkout, the native Klaviyo abandoned-cart flow already does this — build that and stop. Reach for n8n only when the native event doesn't fire (headless or custom checkout, the snippet not loading, a cart that lives outside Shopify) or when you need to guard the trigger with data the native event can't carry.

2. 02

   Capture the abandonment signal at the source

   Runs itself

   Get the signal from somewhere that doesn't depend on a browser. The reliable source on Shopify is the checkouts/create and checkouts/update webhooks: the abandoned-checkout object fires when a customer reaches checkout and provides contact details, and it carries everything you need — email and phone (with consent flags), the checkout token, line items, total price, currency, and the abandoned_checkout_url (the recovery link that drops them back into their cart). Point those webhooks at an n8n webhook node. If your checkout is fully custom or headless and doesn't emit Shopify's checkout object, POST your own 'checkout started' payload from the storefront to the same n8n webhook the moment the customer hits the checkout step, with those same fields.

3. 03

   Hold the open checkout and wait out the window

   Runs itself

   Don't fire the instant a checkout starts — most 'abandoners' are mid-purchase. Store each open checkout keyed by its checkout token, with its timestamp and payload, in something durable: an Airtable/Sheet row, a small database, or a Redis key. Then wait the abandonment window from step one before treating it as abandoned. A scheduled n8n sweep over the open-checkout store (every few minutes, picking up rows older than the window) is more robust than an in-memory Wait node, because it survives restarts and won't lose carts if n8n bounces mid-wait.

4. 04

   Confirm it actually didn't convert before firing

   Runs itself

   This is the guardrail that prevents the single worst email in ecommerce — 'you left something behind!' sent to someone who already paid. Before enqueuing, check Shopify for an order matching the checkout token (or the email within the window); Shopify's orders/create webhook can also flip a 'converted' flag on your stored row as soon as the purchase lands. Drop any checkout that completed or was already recovered, and suppress if the same customer placed any order in the last little while. The cart has to still be genuinely open to move forward.

5. 05

   Enrich, check stock, and apply exclusions

   Runs itself

   Now decide whether this abandoner should be reminded at all. Re-check inventory on the cart's items — reminding someone about a product that's now sold out is worse than staying quiet, so skip those (or swap in an in-stock alternate if that's your style). Honor consent: only queue email or SMS for people who actually opted in. Drop wholesale and B2B checkouts, and skip anyone you don't want double-messaged if they're mid-sequence in another high-priority flow. Attach what the email will render: line-item titles, images, prices, quantities, the cart total, and the recovery URL.

6. 06

   Stamp an idempotency key so a cart enters once

   Runs itself

   The moment a checkout clears the guards and gets enqueued, write a key to your store — the checkout token plus a 'reminded' flag and timestamp. A duplicate checkouts/update, the sweep running twice, or a manual re-run all see the key and skip. Dedupe on this key, not on the Klaviyo send, so a flaky retry can never push the same customer into the sequence twice.

7. 07

   Push a custom 'Abandoned Checkout' event into Klaviyo

   Runs itself

   POST to Klaviyo's event API a custom metric — call it something like 'Abandoned Checkout (n8n)' — on the customer's profile, with the properties the messages need: total value, currency, the line items (title, image, price, qty), and the recovery URL. This server-side custom event is the whole point: it lands reliably regardless of whether onsite JavaScript ever saw the checkout, so the flow has a dependable thing to trigger on instead of a snippet that may never have fired.

8. 08

   Let a Klaviyo flow own the cadence and the sends

   Runs itself

   Build a Klaviyo flow triggered on the 'Abandoned Checkout (n8n)' metric. Because n8n already held the abandonment window in step three, the cart is genuinely abandoned by the time the event lands — so the first message can send near-immediately, the second at ~24 hours, and an optional third at ~72 hours (this is where a discount belongs, if you use one). Add a flow filter that exits anyone who has placed an order since the trigger (Klaviyo's conversion suppression), and let Klaviyo handle quiet hours, throttling, and unsubscribes. Owning the sends here means consent and timing are respected for free, instead of you firing raw API blasts that ignore them.

9. 09

   Catch failures and watch the recovered-order rate

   Runs itself

   On inventory and revenue work, a silently failed call is the expensive kind. Wrap the Klaviyo event POST in a bounded retry with backoff, and if it still fails, push the cart to a Slack or exception lane rather than dropping a recoverable order on the floor. Then watch the number that matters: the recovered-order rate of the flow. If it sags after a change, you'll usually find the window got too long, the second email turned naggy, or the stock check is suppressing more than it should — all tunable, none visible unless you're looking.

02/The stack

What it’s built on

Shopify

The reliable, server-side source of the abandonment signal: its checkouts webhooks emit the abandoned-checkout object (line items, totals, and the recovery URL), and its orders webhook is how you confirm a cart did or didn't convert before reminding anyone.

n8n

The event source and the brain. It catches the checkout webhook (or your storefront's POST), holds the cart for the abandonment window, re-checks for conversion, runs the inventory and consent guards, dedupes, and only then fires the Klaviyo event.n8n is open-source and self-hostable for free; the cloud tier just saves you running it yourself. This is a build where it earns its place over Zapier — the open-checkout store, the conversion re-check, the stock guard, and the dedupe key need real branching and a persistent store, not single-step zaps.

Klaviyo

Owns the cadence and the messages. The custom 'Abandoned Checkout' event triggers a flow that spaces the follow-ups, exits anyone who buys, and respects consent, quiet hours, and unsubscribes automatically.Klaviyo's free tier is plenty to build and test this on, and you're almost certainly already running it. Worth saying plainly: its native abandoned-cart flow is genuinely good — if your onsite tracking fires Started Checkout reliably, use it and skip this build. This recipe is for when it doesn't.

03/Questions

Before you build