communicationapi_key

Klaviyo

E-commerce email + SMS.

Verdict

Klaviyo is an email and SMS marketing platform. This MCP lets your team track customer events, manage subscriber lists, and trigger campaigns without leaving Switchy. Marketing ops can add profiles to segments, create campaigns, and monitor back-in-stock subscriptions by @mentioning Klaviyo in a Space. Engineers can bulk-create events from support conversations or product feedback. The MCP handles up to 1,000 profiles or events per request, but you'll need a Klaviyo API key with appropriate scopes — some tools require campaigns:write or lists:write. Client-side tracking isn't exposed here; use the server-side endpoints.

Common use cases

Add support contacts to nurture lists
Track product usage events from chat
Estimate campaign reach before sending
Subscribe customers to restock alerts
Clone successful campaigns for A/B tests

Integration

Vendor: Klaviyo
Category: communication
Auth: API_KEY
Tools: 50
Composio slug: klaviyo

Tools

Add Profile to List
Add profiles to a klaviyo list by profile ids or email addresses. this action subscribes profiles to a marketing list, which is ideal for giving marketing consent. you can add up to 1000 profiles per call using either their klaviyo profile
Assign campaign message template
Creates a non-reusable version of the template and assigns it to the message. *rate limits*: burst: `10/s` steady: `150/m` **scopes:** `campaigns:write`
Bulk create client events
Use the client-side endpoint with a public api key to track profile activity. it accepts up to 1000 events/request with rates of 10/s burst and 150/m steady. for server-side, use the bulk create event endpoint.
Bulk create events
This api endpoint creates or updates profiles by batching up to 1,000 events, with a 5mb payload limit. minimum required: a profile id and metric name. it has rate limits of 10 events per second burst and 150 events per minute. scope is `ev
Create back in stock subscription
Use the server-side endpoint to subscribe to restock alerts, following the back in stock api guide. for client-side, use the post endpoint provided. rate limits: 350/s burst and 3500/m steady. required scopes: catalogs:write, profiles:write
Create campaign
Creates a campaign given a set of parameters, then returns it. *rate limits*: burst: `10/s` steady: `150/m` **scopes:** `campaigns:write`
Create campaign clone
Clones an existing campaign, returning a new campaign based on the original with a new id and name. *rate limits*: burst: `10/s` steady: `150/m` **scopes:** `campaigns:write`
Create Campaign Recipient Estimation Job
Start an asynchronous task to estimate the number of recipients for a campaign. this action creates a background job that calculates how many profiles would receive the campaign based on its current audience settings. use the job id returne
Create campaign send job
Trigger a campaign to send asynchronously *rate limits*: burst: `10/s` steady: `150/m` **scopes:** `campaigns:write`
Create catalog category
Create a new catalog category. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Create catalog category relationships items
Create a new item relationship for the given category id. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Create catalog item
Create a new catalog item. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Create catalog item relationships categories
Create a new catalog category relationship for the given item id. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Create catalog variant
Create a new variant for a related catalog item. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Create client back in stock subscription
Use the endpoint for client-side back in stock notifications with a public api key. for server-side, use post /api/back-in-stock-subscriptions. limits are 350 requests per second and 3500 per minute. requires 'catalogs:write' and 'profiles:
Create client event
Create client-side events to track profiles using a public api key, not for updating identifiers (server-side only). rate limits: 350/s, 3500/m. use `events:write` scope.
Create client subscription
Endpoint manages email/sms opt-ins using consent and requires public api key for client use. allows single-channel with details. rate limit: 100/s burst, 700/m steady, under 'subscriptions:write'.
Create coupon
Creates a new coupon. *rate limits*: burst: `3/s` steady: `60/m` **scopes:** `coupons:write`
Create coupon code
Synchronously creates a coupon code for the given coupon. *rate limits*: burst: `350/s` steady: `3500/m` **scopes:** `coupon-codes:write`
Create event
Create or update a profile event with minimum identifiers and metric name. success means validation, not completion. burst limit: 350/s, steady: 3500/m. scope required: `events:write`.
Create list
Create a new list. *rate limits*: burst: `10/s` steady: `150/m` daily: `100/d` **scopes:** `lists:write`
Create or update client profile
Update user profiles without tracking using a public client-side api; use a private server-side api for identifier changes. burst rate is 350 requests/sec and 3500 requests/min with 'profiles:write' access.
Create or update client push token
This endpoint for mobile sdks (ios & android) creates/updates push tokens using a public api key. push notifications must be enabled. for migrating tokens use the server-side post endpoint. rate limits are 3/s burst, 150/m steady.
Create or Update Profile
Create or update a profile in klaviyo with the given attributes. this action allows you to create a new profile or update an existing one if it already exists (based on email or other identifiers). returns 201 for creation, 200 for update.
Create or update push token
Migrate or create push tokens with klaviyo's endpoint, utilizing their mobile sdks for ios & android. rate limits: 75/s burst, 700/m steady. requires profiles:write and push-tokens:write scopes.
Create profile
Create a new profile. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `profiles:write`
Create segment
Create a segment. *rate limits*: burst: `1/s` steady: `15/m` daily: `100/d` **scopes:** `segments:write`
Create tag
Summary: instructions on creating a tag within an account's designated tag group with a maximum of 500 tags, with optional tag group specification. rate limits are 3/s burst and 60/min steady. tag: #tagcreationlimitandrate
Create tag group
Create tag groups up to 50 per account, defaulting to non-exclusive unless specified. related resources can have multiple non-exclusive tags but only one if exclusive. rate limits: 3/s burst, 60/m steady. scopes needed: tags:read, tags:writ
Create tag relationships campaigns
Summary: link a tag to campaigns, ensuring a limit of 100 tags per campaign. campaign ids should be sent via request body. rate limit: 3/s, 60/m. required scopes: campaigns:write, tags:write. tag: #campaigntagginglimits
Create tag relationships flows
Assign tags to flows using their ids in the request body, ensuring a flow is not linked to over 100 tags. rate limits are 3/s burst and 60/m steady. required scopes: `flows:write` and `tags:write`. tag: flow-tag association limits
Create tag relationships lists
Summary: a tag can be added to one or more lists, with a max of 100 tags per list. use the request body to link tag and list ids. tag: #apiusagelimits scopes: lists:write, tags:write
Create tag relationships segments
Summary: set tag associations with segments using the request body, limited to one tag per segment and up to 100 tags per segment. rate limits are three requests per second and sixty per minute. tags: segments:write, tags:write
Create template
Summary: custom html templates can be created unless an account reaches 1,000 template limit. use sparse fieldsets to request specific fields. rate limits are 10 per second and 150 per minute. requires 'templates:write' scope.
Create template clone
Clone a template by its id, but cloning fails if account has 1,000+ templates. api limit: 1,000 templates. rate limits are 10 per second and 150 per minute. requires `templates:write` scope.
Create template render
Render an email template with specific context and sparse fieldsets, then get html/plain text. rate limit: 3/s burst, 60/m steady. scope: templates:read.
Create webhook
Create a new webhook *rate limits*: burst: `1/s` steady: `15/m` **scopes:** `webhooks:write`
Delete campaign
destructive
Delete a campaign with the given campaign id. *rate limits*: burst: `10/s` steady: `150/m` **scopes:** `campaigns:write`
Delete catalog category
destructive
Delete a catalog category using the given category id. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Delete catalog category relationships items
destructive
Delete item relationships for the given category id. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Delete catalog item
destructive
Delete a catalog item with the given item id. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Delete catalog item relationships categories
destructive
Delete catalog category relationships for the given item id. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Delete catalog variant
destructive
Delete a catalog item variant with the given variant id. *rate limits*: burst: `75/s` steady: `700/m` **scopes:** `catalogs:write`
Delete coupon
destructive
Delete the coupon with the given coupon id. *rate limits*: burst: `3/s` steady: `60/m` **scopes:** `coupons:write`
Delete coupon code
destructive
Deletes a coupon code specified by the given identifier synchronously. if a profile has been assigned to the coupon code, an exception will be raised *rate limits*: burst: `350/s` steady: `3500/m` **scopes:** `coupon-codes:writ
Delete flow
destructive
Delete a flow with the given flow id. *rate limits*: burst: `3/s` steady: `60/m` **scopes:** `flows:write`
Delete list
destructive
Delete a list with the given list id. *rate limits*: burst: `10/s` steady: `150/m` **scopes:** `lists:write`
Delete segment
destructive
Delete a segment with the given segment id. *rate limits*: burst: `3/s` steady: `60/m` **scopes:** `segments:write`
Delete tag
destructive
Delete the tag with the given tag id. any associations between the tag and other resources will also be removed. *rate limits*: burst: `3/s` steady: `60/m` **scopes:** `tags:read` `tags:write`
Delete tag group
destructive
Delete a specified tag group and its contents; associated resource links will be removed. the default group is undeletable. rate limits: 3/s burst, 60/m steady. requires tags:read and tags:write permissions.

Setup

Setup guide

11. In Switchy, open your workspace settings and navigate to Integrations. 2. Find Klaviyo in the MCP directory and click Connect. 3. You'll be prompted to paste a Klaviyo private API key — generate one in your Klaviyo account under Settings > API Keys > Create Private API Key. 4. Grant the key at minimum these scopes: campaigns:read, campaigns:write, lists:read, lists:write, profiles:read, profiles:write, events:write. 5. Paste the key into Switchy and click Authorize. 6. To test, open any Space and type '@Klaviyo create a campaign with subject line Test Campaign' — if the MCP responds with a campaign ID, you're connected. 7. Use '@Klaviyo add profile to list' or '@Klaviyo bulk create events' to invoke other tools. 8. If a tool fails with a 403 error, revisit your API key scopes in Klaviyo and regenerate with the missing permission.

What teammates see: by default, memories from Klaviyo are scoped to the Space (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.

Works well with

Top models

Compatibility data appears once enough Spaces have used this MCP together with a given model.

How Switchy teams use it

Not enough Spaces yet to publish anonymised usage stats (we require ≥ 50 Spaces per week).

Starter prompts

Add Trial Users to List

@Klaviyo add these emails to the 'Q1 Trial Users' list: user1@example.com, user2@example.com, user3@example.com. Subscribe them with marketing consent.

Open in a Space →

Log Checkout Events

@Klaviyo bulk create events for profile IDs 01ABC, 02DEF, 03GHI with metric name 'Completed Checkout' and properties: order_value=99.99, product_id=SKU123.

Open in a Space →

Estimate Campaign Audience

@Klaviyo create a recipient estimation job for campaign ID camp_12345. Tell me how many profiles are in the audience.

Open in a Space →

Clone Last Month's Campaign

@Klaviyo clone campaign ID camp_67890 and name the new version 'February Product Launch v2'. Return the new campaign ID.

Open in a Space →

Subscribe to Restock Alerts

@Klaviyo create a back in stock subscription for email customer@example.com, variant ID var_456, and channel email. Use profile ID prof_789.

Open in a Space →

Example outputs

Illustrative - representative of the model's voice and quality, not literal recordings.

Prompt

@Klaviyo show me all active campaigns from the last 30 days and summarize their open rates and click-through performance

Output

Here's a summary of your active campaigns from the past month: **Holiday Sale 2024** (sent Dec 15): 24.3% open rate, 3.8% CTR, 12,450 recipients **New Product Launch** (sent Dec 8): 31.2% open rate, 5.1% CTR, 8,920 recipients **Weekly Newsletter #47** (sent Dec 1): 19.7% open rate, 2.4% CTR, 15,300 recipients Your product launch campaign significantly outperformed the others in engagement. The holiday sale had lower-than-average opens, possibly due to inbox saturation during peak season.

Notes

This example demonstrates Klaviyo's campaign analytics retrieval combined with AI synthesis. The MCP provides raw campaign metrics; the AI interprets trends. Requires campaigns:read scope. Note that Klaviyo's API returns detailed metrics per campaign, but aggregating insights across multiple campaigns benefits from AI reasoning rather than manual spreadsheet work.

Prompt

@Klaviyo add these 15 email addresses from our webinar signup sheet to the 'Q1 Product Updates' list and confirm they're subscribed

Output

Successfully added 15 profiles to the 'Q1 Product Updates' list: - 13 profiles subscribed (consent recorded) - 2 profiles already existed on the list (no duplicate created) - 0 failures All 15 email addresses now have active subscriptions to receive marketing emails for this list. Klaviyo recorded consent timestamps for the 13 new additions. The list now contains 1,847 total subscribed profiles.

Notes

This write action uses the 'Add Profile to List' tool, which handles up to 1,000 profiles per request. The MCP subscribes profiles and grants marketing consent in one operation—this is a side-effect that triggers email eligibility. Always verify you have proper consent before adding profiles. The 10/s burst and 150/m rate limits mean bulk operations over 1,000 profiles require batching.

Prompt

@Klaviyo create a new campaign called 'Flash Sale Reminder' targeting our VIP segment, then estimate how many recipients it would reach before I send it

Output

Campaign created successfully: **Campaign ID:** camp_01JGXYZ123ABC **Name:** Flash Sale Reminder **Status:** Draft **Target Segment:** VIP Customers Started recipient estimation job (job_est_456DEF). This background task is calculating how many profiles in your VIP segment would receive this campaign based on current list membership and suppression rules. Estimation typically completes in 30-90 seconds. The campaign remains in draft status until you explicitly schedule or send it.

Notes

This example chains two tools: campaign creation and recipient estimation. The estimation runs asynchronously—Klaviyo doesn't return the count immediately. In practice, you'd poll the job status or wait for completion. Requires campaigns:write scope. This workflow prevents accidental sends to wrong audience sizes by letting you verify reach before committing. Rate limits (10/s burst, 150/m steady) apply to both operations.

Use-case deep-dives

E-commerce launch coordination

When Klaviyo MCP wins for product drop campaigns

A 6-person DTC brand is launching a limited-edition product line and needs to coordinate email campaigns, back-in-stock alerts, and list segmentation across marketing and ops. The Klaviyo MCP is the right call here because it exposes the full campaign creation and list management stack—your team can draft campaigns in Switchy, assign templates, clone previous high-performers, and bulk-add profiles to launch lists without context-switching to the Klaviyo UI. The 50-tool surface means you can also fire bulk events (order confirmations, cart abandons) and subscribe customers to restock alerts, all from one conversation. The threshold: if your launch involves more than 3-4 campaigns or you're coordinating across Shopify and customer support tools, the API key auth and rate limits (10/s burst) start to feel restrictive. For a single-channel product drop with under 10k profiles, this MCP turns launch day into a scripted runbook instead of a tab circus.

Customer lifecycle event tracking

When this MCP handles post-purchase automation at scale

A 12-person SaaS company is building a customer health scoring system that triggers email nurture based on product usage, trial expirations, and support ticket volume. The Klaviyo MCP is borderline here—it shines for bulk event ingestion (up to 1000 events per request) and profile updates, so your ops team can push lifecycle events (trial started, feature adopted, churn risk) directly from Switchy without writing custom scripts. The 'bulk create events' and 'add profile to list' tools let you automate list moves based on behavior, which is exactly what lifecycle scoring needs. The trade-off: Klaviyo's event model is email-first, so if your scoring logic depends on CRM data (Salesforce opportunities, support ticket sentiment), you'll need a second MCP in the conversation. If 80% of your scoring inputs live in Klaviyo or can be pushed as events, this MCP turns your lifecycle playbook into a conversational workflow instead of a Zapier spaghetti diagram.

Agency client campaign reporting

When Klaviyo MCP falls short for multi-client dashboards

A 4-person email marketing agency manages Klaviyo accounts for 15 e-commerce clients and needs to pull campaign performance, estimate recipient counts, and clone top campaigns across accounts during monthly reviews. The Klaviyo MCP is not the right call for this scenario—it requires one API key per client, so you'd need 15 separate MCP connections in Switchy, and the toolset doesn't expose bulk reporting or cross-account analytics. The 'create campaign recipient estimation job' and 'create campaign clone' tools work fine for single-account workflows, but the MCP has no read-heavy tools for pulling historical sends or comparing performance across clients. The threshold: if you're managing 1-3 clients or your reporting lives in a separate BI tool, the MCP is fine for campaign execution. Beyond that, you're better off using Klaviyo's reporting UI or a dedicated analytics MCP and reserving this one for campaign creation and list ops only.

Frequently asked

What can the Klaviyo MCP do in Switchy?

The Klaviyo MCP lets your AI agents manage email campaigns, track customer events, and update subscriber lists directly from Switchy. It handles tasks like adding profiles to lists, creating campaigns, subscribing users to back-in-stock alerts, and bulk-importing events. You get 50 tools covering most of Klaviyo's marketing automation workflows without switching to the Klaviyo dashboard.

Do I need a Klaviyo private API key or public key?

You need a private API key with appropriate scopes like campaigns:write and lists:write. Public keys only work for client-side event tracking, which isn't what the MCP uses. Generate the private key in Klaviyo's account settings under API Keys, and make sure the key has permissions for the campaigns and lists you want the AI to manage.

Can the Klaviyo MCP send emails or just create drafts?

It creates and configures campaigns but doesn't send them automatically. You can build campaigns, assign templates, clone existing ones, and estimate recipient counts, but you'll still need to manually approve and send from Klaviyo's interface. This prevents accidental sends to your entire list. If you need fully automated sends, you'll need Klaviyo's own automation flows.

How is this different from using Klaviyo's API directly?

The MCP wraps Klaviyo's REST API into natural-language tools your AI can call. Instead of writing code to POST events or manage lists, you ask the AI to do it. You still hit the same rate limits Klaviyo enforces, but you skip the integration work. If you already have custom Klaviyo scripts, the MCP won't replace them—it's for teams that want AI-driven workflows without engineering.

Who on my team should connect the Klaviyo MCP?

Whoever owns your Klaviyo account and understands your list segmentation. The API key grants broad access to campaigns and subscriber data, so don't hand it to someone who doesn't know which lists are safe to modify. Once connected, any Switchy user in your workspace can trigger Klaviyo actions through the AI, so set clear usage guidelines upfront.

Compare with

Mailchimp

Compare with anything else →