Syncing Calendly Appointments to CRM Contact Creation

Hey there, Darian here. Before I automated this workflow, part of my Monday morning ritual involved manually cross-referencing our sales team’s Calendly bookings with our CRM. I’d copy-paste names, emails, and notes, trying not to make any typos. It was a tedious, error-prone process that easily burned an hour every week. Once I realized how much time I was wasting on a task a simple script could handle, I built this integration. It’s been a set-and-forget solution that has saved our team countless hours and eliminated data entry mistakes. Let’s get you set up so you can reclaim that time, too.

Prerequisites

Before we dive in, make sure you have the following ready:

• A Calendly account with access to generate a personal access token (API key).
• A CRM with a REST API for creating and searching for contacts. I’ll use a generic example, but the logic applies to HubSpot, Salesforce, Zoho, etc.
• Python 3 installed on the machine where this script will run.
• Basic familiarity with making API requests and handling JSON data.

The Guide: Step-by-Step

Alright, let’s get into the nuts and bolts. The goal is to write a Python script that fetches new appointments from Calendly, checks if the attendee already exists in our CRM, and if not, creates a new contact record for them.

Step 1: Project Setup and Dependencies

I’ll skip the standard virtual environment setup since you likely have your own workflow for that. Let’s jump straight to the Python logic. You’ll need a couple of libraries to make this work. In your terminal, you can install them using pip. You’ll want ‘requests’ for making the API calls and ‘python-dotenv’ to manage our secret keys safely. Just run a pip install for requests and python-dotenv.

Step 2: Securely Store Your API Keys

First rule of DevOps: never hardcode your secrets. We’ll create a file named config.env in the same directory as our script to hold our API keys. This file should never be committed to version control.

Your config.env file should look something like this:

CALENDLY_API_KEY="your_calendly_personal_access_token"
CRM_API_KEY="your_crm_api_key"
CRM_API_ENDPOINT="https://api.yourcrm.com/v1/contacts"
CALENDLY_USER_URI="your_calendly_user_uri"

Pro Tip: You can find your Calendly User URI by making an API call to /users/me. It will look something like https://api.calendly.com/users/AABBC123XYZ. This is needed to fetch events specific to your account.

Step 3: The Script – Fetching New Calendly Appointments

Now for the fun part. Let’s start building our Python script. We’ll begin by loading our secrets and writing a function to pull the latest scheduled events from Calendly. We’ll only pull events from the last hour to keep the script efficient.

import requests
import os
from dotenv import load_dotenv
from datetime import datetime, timedelta

# Load environment variables from config.env
load_dotenv('config.env')

CALENDLY_TOKEN = os.getenv('CALENDLY_API_KEY')
CALENDLY_USER_URI = os.getenv('CALENDLY_USER_URI')

def get_recent_calendly_events():
    """Fetches Calendly events scheduled in the last hour."""
    print("Fetching recent events from Calendly...")
    headers = {
        'Authorization': f'Bearer {CALENDLY_TOKEN}',
        'Content-Type': 'application/json',
    }
    
    # Calculate the time window for the query
    one_hour_ago = (datetime.utcnow() - timedelta(hours=1)).isoformat() + "Z"

    # In my production setups, I filter by a specific event type if needed.
    params = {
        'user': CALENDLY_USER_URI,
        'min_start_time': one_hour_ago,
        'sort': 'start_time:asc',
        'status': 'active', # Only fetch active, not cancelled, events
    }
    
    url = "https://api.calendly.com/scheduled_events"
    
    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()  # This will raise an exception for HTTP errors
        
        events = response.json().get('collection', [])
        print(f"Found {len(events)} new event(s).")
        return events
    except requests.exceptions.RequestException as e:
        print(f"Error fetching from Calendly: {e}")
        return []

This function sets up the authentication headers, defines a time window to avoid pulling our entire event history, and makes the API call. Error handling is included because APIs can and do fail.

Step 4: The Script – Interacting with Your CRM

Next, we need two functions to talk to our CRM: one to check if a contact already exists (to prevent duplicates) and one to create a contact if they don’t.

CRM_API_KEY = os.getenv('CRM_API_KEY')
CRM_API_ENDPOINT = os.getenv('CRM_API_ENDPOINT')

def check_crm_for_contact(email):
    """Checks if a contact with the given email exists in the CRM."""
    headers = {
        'Authorization': f'Bearer {CRM_API_KEY}',
        'Content-Type': 'application/json',
    }
    params = {'email': email}
    
    try:
        response = requests.get(CRM_API_ENDPOINT, headers=headers, params=params)
        response.raise_for_status()
        data = response.json()
        # The logic here depends heavily on your CRM's API response structure
        if data.get('total', 0) > 0:
            print(f"Contact {email} already exists in CRM.")
            return True
        return False
    except requests.exceptions.RequestException as e:
        print(f"Error checking CRM for contact {email}: {e}")
        return True # Assume exists to prevent duplicates on error

def create_crm_contact(name, email):
    """Creates a new contact in the CRM."""
    print(f"Creating CRM contact for {name} ({email})...")
    headers = {
        'Authorization': f'Bearer {CRM_API_KEY}',
        'Content-Type': 'application/json',
    }
    # This payload will vary based on your CRM's requirements
    payload = {
        'properties': {
            'firstname': name.split(' ')[0],
            'lastname': ' '.join(name.split(' ')[1:]) if ' ' in name else '',
            'email': email,
            'lead_source': 'Calendly Booking'
        }
    }
    
    try:
        response = requests.post(CRM_API_ENDPOINT, headers=headers, json=payload)
        response.raise_for_status()
        print(f"Successfully created contact for {email}.")
        return True
    except requests.exceptions.RequestException as e:
        print(f"Error creating CRM contact for {email}: {e}")
        return False

Pro Tip: In the `create_crm_contact` function, I always add a `lead_source` property. This makes it incredibly easy for the sales and marketing teams to track where new leads are coming from. It’s a small detail that provides a ton of value.

Step 5: Putting It All Together

Now, let’s create a main function to orchestrate the entire process. It will fetch events, loop through them, get the attendee’s details, and then call our CRM functions.

def get_invitee_details(event_uri):
    """Fetches invitee details for a specific event."""
    headers = {'Authorization': f'Bearer {CALENDLY_TOKEN}'}
    invitee_url = f"{event_uri}/invitees"
    try:
        response = requests.get(invitee_url, headers=headers)
        response.raise_for_status()
        # Usually there is only one invitee for a 1-on-1 meeting
        invitees = response.json().get('collection', [])
        if invitees:
            return invitees[0] # Return the first invitee
    except requests.exceptions.RequestException as e:
        print(f"Could not fetch invitee for event {event_uri}: {e}")
    return None

def main():
    """Main function to run the sync process."""
    print("Starting Calendly to CRM sync process...")
    events = get_recent_calendly_events()
    
    if not events:
        print("No new events to process. Exiting.")
        return

    for event in events:
        event_uri = event.get('uri')
        invitee = get_invitee_details(event_uri)
        
        if invitee:
            invitee_email = invitee.get('email')
            invitee_name = invitee.get('name')
            
            if invitee_email and invitee_name:
                if not check_crm_for_contact(invitee_email):
                    create_crm_contact(invitee_name, invitee_email)
            else:
                print(f"Skipping event {event_uri} due to missing name or email.")
        else:
            print(f"No invitee found for event {event_uri}.")
            
    print("Sync process complete.")

if __name__ == "__main__":
    main()

Step 6: Automating the Script

To make this truly hands-off, you can schedule it to run automatically. On a Linux-based server, a cron job is the perfect tool for this. You could set it to run every hour, for instance.

A simple cron entry would look like this (remember to use the correct path to your python interpreter and script):

0 * * * * python3 path/to/your/script.py

This tells the system to execute your Python script at the beginning of every hour.

Common Pitfalls (Where I Usually Mess Up)

• API Rate Limits: When I first built this, I ran the script every five minutes. I hit the API rate limit pretty quickly. Running it once an hour is usually more than enough and keeps you safely within the free tier limits of most APIs.
• Handling Duplicates: The “check before you create” step is non-negotiable. Skipping it will lead to a messy CRM and an annoyed sales team. Trust me on this one.
• Timezone Headaches: Calendly’s API returns times in UTC. When you first set the `min_start_time` parameter, make sure you’re sending a UTC timestamp, or you might miss events. The `datetime.utcnow()` in the script handles this correctly.
• Forgetting to Secure Secrets: I can’t stress this enough. If you accidentally commit your `config.env` file to a public repository, consider those keys compromised immediately. Add it to your `.gitignore` file right now.

Conclusion

And there you have it. A robust, automated workflow that syncs new Calendly bookings to your CRM. This script is a solid foundation; you can expand it to add more details to the contact record, like the event type or answers to custom questions from the booking form. By automating these small, repetitive tasks, you free yourself up to focus on the more complex engineering challenges. Hope this helps you out.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions