Menu

Mattering Automations Klaviyo integration

Connect Klaviyo to Mattering Automations: profiles, consent, lists, segments, events, campaigns, flows, templates, catalog, and reporting as workflow steps, authenticated with a Klaviyo private API key.

The Mattering Automations Klaviyo integration adds Klaviyo to your automation canvas: sync profiles, record events, manage list membership, read segments, build campaign drafts and check who they would reach before sending, switch flows on and off, create and preview templates, read the product catalog, and pull campaign, flow, and segment performance reports. Because the nodes live on the same canvas as every other connector, a Klaviyo step can sit directly next to a helpdesk step, a CRM step, or a task in Mattering Productivity.

Setup takes a few minutes: create a private API key in Klaviyo, attach it as a credential in Mattering, and test the connection. Two things this integration does for you are worth knowing up front. Klaviyo's auth header is Authorization: Klaviyo-API-Key followed by the private key, which is neither Bearer nor Basic, and the integration builds that header itself, so the credential form is one field holding the key. Klaviyo also versions by a dated revision header rather than a URL path, and the integration pins revision 2026-07-15 on every request, so the API does not shift under your workflows between releases.

The care lives in the consent and outbound nodes. Klaviyo: Unsubscribe Profiles (Revokes Marketing Consent) unsubscribes globally any profile that is not a member of the list you named, Klaviyo: Send Campaign (Sends Real Email or SMS) and Klaviyo: Update Flow Status (Live Sends Real Messages) start real outbound messaging at scale, and exactly one node destroys data: Klaviyo: Merge Profiles (Permanently Deletes the Source). Everything else in the integration is reversible. This guide walks through setup, then the safe patterns, and ends with the full node reference.

Before you start

  • A Klaviyo account. The free tier issues private API keys with full scope selection, which is enough to exercise the read nodes and the reversible writes on a throwaway account.
  • Permission to create a private API key in Klaviyo's account settings.
  • A Mattering workspace with access to the Automations app.
  • For the send, consent, and flow nodes: a key with the matching write scopes, and a one person list you own to send proofs to, since Klaviyo has no send test endpoint in the API.

Create a Klaviyo private API key

Mattering authenticates to Klaviyo with a private API key, the value that starts with pk_. Klaviyo scopes keys at creation, offering Read Only, Full Access, or a custom per resource set such as metrics:read, profiles:write, or campaigns:write.

In Klaviyo, open account settings and go to API keys.
Create a private API key and choose its scopes. A Read Only key drives all 28 read nodes; the connection test itself needs only metrics:read.
Copy the key. It starts with pk_ and is a single opaque value.
Paste only the key. Klaviyo's documented scheme is Authorization: Klaviyo-API-Key followed by the private key, which is neither Bearer nor Basic, and the integration builds that header for you. Adding the header name or a prefix by hand is the most common cause of a 401 on a key that is actually fine.
Klaviyo key scopes are fixed at creation and cannot be edited afterwards. If a node later fails with a 403, the key was minted without the scope that node needs, and the fix is a new key rather than an edit. Scope each key to what its automations actually do instead of reaching for Full Access by default.

Connect Klaviyo to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Klaviyo from the list.
Click Create new credential, paste your private API key, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection: Mattering calls Klaviyo's metrics endpoint with the Klaviyo-API-Key header and the pinned revision, and confirms the key authenticates. That endpoint is the probe partly for safety, since its response carries event type definitions and no key material of any kind.
Click Connect. All 49 Klaviyo nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: a Klaviyo section should list the query and action nodes. Drop Klaviyo: List Metrics onto the canvas and run a test step. It needs no configuration, is a pure read, and returns the event types the account knows about, such as Placed Order or Opened Email. Keep the metric ids you care about, because they are the input to Klaviyo: Query Metric Aggregates and to the conversion metric on the reporting nodes.

To confirm the rest of the surface, run Klaviyo: List Lists and Klaviyo: List Flows to resolve names to ids, and Klaviyo: List Profiles with a filter such as equals(email,"jane@example.com") to check a lookup. Everything in the verify path is read-only. Note that Klaviyo: Get Account Details also works with a Read Only key, but its response echoes attributes.public_api_key, the public site id from your onsite tracking script; that value is not a secret, but keep this node's raw output out of logs and third party systems on principle.

Node reference

49 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 28

Klaviyo: Campaign Performance Report

klaviyo_query_campaign_values

Campaign analytics that match Klaviyo's own dashboard: opens, clicks, conversions, revenue, unsubscribes and rates, over a timeframe, grouped however you like. A POST because the query rides in the body; it reads and changes nothing. Results come back as one row per grouping, each with a groupings object and a statistics object. Rate limited hard by Klaviyo (about 1 per second, 2 per minute and 225 per day across the reporting endpoints), so treat it as a scheduled report, not a per record lookup.

Klaviyo: Flow Performance Report

klaviyo_query_flow_values

Flow analytics that match Klaviyo's own dashboard: how the welcome series, abandoned cart and win back flows are actually performing, with opens, clicks, conversions and revenue over a timeframe. Reads and changes nothing. Group by flow_id or flow_message_id to see which step in a series is carrying the results. Rate limited hard by Klaviyo (about 1 per second, 2 per minute and 225 per day across the reporting endpoints), so treat it as a scheduled report, not a per record lookup.

Klaviyo: Get Account Details

klaviyo_get_accounts

Read the account the connected private key belongs to: organization name, default sender name and email, website, industry, timezone, preferred currency and locale. Klaviyo returns exactly one account object in the array. Useful for stamping currency or timezone onto downstream records, and for confirming an automation is pointed at the right Klaviyo account before it does anything. Note that Klaviyo also returns attributes.public_api_key here, which is the public site id embedded in your onsite tracking script, not the private key; even so, avoid piping this node's raw output into logs or third party systems. Needs the accounts:read scope, and is rate limited to about 1 per second and 15 per minute, so call it once and reuse the result.

Klaviyo: Get Campaign

klaviyo_get_campaign

Fetch one campaign by id: its status, included and excluded audiences, send strategy, send options and timestamps. Always run this immediately before Klaviyo: Send Campaign and check attributes.audiences against what you expect. The audiences array is the list of people who will actually receive the email, and it is the field most likely to be wrong.

Klaviyo: Get Campaign Recipient Estimate

klaviyo_get_campaign_recipient_estimation

Read the estimated number of recipients for a campaign: data.data.attributes.estimated_recipient_count. This is the number you gate a send on. Wire it into a condition before Klaviyo: Send Campaign so an automation refuses to fire when the count is zero (broken audience) or wildly larger than expected (a segment rule change). Refresh it first with Klaviyo: Refresh Campaign Recipient Estimate if the audience has changed recently.

Klaviyo: Get Event

klaviyo_get_event

Fetch a single event by id, including its full event_properties payload and its links to the profile and metric. Use it to expand one row returned by Klaviyo: List Events, or to resolve an event id received from an upstream node.

Klaviyo: Get Flow

klaviyo_get_flow

Fetch one flow by id, with its current status and trigger type. The check to run before and after Klaviyo: Update Flow Status, and the way an automation can assert that a critical welcome or abandoned cart flow is still live.

Klaviyo: Get List

klaviyo_get_list

Fetch one list by id: name, timestamps, and its opt in process (single or double). Set additional_fields_list to profile_count to also get the number of people on it, which is the cheapest way to answer "how many humans am I about to email" before a send. Note that asking for profile_count drops the call into a much lower rate limit bucket (about 1 per second, 15 per minute), so read it once per run rather than in a loop.

Klaviyo: Get Lists for Profile

klaviyo_get_lists_for_profile

List the list memberships of one profile. The safety check in front of Klaviyo: Unsubscribe Profiles, which globally unsubscribes anyone who is not on the list you name, so confirming membership first is the difference between removing someone from a newsletter and cutting them off from all your marketing. Rate limited to about 3 per second and 60 per minute.

Klaviyo: Get Messages for Campaign

klaviyo_get_messages_for_campaign

List the messages that belong to a campaign, with their definition (channel, label, subject, from address) and the template attached to each. Use it to read back what a draft will actually say, or to get a campaign message id for further work. Include the template to inspect the rendered content source in the same call.

Klaviyo: Get Profile

klaviyo_get_profile

Fetch one profile by its Klaviyo id, including identifiers, name, location, and custom properties. Set additional_fields_profile to subscriptions when you need the person's current consent state per channel, which is the honest way to check whether you may email them before an automation does. Output contains personal data and is stored in the execution record.

Klaviyo: Get Profiles for List

klaviyo_get_profiles_for_list

Page through the profiles on a list. Use it to export members into another system, to check whether a specific address is on the list before unsubscribing it, or to size an audience before a send. Output is personal data and is stored in the execution record, so page deliberately rather than dumping a large list into an automation run. Returns at most 100 profiles per page.

Klaviyo: Get Profiles for Segment

klaviyo_get_profiles_for_segment

Page through the profiles currently matching a segment. Segments are dynamic, so this is a snapshot, not a stable list. Useful for syncing a computed audience into another system or for spot checking who a campaign would reach. Output is personal data and is stored in the execution record. Returns at most 100 profiles per page.

Klaviyo: Get Segment

klaviyo_get_segment

Fetch one segment by id, including its condition definition and whether it is currently processing. Set additional_fields_segment to profile_count to get the current member count, which is the pre send sanity check for any campaign targeting this segment: a rule change can quietly turn a 200 person segment into a 200,000 person one. Asking for profile_count lowers the rate limit to about 1 per second, so read it once per run.

Klaviyo: Get Template

klaviyo_get_template

Fetch one template by id, including its HTML and plain text source. Useful for archiving a template into version control or diffing it before a change. The html attribute is a full email document, so this node's output can be a large text value in the execution record.

Klaviyo: List Campaigns

klaviyo_list_campaigns

List campaigns with their status, audiences, send strategy and timestamps. Klaviyo REQUIRES a channel filter on this endpoint, so the filter field is pre-filled with the email channel; swap it for sms or mobile_push, or combine it with a status filter to find, say, every draft. Returns at most 100 campaigns per page.

Klaviyo: List Catalog Categories

klaviyo_list_catalog_categories

List the catalog's categories, the groupings used to filter products in recommendation and product feed blocks. Returns each category's external id, name and composite Klaviyo id. Use a category id with Klaviyo: List Catalog Items to pull everything in one department. Returns at most 100 categories per page.

Klaviyo: List Catalog Items

klaviyo_list_catalog_items

List products in the Klaviyo catalog, the data behind product blocks, back in stock alerts and abandoned browse content. Returns title, description, price, URLs, images, custom metadata and published state. Filter by category or title to find the item id (a composite such as $custom:::$default:::SKU-1) that other catalog features need. Returns at most 100 items per page.

Klaviyo: List Events

klaviyo_list_events

List raw events recorded in the account: orders, product views, email opens, custom activity. Filter by metric, by profile, or by a datetime window to pull a feed of recent activity into an automation. Each event carries its event_properties payload, its timestamp, and links to the metric and profile behind it. Event bodies contain personal and order data and are stored in the execution record, so filter tightly and keep page_size small rather than pulling the whole history. Returns at most 200 events per page.

Klaviyo: List Flows

klaviyo_list_flows

List the account's automated flows with their name, status (draft, manual or live), trigger type and timestamps. This is the node that tells you which automations are armed: filter on equals(status,"live") before pushing events or list additions in bulk, because a live flow turns those writes into real outbound messages. Rate limited to about 3 per second and 60 per minute; returns at most 50 flows per page.

Klaviyo: List Lists

klaviyo_list_lists

List the account's lists (Klaviyo's static, consent bearing audiences) with their names, creation dates and opt in process. This is how you turn a human readable list name into the list id that every other list node, the subscribe nodes and campaign audiences require. Returns at most 10 lists per page, so paginate with page_cursor on accounts with many lists.

Klaviyo: List Metrics

klaviyo_list_metrics

List every metric in the Klaviyo account: the event types Klaviyo knows about, such as Placed Order, Viewed Product, Opened Email, or any custom event your integrations send. Returns each metric's id, name, created and updated timestamps, and the integration that owns it. Metric ids are the input to Query Metric Aggregates and to the conversion_metric_id on the reporting nodes, so this is usually the first call in a Klaviyo automation. It is also the connector's credential health check: it needs no configuration, only the metrics:read scope, and its response contains no key or account secret of any kind. Returns at most 200 metrics per page.

Klaviyo: List Profiles

klaviyo_list_profiles

List profiles in the account, or look one up by email, phone number or external id using a filter. The everyday use is resolving an address to a Klaviyo profile id: filter on equals(email,"jane@example.com") and read data.data[0].id. Output contains personal data (names, addresses, custom properties) and is stored in the execution record, so filter to the profiles you need instead of paging the whole account. Returns at most 100 profiles per page.

Klaviyo: List Segments

klaviyo_list_segments

List the account's segments: the dynamic, rule based audiences that recompute as profile data changes. Returns each segment's name, definition summary, and whether it is active or still processing. Use it to resolve a segment name to the id that campaign audiences and the suppression nodes need. Returns at most 10 segments per page.

Klaviyo: List Tags

klaviyo_list_tags

List the account's tags, the labels used to organize campaigns, flows, lists and segments. Include the tag group to see how they are categorized, or the related resources to see what each tag is applied to. Handy for reporting: pull every campaign carrying a given tag and roll up its performance. Returns at most 50 tags per page; an account can hold at most 500 tags.

Klaviyo: List Templates

klaviyo_list_templates

List the account's email templates with their names, editor type and timestamps. Use it to resolve a template name to the id that Klaviyo: Render Template needs. Note that template HTML can be large, so leave additional_fields_template blank unless you actually need the drag and drop definition.

Klaviyo: Query Metric Aggregates

klaviyo_query_metric_aggregates

Aggregate the events behind one metric into counts, sums or unique profile counts over time, optionally grouped by dimensions such as message, flow, campaign name or email domain. This is the raw event analytics endpoint: revenue by week from Placed Order, opens by message, signups by day. It is a POST because the query rides in the body, but it reads and changes nothing. For numbers that match the campaign and flow dashboards in Klaviyo's own UI, use the reporting nodes instead. Results are returned as parallel arrays: data.data.attributes.dates lines up with each row's measurement arrays.

Klaviyo: Segment Growth Report

klaviyo_query_segment_values

Segment membership analytics: total members, members added, members removed and net change over a timeframe. Reads and changes nothing. This is the audience health report: a segment shrinking week over week, or a suppression heavy list, shows up here before it shows up in campaign performance. Note that this endpoint takes no conversion_metric_id, unlike the campaign and flow reports. Rate limited hard by Klaviyo (about 1 per second, 2 per minute and 225 per day across the reporting endpoints), so treat it as a scheduled report, not a per record lookup.

Action nodes 21

Klaviyo: Add Profiles to List

klaviyo_add_profiles_to_list

Add existing profiles to a list by profile id. This is membership only: Klaviyo is explicit that it does NOT grant marketing consent, so use Klaviyo: Subscribe Profiles when you need consent as well. Reversible with Klaviyo: Remove Profiles from List. One caution: if a live flow is triggered by "Added to List" on this list, adding profiles will make that flow send real messages, so check List Flows before pointing a bulk import at a list with a welcome series on it. Maximum 1000 profiles per call. Returns 204 with an empty body.

Klaviyo: Cancel or Revert Campaign Send

klaviyo_cancel_campaign_send

The emergency stop for a sending or scheduled campaign. Action `cancel` permanently cancels it (status becomes Cancelled); action `revert` puts it back to Draft so it can be fixed and sent again. This node ships as a Reversible Write on purpose: it is the safety control, and blocking it behind a warning would be backwards. Understand its limit though: it stops what has not gone out yet. Messages already delivered stay delivered.

Klaviyo: Create Back in Stock Subscription

klaviyo_create_back_in_stock_subscription

Register one person to be notified when a specific product variant is back in stock. Nothing is sent right now: the message goes out later, once, when Klaviyo sees the variant restocked, so this is a single opt in request rather than a broadcast. Still a real future message to a real person, so only register people who asked. This is the server side endpoint; a public storefront widget should use Klaviyo's client side variant instead of exposing a private key. Returns 202 when accepted.

Klaviyo: Create Campaign (Draft)

klaviyo_create_campaign

Create a campaign as a DRAFT. Nothing is emailed by this node. You give it a name, the audiences to include and exclude, and the message basics (subject, preview text, from address and label), and Klaviyo returns a campaign you can inspect, attach a template to, and only then send. Klaviyo's real request body nests a campaign-messages array inside attributes, with the definition, channel and content objects several levels down; you fill flat fields here and the connector assembles that envelope. Anything exotic (SMS definitions, smart send time, throttled sends, tracking options) goes through extra_attributes.

Klaviyo: Create List

klaviyo_create_list

Create a new, empty list. Nothing is emailed by this node. The opt in process you choose here is consequential later: a double opt in list makes Klaviyo: Subscribe Profiles send a confirmation email to every address, while a single opt in list subscribes them outright. Klaviyo caps list creation at about 150 per day, so this is not a per record node. The connector builds the JSON:API envelope from the flat fields below.

Klaviyo: Create Tag

klaviyo_create_tag

Create a tag so campaigns, flows, lists and segments can be grouped and reported on consistently. Nothing is emailed by this node. If you do not name a tag group, Klaviyo puts the tag in the account's default group. Accounts are capped at 500 unique tags, so generate them from a controlled vocabulary rather than per record. Needs both tags:read and tags:write on the key.

Klaviyo: Create Template

klaviyo_create_template

Create a new email template from HTML. Nothing is emailed by this node; a template is content, not a send. Useful for generating templates from a CMS, a design system or an AI step and pushing them into Klaviyo for a human to review. Klaviyo caps templates created through the API at 1,000 per account, so this is not a per record node. Klaviyo template syntax is Django like, so {{ first_name }} style variables in your HTML survive intact; preview the result with Klaviyo: Render Template before attaching it to anything that sends.

Klaviyo: Create or Update Profile (Upsert)

klaviyo_create_or_update_profile

The profile sync workhorse: create a profile if it does not exist, update it if it does, matched on the identifier you pass. Returns 201 when a profile was created and 200 when an existing one was updated. Nothing is emailed by this node, and it does NOT grant marketing consent: a profile created here is a contact record, not a subscriber. Use Klaviyo: Subscribe Profiles for consent. Careful with clearing: omitting a field leaves it unchanged, but sending it explicitly empty clears it. Maximum payload 100KB. You supply flat fields; the connector builds the JSON:API profile envelope.

Klaviyo: Merge Profiles (Permanently Deletes the Source)

klaviyo_merge_profiles

DESTRUCTIVE AND IRREVERSIBLE. Merges a source profile into a destination profile and, in Klaviyo's own words, DELETES the source profile in the process. Event history, list memberships and properties are consolidated onto the destination according to Klaviyo's merge rules, and there is no unmerge. Use it only for genuine duplicate cleanup, where you have already read BOTH profiles with Klaviyo: Get Profile, confirmed they are the same human, and decided which one survives. The merge runs as an asynchronous job, so a 201 means accepted, not finished. Accepts exactly one source profile per call.

Klaviyo: Refresh Campaign Recipient Estimate

klaviyo_refresh_campaign_recipient_estimation

Kick off an asynchronous job that recalculates how many people a campaign would reach. Nothing is emailed by this node and nothing about the campaign changes. Run it, wait a moment, then read the number with Klaviyo: Get Campaign Recipient Estimate. This pair is the documented safe path before a send: know the audience size before you commit. Returns 202 when the job is accepted.

Klaviyo: Remove Profiles from List

klaviyo_remove_profiles_from_list

Remove profiles from a list. Nothing is deleted: the profiles keep existing, keep their event history, and Klaviyo documents that their consent and subscription status are unchanged. They simply stop receiving marketing sent to this particular list. This is the correct node when you want to take someone off one audience without touching their global consent, and it is reversible with Klaviyo: Add Profiles to List. Maximum 1000 profiles per call. Returns 204 with an empty body.

Klaviyo: Render Template (Preview, Sends Nothing)

klaviyo_render_template

Render a template with sample data and get back the HTML, plain text and AMP versions. NOTHING IS SENT and nothing is changed: this is the preview step in the safe send path. Pass the variables your template expects in `context` and check that merge tags resolve, that no placeholder leaks through, and that the copy reads correctly, all before a campaign goes near a real audience. Klaviyo renders with Django like syntax, and variables with no matching context value are treated as false rather than erroring, which is exactly how a broken personalization ships silently. Output includes full email HTML, so it is a large text value.

Klaviyo: Send Campaign (Sends Real Email or SMS)

klaviyo_send_campaign

SENDS THE CAMPAIGN TO ITS ENTIRE AUDIENCE FOR REAL, AND THERE IS NO UNDO ONCE MESSAGES LEAVE. Every profile in the campaign's included audiences, minus the excluded ones, receives the email or SMS. Delivered mail cannot be recalled; the only stop is Klaviyo: Cancel Campaign Send, and it only helps while the job is still queued or in flight. Run the safe path first, every time: (1) Klaviyo: Get Campaign and read attributes.audiences, (2) Klaviyo: Refresh Campaign Recipient Estimate then Klaviyo: Get Campaign Recipient Estimate and check the count is what you expect, (3) Klaviyo: Get Messages for Campaign and confirm the subject and from address, (4) preview the rendered body with Klaviyo: Render Template, (5) send a real proof to yourself by pointing a copy of the campaign at a one person list you own. Only then run this node. Because there is no per node dry run, an automation that reaches this node on a bad trigger has already mailed everyone. Returns 202 with a send job you can poll.

Klaviyo: Subscribe Profiles (Grants Marketing Consent)

klaviyo_subscribe_profiles

RECORDS MARKETING CONSENT FOR REAL PEOPLE, AND CAN SEND REAL EMAIL. This node writes an opt in record: if the target list uses double opt in, Klaviyo immediately emails every address you pass asking them to confirm; if it uses single opt in, they are subscribed outright and your next campaign reaches them. Consent you did not actually collect is a legal problem, not just a data problem, and there is no clean undo: unsubscribing does not restore the previous state, it records a second consent event. Only feed this node addresses that opted in through a form or checkout you control, and put the provenance in custom_source so the record is auditable. Use historical_import only for consent already collected outside Klaviyo, with its original timestamp. To add someone to a list WITHOUT changing consent, use Klaviyo: Add Profiles to List instead. Runs as an asynchronous job; 202 means accepted. Maximum 1000 profiles per call.

Klaviyo: Suppress Profiles

klaviyo_suppress_profiles

Stop email marketing reaching specific addresses, independent of their consent status: a suppressed profile receives no email marketing even if it is subscribed. Use it for complaint handling, competitor addresses, or role accounts you never want mailed. This is the REVERSIBLE half of a documented pair: Klaviyo: Unsuppress Profiles clears suppressions created here (reason USER_SUPPRESSED). It does not delete anything and it does not change consent records. Suppress either an explicit list of email addresses, or everyone currently in a list or segment. Maximum 100 email addresses per call; runs as an asynchronous job, so 202 means accepted.

Klaviyo: Track Event

klaviyo_create_event

Record activity against a profile: a purchase, a signup, a support ticket, any custom event you want Klaviyo to segment and trigger on. Klaviyo creates the metric on first use if it does not exist yet, and creates or updates the profile from the identifiers you pass, so this one node covers the whole tracking path. Two things to know before wiring it into a loop. First, if a LIVE flow is triggered by this metric, sending the event will make Klaviyo send real email or SMS to that profile: check List Flows for a live flow on the metric before pointing a high volume automation at it. Second, events cannot be deleted through the API, so a mistaken backfill stays in the account's history; set unique_id when replaying so retries deduplicate. You supply flat fields and the connector builds Klaviyo's nested JSON:API event envelope for you. Returns 202 with an empty body when accepted for processing.

Klaviyo: Unsubscribe Profiles (Revokes Marketing Consent)

klaviyo_unsubscribe_profiles

REVOKES MARKETING CONSENT, AND CAN DO IT GLOBALLY. Klaviyo documents the trap plainly: any profile you pass that is NOT a member of the list you name is unsubscribed from ALL of your marketing on that channel, not just from that list. Check membership first with Klaviyo: Get Lists for Profile. Consent cannot be restored programmatically once revoked; re subscribing requires a fresh, genuine opt in. If you only want to take someone off a list while leaving their consent intact, use Klaviyo: Remove Profiles from List instead, which the docs confirm does not touch subscription status. Runs as an asynchronous job; 202 means accepted. Maximum 1000 profiles per call.

Klaviyo: Unsuppress Profiles

klaviyo_unsuppress_profiles

Lift manual suppressions so email marketing can reach these addresses again. The documented undo for Klaviyo: Suppress Profiles. Important limit: it only clears suppressions with reason USER_SUPPRESSED. Profiles that unsubscribed themselves, or that Klaviyo suppressed for INVALID_EMAIL or HARD_BOUNCE, are deliberately left alone, so this node cannot be used to mail someone who opted out or whose address is dead. Maximum 100 email addresses per call; runs as an asynchronous job, so 202 means accepted.

Klaviyo: Update Campaign

klaviyo_update_campaign

Update a draft campaign: rename it, change who it targets, or change its send strategy. Nothing is emailed by this node. Be aware that the audience arrays REPLACE the existing ones rather than adding to them, so send the complete list you want, and re-read the campaign afterwards with Klaviyo: Get Campaign to confirm the audience is what you intended before any send.

Klaviyo: Update Flow Status (Live Sends Real Messages)

klaviyo_update_flow_status

SETTING A FLOW LIVE ARMS AUTOMATED OUTBOUND MESSAGING. From that moment every profile that meets the trigger receives real email or SMS, with no further human step, for as long as the flow stays live. Klaviyo applies the status to the flow AND to all of its actions. Messages already sent cannot be recalled, which is why this is not a routine write, even though flipping the status back to draft or manual does stop future sends. Before setting a flow live: read it with Klaviyo: Get Flow, confirm the trigger is what you think it is, and confirm the content has been reviewed. Setting a flow to draft or manual is the safe direction and is what you should automate if you automate anything here (for example, pausing a promotional flow during an incident). Rate limited to about 3 per second and 60 per minute.

Klaviyo: Update Profile

klaviyo_update_profile

Update an existing profile by id. Only the fields you fill are sent, so untouched attributes keep their current values. Sends no email and grants no consent. Use Klaviyo: Create or Update Profile (Upsert) when you are not sure the profile exists yet, or when you want to match on email rather than id. Custom properties in `properties` are merged key by key, not replaced wholesale.

Using the integration

On the automation canvas

Klaviyo nodes chain with every other node, which is the main reason to run Klaviyo here rather than in isolation. A resolved helpdesk ticket can record activity with Klaviyo: Track Event, a churned CRM deal can trigger Klaviyo: Suppress Profiles, a scheduled Klaviyo: Campaign Performance Report can write rows into a Mattering database, and an incident can pause a promotional flow by setting it back to draft. Approvals, run history, and retries are the platform's, not something you build per integration.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter can read profiles, look up segments, and pull performance reports through the same nodes your workflows use. Klaviyo also operates its own official remote MCP server; if you only want an assistant talking to Klaviyo alone, that is a reasonable option. What this integration adds is Klaviyo sitting beside every other connector in one workflow. Either way, the read nodes are the safe surface for an agent: keep the send and consent nodes behind an approval step.

Flat fields in, JSON:API out

Klaviyo's API is JSON:API styled. A real write body wraps a resource type, an id, an attributes object, and a relationships object, and a campaign create nests a messages array with a definition and content several levels down. The integration assembles all of that from flat typed fields, so you never type a resource type into a config panel. Reads still come back JSON:API shaped, so the fields you want sit one level down under attributes: the drag path is data.data[0].attributes.name, not data.data[0].name, and every node's sample output shows that real nesting so the paths are right before the first run. Two other Klaviyo conventions to expect: filtering is a function grammar in a single filter field (equals(email,"jane@example.com"), greater-or-equal with an unquoted datetime, comma as an implicit AND), and pagination is cursor based, so each list node has a page cursor field you read out of links.next.

Membership is not consent, and unsubscribing has a global edge

These are the nodes to be careful with. Klaviyo: Add Profiles to List adds membership and grants no marketing consent; Klaviyo: Subscribe Profiles (Grants Marketing Consent) writes an opt in record and, on a double opt in list, immediately emails every address you pass. On the way out, Klaviyo: Remove Profiles from List takes someone off one audience and Klaviyo documents that it does not touch their consent or subscription status. Klaviyo: Unsubscribe Profiles (Revokes Marketing Consent) is the one with the trap: Klaviyo's own docs state that any profile you pass which is NOT a member of the list you named is unsubscribed from ALL of your marketing on that channel. That is irreversible from the API, since consent cannot be restored programmatically and re-subscribing requires a fresh genuine opt in. This is why the integration ships Klaviyo: Get Lists for Profile: look up the profile's memberships first and branch on the result, or use the removal node when you only meant to take someone off one list.

The safe send path

Sending a campaign and setting a flow live are irreversible outbound at scale, so treat them as deliberate steps rather than routine writes. The documented path: build with Klaviyo: Create Campaign (Draft), which emails nobody; read Klaviyo: Get Campaign and check attributes.audiences, the field most likely to be wrong; run Klaviyo: Refresh Campaign Recipient Estimate then Klaviyo: Get Campaign Recipient Estimate and gate on the count so the workflow refuses to fire on zero or on a number far above expectation; confirm the subject and from address with Klaviyo: Get Messages for Campaign; preview the body with the Render Template (Preview, Sends Nothing) node, which sends nothing and catches merge tags that silently resolve to nothing; and send a real proof to yourself by pointing a copy of the campaign at a one person list you own. Only then run Klaviyo: Send Campaign (Sends Real Email or SMS). Klaviyo: Cancel or Revert Campaign Send is the brake and ships without a warning gate on purpose, but it only stops what has not gone out. For flows, Klaviyo: Update Flow Status (Live Sends Real Messages) set to draft or manual is the safe direction and the one worth automating.

Suppression is reversible, merging is not

Klaviyo: Suppress Profiles stops email marketing reaching specific addresses regardless of their consent status, which is the right tool for complaint handling, competitor addresses, and role accounts. It deletes nothing and changes no consent record, and Klaviyo: Unsuppress Profiles is its documented undo. One honest limit: unsuppressing only clears the suppressions this integration created, and deliberately leaves self service unsubscribes, invalid addresses, and hard bounces alone, so it cannot be used to mail someone who opted out. The single genuinely destructive node in the integration is Klaviyo: Merge Profiles (Permanently Deletes the Source), which Klaviyo documents as deleting the source profile as part of the merge, with no unmerge. Read both profiles with Klaviyo: Get Profile and confirm they are the same person before running it.

Troubleshooting

Test Connection fails with a 401
Either the key is wrong, or a header was pasted into the key field. The credential holds only the pk_ value; the integration builds Authorization: Klaviyo-API-Key around it. If the field contains the header name, the word Bearer, or a trailing space picked up when copying, Klaviyo rejects it. Paste the raw key again from Klaviyo's API keys screen, and confirm the key has not been revoked.
Test Connection passes but a node returns a 403
The key is under-scoped. The connection test only reads metrics, which a Read Only key allows, so a key minted Read Only passes the test and then fails on the first write node. Klaviyo scopes are fixed at creation and cannot be edited, so create a new key with the scopes your automations need (for example profiles:write, lists:write, subscriptions:write, campaigns:write) and update the credential on the connector.
A hand built HTTP call to Klaviyo returns 401 while the connector nodes work
Klaviyo does not use Bearer or Basic auth. The documented scheme is Authorization: Klaviyo-API-Key followed by the private key, and Klaviyo also requires a dated revision header on every request; a call missing either one fails even with a perfectly good key. The Klaviyo nodes build both for you and pin revision 2026-07-15, which is why the same credential behaves differently in a generic HTTP node. Prefer the connector nodes, and if you must hand roll a call, copy both headers exactly.
Requests start failing with 429
Klaviyo rate limits per endpoint and returns a Retry-After header on a 429. The tight ones are the reporting nodes, roughly 1 per second, 2 per minute, and 225 per day across them, so schedule those rather than calling them per record. Asking Klaviyo: Get List or Klaviyo: Get Segment for a profile count also drops that call into a much lower bucket, so read the count once per run instead of inside a loop, and cache ids resolved by Klaviyo: List Lists rather than re-resolving them on every iteration.
A field path from a node's output is always empty
The path is probably missing the JSON:API nesting. Klaviyo returns records with the real fields one level down under attributes, so a list name is at data.data[0].attributes.name and a single record is at data.data.attributes.name, not data.data[0].name. Each node's sample output shows the true nesting, so drag the path from the Input column rather than typing it. Ids are the exception: they sit at the top of each record, as data.data[0].id.
Adding profiles to a list unexpectedly sent email
A live flow triggered on Added to List fired. Klaviyo: Add Profiles to List grants no consent and sends nothing itself, but a welcome series armed on that list turns every addition into real outbound messages. Read Klaviyo: List Flows and filter on live status before pointing a bulk import at a list. The same applies to Klaviyo: Track Event when a live flow is triggered by that metric, and events cannot be deleted through the API, so set a unique id when replaying so retries deduplicate.
A profile stopped receiving all marketing after an unsubscribe step
That is Klaviyo's documented behavior, not a bug in the workflow. Klaviyo: Unsubscribe Profiles (Revokes Marketing Consent) unsubscribes globally on that channel any profile that is not a member of the list you named. Consent cannot be restored programmatically; the person has to opt in again through a form or checkout. Prevent it by checking membership with Klaviyo: Get Lists for Profile before the unsubscribe step, and by using Klaviyo: Remove Profiles from List whenever the intent is to take someone off one audience rather than to revoke consent.
Unsuppress ran successfully but the address still gets no email
Unsuppression is deliberately narrow. Klaviyo: Unsuppress Profiles only clears the suppressions created by Klaviyo: Suppress Profiles; it leaves profiles that unsubscribed themselves and addresses Klaviyo suppressed as invalid or hard bouncing exactly as they are. If the address opted out, it needs a genuine new opt in. If it hard bounced, the address itself is the problem. Check the profile's subscription state with Klaviyo: Get Profile and ask for the subscriptions detail to see which of those applies.

Klaviyo is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products