How to integrate Klaviyo MCP with Mastra AI

This guide walks you through connecting Klaviyo to Mastra AI using the Composio tool router. By the end, you'll have a working Klaviyo agent that can add new subscribers to main email list, clone last week's campaign for reuse, estimate recipients for upcoming product launch through natural language commands. This guide will help you understand how to give your Mastra AI agent real control over a Klaviyo account through Composio's Klaviyo MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved.

Get started for freeGet a demo
Klaviyo logoKlaviyo
Api KeyOauth2

Klaviyo is a data-driven email and SMS marketing platform for e-commerce brands. It helps deliver targeted messages, track conversions, and build scalable customer relationships.

225 Tools

Introduction

This guide walks you through connecting Klaviyo to Mastra AI using the Composio tool router. By the end, you'll have a working Klaviyo agent that can add new subscribers to main email list, clone last week's campaign for reuse, estimate recipients for upcoming product launch through natural language commands.

This guide will help you understand how to give your Mastra AI agent real control over a Klaviyo account through Composio's Klaviyo MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Klaviyo with

ChatGPTOpenAI Agents SDKClaude Agent SDKClaude CodeClaude CoworkCodexOpenCodeCursorVS CodeOpenClawHermesCLIGoogle ADKLangChainVercel AI SDKLlamaIndexCrewAI

TL;DR

Here's what you'll learn:
  • Set up your environment so Mastra, OpenAI, and Composio work together
  • Create a Tool Router session in Composio that exposes Klaviyo tools
  • Connect Mastra's MCP client to the Composio generated MCP URL
  • Fetch Klaviyo tool definitions and attach them as a toolset
  • Build a Mastra agent that can reason, call tools, and return structured results
  • Run an interactive CLI where you can chat with your Klaviyo agent

What is Mastra AI?

Mastra AI is a TypeScript framework for building AI agents with tool support. It provides a clean API for creating agents that can use external services through MCP.

Key features include:

  • MCP Client: Built-in support for Model Context Protocol servers
  • Toolsets: Organize tools into logical groups
  • Step Callbacks: Monitor and debug agent execution
  • OpenAI Integration: Works with OpenAI models via @ai-sdk/openai

What is the Klaviyo MCP server, and what's possible with it?

The Klaviyo MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Klaviyo account. It provides structured and secure access to your marketing campaigns, contact lists, and automation features, so your agent can perform actions like creating campaigns, managing subscribers, sending messages, and analyzing engagement—all on your behalf.

  • Automated campaign creation and sending: Instantly have your agent create new marketing campaigns, clone existing ones, and trigger campaign sends to targeted audiences.
  • Subscriber and list management: Add or update profiles in specific Klaviyo lists, subscribe contacts to marketing lists, and ensure your audience is always up to date.
  • Event and engagement tracking: Automatically record customer activities or bulk-create profile events to power segmentation and analytics.
  • Catalog and back-in-stock automation: Let your agent create product catalog categories, manage restock alerts, and help drive timely customer notifications about inventory.
  • Campaign recipient estimation and analytics: Start background jobs to estimate campaign reach and analyze how many recipients meet your targeting criteria before a send.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Node.js 18 or higher
  • A Composio account with an active API key
  • An OpenAI API key
  • Basic familiarity with TypeScript
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key.
  • You need credits or a connected billing setup to use the models.
  • Store the key somewhere safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Go to Settings and copy your API key.
  • This key lets your Mastra agent talk to Composio and reach Klaviyo through MCP.
3

Install dependencies

bash
npm install @composio/core @mastra/core @mastra/mcp @ai-sdk/openai dotenv

Install the required packages.

What's happening:

  • @composio/core is the Composio SDK for creating MCP sessions
  • @mastra/core provides the Agent class
  • @mastra/mcp is Mastra's MCP client
  • @ai-sdk/openai is the model wrapper for OpenAI
  • dotenv loads environment variables from .env
4

Set up environment variables

bash
COMPOSIO_API_KEY=your_composio_api_key_here
COMPOSIO_USER_ID=your_user_id_here
OPENAI_API_KEY=your_openai_api_key_here

Create a .env file in your project root.

What's happening:

  • COMPOSIO_API_KEY authenticates your requests to Composio
  • COMPOSIO_USER_ID tells Composio which user this session belongs to
  • OPENAI_API_KEY lets the Mastra agent call OpenAI models
5

Import libraries and validate environment

typescript
import "dotenv/config";
import { openai } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { MCPClient } from "@mastra/mcp";
import { Composio } from "@composio/core";
import * as readline from "readline";

import type { AiMessageType } from "@mastra/core/agent";

const openaiAPIKey = process.env.OPENAI_API_KEY;
const composioAPIKey = process.env.COMPOSIO_API_KEY;
const composioUserID = process.env.COMPOSIO_USER_ID;

if (!openaiAPIKey) throw new Error("OPENAI_API_KEY is not set");
if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set");
if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set");

const composio = new Composio({
  apiKey: composioAPIKey as string,
});
What's happening:
  • dotenv/config auto loads your .env so process.env.* is available
  • openai gives you a Mastra compatible model wrapper
  • Agent is the Mastra agent that will call tools and produce answers
  • MCPClient connects Mastra to your Composio MCP server
  • Composio is used to create a Tool Router session
6

Create a Tool Router session for Klaviyo

typescript
async function main() {
  const session = await composio.create(
    composioUserID as string,
    {
      toolkits: ["klaviyo"],
    },
  );

  const composioMCPUrl = session.mcp.url;
  console.log("Klaviyo MCP URL:", composioMCPUrl);
What's happening:
  • create spins up a short-lived MCP HTTP endpoint for this user
  • The toolkits array contains "klaviyo" for Klaviyo access
  • session.mcp.url is the MCP URL that Mastra's MCPClient will connect to
7

Configure Mastra MCP client and fetch tools

typescript
const mcpClient = new MCPClient({
    id: composioUserID as string,
    servers: {
      nasdaq: {
        url: new URL(composioMCPUrl),
        requestInit: {
          headers: session.mcp.headers,
        },
      },
    },
    timeout: 30_000,
  });

console.log("Fetching MCP tools from Composio...");
const composioTools = await mcpClient.getTools();
console.log("Number of tools:", Object.keys(composioTools).length);
What's happening:
  • MCPClient takes an id for this client and a list of MCP servers
  • The headers property includes the x-api-key for authentication
  • getTools fetches the tool definitions exposed by the Klaviyo toolkit
8

Create the Mastra agent

typescript
const agent = new Agent({
    name: "klaviyo-mastra-agent",
    instructions: "You are an AI agent with Klaviyo tools via Composio.",
    model: "openai/gpt-5",
  });
What's happening:
  • Agent is the core Mastra agent
  • name is just an identifier for logging and debugging
  • instructions guide the agent to use tools instead of only answering in natural language
  • model uses openai("gpt-5") to configure the underlying LLM
9

Set up interactive chat interface

typescript
let messages: AiMessageType[] = [];

console.log("Chat started! Type 'exit' or 'quit' to end.\n");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: "> ",
});

rl.prompt();

rl.on("line", async (userInput: string) => {
  const trimmedInput = userInput.trim();

  if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) {
    console.log("\nGoodbye!");
    rl.close();
    process.exit(0);
  }

  if (!trimmedInput) {
    rl.prompt();
    return;
  }

  messages.push({
    id: crypto.randomUUID(),
    role: "user",
    content: trimmedInput,
  });

  console.log("\nAgent is thinking...\n");

  try {
    const response = await agent.generate(messages, {
      toolsets: {
        klaviyo: composioTools,
      },
      maxSteps: 8,
    });

    const { text } = response;

    if (text && text.trim().length > 0) {
      console.log(`Agent: ${text}\n`);
        messages.push({
          id: crypto.randomUUID(),
          role: "assistant",
          content: text,
        });
      }
    } catch (error) {
      console.error("\nError:", error);
    }

    rl.prompt();
  });

  rl.on("close", async () => {
    console.log("\nSession ended.");
    await mcpClient.disconnect();
    process.exit(0);
  });
}

main().catch((err) => {
  console.error("Fatal error:", err);
  process.exit(1);
});
What's happening:
  • messages keeps the full conversation history in Mastra's expected format
  • agent.generate runs the agent with conversation history and Klaviyo toolsets
  • maxSteps limits how many tool calls the agent can take in a single run
  • onStepFinish is a hook that prints intermediate steps for debugging

Complete Code

Here's the complete code to get you started with Klaviyo and Mastra AI:

typescript
import "dotenv/config";
import { openai } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { MCPClient } from "@mastra/mcp";
import { Composio } from "@composio/core";
import * as readline from "readline";

import type { AiMessageType } from "@mastra/core/agent";

const openaiAPIKey = process.env.OPENAI_API_KEY;
const composioAPIKey = process.env.COMPOSIO_API_KEY;
const composioUserID = process.env.COMPOSIO_USER_ID;

if (!openaiAPIKey) throw new Error("OPENAI_API_KEY is not set");
if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set");
if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set");

const composio = new Composio({ apiKey: composioAPIKey as string });

async function main() {
  const session = await composio.create(composioUserID as string, {
    toolkits: ["klaviyo"],
  });

  const composioMCPUrl = session.mcp.url;

  const mcpClient = new MCPClient({
    id: composioUserID as string,
    servers: {
      klaviyo: {
        url: new URL(composioMCPUrl),
        requestInit: {
          headers: session.mcp.headers,
        },
      },
    },
    timeout: 30_000,
  });

  const composioTools = await mcpClient.getTools();

  const agent = new Agent({
    name: "klaviyo-mastra-agent",
    instructions: "You are an AI agent with Klaviyo tools via Composio.",
    model: "openai/gpt-5",
  });

  let messages: AiMessageType[] = [];

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: "> ",
  });

  rl.prompt();

  rl.on("line", async (input: string) => {
    const trimmed = input.trim();
    if (["exit", "quit"].includes(trimmed.toLowerCase())) {
      rl.close();
      return;
    }

    messages.push({ id: crypto.randomUUID(), role: "user", content: trimmed });

    const { text } = await agent.generate(messages, {
      toolsets: { klaviyo: composioTools },
      maxSteps: 8,
    });

    if (text) {
      console.log(`Agent: ${text}\n`);
      messages.push({ id: crypto.randomUUID(), role: "assistant", content: text });
    }

    rl.prompt();
  });

  rl.on("close", async () => {
    await mcpClient.disconnect();
    process.exit(0);
  });
}

main();

Conclusion

You've built a Mastra AI agent that can interact with Klaviyo through Composio's Tool Router. You can extend this further by:
  • Adding other toolkits like Gmail, Slack, or GitHub
  • Building a web-based chat interface around this agent
  • Using multiple MCP endpoints to enable cross-app workflows
TOOLS

Supported Tools

Every Klaviyo action and event your agent gets out of the box.

Add Profile to List

Add profiles to a Klaviyo list by profile IDs or email addresses.

Assign campaign message template

Creates a non-reusable version of the template and assigns it to the message.

Bulk create client events

Use the client-side endpoint with a public API key to track profile activity.

Bulk create events

Bulk create events for multiple profiles in a single request.

Cancel Campaign Send

Cancel or revert a campaign send job.

Create back in stock subscription

Use the server-side endpoint to subscribe to restock alerts, following the Back in Stock API guide.

Create campaign

Creates a campaign given a set of parameters, then returns it.

Create campaign clone

Clones an existing campaign, returning a new campaign based on the original with a new ID and name.

Create Campaign Recipient Estimation Job

Start an asynchronous task to estimate the number of recipients for a campaign.

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.

Create catalog category relationships items

Create a new item relationship for the given category ID.

Create catalog item

Create a new catalog item.

Create catalog item relationships categories

Create a new catalog category relationship for the given item ID.

Create catalog variant

Create a new variant for a related catalog item.

Create client back in stock subscription

Use the endpoint for client-side back in stock notifications with a public API key.

Create Client Event V2

Create a client-side event in Klaviyo to track user interactions.

Create client subscription

Endpoint manages email/SMS opt-ins using consent and requires public API key for client use.

Create coupon

Creates a new coupon.

Create coupon code

Synchronously creates a coupon code for the given coupon.

Create event

Create or update a profile event with minimum identifiers and metric name.

Create list

Create a new list.

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.

Create or update client push token

This endpoint for mobile SDKs (iOS & Android) creates/updates push tokens using a public API key.

Create or Update Profile

Create or update a profile in Klaviyo with the given attributes.

Create or update push token

Create or update a push token for mobile push notifications.

Create profile

Create a new profile.

Create segment

Create a segment.

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.

Create tag group

Create tag groups up to 50 per account, defaulting to non-exclusive unless specified.

Create Tag Relationships

Associate a tag with other resources (flows, lists, segments, or campaigns) in Klaviyo.

Create template

Summary: Custom HTML templates can be created unless an account reaches 1,000 template limit.

Create template clone

Clone a template by its ID, but cloning fails if account has 1,000+ templates.

Create template render

Render an email template with specific context and sparse fieldsets, then get HTML/plain text.

Create webhook

Create a new Webhook to receive real-time notifications when specific events occur in Klaviyo (e.

Delete campaign

Delete a campaign with the given campaign ID.

Delete catalog category

Delete a catalog category using the given category ID.

Delete catalog category relationships items

Delete item relationships for the given category ID.

Delete catalog item

Delete a catalog item with the given item ID.

Delete catalog item relationships categories

Delete catalog category relationships for the given item ID.

Delete catalog variant

Delete a catalog item variant with the given variant ID.

Delete coupon

Delete the coupon with the given coupon ID.

Delete coupon code

Deletes a coupon code specified by the given identifier synchronously.

Delete flow

Delete a flow with the given flow ID.

Delete list

Delete a list with the given list ID.

Delete segment

Delete a segment with the given segment ID.

Delete tag

Delete the tag with the given tag ID.

Delete tag group

Delete a specified tag group and its contents; associated resource links will be removed.

Delete Tag Relationships

Remove a tag's association with other resources like flows, campaigns, lists, or segments.

Delete template

Permanently delete a template from your Klaviyo account using its unique template ID.

Delete webhook

Permanently delete a webhook subscription from your Klaviyo account.

Get account

Retrieve a single account object by its account ID.

Get accounts

Use a private API key to fetch an associated account's details like contact info, timezone, and currency, as well as validate the key.

Get Bulk Create Coupon Codes Job

Tool to get a coupon code bulk create job with the given job ID.

Get Bulk Delete Catalog Items Job

Get a catalog item bulk delete job with the given job ID.

Get bulk profile import job

Get a bulk profile import job with the given job ID.

Get bulk profile import job errors

Get import errors for the bulk profile import job with the given ID.

Get bulk profile import job lists

Get list for the bulk profile import job with the given ID.

Get bulk profile import job profiles

Get profiles for the bulk profile import job with the given ID.

Get bulk profile import job relationships lists

Get list relationship for the bulk profile import job with the given ID.

Get bulk profile import job relationships profiles

Get profile relationships for the bulk profile import job with the given ID.

Get bulk profile import jobs

Get all bulk profile import jobs.

Get bulk update catalog items job

Get a catalog item bulk update job with the given job ID.

Get Bulk Update Categories Job

Retrieve a catalog category bulk update job by its ID from Klaviyo.

Get Bulk Update Variants Job

Tool to retrieve a catalog variant bulk update job by its ID.

Get Campaign

Retrieve a specific campaign by its ID from Klaviyo.

Get campaign campaign messages

Return all messages that belong to the given campaign.

Get campaign message

Returns a specific message based on a required id.

Get campaign message campaign

Return the related campaign*Rate limits*:Burst: `10/s`Steady: `150/m` **Scopes:** `campaigns:read`

Get campaign message relationships campaign

Returns the ID of the related campaign*Rate limits*:Burst: `10/s`Steady: `150/m` **Scopes:** `campaigns:read`

Get campaign message relationships template

Returns the ID of the related template*Rate limits*:Burst: `10/s`Steady: `150/m` **Scopes:** `campaigns:read` `templates:read`

Get campaign message template

Return the related template*Rate limits*:Burst: `10/s`Steady: `150/m` **Scopes:** `campaigns:read` `templates:read`

Get campaign recipient estimation

Get estimated recipients for a given campaign ID using `Create Campaign Recipient Estimation Job`.

Get campaign recipient estimation job

Retrieve the status of a recipient estimation job triggered with the `Create Campaign Recipient Estimation Job` endpoint.

Get campaign relationships campaign messages

Returns the IDs of all messages associated with the given campaign.

Get campaign relationships tags

Returns the IDs of all tags associated with the given campaign.

Get Campaigns

Retrieve campaigns from your Klaviyo account.

Get campaign send job

Get a campaign send job*Rate limits*:Burst: `10/s`Steady: `150/m` **Scopes:** `campaigns:read`

Get campaign tags

Return all tags that belong to the given campaign.

Get catalog categories

Retrieve up to 100 account catalog categories, sortable by creation date.

Get catalog category

Get a catalog category with the given category ID.

Get catalog category items

Retrieve up to 100 sorted items per request from a category using the category ID.

Get catalog category relationships items

Get all items in the given category ID.

Get catalog item

Get a specific catalog item with the given item ID.

Get catalog item categories

Retrieve the catalog categories for an item by ID, sorted by 'created' date, with a 100-category maximum per request.

Get catalog item relationships categories

Get all catalog categories that a particular item is in.

Get catalog items

Retrieve up to 100 sorted catalog items per account, with `$custom` integration and `$default` type.

Get catalog item variants

Retrieve up to 100 variants per request for a specific item ID, sortable by creation date.

Get catalog variant

Get a catalog item variant with the given variant ID.

Get catalog variants

Retrieve up to 100 account variants per request, sortable by creation date.

Get coupon

Get a specific coupon with the given coupon ID.

Get coupon code

Returns a Coupon Code specified by the given identifier.

Get coupon code bulk create job

Get a coupon code bulk create job with the given job ID.

Get coupon code bulk create jobs

Get all coupon code bulk create jobs.

Get coupon code relationships coupon

Gets a list of coupon code relationships associated with the given coupon id*Rate limits*:Burst: `75/s`Steady: `700/m` **Scopes:** `coupon-codes:read`

Get coupon codes

Obtains coupon codes using necessary coupon or profile filters.

Get coupon codes for coupon

Gets a list of coupon codes associated with the given coupon id*Rate limits*:Burst: `75/s`Steady: `700/m` **Scopes:** `coupon-codes:read`

Get coupon for coupon code

Get the coupon associated with a given coupon code ID.

Get Coupon ID for Coupon Code

Tool to get the coupon relationship associated with a given coupon code ID.

Get Coupon Relationships Coupon Codes

Retrieves the coupon code relationships (resource identifiers) for a given coupon.

Get coupons

Get all coupons in an account.

Get create categories job

Get a catalog category bulk create job with the given job ID.

Get create categories jobs

Get all catalog category bulk create jobs.

Get create items job

Get a catalog item bulk create job with the given job ID.

Get create items jobs

Get all catalog item bulk create jobs.

Get create variants job

Get a catalog variant bulk create job with the given job ID.

Get create variants jobs

Get all catalog variant bulk create jobs.

Get delete categories job

Get a catalog category bulk delete job with the given job ID.

Get delete categories jobs

Get all catalog category bulk delete jobs.

Get delete items jobs

Get all catalog item bulk delete jobs.

Get delete variants job

Get a catalog variant bulk delete job with the given job ID.

Get delete variants jobs

Get all catalog variant bulk delete jobs.

Get event

Get an event with the given event ID.

Get event metric

Get the metric for an event with the given event ID.

Get event profile

Get the profile associated with an event with the given event ID.

Get Event Relationships

Get metrics or profile relationships for a specific event.

Get events

Get all events in an account Requests can be sorted by the following fields: `datetime`, `timestamp` Returns a maximum of 200 events per page.

Get flow

Get a flow with the given flow ID.

Get flow action

Get a flow action from a flow with the given flow action ID.

Get flow action for message

Get the flow action for a flow message with the given message ID.

Get flow action messages

Retrieve up to 50 flow messages per request by action ID, sortable by various fields, with ascending/descending options, and paginated using `page[size]` and `page[number]`.

Get Parent Flow for Flow Action

Get the parent flow associated with a given flow action ID.

Get flow action relationships messages

Retrieves up to 50 flow message relationships per request for a specified flow action ID, with cursor pagination.

Get flow flow actions

Get all flow actions associated with the given flow ID.

Get flow for flow action

Get the flow associated with the given action ID.

Get flow message

Get the flow message of a flow with the given message ID.

Get flow message relationships action

Get the flow action relationship for a specific flow message.

Get flow message relationships template

Returns the ID of the related template*Rate limits*:Burst: `3/s`Steady: `60/m` **Scopes:** `templates:read`

Get flow message template

Return the related template*Rate limits*:Burst: `3/s`Steady: `60/m` **Scopes:** `templates:read`

Get flow relationships flow actions

Retrieve all flow action relationships for a specific flow ID, sortable by `id`, `status`, `created`, `updated`.

Get flow relationships tags

Return the tag IDs of all tags associated with the given flow.

Get flows

Get all flows in an account.

Get flow tags

Return all tags associated with the given flow ID.

Get form

Get the form with the given ID.

Get form for form version

Get the form associated with the given form version.

Get form id for form version

Get the ID of the form associated with the given form version.

Get forms

Get all forms in an account.

Get form version

Retrieve detailed information about a specific form version by its ID.

Get image

Get the image with the given image ID.

Get images

Get all images in an account.

Get list

API allows 75 req/sec and 700 req/min, but with 'profile_count' param, it's 1 req/sec and 15 req/min.

Get list profiles

Retrieve profiles in a list by ID, filterable by email/phone/push token/join date, sortable by join date.

Get List Relationships

Get profile membership relationships for a Klaviyo list.

Get list relationships tags

Returns the tag IDs of all tags associated with the given list.

Get Lists

Retrieve marketing lists from your Klaviyo account.

Get list tags

Return all tags associated with the given list ID.

Get metric

Get a metric with the given metric ID.

Get metrics

Get all metrics in an account.

Get profile

Get the profile with the given profile ID.

Get profile lists

Get list memberships for a profile with the given profile ID.

Get Profile Relationships

Tool to get list membership or segment membership relationships for a profile with the given profile ID.

Get Profiles

Retrieve profiles from your Klaviyo account.

Get profile segments

Get segment memberships for a profile with the given profile ID.

Get segment

Fetch a segment by ID with default rates of 75/s and 700/m, or with `additional-fields` at 1/s and 15/m.

Get segment profiles

Retrieve profiles in a segment by ID, filtering by email, phone, token, or join date, and sorting by join date.

Get Segment Relationships

Get all profile membership or tag relationships for a segment.

Get segments

Fetch segments from an account with filters like `name`, `created`, and `updated`.

Get segment tags

Return all tags associated with the given segment ID.

Get tag

Retrieve the tag with the given tag ID.

Get tag group

Retrieve the tag group with the given tag group ID.

Get tag group relationships tags

Returns the tag IDs of all tags inside the given tag group.

Get tag groups

Retrieve up to 25 tag groups per account, sortable/filterable by specific attributes.

Get tag group tags

Return the tags for a given tag group ID.

Get Tag Relationships

Tool to retrieve relationship IDs for a tag.

Get tags

Retrieve up to 50 account tags at once, filterable/sortable by name or id, with cursor pagination.

Get tag tag group

Returns the tag group resource for a given tag ID.

Get template

Get a template with the given template ID.

Get templates

Retrieve account templates with sorting options (`id`, `name`, `created`, `updated`).

Get update categories jobs

Get all catalog category bulk update jobs.

Get update items job

Get a catalog item bulk update job with the given job ID.

Get update items jobs

Get all catalog item bulk update jobs.

Get update variants jobs

Get all catalog variant bulk update jobs.

Get Variant IDs for Catalog Item

Tool to get all variant IDs related to a given catalog item ID.

Get version ids for form

Get the IDs of the form versions for the given form.

Get versions for form

Get the form versions for the given form.

Get webhook

Get the webhook with the given ID.

Get webhooks

Get all webhooks in an account.

Get webhook topic

Retrieve details of a specific webhook topic by its ID.

Get webhook topics

Get all webhook topics in a Klaviyo account.

Merge profiles

Merge one or more source profiles into a destination profile.

Query campaign values

Returns the requested campaign analytics values data*Rate limits*:Burst: `1/s`Steady: `2/m`Daily: `225/d` **Scopes:** `campaigns:read`

Query flow series

Returns time-series analytics data for flows, enabling performance tracking over time intervals.

Query flow values

Returns the requested flow analytics values data*Rate limits*:Burst: `1/s`Steady: `2/m`Daily: `225/d` **Scopes:** `flows:read`

Query metric aggregates

The Klaviyo endpoint fetches metric events, handling JSON requests for custom data queries, sorting, and filtering; offers grouping and time-based filters; requires adherence to rate limits (3 requests per second, 60 per minute) under 'metrics:read'.

Remove Profile from List

Remove profiles from a Klaviyo list by profile IDs or email addresses.

Request profile deletion

To delete a profile, use only one identifier: email, phone number, or ID.

Spawn bulk profile import job

Initiate a job to create/update a batch of profiles, up to 10,000 with a max size of 5MB per request.

Spawn coupon code bulk create job

Create a coupon-code-bulk-create-job to bulk create a list of coupon codes.

Spawn create categories job

Create bulk job for up to 100 catalog categories with a 5MB size limit and a max of 500 concurrent jobs.

Spawn create items job

Create batches of up to 100 catalog items with a 5MB size limit using the bulk job, which allows 500 concurrent jobs.

Spawn create variants job

Initiate a job to bulk create up to 100 catalog variants, with a 5MB payload size limit.

Spawn delete categories job

Delete multiple catalog categories in bulk, with a limit of 100 per request and a 5MB payload size.

Spawn delete items job

Delete batches of catalog items with a bulk job, max 100 items/request, 5MB size limit, and up to 500 concurrent jobs.

Spawn delete variants job

Delete multiple catalog variants with a bulk job, max 100 per request, 5MB size limit.

Spawn update categories job

Create a job to bulk update up to 100 categories, with a 5MB size limit and a maximum of 500 concurrent jobs.

Spawn update items job

You can bulk update up to 100 catalog items with a 5MB payload limit.

Spawn update variants job

Create a job to bulk update up to 100 catalog variants with a 5MB payload limit.

Subscribe profiles

The API supports double opt-in for marketing, with 'historical_import' bypassing consent.

Suppress profiles

Suppress profiles by email, segment, or list ID to stop email marketing, regardless of consent.

Unregister client push token

This endpoint unsubscribes a push token, for use with Klaviyo's mobile SDKs and a public API key.

Unsubscribe profiles

Opt-out profiles from email or SMS marketing.

Unsubscribe Profiles Bulk

Tool to unsubscribe one or more profiles from a Klaviyo list.

Unsuppress profiles

Remove 'USER_SUPPRESSED' blocks on profiles manually via email, segment, or list ID.

Unsuppress Profiles (Bulk)

Tool to unsuppress one or more profiles from email marketing by email address.

Update Campaign

Update a campaign with the specified attributes.

Update campaign message

Update a campaign message*Rate limits*:Burst: `10/s`Steady: `150/m` **Scopes:** `campaigns:write`

Update catalog category

Update a catalog category with the given category ID.

Update Catalog Category Relationships

Tool to update item relationships for a catalog category.

Update catalog category relationships items

Update item relationships for the given category ID.

Update catalog item

Update a catalog item with the given item ID.

Update catalog item relationships categories

Update catalog category relationships for the given item ID.

Update catalog variant

Update a catalog item variant with the given variant ID.

Update coupon

Update an existing coupon's properties.

Update coupon code

Updates a coupon code specified by the given identifier synchronously.

Update flow status

Update the status of a flow with the given flow ID, and all actions in that flow.

Update image

Update the image with the given image ID.

Update list

Update the name of a list with the given list ID.

Update profile

Update profiles with the provided ID.

Update segment

Update a segment with the given segment ID.

Update tag

Update the tag with the given tag ID.

Update tag group

Update the tag group with the given tag group ID.

Update template

Update an existing email template by ID.

Update webhook

Update the webhook with the given ID.

Upload image from file

Upload an image from a file.

Upload image from url

Import an image from a url or data uri.

FRAMEWORKS

How to build Klaviyo MCP Agent with another framework

ChatGPT logo

ChatGPT

Use Klaviyo MCP with ChatGPT

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Klaviyo MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Klaviyo MCP with Claude Agent SDK

Claude Code logo

Claude Code

Use Klaviyo MCP with Claude Code

Claude Cowork logo

Claude Cowork

Use Klaviyo MCP with Claude Cowork

Codex logo

Codex

Use Klaviyo MCP with Codex

Cursor logo

Cursor

Use Klaviyo MCP with Cursor

OpenClaw logo

OpenClaw

Use Klaviyo MCP with OpenClaw

Hermes logo

Hermes

Use Klaviyo MCP with Hermes

CLI logo

CLI

Use Klaviyo MCP with CLI

Google ADK logo

Google ADK

Use Klaviyo MCP with Google ADK

LangChain logo

LangChain

Use Klaviyo MCP with LangChain

Vercel AI SDK logo

Vercel AI SDK

Use Klaviyo MCP with Vercel AI SDK

LlamaIndex logo

LlamaIndex

Use Klaviyo MCP with LlamaIndex

CrewAI logo

CrewAI

Use Klaviyo MCP with CrewAI

OpenCode logo

OpenCode

Use Klaviyo MCP with OpenCode

VS Code logo

VS Code

Use Klaviyo MCP with VS Code

FAQ

Frequently asked questions

With a standalone Klaviyo MCP server, the agents and LLMs can only access a fixed set of Klaviyo tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Klaviyo and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. Mastra AI fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Klaviyo tools.

Yes, absolutely. You can configure which Klaviyo scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Klaviyo data and credentials are handled as safely as possible.

Start with Klaviyo.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Klaviyo tool your agent needs.Free to start.

Start building
Customer stories

Teams ship real agents on Composio

GET STARTED FOR FREEBOOK A DEMO
agent.aiZoomLettaGleanHubSpotAWSWabi

Karan skipped his own birthday party to fix our critical issue. It was 10pm and he diverted his Waymo to help us instead. This really sets the bar — it shows the commitment you need when users rely on your software.

Harsha Gaddipati
Harsha Gaddipati
Co-founder, Slashy

A lot of students tell us that the moment their connected tools start talking to each other inside Opennote feels almost magical. The agent just knows them, and it's immensely helped keep new users on the platform.

Abhi Arya
Abhi Arya
Co-founder, Opennote

We chose Composio over Pipedream because it delivered depth where it mattered — niche tools and tricky edge cases other platforms simply ignored. That gave us confidence to scale without compromising.

Nirman Dave
Nirman Dave
CEO, Zams

As a solo builder, shipping fast is life or death. The only way I can outcompete incumbents is by outmanoeuvring them. Getting bogged down managing agent auth would have been a death sentence.

Ryan Yu
Ryan Yu
Founder, Extra Thursday

Before Composio, adding tool integrations was slow and resource-intensive. Each one could take weeks of engineering time, and maintaining them meant constantly keeping up with API changes.

Tomisin Jenrola
Tomisin Jenrola
Founder & CEO, SwarmZero

With hands-on help from their founder, we integrated Gmail and Google Drive in just 30 minutes. This level of personal support and commitment is exactly what startups should strive for.

Jerome Leclanche
Jerome Leclanche
Co-Founder, Ingram Technologies