Klaviyo API + MCP (2026): First Marketing ESP with GA MCP Server

Klaviyo’s API v2023 is one of the most modern and well-designed ESP APIs on the market. Stable date-versioned schema (revision header per request), 5 official SDKs, generous rate limits with distinct steady-state and burst budgets per endpoint category. What sets Klaviyo apart from every other marketing ESP in 2026: it ships an official Model Context Protocol server, Generally Available, letting Claude Desktop, Cursor, and ChatGPT (Pro/Plus) drive Klaviyo operations through natural language. This tab inventories the API surface, MCP capabilities, and the gotchas ecommerce buyers need to evaluate before committing.

At a glance

MCP integration in 2026

Model Context Protocol is the emerging standard for connecting LLM agents to external tools. Klaviyo is one of the first ecommerce marketing platforms to ship an official MCP server past the BETA phase — a signal of how seriously the company treats AI-agent-driven workflows.

Available MCP servers for Klaviyo

Three ways to reach Klaviyo from an AI agent as of August 2026, ordered by maturity. Only the first is official Klaviyo, and it is the most maintained.

API v2023 essentials

Klaviyo’s API v2023 uses a date-based revision system (similar to Stripe): every request specifies a revision header, and Klaviyo maintains backward compatibility per revision. This is unusually developer-friendly for the ESP category.

The JSON:API spec adds some verbosity (every object has type, id, attributes, relationships wrappers) but delivers cleaner semantics for graph-like customer data. If you have not used JSON:API before, expect a 30-minute learning curve; the official SDKs abstract most of the ceremony away.

Authentication methods

Two API key types, both operating through custom HTTP headers.

Private API key (server-side)

Used for the majority of API calls: profiles, events, segments, campaigns, flows, templates, reporting. Full read/write access at the account level. Generate under Account › Settings › API Keys. Send in the Authorization header:

Authorization: Klaviyo-API-Key pk_XXXXXXXXXXXXXXXX
revision: 2023-10-15
Content-Type: application/json
Accept: application/json

Private keys support optional scopes: read-only, campaign management, profile management, etc. Scoped keys are the recommended pattern for third-party integrations — unlike most ESPs, Klaviyo genuinely offers granular scopes.

Public API key (client-side)

Used for browser-safe operations: track events from client-side JavaScript, identify profiles, subscribe to lists. Six-character alphanumeric ID passed as a query parameter or in JavaScript SDK config. Cannot be used for read operations or destructive actions — safe to expose in front-end code.

Rate limits

Klaviyo publishes per-endpoint rate limits with distinct burst (short-window peak) and steady-state (per-minute sustained) buckets. This is more granular than any competitor ESP in 2026 — use it to your advantage when planning batch operations.

The Events endpoint at 3,500/min steady-state is designed for high-volume ecommerce event ingestion (order placed, viewed product, added to cart, checkout started). For bulk profile operations, use the async job endpoints instead of looping single-profile calls — the job endpoints do not consume the 75/s profile burst budget.

Official SDKs

Five official client libraries maintained by Klaviyo. All auto-generated from the OpenAPI spec, updated per API revision release.

No official Go, Rust, Kotlin, or Swift SDKs. For those languages, call the API directly with your language’s HTTP client — the OpenAPI spec is public and can be used to generate a client with openapi-generator if needed. The 5 official SDKs are actively maintained per API revision — new SDK releases follow each date-versioned API revision within days.

Endpoints reference

The endpoint groups you will actually use in production. Full reference at developers.klaviyo.com.

Code examples

Two representative snippets covering the most common first-day tasks: track an event, then upsert a profile.

Python: track an event and upsert profile properties

from klaviyo_api import KlaviyoAPI

client = KlaviyoAPI(
    api_key='pk_YOUR_PRIVATE_KEY',
    max_delay=60,
    max_retries=3
)

# Track a "Placed Order" event, upserting profile in the same call
response = client.Events.create_event({
    'data': {
        'type': 'event',
        'attributes': {
            'properties': {
                'OrderId': 'ORD-1234',
                'Total': 89.50,
                'Items': ['Product A', 'Product B']
            },
            'metric': {
                'data': {
                    'type': 'metric',
                    'attributes': {'name': 'Placed Order'}
                }
            },
            'profile': {
                'data': {
                    'type': 'profile',
                    'attributes': {
                        'email': 'customer@example.com',
                        'first_name': 'Alaa',
                        'last_name': 'Touil'
                    }
                }
            }
        }
    }
})

print(f"Event tracked: {response['data']['id']}")

Node.js: create a campaign and send it

const { KlaviyoApi } = require('klaviyo-api');

const client = new KlaviyoApi({ apiKey: 'pk_YOUR_PRIVATE_KEY' });

async function sendCampaign(listId) {
  // 1. Create the campaign
  const campaign = await client.Campaigns.createCampaign({
    data: {
      type: 'campaign',
      attributes: {
        name: 'Weekly Newsletter',
        audiences: { included: [listId] },
        send_options: { use_smart_sending: true },
        tracking_options: {
          is_add_utm: true,
          utm_params: [{ name: 'utm_source', value: 'klaviyo' }]
        }
      }
    }
  });

  // 2. Set message content (HTML + subject) - separate call
  // 3. Trigger send
  const job = await client.Campaigns.createCampaignSendJob({
    data: {
      type: 'campaign-send-job',
      id: campaign.data.id
    }
  });

  console.log(`Campaign send job created: ${job.data.id}`);
}

sendCampaign('LIST_ID_HERE').catch(console.error);

Common gotchas

Deprecations and changelog

Klaviyo maintains a public API changelog at developers.klaviyo.com/en/reference/api-revisions. Key items to know:

• API v2023 is current. Date-versioned revisions maintain backward compatibility. New revisions add features; old revisions continue to work indefinitely.
• Legacy v1 and v2 APIs deprecated. Klaviyo has communicated a shutoff timeline for the pre-2023 APIs. Migrate to v2023 for any active integration.
• Klaviyo MCP Server released GA in 2026 after a beta phase. First marketing-focused ESP to reach MCP GA.
• Scoped API keys added in 2024. Read-only + full + object-scoped tokens. Recommended pattern for third-party integrations.
• Bulk profile import job endpoint added in 2023. Preferred over looping single-profile POST calls for large migrations.

Frequently asked questions