Amplitude Connector

Connect Amplitude to Brevo through Tajo to leverage product analytics data for marketing automation. Sync behavioral cohorts, user properties, and product events to power targeted campaigns.

Overview

Property	Value
Platform	Amplitude
Category	Analytics (Custom)
Setup Complexity	Medium
Official Integration	No
Data Synced	Events, Users, Cohorts, Properties
Available Skills	6

Features

Event forwarding - Send Amplitude track events to Brevo for marketing automation triggers
Cohort sync - Export Amplitude behavioral cohorts as Brevo contact lists
User property sync - Map Amplitude user properties to Brevo contact attributes
Revenue tracking - Sync revenue events for customer lifetime value analysis
Behavioral segmentation - Use Amplitude engagement data in Brevo segments
HTTP V2 API integration - Direct integration with Amplitude’s HTTP V2 ingestion API

Prerequisites

Before you begin, ensure you have:

An Amplitude account with a project created
Your Amplitude API Key and Secret Key
A Brevo account with API access
A Tajo account with API credentials

Authentication

Amplitude API Keys

Amplitude uses API Key and Secret Key pairs for authentication. The API Key identifies your project, while the Secret Key authenticates server-side requests.

# Find your keys in Amplitude:
# Settings > Projects > [Your Project] > General

HTTP V2 API Authentication

The HTTP V2 API uses the API key in the request body:

curl -X POST https://api2.amplitude.com/2/httpapi \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_AMPLITUDE_API_KEY",
    "events": [...]
  }'

Configuration

Basic Setup

connectors:
  amplitude:
    enabled: true
    api_key: "your-amplitude-api-key"
    secret_key: "your-amplitude-secret-key"
    data_center: "US"  # or "EU"

    # Data sync options
    sync:
      events: true
      user_properties: true
      cohorts: true
      revenue: true

    # Brevo list assignment
    lists:
      active_users: 10
      power_users: 11
      churning_users: 12

Event Mapping

Map Amplitude events to Brevo automation triggers:

event_mapping:
  # Amplitude event -> Brevo event
  "Purchase": "order_completed"
  "Sign Up": "customer_created"
  "Add to Cart": "cart_updated"
  "Page View": "page_viewed"
  "Feature Click": "feature_used"

  # Revenue events
  "Revenue": "revenue_event"
  "Subscription Started": "subscription_created"

User Property Mapping

Map Amplitude user properties to Brevo contact attributes:

property_mapping:
  # Amplitude property -> Brevo attribute
  email: email
  first_name: FIRSTNAME
  last_name: LASTNAME
  phone: SMS
  plan_type: PLAN
  signup_date: SIGNUP_DATE
  total_purchases: ORDER_COUNT
  lifetime_revenue: LTV
  last_active: LAST_ACTIVE
  device_type: DEVICE

API Endpoints

Method	Endpoint	Description
`POST`	`/2/httpapi`	Upload events (HTTP V2 API)
`POST`	`/batch`	Bulk upload events (Batch API)
`POST`	`/identify`	Set user properties
`POST`	`/groupidentify`	Set group properties
`GET`	`/2/export`	Export raw event data
`GET`	`/2/usersearch`	Search for users
`GET`	`/2/useractivity`	Get user activity timeline
`POST`	`/api/3/cohort/export`	Export cohort members
`GET`	`/api/3/chart/{chart_id}/query`	Query saved chart data

Code Examples

Initialize Amplitude Connector

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

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

// Connect Amplitude project
await tajo.connectors.connect('amplitude', {
  apiKey: process.env.AMPLITUDE_API_KEY,
  secretKey: process.env.AMPLITUDE_SECRET_KEY,
  dataCenter: 'US'
});

Send Events via HTTP V2 API

// Send events to Amplitude (automatically forwarded to Brevo)
const response = await fetch('https://api2.amplitude.com/2/httpapi', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    api_key: process.env.AMPLITUDE_API_KEY,
    events: [
      {
        user_id: "user_123",
        event_type: "Purchase",
        event_properties: {
          revenue: 89.99,
          product_id: "SKU-001",
          product_name: "Widget Pro"
        },
        user_properties: {
          $set: {
            email: "[email protected]",
            plan_type: "premium"
          }
        },
        time: Date.now()
      }
    ]
  })
});

// Expected response: { "code": 200, "events_ingested": 1 }

Sync Cohort to Brevo List

// Export an Amplitude cohort and sync to Brevo
const cohort = await tajo.connectors.syncCohort('amplitude', {
  cohortId: 'abc123',
  targetList: 11,  // Brevo list ID
  syncMode: 'mirror'  // mirror, append, or remove
});

console.log(cohort);
// {
//   cohortName: "Power Users",
//   membersCount: 2450,
//   syncedToBrevo: 2450,
//   listId: 11
// }

Rate Limits

API	Limit	Details
HTTP V2 API	1,000 events/sec	Per project, burst up to 2,000/sec
Batch API	1,000 events/batch	Max 20 batches/sec
Identify API	1,000 req/sec	Per project
Export API	360 requests/hour	Per project
Cohort Export	1 concurrent export	Per cohort
Dashboard REST API	360 requests/hour	Per project

Event Size Limits

Each event payload cannot exceed 1 MB. The HTTP V2 API accepts up to 2,000 events per request with a max body size of 20 MB.

Troubleshooting

Issue	Cause	Solution
Events return `invalid` status	Missing required fields	Ensure `user_id` or `device_id` is set on every event
User properties not syncing	Wrong property operator	Use `$set` for setting, `$setOnce` for first-touch values
Cohort export empty	Cohort still computing	Wait for cohort computation to complete before export
429 Too Many Requests	Rate limit exceeded	Implement exponential backoff and use batch API
Revenue not tracking	Missing revenue fields	Include `price`, `quantity`, and `revenue` in event properties
EU data not routing	Wrong data center	Set `data_center: "EU"` and use `api.eu.amplitude.com`

Best Practices

Use the HTTP V2 API - Prefer the V2 API over the legacy HTTP API for better validation and error responses
Batch events - Send events in batches of up to 1,000 for optimal throughput
Set user properties on events - Include user_properties on track events to reduce identify calls
Use cohorts for segmentation - Sync behavioral cohorts rather than replicating complex segmentation logic
Track revenue events properly - Use revenue, price, and productId fields for accurate revenue tracking
Monitor ingestion health - Check Amplitude’s Ingestion Debugger for event validation errors
Implement server-side tracking - Use server-side SDKs for reliable event delivery

Security

HTTPS only - All API communication requires TLS 1.2+
API key rotation - Rotate Secret Keys periodically via Amplitude settings
IP allowlisting - Available on Enterprise plans
SOC 2 Type II - Amplitude is SOC 2 Type II certified
GDPR/CCPA - Support for user data deletion and export requests
EU data residency - EU data center option available

Open-Source Implementation Map

No official open-source repository was found in the current Tajo connector catalog for Amplitude. 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.