Zapier Integration for ChatGPT Apps: Automation Platform Guide

Integrating your ChatGPT app with Zapier unlocks access to 5,000+ applications and enables millions of users to automate workflows involving your AI-powered features. Whether you're building appointment scheduling, lead management, customer support, or content generation tools, Zapier integration transforms your ChatGPT app into a powerful automation hub that connects seamlessly with Gmail, Slack, HubSpot, Salesforce, and thousands of other platforms.

This comprehensive guide walks you through building production-ready Zapier integrations for ChatGPT applications. You'll learn how to implement polling and webhook triggers, create robust actions, handle OAuth2 authentication, manage error cases, and deploy your integration to Zapier's marketplace. We'll cover enterprise-grade patterns including deduplication, rate limiting, pagination, and real-time webhook delivery—all essential for apps serving thousands of concurrent users.

Unlike basic integration tutorials, this guide focuses on ChatGPT-specific patterns: handling conversational context in Zap workflows, structuring app outputs for optimal automation, managing user authentication across ChatGPT and external platforms, and designing triggers that intelligently detect when AI interactions require automated follow-up actions. By the end, you'll have a complete Zapier integration that makes your ChatGPT app indispensable for business automation workflows.

The Zapier Platform CLI enables JavaScript/Node.js developers to build integrations that feel native to Zapier's ecosystem while maintaining full control over authentication, data transformation, and API communication. Let's build an enterprise-grade integration that scales from MVP to millions of monthly API calls.

Zapier Platform CLI Setup

The Zapier Platform CLI provides the foundation for building, testing, and deploying integrations programmatically. Unlike the web-based Visual Builder (limited to simple REST APIs), the CLI offers complete control over authentication flows, complex data transformations, error handling, and webhook management—critical for ChatGPT apps with sophisticated AI interactions.

Start by installing the Zapier Platform CLI and initializing your integration project. This creates the scaffolding for triggers, actions, authentication, and testing infrastructure:

# Install Zapier Platform CLI globally
npm install -g zapier-platform-cli

# Authenticate with your Zapier developer account
zapier login

# Create a new integration project
zapier init chatgpt-automation --template minimal

# Navigate to project directory
cd chatgpt-automation

# Install dependencies
npm install

# Validate project structure
zapier validate

The CLI generates a standard project structure with index.js (app definition), triggers/, creates/, searches/, authentication.js, and test/ directories. This modular architecture separates concerns and enables team collaboration on complex integrations.

Configure your app's basic metadata and authentication requirements in index.js. This example demonstrates OAuth2 authentication (recommended for production apps) with session refresh capabilities:

// index.js - Zapier App Definition
const authentication = require('./authentication');
const newAppointmentTrigger = require('./triggers/new_appointment');
const createContactAction = require('./creates/create_contact');
const updateLeadAction = require('./creates/update_lead');

module.exports = {
  version: require('./package.json').version,
  platformVersion: require('zapier-platform-core').version,

  // Authentication configuration
  authentication: authentication,

  // Triggers: Events that start a Zap
  triggers: {
    [newAppointmentTrigger.key]: newAppointmentTrigger,
  },

  // Creates (Actions): Operations that modify data
  creates: {
    [createContactAction.key]: createContactAction,
    [updateLeadAction.key]: updateLeadAction,
  },

  // Before/after hooks for global request/response handling
  beforeRequest: [
    (request, z, bundle) => {
      // Add authentication headers to all requests
      if (bundle.authData.access_token) {
        request.headers.Authorization = `Bearer ${bundle.authData.access_token}`;
      }

      // Add rate limiting headers
      request.headers['X-Zapier-Request-ID'] = bundle.meta.zap?.id || 'test';

      // Log outgoing requests (development only)
      if (process.env.NODE_ENV !== 'production') {
        z.console.log('Request:', request.method, request.url);
      }

      return request;
    }
  ],

  afterResponse: [
    (response, z, bundle) => {
      // Global error handling
      if (response.status === 401) {
        throw new z.errors.RefreshAuthError('Authentication expired');
      }

      if (response.status === 429) {
        throw new z.errors.ThrottledError(
          'API rate limit exceeded. Please try again in a few minutes.'
        );
      }

      if (response.status >= 500) {
        throw new z.errors.Error(
          `Service temporarily unavailable (${response.status}). Please try again.`
        );
      }

      // Log response for debugging
      if (process.env.NODE_ENV !== 'production') {
        z.console.log('Response:', response.status);
      }

      return response;
    }
  ],

  // Hydration for lazy-loading large payloads
  hydrators: {},

  // Resources (DRY approach for triggers/searches/creates)
  resources: {},
};

Authentication is the foundation of secure Zapier integrations. For ChatGPT apps handling sensitive business data, OAuth2 provides the best user experience and security posture. Create authentication.js with OAuth2 configuration:

// authentication.js - OAuth2 Authentication Configuration
const getAccessToken = async (z, bundle) => {
  const response = await z.request({
    url: 'https://api.yourdomain.com/oauth/token',
    method: 'POST',
    body: {
      grant_type: 'authorization_code',
      code: bundle.inputData.code,
      client_id: process.env.CLIENT_ID,
      client_secret: process.env.CLIENT_SECRET,
      redirect_uri: bundle.inputData.redirect_uri,
    },
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
  });

  // Return token data for storage
  return {
    access_token: response.data.access_token,
    refresh_token: response.data.refresh_token,
    expires_in: response.data.expires_in,
  };
};

const refreshAccessToken = async (z, bundle) => {
  const response = await z.request({
    url: 'https://api.yourdomain.com/oauth/token',
    method: 'POST',
    body: {
      grant_type: 'refresh_token',
      refresh_token: bundle.authData.refresh_token,
      client_id: process.env.CLIENT_ID,
      client_secret: process.env.CLIENT_SECRET,
    },
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
  });

  return {
    access_token: response.data.access_token,
    refresh_token: response.data.refresh_token,
    expires_in: response.data.expires_in,
  };
};

const testAuth = async (z, bundle) => {
  // Verify authentication by fetching user profile
  const response = await z.request({
    url: 'https://api.yourdomain.com/v1/me',
    method: 'GET',
  });

  if (response.status !== 200) {
    throw new Error('Invalid authentication credentials');
  }

  return response.data; // Returns user object
};

module.exports = {
  type: 'oauth2',

  oauth2Config: {
    authorizeUrl: {
      url: 'https://api.yourdomain.com/oauth/authorize',
      params: {
        client_id: '{{process.env.CLIENT_ID}}',
        redirect_uri: '{{bundle.inputData.redirect_uri}}',
        response_type: 'code',
        scope: 'read write appointments contacts',
      },
    },

    getAccessToken: getAccessToken,

    refreshAccessToken: refreshAccessToken,

    autoRefresh: true, // Automatically refresh when access_token expires
  },

  test: testAuth,

  connectionLabel: '{{email}}', // Display user's email in Zapier UI
};

Test your authentication configuration locally before deploying. The Zapier CLI provides a test harness that simulates the OAuth flow:

# Set environment variables for OAuth credentials
export CLIENT_ID=your_client_id
export CLIENT_SECRET=your_client_secret

# Run authentication tests
zapier test --grep authentication

# Start OAuth flow in browser (for manual testing)
zapier login --oauth

The Zapier Platform CLI enforces strict validation rules for app configuration, input/output schemas, and API responses. Run zapier validate frequently during development to catch configuration errors before deployment. Learn more about authentication patterns and best practices for ChatGPT app builders.

Triggers Implementation

Triggers are events that start Zaps when something happens in your ChatGPT app. For example: "New Appointment Scheduled," "Lead Captured from Chat," "Support Ticket Created," or "AI Analysis Completed." Zapier supports two trigger types: polling triggers (check for new data every 1-15 minutes) and webhook triggers (instant push notifications when events occur).

Polling triggers query your API endpoint periodically to detect new records. They're simpler to implement but have latency (1-15 minute intervals depending on Zapier plan). Here's a production-ready polling trigger for new appointments:

// triggers/new_appointment.js - Polling Trigger Implementation
const perform = async (z, bundle) => {
  // Fetch recent appointments from your API
  const response = await z.request({
    url: 'https://api.yourdomain.com/v1/appointments',
    method: 'GET',
    params: {
      // Only fetch records created after last poll
      created_after: bundle.meta.page === 0
        ? new Date(Date.now() - 15 * 60 * 1000).toISOString() // Last 15 minutes
        : bundle.meta.page, // Pagination cursor for historical loads

      limit: 100, // Fetch up to 100 records per poll

      sort: 'created_at:desc', // Newest first

      // Filter by user's ChatGPT app ID
      app_id: bundle.authData.app_id,
    },
  });

  // Transform API response to Zapier-friendly format
  return response.data.appointments.map(appointment => ({
    // CRITICAL: id must be unique and unchanging (used for deduplication)
    id: appointment.id,

    // All other fields available in Zap
    client_name: appointment.client_name,
    client_email: appointment.client_email,
    client_phone: appointment.client_phone,

    appointment_date: appointment.scheduled_at,
    appointment_time: new Date(appointment.scheduled_at).toLocaleTimeString('en-US'),

    service_type: appointment.service_type,
    duration_minutes: appointment.duration,

    status: appointment.status,

    notes: appointment.notes,

    chatgpt_conversation_url: appointment.chat_url,

    // ISO 8601 timestamp for Zapier's date/time filters
    created_at: appointment.created_at,

    // Include raw object for advanced users
    raw: appointment,
  }));
};

const performList = async (z, bundle) => {
  // Called when user sets up trigger to load sample data
  const response = await z.request({
    url: 'https://api.yourdomain.com/v1/appointments',
    method: 'GET',
    params: {
      limit: 10,
      sort: 'created_at:desc',
      app_id: bundle.authData.app_id,
    },
  });

  return response.data.appointments.map(appointment => ({
    id: appointment.id,
    client_name: appointment.client_name,
    client_email: appointment.client_email,
    appointment_date: appointment.scheduled_at,
    service_type: appointment.service_type,
    status: appointment.status,
    created_at: appointment.created_at,
  }));
};

module.exports = {
  key: 'new_appointment',
  noun: 'Appointment',
  display: {
    label: 'New Appointment',
    description: 'Triggers when a new appointment is scheduled via ChatGPT.',
    important: true, // Featured in Zapier app directory
  },

  operation: {
    perform: perform,

    // Sample data for Zapier editor (before user connects account)
    sample: {
      id: 'appt_1234567890',
      client_name: 'John Smith',
      client_email: 'john@example.com',
      client_phone: '+1-555-123-4567',
      appointment_date: '2026-12-28T14:00:00Z',
      appointment_time: '2:00:00 PM',
      service_type: 'Personal Training Session',
      duration_minutes: 60,
      status: 'confirmed',
      notes: 'Client requested morning appointment',
      chatgpt_conversation_url: 'https://chatgpt.com/share/abc123',
      created_at: '2026-12-25T10:30:00Z',
    },

    // Output field definitions (helps Zapier autocomplete in editor)
    outputFields: [
      { key: 'id', label: 'Appointment ID', type: 'string' },
      { key: 'client_name', label: 'Client Name', type: 'string' },
      { key: 'client_email', label: 'Client Email', type: 'string' },
      { key: 'client_phone', label: 'Client Phone', type: 'string' },
      { key: 'appointment_date', label: 'Appointment Date/Time', type: 'datetime' },
      { key: 'appointment_time', label: 'Time (Formatted)', type: 'string' },
      { key: 'service_type', label: 'Service Type', type: 'string' },
      { key: 'duration_minutes', label: 'Duration (Minutes)', type: 'integer' },
      { key: 'status', label: 'Status', type: 'string' },
      { key: 'notes', label: 'Notes', type: 'text' },
      { key: 'chatgpt_conversation_url', label: 'ChatGPT Conversation URL', type: 'string' },
      { key: 'created_at', label: 'Created At', type: 'datetime' },
    ],

    // Polling configuration
    canPaginate: true,

    performList: performList,
  },
};

Webhook triggers provide instant notifications when events occur, eliminating polling delays. They require your API to send HTTP POST requests to Zapier's webhook URL when events happen:

// triggers/new_appointment_webhook.js - Webhook Trigger Implementation
const subscribeHook = async (z, bundle) => {
  // Subscribe to webhook events
  const response = await z.request({
    url: 'https://api.yourdomain.com/v1/webhooks',
    method: 'POST',
    body: {
      target_url: bundle.targetUrl, // Zapier's unique webhook URL
      event: 'appointment.created',
      app_id: bundle.authData.app_id,
    },
  });

  // Return webhook subscription ID (used for unsubscribe)
  return { id: response.data.webhook_id };
};

const unsubscribeHook = async (z, bundle) => {
  // Unsubscribe from webhook when Zap is deleted
  await z.request({
    url: `https://api.yourdomain.com/v1/webhooks/${bundle.subscribeData.id}`,
    method: 'DELETE',
  });

  return {}; // Must return object
};

const parsePayload = (z, bundle) => {
  // Zapier sends webhook payload in bundle.cleanedRequest
  const appointment = bundle.cleanedRequest;

  // Transform webhook payload to consistent format
  return {
    id: appointment.id,
    client_name: appointment.client_name,
    client_email: appointment.client_email,
    client_phone: appointment.client_phone,
    appointment_date: appointment.scheduled_at,
    service_type: appointment.service_type,
    status: appointment.status,
    notes: appointment.notes,
    chatgpt_conversation_url: appointment.chat_url,
    created_at: appointment.created_at,
  };
};

const performList = async (z, bundle) => {
  // Load recent appointments for testing/setup
  const response = await z.request({
    url: 'https://api.yourdomain.com/v1/appointments',
    method: 'GET',
    params: {
      limit: 10,
      sort: 'created_at:desc',
    },
  });

  return response.data.appointments.map(appointment => ({
    id: appointment.id,
    client_name: appointment.client_name,
    client_email: appointment.client_email,
    appointment_date: appointment.scheduled_at,
    service_type: appointment.service_type,
    created_at: appointment.created_at,
  }));
};

module.exports = {
  key: 'new_appointment_instant',
  noun: 'Appointment',
  display: {
    label: 'New Appointment (Instant)',
    description: 'Triggers instantly when a new appointment is scheduled via ChatGPT.',
    important: true,
  },

  operation: {
    type: 'hook',

    performSubscribe: subscribeHook,
    performUnsubscribe: unsubscribeHook,

    perform: parsePayload,
    performList: performList,

    sample: {
      id: 'appt_1234567890',
      client_name: 'John Smith',
      client_email: 'john@example.com',
      appointment_date: '2026-12-28T14:00:00Z',
      service_type: 'Personal Training Session',
      status: 'confirmed',
      created_at: '2026-12-25T10:30:00Z',
    },

    outputFields: [
      { key: 'id', label: 'Appointment ID' },
      { key: 'client_name', label: 'Client Name' },
      { key: 'client_email', label: 'Client Email' },
      { key: 'appointment_date', label: 'Appointment Date/Time', type: 'datetime' },
      { key: 'service_type', label: 'Service Type' },
      { key: 'status', label: 'Status' },
      { key: 'created_at', label: 'Created At', type: 'datetime' },
    ],
  },
};

Deduplication is critical for polling triggers—Zapier automatically deduplicates based on the id field. Ensure your id values are unique, unchanging, and sortable by creation time (UUIDs, database IDs, or timestamp-based IDs work well). Explore webhook trigger patterns and real-time automation strategies for ChatGPT apps.

Actions Implementation

Actions (called "Creates" in Zapier terminology) allow Zaps to modify data in your ChatGPT app. Common actions include "Create Contact," "Update Lead Status," "Schedule Appointment," "Send Message," or "Generate AI Content." Actions receive input data from previous Zap steps and return output data for subsequent steps.

Here's a production-ready action for creating contacts in your ChatGPT app:

// creates/create_contact.js - Create Action Implementation
const perform = async (z, bundle) => {
  // bundle.inputData contains values from Zapier form
  const response = await z.request({
    url: 'https://api.yourdomain.com/v1/contacts',
    method: 'POST',
    body: {
      name: bundle.inputData.name,
      email: bundle.inputData.email,
      phone: bundle.inputData.phone,
      company: bundle.inputData.company,

      // Optional fields
      job_title: bundle.inputData.job_title,
      tags: bundle.inputData.tags ? bundle.inputData.tags.split(',').map(t => t.trim()) : [],

      // Custom fields (dynamic from ChatGPT app schema)
      custom_fields: bundle.inputData.custom_fields || {},

      // Metadata
      source: 'zapier',
      zapier_zap_id: bundle.meta.zap?.id,

      app_id: bundle.authData.app_id,
    },
  });

  // Return created contact (available to subsequent Zap steps)
  return {
    id: response.data.id,
    name: response.data.name,
    email: response.data.email,
    phone: response.data.phone,
    company: response.data.company,
    job_title: response.data.job_title,
    tags: response.data.tags,
    created_at: response.data.created_at,
    profile_url: `https://yourdomain.com/contacts/${response.data.id}`,
  };
};

module.exports = {
  key: 'create_contact',
  noun: 'Contact',
  display: {
    label: 'Create Contact',
    description: 'Creates a new contact in your ChatGPT app.',
    important: true,
  },

  operation: {
    perform: perform,

    // Input fields (form displayed in Zapier editor)
    inputFields: [
      {
        key: 'name',
        label: 'Full Name',
        type: 'string',
        required: true,
        helpText: 'Contact\'s full name (first and last)',
      },
      {
        key: 'email',
        label: 'Email Address',
        type: 'string',
        required: true,
        helpText: 'Contact\'s email address',
      },
      {
        key: 'phone',
        label: 'Phone Number',
        type: 'string',
        required: false,
        helpText: 'Contact\'s phone number (any format)',
      },
      {
        key: 'company',
        label: 'Company',
        type: 'string',
        required: false,
      },
      {
        key: 'job_title',
        label: 'Job Title',
        type: 'string',
        required: false,
      },
      {
        key: 'tags',
        label: 'Tags',
        type: 'string',
        required: false,
        helpText: 'Comma-separated tags (e.g., "lead, high-priority, fitness")',
      },
      {
        key: 'custom_fields',
        label: 'Custom Fields',
        type: 'text',
        required: false,
        helpText: 'JSON object with custom field data',
      },
    ],

    // Sample output (shown before user tests action)
    sample: {
      id: 'contact_1234567890',
      name: 'Jane Doe',
      email: 'jane@example.com',
      phone: '+1-555-987-6543',
      company: 'Acme Corp',
      job_title: 'Marketing Director',
      tags: ['lead', 'enterprise'],
      created_at: '2026-12-25T11:00:00Z',
      profile_url: 'https://yourdomain.com/contacts/contact_1234567890',
    },

    // Output fields (available to subsequent Zap steps)
    outputFields: [
      { key: 'id', label: 'Contact ID' },
      { key: 'name', label: 'Name' },
      { key: 'email', label: 'Email' },
      { key: 'phone', label: 'Phone' },
      { key: 'company', label: 'Company' },
      { key: 'job_title', label: 'Job Title' },
      { key: 'tags', label: 'Tags', type: 'string' },
      { key: 'created_at', label: 'Created At', type: 'datetime' },
      { key: 'profile_url', label: 'Profile URL' },
    ],
  },
};

Update actions allow Zaps to modify existing records. They typically require a record ID (often from a previous trigger/search step) plus fields to update:

// creates/update_lead.js - Update Action Implementation
const perform = async (z, bundle) => {
  const leadId = bundle.inputData.lead_id;

  // Build update payload (only include provided fields)
  const updates = {};
  if (bundle.inputData.status) updates.status = bundle.inputData.status;
  if (bundle.inputData.priority) updates.priority = bundle.inputData.priority;
  if (bundle.inputData.assigned_to) updates.assigned_to = bundle.inputData.assigned_to;
  if (bundle.inputData.notes) updates.notes = bundle.inputData.notes;

  const response = await z.request({
    url: `https://api.yourdomain.com/v1/leads/${leadId}`,
    method: 'PATCH',
    body: {
      ...updates,
      updated_by: 'zapier',
      zapier_zap_id: bundle.meta.zap?.id,
    },
  });

  return {
    id: response.data.id,
    status: response.data.status,
    priority: response.data.priority,
    assigned_to: response.data.assigned_to,
    notes: response.data.notes,
    updated_at: response.data.updated_at,
  };
};

const getLeadDropdown = async (z, bundle) => {
  // Dynamic dropdown: fetch leads from API
  const response = await z.request({
    url: 'https://api.yourdomain.com/v1/leads',
    method: 'GET',
    params: {
      limit: 100,
      status: 'active',
    },
  });

  // Return array of {id, label} objects
  return response.data.leads.map(lead => ({
    id: lead.id,
    label: `${lead.name} (${lead.email})`,
  }));
};

module.exports = {
  key: 'update_lead',
  noun: 'Lead',
  display: {
    label: 'Update Lead',
    description: 'Updates an existing lead in your ChatGPT app.',
  },

  operation: {
    perform: perform,

    inputFields: [
      {
        key: 'lead_id',
        label: 'Lead',
        type: 'string',
        required: true,
        dynamic: 'lead_list.id.label', // Dynamic dropdown
        helpText: 'Select the lead to update',
      },
      {
        key: 'status',
        label: 'Status',
        type: 'string',
        required: false,
        choices: ['new', 'contacted', 'qualified', 'proposal', 'won', 'lost'],
      },
      {
        key: 'priority',
        label: 'Priority',
        type: 'string',
        required: false,
        choices: ['low', 'medium', 'high', 'urgent'],
      },
      {
        key: 'assigned_to',
        label: 'Assigned To',
        type: 'string',
        required: false,
        helpText: 'User ID or email of assignee',
      },
      {
        key: 'notes',
        label: 'Notes',
        type: 'text',
        required: false,
      },
    ],

    sample: {
      id: 'lead_1234567890',
      status: 'qualified',
      priority: 'high',
      assigned_to: 'user_9876543210',
      notes: 'Updated via Zapier automation',
      updated_at: '2026-12-25T11:15:00Z',
    },

    outputFields: [
      { key: 'id', label: 'Lead ID' },
      { key: 'status', label: 'Status' },
      { key: 'priority', label: 'Priority' },
      { key: 'assigned_to', label: 'Assigned To' },
      { key: 'notes', label: 'Notes' },
      { key: 'updated_at', label: 'Updated At', type: 'datetime' },
    ],
  },
};

Error handling is critical for production integrations. The Zapier Platform provides built-in error classes that trigger appropriate retry behavior:

// utils/error_handler.js - Centralized Error Handling
const handleAPIError = (response, z) => {
  // 400-level errors (client errors) - don't retry
  if (response.status === 400) {
    throw new z.errors.Error(
      `Invalid request: ${response.data.message || 'Check your input data'}`
    );
  }

  if (response.status === 401 || response.status === 403) {
    throw new z.errors.RefreshAuthError(
      'Authentication failed. Please reconnect your account.'
    );
  }

  if (response.status === 404) {
    throw new z.errors.Error(
      `Resource not found: ${response.data.message || 'The requested item does not exist'}`
    );
  }

  if (response.status === 422) {
    const errors = response.data.errors || {};
    const errorMessages = Object.entries(errors)
      .map(([field, messages]) => `${field}: ${messages.join(', ')}`)
      .join('; ');

    throw new z.errors.Error(`Validation failed: ${errorMessages}`);
  }

  // 500-level errors (server errors) - retry automatically
  if (response.status >= 500) {
    throw new z.errors.Error(
      `Server error (${response.status}). Zapier will automatically retry.`
    );
  }

  // Rate limiting - retry with backoff
  if (response.status === 429) {
    const retryAfter = response.headers['retry-after'] || 60;
    throw new z.errors.ThrottledError(
      `Rate limit exceeded. Retry after ${retryAfter} seconds.`
    );
  }
};

module.exports = { handleAPIError };

Test your actions thoroughly using the Zapier CLI test suite. The CLI simulates user input and validates output schemas:

# Run all tests
zapier test

# Test specific action
zapier test --grep "create_contact"

# Test with sample input data
zapier invoke creates.create_contact --inputData='{"name":"Test User","email":"test@example.com"}'

Learn more about action best practices and building ChatGPT app APIs for automation.

Authentication Strategies

Secure authentication is foundational to Zapier integrations handling sensitive business data. The Zapier Platform supports four authentication types: API Key, OAuth2, Session Auth, and Digest Auth. For ChatGPT apps, OAuth2 provides the best security and user experience—users authorize access without sharing passwords, and you maintain granular permission control.

OAuth2 authentication requires three endpoints in your API: authorization URL (where users grant permission), token exchange URL (exchanges authorization code for access token), and token refresh URL (renews expired access tokens). Here's a complete implementation:

// authentication.js - Production OAuth2 Implementation
const config = {
  type: 'oauth2',

  oauth2Config: {
    // Step 1: Authorization URL (user clicks "Connect" in Zapier)
    authorizeUrl: {
      url: 'https://api.yourdomain.com/oauth/authorize',
      params: {
        client_id: '{{process.env.CLIENT_ID}}',
        redirect_uri: '{{bundle.inputData.redirect_uri}}',
        response_type: 'code',
        scope: 'read write appointments contacts leads webhooks',
        state: '{{bundle.inputData.state}}', // CSRF protection
      },
    },

    // Step 2: Exchange authorization code for access token
    getAccessToken: async (z, bundle) => {
      const response = await z.request({
        url: 'https://api.yourdomain.com/oauth/token',
        method: 'POST',
        body: {
          grant_type: 'authorization_code',
          code: bundle.inputData.code,
          client_id: process.env.CLIENT_ID,
          client_secret: process.env.CLIENT_SECRET,
          redirect_uri: bundle.inputData.redirect_uri,
        },
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
      });

      // Validate token response
      if (!response.data.access_token) {
        throw new z.errors.Error('Invalid token response from OAuth server');
      }

      // Store token data in bundle.authData
      return {
        access_token: response.data.access_token,
        refresh_token: response.data.refresh_token,
        expires_in: response.data.expires_in,
        token_type: response.data.token_type || 'Bearer',

        // Store additional user context
        user_id: response.data.user_id,
        app_id: response.data.app_id,
        account_email: response.data.email,
      };
    },

    // Step 3: Refresh expired access token
    refreshAccessToken: async (z, bundle) => {
      const response = await z.request({
        url: 'https://api.yourdomain.com/oauth/token',
        method: 'POST',
        body: {
          grant_type: 'refresh_token',
          refresh_token: bundle.authData.refresh_token,
          client_id: process.env.CLIENT_ID,
          client_secret: process.env.CLIENT_SECRET,
        },
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
      });

      // Return updated token data
      return {
        access_token: response.data.access_token,
        refresh_token: response.data.refresh_token || bundle.authData.refresh_token,
        expires_in: response.data.expires_in,
        token_type: response.data.token_type || 'Bearer',
      };
    },

    // Automatic token refresh when API returns 401
    autoRefresh: true,

    // Scope definitions (optional, for documentation)
    scope: {
      read: 'View appointments, contacts, and leads',
      write: 'Create and update appointments, contacts, and leads',
      appointments: 'Manage appointment scheduling',
      contacts: 'Manage contact database',
      leads: 'Manage lead pipeline',
      webhooks: 'Subscribe to real-time events',
    },
  },

  // Test authentication after connection
  test: async (z, bundle) => {
    const response = await z.request({
      url: 'https://api.yourdomain.com/v1/me',
      method: 'GET',
    });

    if (response.status !== 200) {
      throw new z.errors.Error('Authentication test failed');
    }

    // Return user profile data
    return {
      id: response.data.id,
      email: response.data.email,
      name: response.data.name,
      app_id: response.data.app_id,
    };
  },

  // Connection label (shown in Zapier account list)
  connectionLabel: '{{email}} ({{name}})',

  // Fields available in bundle.authData throughout app
  fields: [
    { key: 'access_token', type: 'string', required: true },
    { key: 'refresh_token', type: 'string', required: false },
  ],
};

module.exports = config;

For simpler integrations, API Key authentication provides a lightweight alternative. Users paste their API key from your ChatGPT app settings into Zapier:

// authentication.js - API Key Authentication
const config = {
  type: 'custom',

  fields: [
    {
      key: 'api_key',
      label: 'API Key',
      type: 'string',
      required: true,
      helpText: 'Find your API key in ChatGPT App Settings → Integrations',
    },
  ],

  test: async (z, bundle) => {
    const response = await z.request({
      url: 'https://api.yourdomain.com/v1/me',
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${bundle.authData.api_key}`,
      },
    });

    if (response.status !== 200) {
      throw new z.errors.Error('Invalid API key');
    }

    return response.data;
  },

  connectionLabel: '{{email}}',
};

module.exports = config;

Session-based authentication works for apps that use cookie-based sessions (less common for APIs):

// authentication.js - Session Authentication
const config = {
  type: 'session',

  sessionConfig: {
    perform: async (z, bundle) => {
      const response = await z.request({
        url: 'https://api.yourdomain.com/v1/auth/login',
        method: 'POST',
        body: {
          email: bundle.authData.email,
          password: bundle.authData.password,
        },
      });

      // Store session token
      return {
        sessionToken: response.data.session_token,
        user_id: response.data.user_id,
      };
    },
  },

  fields: [
    { key: 'email', label: 'Email', type: 'string', required: true },
    { key: 'password', label: 'Password', type: 'password', required: true },
  ],

  test: async (z, bundle) => {
    const response = await z.request({
      url: 'https://api.yourdomain.com/v1/me',
      headers: {
        'X-Session-Token': bundle.authData.sessionToken,
      },
    });

    return response.data;
  },

  connectionLabel: '{{email}}',
};

module.exports = config;

Secure your OAuth credentials using environment variables (never hardcode in source code). Set environment variables in Zapier's developer dashboard and reference them with process.env.CLIENT_ID:

# .env file (local development only - NEVER commit)
CLIENT_ID=your_client_id_here
CLIENT_SECRET=your_client_secret_here
API_BASE_URL=https://api.yourdomain.com

# Set environment variables in Zapier (for production)
zapier env:set 1.0.0 CLIENT_ID=your_client_id
zapier env:set 1.0.0 CLIENT_SECRET=your_client_secret

Test authentication flows thoroughly, including token expiration and refresh scenarios. The Zapier Platform automatically refreshes tokens when autoRefresh: true and your API returns HTTP 401. Learn more about OAuth2 implementation and securing ChatGPT app integrations.

Production Deployment

Once your integration is tested and ready for users, deploy it to Zapier's platform. The deployment process includes versioning, environment configuration, validation checks, and optional submission to Zapier's public app directory (5,000+ integrations discovered by millions of users).

Prepare your integration for deployment by running comprehensive validation and tests:

# Validate app configuration
zapier validate

# Run full test suite
zapier test

# Check for best practice violations
zapier validate --strict

# Build integration package
zapier build

# Test authentication flow
zapier login --oauth

# Verify environment variables are set
zapier env:get 1.0.0

Deploy your integration to Zapier's platform. Each deployment creates a new version (use semantic versioning: 1.0.0, 1.1.0, 2.0.0):

# Deploy version 1.0.0 (initial release)
zapier push

# Promote to production (makes version live for users)
zapier promote 1.0.0

# Migrate users from old version to new version
zapier migrate 1.0.0 1.1.0 100% # Migrate 100% of users

# Deprecate old version (prevent new users from connecting)
zapier deprecate 1.0.0 2026-12-31 # Deprecate by date

Monitor your integration's health using Zapier's monitoring dashboard. Track API errors, authentication failures, and usage metrics:

// utils/monitoring.js - Logging and Monitoring
const logRequest = (request, z, bundle) => {
  // Log all outgoing requests (development only)
  if (process.env.NODE_ENV !== 'production') {
    z.console.log('Request:', {
      method: request.method,
      url: request.url,
      params: request.params,
      zapId: bundle.meta.zap?.id,
      userId: bundle.authData.user_id,
    });
  }
};

const logResponse = (response, z, bundle) => {
  // Log response metadata
  z.console.log('Response:', {
    status: response.status,
    duration: response.timing?.duration,
  });

  // Track errors for monitoring
  if (response.status >= 400) {
    z.console.error('API Error:', {
      status: response.status,
      message: response.data.message,
      zapId: bundle.meta.zap?.id,
    });
  }
};

module.exports = { logRequest, logResponse };

Submit your integration to Zapier's app directory for public discovery. This requires meeting quality standards (comprehensive documentation, reliable performance, responsive support):

# Generate app documentation
zapier scaffold docs

# Submit for review
zapier promote 1.0.0 --public

# Check review status
zapier status

Provide user support by monitoring the Zapier integration dashboard. Common support scenarios include authentication issues (expired tokens, permission errors), trigger/action failures (API changes, invalid input), and performance problems (rate limiting, timeouts).

Maintain your integration by deploying regular updates, fixing bugs, and adding new triggers/actions based on user feedback. Use semantic versioning to communicate changes:

• Patch versions (1.0.1): Bug fixes, no breaking changes
• Minor versions (1.1.0): New features, backward compatible
• Major versions (2.0.0): Breaking changes, requires user migration

Learn more about Zapier deployment best practices and scaling ChatGPT app integrations.

Conclusion

Building a Zapier integration for your ChatGPT app unlocks exponential growth by connecting your AI-powered features to 5,000+ business applications. By implementing production-ready polling and webhook triggers, robust actions with comprehensive error handling, secure OAuth2 authentication, and enterprise-grade monitoring, you transform your ChatGPT app from a standalone tool into an indispensable automation hub.

The patterns covered in this guide—deduplication logic, token refresh handling, dynamic input fields, webhook subscriptions, and structured output schemas—form the foundation of integrations serving millions of automated workflows. Whether you're building appointment scheduling, lead management, customer support, or content generation features, these implementations scale from MVP to enterprise deployment.

Ready to build your ChatGPT app with built-in Zapier integration? Start your free trial at MakeAIHQ.com and deploy a production-ready ChatGPT app with Zapier automation in under 48 hours—no coding required. Our platform generates the MCP server architecture, widget components, authentication flows, and webhook infrastructure automatically, giving you a complete ChatGPT App Store submission package with Zapier integration from day one.

For developers building custom integrations, explore our comprehensive guides on ChatGPT app API design, webhook implementation patterns, OAuth2 authentication, and real-time automation strategies. Transform your ChatGPT app into an automation powerhouse that connects seamlessly with the business tools your customers use every day.