Claude + MCP Google Calendar: Auto-Book Appointments with AI

The Problem With Current Booking Tools

Prerequisites

• Claude API key — get one at console.anthropic.com
• Google Cloud project with Calendar API enabled
• OAuth 2.0 credentials (client ID + secret) from Google Cloud Console
• Python 3.11+ installed on your machine
• pip packages: anthropic, google-auth-oauthlib, google-api-python-client

Step 1: Enable Google Calendar API and Get Credentials

1. Go to console.cloud.google.com and create a new project (e.g., "Salon Booking Bot")
2. In the sidebar, go to APIs & Services → Library
3. Search for "Google Calendar API" and click Enable
4. Go to APIs & Services → Credentials → Create Credentials → OAuth 2.0 Client ID
5. Choose "Desktop application" as the application type
6. Download the credentials JSON file — save it as credentials.json in your project folder
7. In APIs & Services → OAuth Consent Screen, add your email as a test user (required while in development)

Step 2: Install and Configure the Google Calendar MCP Server

npm install -g @modelcontextprotocol/server-google-calendar

{
  "mcpServers": {
    "google-calendar": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-google-calendar"],
      "env": {
        "GOOGLE_CLIENT_ID": "your-client-id.apps.googleusercontent.com",
        "GOOGLE_CLIENT_SECRET": "GOCSPX-your-secret"
      }
    }
  }
}

Step 3: Connect Claude API to MCP (Python)

import anthropic
import json
from datetime import datetime, timedelta
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from google.auth.transport.requests import Request
import os
import pickle

SCOPES = ['https://www.googleapis.com/auth/calendar']

def get_calendar_service():
    """Authenticate and return Google Calendar service."""
    creds = None
    if os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)
    
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)
    
    return build('calendar', 'v3', credentials=creds)

def get_available_slots(service, date_str, duration_minutes=60):
    """Find available time slots on a given date."""
    # Parse date and set business hours (9am-6pm)
    target_date = datetime.strptime(date_str, '%Y-%m-%d')
    start_of_day = target_date.replace(hour=9, minute=0, second=0)
    end_of_day = target_date.replace(hour=18, minute=0, second=0)
    
    # Get existing events
    events_result = service.events().list(
        calendarId='primary',
        timeMin=start_of_day.isoformat() + 'Z',
        timeMax=end_of_day.isoformat() + 'Z',
        singleEvents=True,
        orderBy='startTime'
    ).execute()
    
    events = events_result.get('items', [])
    
    # Find free slots
    free_slots = []
    current_time = start_of_day
    
    for event in events:
        event_start = datetime.fromisoformat(
            event['start'].get('dateTime', '').replace('Z', '+00:00')
        ).replace(tzinfo=None)
        
        if (event_start - current_time).total_seconds() >= duration_minutes * 60:
            free_slots.append(current_time.strftime('%I:%M %p'))
        
        event_end = datetime.fromisoformat(
            event['end'].get('dateTime', '').replace('Z', '+00:00')
        ).replace(tzinfo=None)
        current_time = max(current_time, event_end)
    
    # Check slot at end of day
    if (end_of_day - current_time).total_seconds() >= duration_minutes * 60:
        free_slots.append(current_time.strftime('%I:%M %p'))
    
    return free_slots

def book_appointment(service, date_str, time_str, client_name, service_type, duration_minutes=60):
    """Create a calendar event for the appointment."""
    start_dt = datetime.strptime(f"{date_str} {time_str}", '%Y-%m-%d %I:%M %p')
    end_dt = start_dt + timedelta(minutes=duration_minutes)
    
    event = {
        'summary': f"{service_type} — {client_name}",
        'description': f'Booked via AI agent\nClient: {client_name}\nService: {service_type}',
        'start': {'dateTime': start_dt.isoformat(), 'timeZone': 'America/Chicago'},
        'end': {'dateTime': end_dt.isoformat(), 'timeZone': 'America/Chicago'},
        'reminders': {
            'useDefault': False,
            'overrides': [
                {'method': 'email', 'minutes': 24 * 60},
                {'method': 'popup', 'minutes': 60},
            ],
        },
    }
    
    created_event = service.events().insert(
        calendarId='primary',
        body=event
    ).execute()
    
    return created_event.get('htmlLink')

Step 4: Build the Booking Agent Logic

def run_booking_agent(user_request: str, calendar_service):
    """
    Main booking agent: takes a natural language request,
    checks availability, and books the appointment.
    """
    client = anthropic.Anthropic()
    
    # Define tools Claude can use
    tools = [
        {
            "name": "check_availability",
            "description": "Check available appointment slots on a specific date",
            "input_schema": {
                "type": "object",
                "properties": {
                    "date": {
                        "type": "string",
                        "description": "Date in YYYY-MM-DD format, e.g. '2026-06-17'"
                    },
                    "duration_minutes": {
                        "type": "integer",
                        "description": "How long the appointment is in minutes (default 60)"
                    }
                },
                "required": ["date"]
            }
        },
        {
            "name": "book_appointment",
            "description": "Book an appointment by creating a Google Calendar event",
            "input_schema": {
                "type": "object",
                "properties": {
                    "date": {"type": "string", "description": "Date in YYYY-MM-DD format"},
                    "time": {"type": "string", "description": "Time in HH:MM AM/PM format"},
                    "client_name": {"type": "string", "description": "Client's full name"},
                    "service_type": {"type": "string", "description": "Type of service requested"},
                    "duration_minutes": {"type": "integer", "description": "Duration in minutes"}
                },
                "required": ["date", "time", "client_name", "service_type"]
            }
        }
    ]
    
    today = datetime.now().strftime('%Y-%m-%d')
    
    messages = [{
        "role": "user",
        "content": f"Today is {today}. Please help with this booking request: {user_request}"
    }]
    
    system_prompt = """You are a friendly booking assistant for a local hair salon.
    
    When a client requests an appointment:
    1. Extract the requested service, preferred date/time, and client name
    2. Use check_availability to find open slots on their preferred date
    3. If slots are available, use book_appointment to create the event
    4. Confirm the booking with a warm, professional message
    5. If no slots are available, suggest the next available date
    
    Always be conversational and helpful. Duration defaults: haircut=45min, 
    color=120min, blowout=60min, cut+color=150min."""
    
    # Agentic loop
    while True:
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=1024,
            system=system_prompt,
            tools=tools,
            messages=messages
        )
        
        messages.append({"role": "assistant", "content": response.content})
        
        if response.stop_reason == "end_turn":
            # Extract final text response
            for block in response.content:
                if hasattr(block, 'text'):
                    return block.text
            break
        
        if response.stop_reason == "tool_use":
            tool_results = []
            
            for block in response.content:
                if block.type == "tool_use":
                    tool_name = block.name
                    tool_input = block.input
                    
                    # Execute the tool
                    if tool_name == "check_availability":
                        slots = get_available_slots(
                            calendar_service,
                            tool_input["date"],
                            tool_input.get("duration_minutes", 60)
                        )
                        result = {"available_slots": slots, "date": tool_input["date"]}
                    
                    elif tool_name == "book_appointment":
                        event_link = book_appointment(
                            calendar_service,
                            tool_input["date"],
                            tool_input["time"],
                            tool_input["client_name"],
                            tool_input["service_type"],
                            tool_input.get("duration_minutes", 60)
                        )
                        result = {"status": "booked", "calendar_link": event_link}
                    
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": json.dumps(result)
                    })
            
            messages.append({"role": "user", "content": tool_results})


# --- Main entry point ---
if __name__ == "__main__":
    service = get_calendar_service()
    
    # Test with a sample booking request
    request = "Hi, I'm Sarah Johnson and I'd like to book a haircut and blowout for next Tuesday afternoon if possible."
    
    response = run_booking_agent(request, service)
    print(response)

Hi Sarah! I checked Tuesday June 17th and you're in luck — I have a few open 
afternoon slots that would work for a cut and blowout (about 90 minutes):

• 1:00 PM
• 2:30 PM  
• 4:00 PM

I've gone ahead and booked you in for 2:30 PM on Tuesday the 17th. You'll 
receive a calendar confirmation shortly. See you then! 😊

Step 5: Expose as a Webhook for Customer Texts and DMs

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/book', methods=['POST'])
def handle_booking():
    """Webhook endpoint for booking requests."""
    data = request.json
    customer_message = data.get('message', '')
    
    # Initialize calendar service (use stored credentials)
    cal_service = get_calendar_service()
    
    # Run booking agent
    response = run_booking_agent(customer_message, cal_service)
    
    return jsonify({
        "response": response,
        "status": "processed"
    })

if __name__ == '__main__':
    app.run(port=5000)

• WhatsApp Business API (via Twilio) — customers text your WhatsApp number, the message hits your webhook, the agent responds
• Instagram DMs (via Meta's API) — DM-based booking
• Your website chat widget — embed a simple chat interface

Real Example: Austin Hair Salon Before and After

Handling Edge Cases

Comparison: This DIY System vs. Booking Platforms

FAQ

Does this work with Google Workspace (business Google accounts)?

How much does the Google Calendar API cost?

Can customers book via WhatsApp?

How do I handle cancellations?

What if Claude misunderstands a booking request?

Related Articles

• What Is MCP (Model Context Protocol)? Plain-Language Guide for Business Owners
• Best MCP Servers for Local Business: Google Drive, Notion, Slack Setup
• MCP Notion Connector: Build a Client CRM for Your Local Business
• VAPI AI Phone Agent for Local Business: Complete Setup Guide
• AI Agent for Appointment Booking: Complete Guide for Local Businesses