Major

Automate Recharge-to-Klaviyo Win-Back Flows with AI

Turn Recharge cancellations and pauses into relevant Klaviyo win-back journeys with a durable app that records each decision, respects consent, and routes edge cases for review.

Ritvij Gautam
Major and Recharge integration for governed subscriber win-back automation

TL;DR: what you'll build. A Retention Marketing Manager at a DTC subscription brand turns Recharge cancellations and pauses into relevant Klaviyo win-back journeys, instead of one generic "sorry to see you go" email. A Major app holds each subscriber's eligibility checks, segment assignment and review history so every send is explainable. The agent only proposes a supported win-back category; deterministic code enforces consent, suppression and duplicate prevention before anything reaches Klaviyo.

Who owns broken win-back flows, and why they break

The Recharge-Klaviyo integration already lets a merchant send automated email and SMS flows off subscription events. The gap is in what happens next: most win-back flows send the same discount code to every churned subscriber, whether they cancelled over price, a bad flavor, or a shipping delay they never mentioned.

This is a retention marketing problem, and it sits inside the broader AI automation across ecommerce workflows that ecommerce operators are building on Major, as well as the marketing workflows built around agents that retention teams specifically care about.

The Retention Marketing Manager owns this process. They configure Klaviyo flows and segments, but they rarely see which specific signal triggered a send, or whether a subscriber's exclusion window and consent status were actually checked first.

The failure shows up weekly: a flow fires off Recharge's native "Subscription cancelled" event, sends the same template, and the manager finds out it went to someone who should have been suppressed only when a reply complains about it. Recharge and Klaviyo both document the pieces needed to fix this. What is missing is the layer that remembers each decision and makes it auditable.

What the native Recharge-Klaviyo integration already does

Recharge's own integration guide describes the mechanism plainly: Recharge sends event metrics to Klaviyo when specific customer events occur, such as a customer completing checkout or cancelling a subscription, and those metrics can trigger a Klaviyo flow. Recharge also backfills customer data into Klaviyo as custom properties at the customer level, which a marketer can use to build segments and campaigns.

Recharge documents a dedicated Win Backs through Klaviyo setup for exactly this use case. It is a real, supported feature, not a workaround. The native path handles the "did a cancellation happen" question well.

What it does not do on its own is remember why a flow fired, record that a human reviewed an edge case, or stop a second flow from firing on the same cancellation. That is the layer this article adds: an app, not another black-box automation.

The systems involved

Recharge: subscription, customer and order data

Recharge's API getting started guide documents a versioned REST API authenticated with an account API token, sent as the X-Recharge-Access-Token header. The core resources for this workflow are the Subscriptions, Customers and Orders objects.

A subscription record in Recharge ties a product to a customer's address, with a status field (which includes a cancelled state) and a cancellation reason field. Recharge's own docs confirm you can pull every cancelled subscription by filtering the subscriptions endpoint on that cancelled status, paginated up to 250 records per call. That filter is the backbone of a reconciliation fallback.

Recharge also documents webhooks for subscription lifecycle events, including checkout completion, refund requests and order injections, which is how a merchant gets near-real-time cancellation and pause signals instead of polling. The honest gotcha: Recharge's reviewed docs do not publish specific rate limit numbers, so a production build needs its own backoff testing rather than a documented ceiling to design against.

Klaviyo: profiles, events and flows

Klaviyo's API overview documents three auth methods: a private API key sent via the Authorization header for server-side calls, OAuth for registered tech partners, and a public six-character company ID for client-side calls. Private keys support read-only, full, or custom scopes, and a scope cannot be changed after the key is created.

The two objects that matter here are Profiles and Events, both documented in the Events API overview. An event always has exactly one metric (its type), a profile relationship, and a properties object you can use for segmentation. Klaviyo recommends a unique identifier on every event to avoid silent deduplication when two events land at the same timestamp.

Klaviyo's API supports cursor-based pagination and JSON:API-style filtering, sorting and sparse fieldsets. Rate limits are enforced per account with both a burst window and a longer steady-state window, returning an HTTP 429 when either is exceeded; the exact numbers are listed per endpoint in Klaviyo's reference, not as one global figure.

A note on consent and email law

This workflow sends marketing email, which the CAN-SPAM Act's implementing rule governs. The one requirement that matters for this build: honor opt-outs and suppression within the required window, and never let an automated flow re-add a suppressed profile to a send. Klaviyo's Profiles API exposes bulk suppress and unsuppress endpoints specifically so this check can run as code instead of a manual list.

Split the work: app, agent and workflow

A webhook is a doorbell: Recharge rings the app the moment a subscription changes, instead of the app knocking on Recharge's door every few minutes to ask "anything new?"

The deterministic app is what makes this process different from a one-off flow. It holds durable state: which subscribers were evaluated, what each decision was based on, who approved the ambiguous cases, and whether a Klaviyo event has already fired for a given cancellation. None of that lives in a model's context window, which disappears the moment a conversation ends.

  • Workflow: listens for the Recharge cancellation or pause event (or runs the scheduled reconciliation poll), looks up the subscriber record, calls the agent once eligibility passes, and writes the Klaviyo event or the review-queue entry.
  • Agent: given only the subscriber's permitted history (order count, product, cancellation reason text if present, prior subscription length), proposes a win-back category the marketer has pre-approved, such as "price-sensitive," "product-mismatch," or "needs manual review." It never guesses a reason the data doesn't support.
  • App: the control surface. It shows the marketer every subscriber in the queue, the segment the agent proposed, the consent and suppression check result, and lets them approve, override or flag a case for Klaviyo config changes.
Architecture diagram showing Recharge and Klaviyo connectors feeding a Major app, segmentation agent, consent gate and Klaviyo flow trigger

Recharge-to-Klaviyo win-back automation on Major: app, agent and workflow split

This mirrors the pattern in a sibling ecommerce build, automating a cross-system ecommerce workflow, where the agent only drafts the judgment call and the app enforces everything repeatable. Reason once, then run the app on every subsequent cancellation.

Build a Recharge-to-Klaviyo win-back workflow on Major

  1. Connect the connectors. Add Recharge as a custom API connector scoped to read-only subscription, customer and order access, and add Klaviyo with a private API key scoped to Profiles read/write and Events read/write only. Credentials stay in Major's credential proxy, never in app code. You should see both connectors listed as active resources with their scopes visible in the connector settings.
  2. Build the app. Create a subscribers table (Recharge customer id, email, subscription id, status, cancellation reason), an assignments table (subscriber id, proposed segment, consent check result, suppression check result, duplicate check result, approval status, Klaviyo event id once sent), and a review queue table (subscriber id, reason flagged, marketer decision). You should see a working table view where each row represents one subscriber's current win-back state.
"Build an app called Win-Back Assignment with a subscribers table synced from cancelled and paused Recharge subscriptions, an assignments table that records the agent's proposed segment and every gate check, and a review queue for cases a marketer needs to approve before any Klaviyo event fires."
  1. Add the agent. Give it read-only access to the subscriber's order history and cancellation reason text, and a fixed list of marketer-approved segment categories to choose from. It must never invent a category outside that list, and must flag "needs manual review" when the evidence is insufficient.
"When a subscription moves to cancelled or paused, read the subscriber's order count, product name and cancellation reason. Pick one supported segment from this list: price-sensitive, product-mismatch, shipping-issue, needs-manual-review. Do not infer a reason the data doesn't support."
  1. Set the workflow trigger. Configure the primary trigger on Recharge's subscription-cancelled and subscription-paused webhook events, with a nightly scheduled reconciliation job that queries cancelled subscriptions to catch any webhook that didn't fire. You should see the workflow run log show both trigger types firing independently.
  2. Test in a sandbox Recharge store with a handful of test subscriptions, cancelling one with each cancellation reason your segments cover, and confirm the assignments table shows the correct segment, the suppression check runs against a test-suppressed profile, and no Klaviyo event fires for that suppressed profile. You should see the review queue populate only for the deliberately ambiguous test case.
  3. Roll out with permissions. Grant the Retention Marketing Manager role-based access to approve or override queue entries, restrict the Klaviyo write scope to the workflow's service account only, and turn on audit logging for every approval and every Klaviyo event the workflow sends. You should see an audit trail entry for each subscriber showing who approved what and when.

Governance and IT control

Every credential in this build sits behind Major's credential proxy, scoped to the minimum Recharge and Klaviyo permissions the workflow needs, never embedded in app code or agent prompts.

  • SSO and role-based access: only the Retention Marketing Manager role can approve queue entries or override a segment assignment.
  • Audit logs: every agent proposal, every consent check result, and every Klaviyo event sent is logged with a timestamp and the actor (agent or human).
  • Scoped secrets: the Klaviyo private key carries only Profiles and Events scopes, not Campaigns or account-level write access.
  • Managed database and storage: subscriber state and review history live in Major's managed database, not in a spreadsheet or a Klaviyo custom property that disappears when a profile merges.
  • Versioned deploys: changes to the segment list or eligibility rules go through a reviewable deploy, so a bad rule change doesn't silently affect live subscribers.
  • Approval required: any subscriber the agent cannot confidently categorize is held in the review queue until the marketer acts, never auto-sent.

Failure handling and edge cases

A cancellation event can fire twice, Recharge's API can return a 429, or a profile match in Klaviyo can simply fail because the email on file changed. The workflow has to assume all three will happen.

  • Duplicate events: the assignments table checks for an existing Klaviyo event id for that subscription before sending again; Klaviyo's own unique-identifier field on events provides a second layer of deduplication.
  • API errors and rate limits: both Recharge and Klaviyo calls retry with exponential backoff on a 429 or 5xx, and the workflow logs the failure for the reconciliation job to retry rather than silently dropping the subscriber.
  • Missing profile match: if no Klaviyo profile matches the subscriber's email, the record goes to the review queue instead of creating a new unverified profile.
  • Stale state: the nightly reconciliation job re-reads Recharge's cancelled and paused subscriptions on a schedule, so a missed webhook never leaves a subscriber permanently unprocessed.
  • Consent and suppression: the agent never sees or overrides a suppression flag; that check is deterministic code that runs before any Klaviyo event, full stop.
  • What the agent must never do: send an email, override a suppression result, or invent a cancellation reason the stored data doesn't support. Any of those cases routes to a person.

What to measure

  • Eligible subscribers processed per week: how many cancellations and pauses the app actually evaluated versus how many Recharge recorded.
  • Segment assignment accuracy: the share of agent-proposed segments the marketer approved without an override.
  • Review queue size and age: how many cases sit waiting for a human, and for how long.
  • Suppression catches: how many subscribers the consent check correctly blocked before a send.
  • Manual touches avoided: the drop in subscribers the marketing team had to triage by hand each week.

This is the same owner-facing metric discipline used in Automate lead-score sync between Marketo and Google Ads audiences with AI, where the workflow owner tracks process health, not invented revenue lift.

Before you go live

  • [ ] Recharge connector scoped to read-only subscription, customer and order access
  • [ ] Klaviyo private key scoped to Profiles and Events only, tested against a sandbox account
  • [ ] Test run completed in a sandbox store covering each supported segment and a suppressed profile
  • [ ] Review queue approval flow assigned to the Retention Marketing Manager role
  • [ ] Nightly reconciliation job confirmed against cancelled and paused subscriptions
  • [ ] Audit logging verified for every agent proposal and every Klaviyo event sent
  • [ ] Alert configured for repeated Recharge or Klaviyo API failures
  • [ ] Segment list and eligibility rules reviewed and signed off before the first live cancellation

More ecommerce AI automation use cases

Start building on Major

Build a governed Recharge-to-Klaviyo workflow that remembers each subscriber's eligibility checks, segment assignment and review history.

Related articles

About the author

Ritvij Gautam is Head of Growth at Major.

Last reviewed November 8, 2026 by Ritvij Gautam.

Frequently asked questions

How do Recharge and Klaviyo work together for win-back emails?
Recharge's native integration sends event metrics, such as a subscription cancellation, to Klaviyo, where they can trigger a pre-built win-back flow. A Major app adds a layer on top: it records each subscriber's eligibility, consent and segment assignment so the marketer can see why a specific flow fired, not just that one did.
Can Recharge cancellations trigger a Klaviyo flow?
Yes. Recharge's official integration docs describe sending a subscription-cancelled event metric to Klaviyo, which a merchant can use as a flow trigger. Always check the current event and flow configuration in your own Recharge and Klaviyo accounts before relying on it, since setup varies by store.
What data should a win-back workflow store?
At minimum: the subscriber and subscription reference, the triggering signal and its timestamp, the eligibility and consent check results, the proposed segment and who approved it, and the outcome (Klaviyo event sent, or held for review). This lives in your own app's data model, not a vendor-provided schema.
How should AI decide which win-back message a subscriber receives?
The agent should only choose from a fixed list of marketer-approved segments, based on evidence actually present in the subscriber's record, such as order history or a stated cancellation reason. Deterministic code, not the agent, should enforce consent and suppression, and any ambiguous case should route to a human for review.
Does this replace Recharge's built-in Win Backs through Klaviyo feature?
No. It builds on top of it. The native Win Backs setup handles sending the event and triggering the flow; the added app and agent layer handles remembering why a flow fired, checking consent and duplicates, and giving a marketer a reviewable record of every decision.