Airtable Connector

Connect your Airtable bases to Brevo for CRM synchronization, product catalog management, and automated marketing workflows powered by structured data through Tajo.

Overview

Features

• Table-to-list sync - Sync Airtable table records directly to Brevo contact lists
• Product catalog bridge - Use Airtable tables as product catalogs for email recommendations
• CRM synchronization - Bidirectional sync between Airtable CRM and Brevo contacts
• Form submission events - Forward Airtable form submissions as Brevo events
• View-based filtering - Sync specific Airtable views to targeted Brevo lists
• Webhook automation - Trigger Brevo campaigns when Airtable records change

Prerequisites

Before you begin, ensure you have:

1. An Airtable account (Free plan or above)
2. A Personal Access Token or OAuth app configured
3. Access to the bases and tables you want to sync
4. A Brevo account with API access
5. A Tajo account with an active subscription

Authentication

Airtable supports Personal Access Tokens and OAuth 2.0.

Option 1: Personal Access Token (Recommended)

1. Go to airtable.com/create/tokens
2. Click Create new token
3. Name it “Tajo Integration”
4. Add scopes:

data.records:read
data.records:write
data.recordComments:read
schema.bases:read
webhook:manage

5. Add access to specific bases or all bases
6. Click Create token

Option 2: OAuth 2.0

For multi-user integrations, use the OAuth 2.0 flow:

1. Register your integration at airtable.com/create/oauth
2. Configure redirect URI: https://app.tajo.io/callbacks/airtable
3. Request the same scopes as above

Connecting to Tajo

tajo connectors install airtable \
  --token $AIRTABLE_TOKEN

Configuration

Basic Setup

connectors:
  airtable:
    enabled: true

    sync:
      records: true
      comments: false

    tables:
      - base_id: "appXXXXXXXXXXXXXX"
        table_name: "Customers"
        view: "Active Customers"
        sync_to_list: 28
      - base_id: "appXXXXXXXXXXXXXX"
        table_name: "Products"
        sync_as: "catalog"

Field Mapping

Map Airtable fields to Brevo contact attributes:

field_mapping:
  # Airtable field -> Brevo attribute
  Name: FIRSTNAME
  Email: email
  Phone: SMS
  Company: COMPANY
  Status: LEAD_STATUS
  Revenue: TOTAL_REVENUE
  "Last Contact": LAST_CONTACT_DATE
  Tags: TAGS
  Notes: NOTES
  "Created Time": SIGNUP_DATE

View-Based Sync

views:
  - base_id: "appXXXXXXXXXXXXXX"
    table_name: "Customers"
    view: "High Value"
    sync_to_list: 29
    filter_by_view: true

  - base_id: "appXXXXXXXXXXXXXX"
    table_name: "Customers"
    view: "Churned"
    sync_to_list: 30
    filter_by_view: true

API Endpoints

Tajo integrates with the following Airtable Web 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('airtable', {
  token: process.env.AIRTABLE_TOKEN
});

Sync Table to Brevo

// Sync an Airtable table to a Brevo list
await tajo.connectors.sync('airtable', {
  type: 'full',
  resources: ['records'],
  baseId: 'appXXXXXXXXXXXXXX',
  tableName: 'Customers',
  view: 'Active Customers',
  targetList: 28
});

const status = await tajo.connectors.status('airtable');
console.log(status);
// {
//   connected: true,
//   lastSync: '2024-03-15T15:00:00Z',
//   recordsSynced: 2340,
//   tablesMonitored: 2,
//   basesConnected: 1
// }

Handle Webhooks

// Airtable webhooks notify of changes; fetch details with cursor
app.post('/webhooks/airtable', async (req, res) => {
  const { base, webhook, timestamp } = req.body;

  // Fetch changed records using webhook cursor
  const changes = await tajo.connectors.getWebhookPayloads('airtable', {
    baseId: base.id,
    webhookId: webhook.id,
    cursor: timestamp
  });

  for (const change of changes) {
    await tajo.connectors.handleEvent('airtable', {
      type: change.actionType,
      payload: change
    });
  }

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

Create Record from Brevo

// Create an Airtable record when a Brevo contact converts
tajo.events.on('contact.attribute_updated', async (event) => {
  if (event.attribute === 'LIFECYCLE_STAGE' && event.value === 'customer') {
    await tajo.connectors.create('airtable', {
      baseId: 'appXXXXXXXXXXXXXX',
      tableName: 'Customers',
      fields: {
        Name: event.contact.name,
        Email: event.contact.email,
        Status: 'Customer',
        'Converted Date': new Date().toISOString().split('T')[0]
      }
    });
  }
});

Rate Limits

Airtable enforces rate limits per base:

Troubleshooting

Common Issues

Debug Mode

connectors:
  airtable:
    debug: true
    log_level: verbose
    log_api_calls: true

Test Connection

tajo connectors test airtable
# ✓ API authentication successful
# ✓ Base access verified
# ✓ Table schema readable
# ✓ Record listing operational
# ✓ Webhook registration available

Best Practices

1. Scope tokens to specific bases - Do not grant access to all bases unless necessary
2. Use views for filtered sync - Sync specific views instead of full tables to reduce data volume
3. Batch record operations - Group creates and updates in batches of 10
4. Handle pagination - Airtable returns 100 records per page; iterate with offset
5. Use webhooks for real-time - Register webhooks instead of polling for changes
6. Map field types precisely - Match Airtable field types (select, number, date) to Brevo attribute types

Security

• Personal Access Tokens - Scoped to specific bases and operations
• OAuth 2.0 - Secure authorization flow with refresh tokens
• HTTPS Only - All API communication encrypted via TLS 1.2+
• Base-Level Access Control - Tokens scoped to individual bases
• Encrypted Storage - Tokens encrypted at rest in Tajo
• Webhook HMAC Verification - Verify webhook notification authenticity

Related Resources

• Notion Connector
• GitHub 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 Airtable. 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.