How to Grow Your Creator Email List by Syncing Stripe Supporters into Klaviyo Segments

Build a scheduled Spojit workflow that reads your paying supporters from Stripe, scores them into spend tiers, and writes them into Klaviyo lists so you can email VIP fans differently from casual ones.

What This Integration Does

If you take memberships, tips, or subscription support through Stripe, the people paying you are your warmest audience, but Stripe is a payments tool, not an email tool. This workflow closes that gap. It pulls your customers and their active subscriptions out of Stripe, works out how much each supporter has committed, sorts them into tiers (for example VIP, Supporter, and Lapsed), and adds each one to a matching Klaviyo audience list with their tier stamped onto their profile. From there you can target a launch announcement at top supporters, send a win-back to lapsed ones, or simply thank your VIPs, all without exporting CSVs by hand.

The workflow runs on a Schedule trigger (for example every morning) rather than reacting to a single payment, so it always reflects the current state of your supporter base. On each run it fetches the latest data from Stripe, recomputes tiers with the math utilities, then loops over the supporters and writes them to Klaviyo. Because Klaviyo profiles are keyed on email, adding the same supporter again is safe: add-profiles-to-list and update-profile are idempotent, so a re-run refreshes tiers and list membership instead of creating duplicates. The workflow leaves no state of its own between runs; Stripe and Klaviyo are the source of truth.

Prerequisites

A Stripe connection in Spojit (API key) with read access to customers and subscriptions. See the Stripe connector article.
A Klaviyo connection in Spojit (API key) with permission to read and write profiles and lists. See the Klaviyo connector article.
One or more Klaviyo audience lists already created (for example "VIP Supporters" and "Lapsed Supporters"). Note each list ID; you can confirm them with the list-lists tool.
A decision on your tier thresholds (for example VIP at $50 or more per month, Supporter below that, Lapsed for cancelled subscriptions). You can adjust these later in the Transform node.
If you are new to the Schedule trigger, review Setting Up a Schedule Trigger first.

Step 1: Start the workflow on a Schedule trigger

Create a new workflow and set the Trigger node type to Schedule. Add a 5-field cron expression and an IANA timezone so the sync runs at a quiet hour in your timezone. For a daily 7am run in Sydney, use:

0 7 * * *
Australia/Sydney

A single Schedule trigger can hold multiple schedules if you want, say, a weekday and weekend cadence. The trigger output is {{ scheduledAt }}, which you do not need downstream here; the run simply re-reads everything from Stripe each time it fires.

Step 2: Pull paying supporters from Stripe

Add a Connector node in Direct mode on the stripe connector and select the list-customers tool. Set limit to its maximum of 100 to reduce round trips. Stripe returns paginated results, so to page through your full base, add a Loop node in While mode (or re-call the tool) that passes the last customer ID into starting_after until no more pages return. Capture the accumulated customers as a variable such as {{ customers }}.

Add a second Connector node in Direct mode on stripe using list-subscriptions to read active commitments. Set status to active to count current supporters, and run it again with status set to canceled if you want a Lapsed tier. As with customers, page through using starting_after. Each subscription carries the customer ID, which links it back to a customer record from the previous node.

Step 3: Compute spend tiers with the math utilities

Add a Transform node to join each customer to their subscriptions and produce a clean list of supporters, each with an email and a monthly amount. Inside or alongside the Transform, use Connector nodes in Direct mode on the math connector to do the arithmetic deterministically and with no AI cost:

sum to total a supporter's active subscription amounts.
currency to convert Stripe's smallest-currency-unit integers (for example cents) into a readable dollar value.
average or median across all supporters if you want a relative threshold instead of a fixed one.

Then apply your tier rule in the Transform. A simple shape to emit per supporter:

{
  "email": "fan@example.com",
  "monthly": 60,
  "tier": "VIP",
  "listId": "VList123"
}

Map each tier to the Klaviyo list ID it belongs to (VIP supporters to your VIP list, lapsed supporters to your win-back list). The output of this step should be an array such as {{ supporters }} that the next step can loop over.

Step 4: Loop over supporters and locate their Klaviyo profile

Add a Loop node in ForEach mode over {{ supporters }}. Inside the loop, add a Connector node in Direct mode on the klaviyo connector using list-profiles to find the existing profile by email. Set filter to:

equals(email,"{{ supporter.email }}")

If a profile exists, read its ID from the result. If it does not, add a Condition node and, on the empty branch, call create-profile with an attributes object so every supporter ends up with a profile:

{
  "email": "{{ supporter.email }}",
  "properties": { "supporter_tier": "{{ supporter.tier }}" }
}

Carry the resolved profile ID forward as {{ profileId }} for the write step.

Step 5: Stamp the tier and add the profile to its list

Still inside the loop, add a Connector node in Direct mode on klaviyo using update-profile. Pass the id as {{ profileId }} and an attributes object that records the tier and the latest monthly figure as custom properties:

{
  "properties": {
    "supporter_tier": "{{ supporter.tier }}",
    "monthly_support": "{{ supporter.monthly }}"
  }
}

Then add a Connector node in Direct mode on klaviyo using add-profiles-to-list. Set listId to {{ supporter.listId }} and profileIds to a single-element array containing {{ profileId }}. This places each supporter in the audience list that matches their tier, ready for a Klaviyo campaign or flow.

Step 6: Confirm the run and (optionally) notify yourself

After the loop, add a Send Email node to email yourself a short summary of how many supporters were synced per tier, using upstream variables in the Body field. Recipients must be on your org allowlist (Settings > General > Email recipients). This gives you a daily heartbeat that the sync ran and a quick count to sanity-check against Stripe. If you would rather drop the summary into a channel, swap in a Connector node on the slack connector using send-message instead.

Tips

Keep tier logic in the Transform node and the math tools, not in an Agent-mode node. Spend tiers are arithmetic, so Direct mode keeps the run deterministic and free of AI credit cost.
Set Stripe limit to 100 and page with starting_after so large supporter bases sync in fewer calls.
Want a relative threshold? Use math median across all monthly amounts and tier supporters above the median as VIP, so the cutoff adapts as your base grows.
To scaffold the canvas quickly, ask Miraxa, the intelligent layer across your automation, something like "Add a Loop node over {{ supporters }} that calls Klaviyo update-profile then add-profiles-to-list," then fine-tune the field mappings in the properties panel.

Common Pitfalls

Currency units. Stripe amounts are integers in the smallest currency unit (for example cents). Divide with the math currency tool before comparing against dollar thresholds, or every tier will look inflated.
Wrong list IDs. add-profiles-to-list needs the Klaviyo list ID, not the list name. Run list-lists once and hard-map the IDs in your Transform.
Missing profiles. A paying Stripe supporter may have no Klaviyo profile yet. Handle the empty list-profiles result with a Condition node and create-profile, or those supporters silently drop out of the list.
Tier churn between runs. A supporter who downgrades will keep their old supporter_tier property unless you overwrite it every run. Always call update-profile in the loop so tiers stay current.

Testing

Before scheduling, validate on a small scope. Temporarily set the Stripe list-customers limit to a low value such as 3, or filter to a single known supporter with the email field, and point the loop at one test Klaviyo list. Use the Run button to execute once, then open the execution log to confirm each step's output: the supporter array from your Transform, the resolved profile IDs, and a successful add-profiles-to-list call. Check the supporter's profile in Klaviyo to confirm the supporter_tier property and list membership are correct. Once the tiers and list mapping look right, restore the full limit, point the loop at your real lists, and let the Schedule trigger take over.