GoHighLevel to Airtable Two-Way Sync

const AIRTABLE_TOKEN = process.env.AIRTABLE_TOKEN;
const AIRTABLE_BASE_ID = process.env.AIRTABLE_BASE_ID;
const AIRTABLE_TABLE = 'Contacts'; // your table name
const GHL_TOKEN = process.env.GHL_TOKEN;
const AIRTABLE_RECORD_FIELD = 'Airtable Record ID'; // GHL custom field name

async function airtableRequest(method, path, body) {
  const res = await fetch(`https://api.airtable.com/v0/${AIRTABLE_BASE_ID}/${encodeURIComponent(AIRTABLE_TABLE)}${path}`, {
    method,
    headers: {
      Authorization: `Bearer ${AIRTABLE_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: body ? JSON.stringify(body) : undefined,
  });
  if (!res.ok) throw new Error(`Airtable error: ${res.status} ${await res.text()}`);
  return res.json();
}

export async function POST(req) {
  const payload = await req.json();
  // Skip if this event originated from Airtable (loop prevention)
  if (payload.source === 'airtable-sync') {
    return new Response('skip', { status: 200 });
  }

  const { contactId, email, firstName, lastName, phone, tags } = payload;
  const fields = {
    'GHL Contact ID': contactId,
    Email: email ?? '',
    'First Name': firstName ?? '',
    'Last Name': lastName ?? '',
    Phone: phone ?? '',
    Tags: (tags ?? []).join(', '),
    'Last GHL Sync': new Date().toISOString(),
  };

  // Look up existing Airtable record by GHL contact ID
  const search = await airtableRequest(
    'GET',
    `?filterByFormula=${encodeURIComponent(`{GHL Contact ID}="${contactId}"`)}`
  );

  let airtableRecordId;
  if (search.records.length > 0) {
    // Update existing
    airtableRecordId = search.records[0].id;
    await airtableRequest('PATCH', `/${airtableRecordId}`, { fields });
  } else {
    // Create new
    const created = await airtableRequest('POST', '', { fields });
    airtableRecordId = created.id;

    // Store the Airtable record ID back in GHL
    await fetch(`https://services.leadconnectorhq.com/contacts/${contactId}`, {
      method: 'PUT',
      headers: {
        Authorization: `Bearer ${GHL_TOKEN}`,
        'Content-Type': 'application/json',
        Version: '2021-07-28',
      },
      body: JSON.stringify({
        customFields: [
          { id: process.env.GHL_AIRTABLE_FIELD_ID, value: airtableRecordId },
        ],
      }),
    });
  }

  return new Response('ok', { status: 200 });
}

// This runs inside Airtable's scripting environment
// Triggered when a record is updated
const record = input.config().record; // passed from the automation trigger

const ghlContactId = record['GHL Contact ID'];
if (!ghlContactId) {
  console.log('No GHL Contact ID, skipping');
  return;
}

await fetch('https://yourbackend.com/airtable-to-ghl', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    ghlContactId,
    firstName: record['First Name'],
    lastName: record['Last Name'],
    email: record['Email'],
    phone: record['Phone'],
    tags: record['Tags'] ? record['Tags'].split(', ') : [],
    source: 'airtable',
  }),
});

export async function POST(req) {
  const body = await req.json();
  const { ghlContactId, firstName, lastName, email, phone, tags, source } = body;

  if (source !== 'airtable') {
    return new Response('unexpected source', { status: 400 });
  }

  const res = await fetch(
    `https://services.leadconnectorhq.com/contacts/${ghlContactId}`,
    {
      method: 'PUT',
      headers: {
        Authorization: `Bearer ${process.env.GHL_TOKEN}`,
        'Content-Type': 'application/json',
        Version: '2021-07-28',
      },
      body: JSON.stringify({
        firstName,
        lastName,
        email,
        phone,
        tags,
        // Tag this update so the GHL outbound webhook ignores it
        source: 'airtable-sync',
      }),
    }
  );

  if (!res.ok) {
    console.error('GHL update failed:', await res.text());
    return new Response('error', { status: 500 });
  }
  return new Response('ok', { status: 200 });
}

import crypto from 'crypto';

function hashFields(fields) {
  return crypto
    .createHash('sha256')
    .update(JSON.stringify(fields, Object.keys(fields).sort()))
    .digest('hex');
}

async function syncGhlToAirtable(contact, lastSyncHash) {
  const fields = {
    email: contact.email,
    firstName: contact.firstName,
    lastName: contact.lastName,
    phone: contact.phone,
    tags: (contact.tags ?? []).sort().join(','),
  };
  const currentHash = hashFields(fields);

  if (currentHash === lastSyncHash) {
    console.log('No change, skipping', contact.id);
    return { skipped: true };
  }

  // Write to Airtable and store the new hash
  await writeToAirtable(contact);
  await storeHash(contact.id, currentHash); // your own storage
  return { synced: true, hash: currentHash };
}

{
  "name": "sync_contact_to_airtable",
  "description": "Sync a GoHighLevel contact to Airtable, creating or updating the record.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "contactId": { "type": "string" },
      "email": { "type": "string" },
      "firstName": { "type": "string" },
      "lastName": { "type": "string" },
      "phone": { "type": "string" },
      "tags": { "type": "array", "items": { "type": "string" } }
    },
    "required": ["contactId"]
  }
}