How to Sync Multiple Google Calendars in Real-Time for B2B Teams

Why Manual Google Calendar Sharing Fails B2B Teams

Google Workspace allows calendar sharing, but for professional services and corporate environments, manual sharing does not suffice:

• Corporate Security Restrictions: Enterprise IT administrators commonly disable external calendar sharing. If your client belongs to a secure corporate domain, they cannot share their calendar with your primary agency domain.
• Data Privacy Exposure: Sharing details externally exposes client names, project descriptions, and meeting attachments, violating non-disclosure agreements (NDAs).
• Poor Context Control: Limiting sharing to "free/busy" hides essential context for internal planning while presenting an impersonal view to external schedulers.
• Manual Overhead: Each consultant must configure subscriptions and manage toggle views on multiple accounts, which depends heavily on individual adherence and leads to operational oversights.

Manual Tutorial: Building a Custom Node.js Calendar Sync Script

To avoid manual configuration, teams often write custom synchronization utilities. Below is a step-by-step tutorial to build a custom sync script that connects two separate Google Workspace accounts using official Google APIs in Node.js and TypeScript.

Step 1: Project Initialization and Dependencies

Initialize a clean Node.js and TypeScript environment. Install the official Google APIs SDK and dotenv for managing configuration keys:

mkdir custom-calendar-sync
cd custom-calendar-sync
npm init -y
npm install googleapis dotenv
npm install --save-dev typescript @types/node ts-node

Step 2: Configure Environment Variables

Create a .env file in your project root to secure your API access credentials. Do not commit these sensitive details to public version control:

# Source Google Account Credentials
SOURCE_CLIENT_ID=your_source_client_id.apps.googleusercontent.com
SOURCE_CLIENT_SECRET=your_source_client_secret
SOURCE_REFRESH_TOKEN=your_source_refresh_token
SOURCE_CALENDAR_ID=primary

# Target Google Account Credentials
TARGET_CLIENT_ID=your_target_client_id.apps.googleusercontent.com
TARGET_CLIENT_SECRET=your_target_client_secret
TARGET_REFRESH_TOKEN=your_target_refresh_token
TARGET_CALENDAR_ID=primary

Step 3: The TypeScript Synchronization Script

Create a file named sync.ts. This code initializes separate Google auth clients, pulls active events for the upcoming seven days, applies privacy masking, and writes corresponding blocks to the target calendar:

import { google } from "googleapis";
import * as dotenv from "dotenv";

dotenv.config();

const SOURCE_CALENDAR_ID = process.env.SOURCE_CALENDAR_ID || "primary";
const TARGET_CALENDAR_ID = process.env.TARGET_CALENDAR_ID || "primary";

// Initialize Google OAuth2 Clients for Source and Target
const authSource = new google.auth.OAuth2(
  process.env.SOURCE_CLIENT_ID,
  process.env.SOURCE_CLIENT_SECRET
);
authSource.setCredentials({
  refresh_token: process.env.SOURCE_REFRESH_TOKEN,
});

const authTarget = new google.auth.OAuth2(
  process.env.TARGET_CLIENT_ID,
  process.env.TARGET_CLIENT_SECRET
);
authTarget.setCredentials({
  refresh_token: process.env.TARGET_REFRESH_TOKEN,
});

const sourceCalendar = google.calendar({ version: "v3", auth: authSource });
const targetCalendar = google.calendar({ version: "v3", auth: authTarget });

async function syncEvents() {
  console.log("Fetching events from source calendar...");
  const now = new Date();
  const oneWeekLater = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);

  const response = await sourceCalendar.events.list({
    calendarId: SOURCE_CALENDAR_ID,
    timeMin: now.toISOString(),
    timeMax: oneWeekLater.toISOString(),
    singleEvents: true,
    orderBy: "startTime",
  });

  const sourceEvents = response.data.items || [];
  console.log(`Found ${sourceEvents.length} events on source calendar.`);

  for (const event of sourceEvents) {
    if (!event.start?.dateTime || !event.end?.dateTime) continue;

    const originalId = event.id || "";
    
    // Check if we already synced this event using privateExtendedProperty
    const checkResponse = await targetCalendar.events.list({
      calendarId: TARGET_CALENDAR_ID,
      privateExtendedProperty: `original_id=${originalId}`,
    });

    const alreadySynced = checkResponse.data.items || [];
    if (alreadySynced.length > 0) {
      console.log(`Event ${event.summary} already synced. Skipping.`);
      continue;
    }

    // Insert new event with masked subject for privacy
    await targetCalendar.events.insert({
      calendarId: TARGET_CALENDAR_ID,
      requestBody: {
        summary: "Busy (Synced)",
        description: "Reserved time slot from external Google Calendar.",
        start: {
          dateTime: event.start.dateTime,
          timeZone: event.start.timeZone,
        },
        end: {
          dateTime: event.end.dateTime,
          timeZone: event.end.timeZone,
        },
        extendedProperties: {
          private: {
            original_id: originalId,
          },
        },
      },
    });
    console.log(`Successfully synced event ID: ${originalId}`);
  }
}

syncEvents().catch((err) => {
  console.error("Sync run encountered a critical error:", err);
  process.exit(1);
});

Step 4: Configure the Cron Trigger

To automate execution on your server, set up a cron job. Open your crontab interface:

crontab -e

Add the following rule to execute the sync every 15 minutes and direct output to an operational log file:

*/15 * * * * /usr/bin/ts-node /path/to/project/sync.ts >> /var/log/calendar_sync.log 2>&1

Technical Bottlenecks & Failure Modes of Custom API Sync

While this basic script functions in isolated trials, scaling it to accommodate an active B2B team reveals major technical challenges.

1. API Rate Limits and Quota Exhaustion

Google Calendar API enforces strict request rate limits. Workspace domains are capped at 500 requests per user per 100 seconds. For a team of 15 consultants syncing events bidirectionally, a single morning scheduling flurry can trigger rate limit errors. This leads to dropped events, partial synchronizations, and corrupted event records.

2. Polling Latency vs. Webhook Infrastructure

A cron job running every 15 minutes creates a significant latency gap. If a client books a slot on Calendar A, that slot remains open on Calendar B for up to 14 minutes, leaving a dangerous window for double-bookings. Bypassing this latency requires configuring Google push notification webhooks, which introduces complex requirements: public web server hosting, SSL certificate management, and handling Google's short-lived (maximum 30-day) channel expirations.

3. OAuth Scope Management and Silent Failures

Managing user credentials securely across a team is complex. Refresh tokens issued during GCP consent can expire if the Google Cloud project remains in "Testing" mode, or if security policies require regular credential rotation. When a refresh token expires, the script halts silently, leaving developers to diagnose the cause only after a double-booking has occurred.

3-Way B2B Comparison: WonderCal vs Manual Google API Setup vs Competitors

The table below highlights how these three paths compare across five core B2B operational vectors:

Operational Analysis: Why Database-Level Sync Wins

When choosing a calendar synchronization method, operations leaders must distinguish between comprehensive work management suites and silent utility tools. B2B professionals do not need complex algorithms to schedule their tasks. They need to manage their own schedules, but they need their availability mirrored accurately and privately across separate accounts.

Invisible Database Sync Protects Consultant Productivity

WonderCal operates at the database layer. It does not introduce proprietary scheduling dashboards or force users to change their workflows. It listens directly for Google API changes, strips sensitive client identifiers to protect privacy, and propagates updates to target accounts in under 60 seconds. There are no conflicts, no artificial task blocks, and no scheduling delays.

Bypassing Corporate IT Security Obstacles

Connecting calendars across external corporate client environments is a major challenge. Enterprise security officers block application integrations that request domain-wide super-administrator access due to strict regulatory compliance standards.

Because many commercial schedulers demand broad write permissions to directories, emails, and tasks, IT security filters block them immediately. WonderCal requests only highly restricted, user-specific OAuth scopes required to write calendar events. This minimal footprint ensures consultants can connect secure client accounts without triggering security blocks.

The Financial ROI of Transparent Team Pricing

The financial differences are stark when comparing software expenses for growing B2B teams:

• 15-User Team: Competitors cost $2,160 to $6,120 annually. WonderCal costs $720 annually, saving up to $5,400.
• 30-User Team: Competitors cost $4,320 to $12,240 annually. WonderCal costs $1,440 annually, saving up to $10,800.
• 50-User Team: Competitors cost $7,200 to $20,400 annually. WonderCal costs $2,400 annually, saving up to $18,000.

Choosing WonderCal allows B2B teams to deploy real-time, database-level sync and avoid thousands of dollars in unnecessary software costs.