Customer.io Connector

Connect your Customer.io messaging platform to Brevo for unified customer data, cross-platform campaign coordination, and consolidated engagement analytics.

Overview

Features

• People sync - Bidirectional customer profile synchronization with Brevo contacts
• Event forwarding - Track behavioral events and forward to Brevo for automation triggers
• Campaign analytics - Sync campaign performance metrics for unified reporting
• Workflow data - Mirror Customer.io workflow states in Brevo contact attributes
• Segment replication - Replicate Customer.io segments as Brevo lists
• Object data sync - Sync non-people objects and relationship data

Prerequisites

Before you begin, ensure you have:

1. A Customer.io account with API access
2. Your Site ID and Track API Key (found in Settings > API Credentials)
3. An App API key for reading campaign and segment data
4. A Brevo account with API access
5. A Tajo account with an active subscription

Authentication

Customer.io uses two separate APIs with different authentication methods:

Track API (Behavioral Data)

Used for sending people, events, and device data. Authenticates with Site ID and API Key via Basic Auth.

# Basic Auth: Site ID as username, API Key as password
curl -X POST https://track.customer.io/api/v1/customers/user123 \
  -u "$SITE_ID:$API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "[email protected]"}'

App API (Read Data)

Used for retrieving campaigns, segments, and customer data. Authenticates with a Bearer token.

curl -X GET https://api.customer.io/v1/campaigns \
  -H "Authorization: Bearer $APP_API_KEY"

Connecting to Tajo

tajo connectors install customerio \
  --site-id $CIO_SITE_ID \
  --track-api-key $CIO_TRACK_API_KEY \
  --app-api-key $CIO_APP_API_KEY

Configuration

Basic Setup

connectors:
  customerio:
    enabled: true
    region: "us"  # or "eu" for EU data center

    sync:
      people: true
      events: true
      campaigns: true
      segments: true
      objects: false

    lists:
      all_contacts: 12
      active_subscribers: 13
      churned: 14

Field Mapping

Map Customer.io person attributes to Brevo contact attributes:

field_mapping:
  # Standard fields
  id: CIO_ID
  email: email
  first_name: FIRSTNAME
  last_name: LASTNAME
  phone: SMS

  # Engagement metrics
  created_at: SIGNUP_DATE
  last_activity: LAST_ACTIVE
  plan: PLAN_NAME

  # Custom attributes
  company: COMPANY
  role: JOB_TITLE
  mrr: MONTHLY_REVENUE
  lifecycle_stage: LIFECYCLE_STAGE

Event Mapping

event_mapping:
  # Customer.io event -> Brevo event
  purchase_completed: ORDER_PLACED
  subscription_started: SUBSCRIPTION_START
  feature_activated: FEATURE_USED
  support_ticket_opened: SUPPORT_REQUEST

API Endpoints

Tajo integrates with the following Customer.io API endpoints:

Code Examples

Initialize Connector

import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

await tajo.connectors.connect('customerio', {
  siteId: process.env.CIO_SITE_ID,
  trackApiKey: process.env.CIO_TRACK_API_KEY,
  appApiKey: process.env.CIO_APP_API_KEY,
  region: 'us'
});

Sync People to Brevo

// Incremental sync of Customer.io people
await tajo.connectors.sync('customerio', {
  type: 'incremental',
  resources: ['people'],
  since: '2024-01-01',
  batchSize: 100
});

const status = await tajo.connectors.status('customerio');
console.log(status);
// {
//   connected: true,
//   lastSync: '2024-03-15T14:20:00Z',
//   peopleCount: 32500,
//   campaignsTracked: 18,
//   eventsProcessed: 87000
// }

Forward Events

// Forward Customer.io reporting webhook events to Brevo
app.post('/webhooks/customerio', async (req, res) => {
  const events = req.body;

  for (const event of events) {
    await tajo.connectors.handleEvent('customerio', {
      type: event.metric,
      payload: {
        customerId: event.data.customer_id,
        campaignId: event.data.campaign_id,
        timestamp: event.timestamp
      }
    });
  }

  res.status(200).send('OK');
});

Export Segment

const result = await tajo.connectors.exportSegment('customerio', {
  segmentId: 42,
  targetList: 13,
  includeAttributes: ['email', 'first_name', 'last_name', 'plan']
});

console.log(`Exported ${result.count} people to Brevo list 13`);

Rate Limits

Customer.io enforces different rate limits per API:

Troubleshooting

Common Issues

Debug Mode

connectors:
  customerio:
    debug: true
    log_level: verbose
    log_api_calls: true

Test Connection

tajo connectors test customerio
# ✓ Track API connection successful
# ✓ App API connection successful
# ✓ People accessible
# ✓ Campaigns readable
# ✓ Segments listable

Best Practices

1. Use the Pipelines API for bulk data - The newer Pipelines API is optimized for high-volume ingestion
2. Set up reporting webhooks - Forward Customer.io email events to Tajo in real time
3. Map lifecycle stages - Sync Customer.io segment membership to Brevo attributes
4. Use consistent identifiers - Match id fields across Customer.io and Brevo
5. Sync incrementally - Avoid full exports; leverage last_activity timestamps
6. Monitor webhook delivery - Set up alerts for failed webhook deliveries

Security

• Basic Auth - Track API authenticates with Site ID and API Key
• Bearer Token - App API uses OAuth-style bearer tokens
• HTTPS Only - All API communication encrypted via TLS 1.2+
• Regional Data Centers - EU data center option for GDPR compliance
• Encrypted Storage - All credentials encrypted at rest in Tajo
• Webhook Signatures - Verify webhook payloads with HMAC signatures

Related Resources

• Braze Connector
• Iterable Connector
• Customer Sync Skill
• Brevo Contacts API

Open-Source Implementation Map

No official open-source repository was found in the current Tajo connector catalog for Customer.io. Keep this page focused on the verified public API contract and vendor documentation until an official schema, SDK, MCP server, or public integration repository is available.

Tajo Revamp Checklist

• Verify authentication and scope requirements against the vendor documentation before each connector release.
• Document primary sync objects, external IDs, pagination strategy, and rate limits explicitly.
• Add smoke tests from public API examples rather than undocumented behavior.
• Capture webhook signature verification and replay protection when the vendor supports webhooks.
• Record gaps where no official public repository or schema exists so future maintainers know what still needs source-backed validation.