Want the TL;DR? Summarize this post with:
OpenAI’s new calendar connector is the latest step in ChatGPT acting like your personal assistant. With the new calendar connector enabled, you can ask things like “show me what my day looks like today” and ChatGPT will show you your calendar events for that day. But these new connectors are read-only. They can reference and display events, but they can’t actually create or edit them. If you want to book or reschedule something, you still have to do it manually in your own calendar.
For developers, the real opportunity comes from OpenAI’s function calling. Instead of being limited to read-only calendar views, you can build application features where ChatGPT’s model takes a user’s natural language input and routes it through your own infrastructure, prompting your application to query the Google Calendar API or Microsoft Graph API - the model then confirms the result back to the user in plain language. This means a SaaS chatbot could take a messy request like “I need a call with support to help me debug this issue” and turn it into a confirmed calendar booking.
What is function calling?
OpenAI’s ‘function calling’ lets developers define custom functions (or ‘tools’) that the ChatGPT model can call when it detects the right intent in a user’s message. Instead of just replying with text to the user of no real value or outcome, ChatGPT can output a structured JSON call to one of your functions, which your backend then executes.
How does function calling work?
As the developer, you create function definitions like find_free_slots or create_event, each with a name, description, and a JSON schema for the parameters they accept. OpenAI has detailed documentation on how to create function definitions here. This is what a function definition might look like for a find_free_slots function call.
{
"type": "function",
"name": "find_free_slots",
"description": "Finds available calendar slots",
"parameters": {
"type": "object",
"properties": {
"participants": {
"type": "array",
"items": {
"type": "string"
},
"description": "List of email addresses that should be included"
},
"required_duration": {
"type": "integer",
"description": "Length of the requested meeting in minutes"
},
"query_period": {
"type": "string",
"description": "Desired time range for the meeting."
}
},
"required": [
"attendees",
"duration_minutes",
"query_period"
],
"additionalProperties": false
},
"strict": true
}You then integrate the OpenAI API (the same models that power ChatGPT) into whatever interface your users interact with, for example a chat window inside your SaaS app or a support widget on your website. The user types free-form text into this interface, and your app forwards that text (along with your function definitions) to the OpenAI API.
What it looks like in practice:
1. Your user starts a new conversation. A user might type something unstructured like: “I keep getting errors whenever I run multiple queries at the same time. I don’t know what's going on, I have read your docs but can’t find an obvious cause. I really need to talk with someone in support when I’m next free tomorrow afternoon. I’m in London.”
2. The model decides which tool to use. The model recognises this is a scheduling intent and generates a function call, which might look like the following:
{
"id": "fc_24680uk",
"call_id": "call_24680uk",
"type": "function_call",
"name": "find_free_slots",
"arguments": "{\"participants\":[\"support@company.com\"],\"required_duration\"minutes:30,\"query_period\":\"tomorrow afternoon\",\"time_zone\":\"Europe/London\"}"
}3. Your backend executes the function. The find_free_slots endpoint in your app executes the code that queries the Google Calendar/Microsoft Graph API to find the next available slot. It applies your defined business rules, like working hours and buffers, and returns structured available slots.
4. The ChatGPT model converts this to a natural response for your user. It takes the structured response and turns it into user-friendly text: “I found 15:30-16:00 tomorrow. Do you want to book it?”
5. User confirms: “Yes.”
6. The OpenAI API calls another function. This time, the model outputs a call to your create_event tool, passing the confirmed slot and details.
7. Your backend finalises the booking: create_event triggers your API call to Google’s Calendar API/Microsoft Graph API, creates the calendar entry, and returns success.
8. The ChatGPT model closes the loop with the user. “Your support call is booked in for tomorrow at 15:30–16:00. You’ll get a calendar invite.”
Function calling essentially turns the ChatGPT model into the interpreter and orchestrator. It understands what the user wants, chooses the right tool, and formats the function call with the correct arguments. Your backend remains responsible for executing the actual calendar API calls to find availability and complete the booking.
What about building calendar integrations?
OpenAI’s function calling gives developers a fast track to building automated booking chatbots that understand a user’s natural language input. But while this solves the front-end intelligence problem of understanding what the user wants and orchestrating function calls, the hardest part of scheduling still remains - building reliable calendar integrations that actually sync, schedule, reschedule, and handle time zones.
How to build compliant scheduling solutions that actually scale
By using Cronofy’s APIs, your chatbot can go beyond just finding intent. It can be part of a stack that automates the entire scheduling flow. From checking availability to booking, rescheduling, and keeping calendars in sync across providers, Cronofy removes the burden of maintaining complex calendar integrations so your team can spend more time building more seamless experiences for users.
