How to Integrate Replit with Klaviyo

1// check-klaviyo-secrets.js
2const required = ['KLAVIYO_PRIVATE_KEY'];
3for (const key of required) {
4  if (!process.env[key]) {
5    throw new Error(`Missing secret: ${key}. Add it in Replit Secrets (lock icon 🔒).`);
6  }
7}
8// Validate key format — Klaviyo private keys start with pk_
9if (!process.env.KLAVIYO_PRIVATE_KEY.startsWith('pk_')) {
10  console.warn('Warning: Klaviyo private keys typically start with pk_ — verify you are using the Private key, not the Public key.');
11}
12console.log('Klaviyo secrets configured.');
13console.log('Key prefix:', process.env.KLAVIYO_PRIVATE_KEY.slice(0, 8) + '...');

1// klaviyo-profiles.js — Manage Klaviyo profiles from Replit
2const KLAVIYO_KEY = process.env.KLAVIYO_PRIVATE_KEY;
3const REVISION = '2024-10-15'; // Klaviyo API revision date
4const BASE_URL = 'https://a.klaviyo.com/api';
5
6async function klaviyoRequest(method, endpoint, body = null) {
7  const options = {
8    method,
9    headers: {
10      'Authorization': `Klaviyo-API-Key ${KLAVIYO_KEY}`,
11      'revision': REVISION,
12      'Content-Type': 'application/json',
13      'Accept': 'application/json'
14    }
15  };
16  if (body) options.body = JSON.stringify(body);
17
18  const res = await fetch(`${BASE_URL}${endpoint}`, options);
19  if (!res.ok) {
20    const errText = await res.text();
21    throw new Error(`Klaviyo API ${res.status}: ${errText}`);
22  }
23  // 204 No Content responses have no body
24  if (res.status === 204) return null;
25  return res.json();
26}
27
28// Create or update (upsert) a customer profile
29async function upsertProfile(email, firstName, lastName, phone, customProps = {}) {
30  const payload = {
31    data: {
32      type: 'profile',
33      attributes: {
34        email,
35        first_name: firstName,
36        last_name: lastName,
37        phone_number: phone,  // E.164 format: +15551234567
38        properties: customProps
39      }
40    }
41  };
42
43  // POST /profile-import upserts by email (create or update)
44  const result = await klaviyoRequest('POST', '/profile-import/', payload);
45  const profileId = result?.data?.id;
46  console.log(`Profile upserted: ${profileId} (${email})`);
47  return profileId;
48}
49
50// Get a profile by email
51async function getProfileByEmail(email) {
52  const params = new URLSearchParams({ 'filter': `equals(email,"${email}")` });
53  const result = await klaviyoRequest('GET', `/profiles/?${params}`);
54  return result?.data?.[0] || null;
55}
56
57// Update specific profile properties
58async function updateProfile(profileId, properties) {
59  const payload = {
60    data: {
61      type: 'profile',
62      id: profileId,
63      attributes: { properties }
64    }
65  };
66  return klaviyoRequest('PATCH', `/profiles/${profileId}/`, payload);
67}
68
69// Example
70(async () => {
71  try {
72    const profileId = await upsertProfile(
73      'customer@example.com',
74      'Jane', 'Smith', '+15551234567',
75      { plan_type: 'premium', signup_source: 'checkout' }
76    );
77    console.log('Profile ID:', profileId);
78  } catch (err) {
79    console.error('Error:', err.message);
80  }
81})();
82
83module.exports = { upsertProfile, getProfileByEmail, updateProfile, klaviyoRequest };

1# klaviyo_events.py — Track events and manage subscriptions in Klaviyo
2import os
3import requests
4from datetime import datetime, timezone
5
6KLAVIYO_KEY = os.environ['KLAVIYO_PRIVATE_KEY']
7KLAVIYO_LIST_ID = os.environ.get('KLAVIYO_LIST_ID', '')
8REVISION = '2024-10-15'
9BASE_URL = 'https://a.klaviyo.com/api'
10
11HEADERS = {
12    'Authorization': f'Klaviyo-API-Key {KLAVIYO_KEY}',
13    'revision': REVISION,
14    'Content-Type': 'application/json',
15    'Accept': 'application/json'
16}
17
18def track_event(event_name: str, email: str, properties: dict) -> bool:
19    """
20    Track a custom event for a profile identified by email.
21    Use standard names like 'Placed Order', 'Started Checkout' for e-commerce.
22    """
23    payload = {
24        'data': {
25            'type': 'event',
26            'attributes': {
27                'time': datetime.now(timezone.utc).isoformat(),
28                'value': properties.get('value', 0),
29                'metric': {
30                    'data': {
31                        'type': 'metric',
32                        'attributes': {'name': event_name}
33                    }
34                },
35                'profile': {
36                    'data': {
37                        'type': 'profile',
38                        'attributes': {'email': email}
39                    }
40                },
41                'properties': properties
42            }
43        }
44    }
45    response = requests.post(f'{BASE_URL}/events/', headers=HEADERS, json=payload)
46    response.raise_for_status()
47    print(f'Event tracked: {event_name} for {email}')
48    return True
49
50def track_order(email: str, order_id: str, total: float, items: list):
51    """Track a 'Placed Order' event with line items."""
52    return track_event('Placed Order', email, {
53        'order_id': order_id,
54        'value': total,
55        '$value': total,   # Klaviyo uses $value for revenue tracking
56        'items': items,    # List of {product_id, name, price, quantity}
57        'item_count': len(items)
58    })
59
60def subscribe_to_list(profile_id: str, list_id: str = None) -> bool:
61    """Subscribe a profile to a Klaviyo email list."""
62    lid = list_id or KLAVIYO_LIST_ID
63    if not lid:
64        raise ValueError('No list ID provided. Set KLAVIYO_LIST_ID in Replit Secrets.')
65
66    payload = {
67        'data': [{'type': 'profile', 'id': profile_id}]
68    }
69    response = requests.post(
70        f'{BASE_URL}/lists/{lid}/relationships/profiles/',
71        headers=HEADERS, json=payload
72    )
73    response.raise_for_status()
74    print(f'Profile {profile_id} subscribed to list {lid}')
75    return True
76
77if __name__ == '__main__':
78    # Track a test order event
79    track_order(
80        email='customer@example.com',
81        order_id='ORD-12345',
82        total=99.99,
83        items=[
84            {'product_id': 'PROD-001', 'name': 'Widget Pro', 'price': 49.99, 'quantity': 2}
85        ]
86    )

1// klaviyo-webhook.js — Receive and process Klaviyo webhook events
2const express = require('express');
3const crypto = require('crypto');
4const app = express();
5
6// Use raw body for signature verification
7app.use('/klaviyo/webhook', express.raw({ type: 'application/json' }));
8app.use(express.json());
9
10const WEBHOOK_SECRET = process.env.KLAVIYO_WEBHOOK_SECRET;
11
12function verifyKlaviyoSignature(rawBody, signatureHeader) {
13  if (!WEBHOOK_SECRET) return true; // Skip verification if no secret set (dev only)
14  const expected = crypto
15    .createHmac('sha256', WEBHOOK_SECRET)
16    .update(rawBody)
17    .digest('base64');
18  return crypto.timingSafeEqual(
19    Buffer.from(expected),
20    Buffer.from(signatureHeader || '')
21  );
22}
23
24app.post('/klaviyo/webhook', (req, res) => {
25  const signature = req.headers['x-klaviyo-signature'];
26  const rawBody = req.body; // raw Buffer due to express.raw()
27
28  if (!verifyKlaviyoSignature(rawBody, signature)) {
29    console.error('Invalid Klaviyo webhook signature');
30    return res.status(401).json({ error: 'Invalid signature' });
31  }
32
33  let events;
34  try {
35    events = JSON.parse(rawBody.toString());
36    if (!Array.isArray(events)) events = [events];
37  } catch (err) {
38    return res.status(400).json({ error: 'Invalid JSON' });
39  }
40
41  for (const event of events) {
42    const type = event.type;
43    const attributes = event.attributes || {};
44
45    console.log('Klaviyo webhook event:', type);
46
47    if (type === 'profile.unsubscribed') {
48      const email = attributes.email;
49      console.log(`Unsubscribe received for: ${email}`);
50      // TODO: update subscription status in your database
51    } else if (type === 'email.bounced') {
52      const email = attributes.email;
53      console.log(`Email bounced for: ${email}`);
54      // TODO: mark email as bounced in your database
55    } else if (type === 'sms.unsubscribed') {
56      const phone = attributes.phone_number;
57      console.log(`SMS opt-out from: ${phone}`);
58    } else {
59      console.log('Event data:', JSON.stringify(attributes, null, 2));
60    }
61  }
62
63  res.status(200).json({ received: true });
64});
65
66app.listen(3000, '0.0.0.0', () => {
67  console.log('Klaviyo webhook server running on port 3000');
68  console.log('Set webhook URL in Klaviyo: https://yourapp.replit.app/klaviyo/webhook');
69});