Google Calendar and Booking System Integration: Two-Way Sync Without Losing Your Mind

What is two-way Google Calendar sync in a booking system?

Two-way Google Calendar sync means your booking system and Google Calendar stay in constant conversation. When a customer books an appointment through your system, that time slot appears in your Google Calendar automatically. When you add an event directly in Google Calendar, your booking system becomes aware of it and blocks that time so no double bookings occur. This bidirectional data flow keeps both systems accurate without manual effort.

Single-direction sync is simpler but often causes problems. If your booking system pushes appointments to Google Calendar but never checks Google Calendar for changes, a manually added event will slip through and customers get double-booked. Two-way sync closes that gap, giving you a single source of truth for your availability across both platforms.

Setting up the Google Calendar API for your booking system

Before you can synchronise data, you need to enable the Google Calendar API and configure credentials. This process requires a Google Cloud project and OAuth 2.0 authentication. For server-side operations where no user is present, a service account is the right approach.

Creating credentials and enabling the API

Start by creating a project in Google Cloud Console, then enable the Google Calendar API. Generate a service account key and download the JSON credentials file. Store this file securely on your server and never expose it publicly. The credentials contain sensitive information that grants calendar access, so file permissions should be restricted to the application user only.

To share a calendar with a service account, you need the service account's email address, which appears in the credentials JSON file. Share your Google Calendar with that email address using calendar sharing settings. Without this step, the service account has no access to read or write events.

Installing the Google API PHP client

If you are working with PHP, the official Google API client library handles authentication and API calls. Install it using Composer:

composer require google/apiclient

After installation, load the autoloader and initialise the client using your service account credentials:

putenv('GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json');

$client = new Google_Client();
$client->useApplicationDefaultCredentials();
$client->addScope(Google_Service_Calendar::CALENDAR);

$service = new Google_Service_Calendar($client);

This initialisation works for service account authentication. The credentials path should point to your downloaded JSON file. Keep this path outside your web root to prevent accidental exposure.

Reading events from Google Calendar

To display accurate availability, your booking system needs to read existing events from Google Calendar. The Events.list method retrieves events within a specific time range from a given calendar.

$calendarId = 'primary';
$timeMin = (new DateTime('today'))->format(DateTime::ATOM);
$timeMax = (new DateTime('+30 days'))->format(DateTime::ATOM);

$optParams = [
    'timeMin' => $timeMin,
    'timeMax' => $timeMax,
    'singleEvents' => true,
    'orderBy' => 'startTime'
];

$events = $service->events->listEvents($calendarId, $optParams);

This request fetches all events from today for the next thirty days. The response contains an array of event objects, each with a start time, end time, summary, and other properties. Your booking system can parse these and mark the corresponding slots as unavailable.

Be mindful of recurring events. A standing weekly meeting appears as a recurring event in the API response. Set singleEvents to true to expand recurring events into individual instances, which makes slot blocking more predictable.

Creating and updating events from your booking system

When a customer completes a booking, your system should create a corresponding event in Google Calendar. The Event resource contains the essential fields: summary, start time, end time, description, and attendees.

$event = new Google_Service_Calendar_Event([
    'summary' => 'Appointment with ' . $customerName,
    'start' => [
        'dateTime' => $startDateTime,
        'timeZone' => 'Europe/London',
    ],
    'end' => [
        'dateTime' => $endDateTime,
        'timeZone' => 'Europe/London',
    ],
    'description' => 'Booking ID: ' . $bookingId . '\nCustomer: ' . $customerEmail,
    'reminders' => [
        'useDefault' => false,
        'overrides' => [
            ['method' => 'email', 'minutes' => 60],
            ['method' => 'popup', 'minutes' => 30],
        ],
    ],
]);

$createdEvent = $service->events->insert($calendarId, $event);

Store the Google Calendar event ID alongside your booking record. This ID is essential for updating or deleting the event later. Without it, you cannot modify the correct calendar entry when bookings change.

Handling conflicts and overlapping bookings

Conflict detection is the most important part of a two-way sync. Your system must check Google Calendar before confirming a new booking. If the requested time overlaps with an existing event, the booking should be rejected or the customer prompted to choose a different slot.

A practical approach is to query the calendar for events overlapping a proposed time window before inserting anything:

function checkCalendarConflict($service, $calendarId, $start, $end) {
    $optParams = [
        'timeMin' => (new DateTime($start))->format(DateTime::ATOM),
        'timeMax' => (new DateTime($end))->format(DateTime::ATOM),
        'singleEvents' => true,
    ];

    $events = $service->events->listEvents($calendarId, $optParams);
    return count($events->getItems()) > 0;
}

If this function returns true, an overlap exists and you should not proceed with the booking. Depending on your requirements, you might check for buffers around existing events too. If you allow thirty-minute appointments with fifteen-minute gaps, a new booking starting fifteen minutes after an existing event ends would cause a conflict.

Syncing changes made directly in Google Calendar

The harder part of two-way sync is detecting changes made outside your booking system. Google Calendar does not push updates to your application automatically. Your booking system needs to poll for changes or use watch notifications.

Using watch notifications for real-time updates

Google Calendar supports push notifications via webhooks. When a watched calendar changes, Google sends an HTTP POST to a URL you specify. Your application receives the notification and can fetch the updated event list.

To set up a watch, create a channel on the events resource:

$channel = new Google_Service_Calendar_Channel();
$channel->setId('your-unique-channel-id');
$channel->setType('web_hook');
$channel->setAddress('https://yourdomain.com/webhook/calendar');
$channel->setExpiration(time() + 86400 * 7); // expires in 7 days

$service->events->watch($calendarId, $channel);

Watch channels expire after a configurable period, often seven days. Your application should renew watches regularly through a scheduled task. Failing to renew causes your application to miss updates until you re-establish the watch.

Polling as a fallback approach

If webhooks are too complex, periodic polling works. Run a scheduled task every few minutes to fetch the latest events using a sync token. Sync tokens returned by the API limit responses to only events that changed since the last request, reducing API load compared to full list requests.

$optParams = [
    'syncToken' => $storedSyncToken,
];

$events = $service->events->listEvents($calendarId, $optParams);

If the sync token is expired or invalid, Google returns an error and you must perform a full sync without the token. Store the next sync token from each successful response and use it for the next poll.

Deleting and modifying events when bookings change

Bookings get cancelled, rescheduled, or edited. Your system needs to reflect these changes in Google Calendar by updating or deleting the corresponding event.

To update an event, modify the Event resource and use the update method with the event ID you stored when creating it:

$event = $service->events->get($calendarId, $eventId);
$event->setSummary('Rescheduled: ' . $customerName);
$event->getStart()->setDateTime($newStartDateTime);
$event->getEnd()->setDateTime($newEndDateTime);

$service->events->update($calendarId, $eventId, $event);

To delete an event when a booking is cancelled:

$service->events->delete($calendarId, $eventId);

Always handle errors from these operations. If the event was already deleted manually in Google Calendar, the API returns a not found error. Your application should handle this gracefully and update its internal state accordingly rather than failing visibly to users.

Security considerations for calendar API integration

Granting calendar access requires careful permission management. A service account used only for calendar operations should not have broader permissions than necessary. Use the principle of least privilege when configuring OAuth scopes.

Store credentials outside the web root and restrict file access. Never commit credentials to version control. If credentials are accidentally exposed, revoke them immediately in Google Cloud Console and generate new ones.

Webhook endpoints should verify that requests originate from Google by checking the X-Goog-Channel-token header or validating the origin. This prevents malicious actors from sending fake update notifications to your endpoint.

Performance and rate limiting

The Google Calendar API enforces per-project and per-user rate limits. Free tier limits are restrictive for high-volume applications. If your booking system handles many concurrent users, implement caching for calendar data and batch operations where possible.

Read requests can be cached locally with a short time-to-live. Your booking system checks its cache before calling the API, reducing the number of requests. When a booking is made or changed, update the cache immediately rather than waiting for expiry.

Batch creation of events is supported for scenarios like importing existing bookings. Use the batch endpoint to send multiple create, update, or delete requests in a single HTTP call, reducing overhead.

Testing your integration thoroughly

Before deploying, test the integration across different scenarios. Create bookings through your system and verify they appear in Google Calendar. Add events directly in Google Calendar and confirm your system blocks those times. Cancel bookings and check that calendar events are removed. Reschedule and confirm updates propagate correctly.

Test edge cases: bookings at midnight, overlapping start and end times, very long appointments spanning multiple days, and recurring bookings. Each of these can expose bugs in time zone handling or event boundary logic.

When to consider a third-party booking platform

Building and maintaining two-way Google Calendar sync requires ongoing effort. If your booking volume is modest and requirements are standard, an established booking platform with built-in Google Calendar integration may be more practical. Many platforms handle sync, conflict detection, reminders, and timezone handling out of the box.

If you need custom business logic, specific workflows, or deep integration with other systems, building your own solution gives you control. For businesses in the UK with unique scheduling requirements, a tailored approach may be worth the development investment. A practical review of your specific needs helps determine which path makes sense.

Related practical reading

These related guides can help you connect this topic with the wider website, server, security, and support decisions around it.

• GraphQL in PHP vs REST: When GraphQL Is the Better Choice - useful background for related development decisions
• PHP 8.4: Property Hooks and Asymmetric Visibility - useful background for related development decisions

Making two-way sync work reliably

Two-way Google Calendar sync removes the friction of managing availability across multiple platforms. Customers book through your system with confidence that their appointment is confirmed and reflected in your personal calendar. Staff see their full schedule in Google Calendar without logging into separate tools.

The technical implementation requires attention to conflict detection, error handling, and ongoing maintenance of sync channels. Getting the basics right, storing event IDs, checking for overlaps, and handling failures gracefully creates a solid foundation. Extensions like webhooks and sync tokens improve accuracy and reduce unnecessary API calls.

If your booking system is struggling with double bookings, missed appointments, or manual calendar updates, a well-implemented two-way sync often resolves these issues. Review your current setup, understand where the gaps are, and consider whether building the integration in-house or using a managed platform fits your situation better.