Syncing Calendars Between Two Google Workspace Accounts

/ Blog / By

I recently ran into a problem that’s probably familiar to anyone who works across multiple Google Workspace environments. I use two different accounts: my main account linked to jenario.com and another that belongs to a customer of mine that also happens to use Google Workspace.

The issue was that while I managed to keep my Jenario-Calendar up to date, it didn’t reflect in the other calendar. This made it very confusing for people in the second organization to book meeting with me.

The Problem

Each Google Workspace domain is isolated. Free/busy information doesn’t automatically sync between them, even though both accounts use Google Calendar. That’s fine if you only use one calendar, but as soon as you’re working across different organizations, it becomes a scheduling nightmare.

Some third-party tools can sync calendars automatically, but they’re often blocked on managed workspaces for security reasons. I needed a setup that would let people in workspace managed by my customer see when I was busy, without exposing event details, without using external apps, and without admin privileges.

What Didn’t Work

I tried the obvious paths first:

  • Subscribing to one calendar from the other worked for my personal view, but colleagues in the second domain still saw me as available.
  • Sharing permissions across domains didn’t work because the customer’s workspace didn’t allow external systems from writing into my second calendar.
  • Third-party sync services weren’t allowed.

So I had to find a solution that worked entirely within Google’s ecosystem.

The Solution

The breakthrough was realizing that I could run a Google Apps Script from the managed account itself. That script reads my events from the other calendar (which I shared read-only) and automatically creates simple “busy” placeholders on the managed calendar.

This doesn’t expose event details and doesn’t require admin rights. It just copies the busy time ranges so others can see when I’m not available.

Here’s an anonymized version of the script:

function syncBusyTimes() {
  // Calendar that contains your actual events (shared read-only)
  const sourceCal = CalendarApp.getCalendarById('primary_calendar_id@example.com');
  // Your managed account's own calendar
  const targetCal = CalendarApp.getDefaultCalendar();

  const now = new Date();
  const future = new Date();
  future.setDate(now.getDate() + 30); // look 30 days ahead

  // Get events from the primary calendar
  const events = sourceCal.getEvents(now, future);

  // Remove previously mirrored placeholders
  const existing = targetCal.getEvents(now, future, { search: "[Busy from external calendar]" });
  existing.forEach(e => e.deleteEvent());

  // Create new placeholders for busy periods
  events.forEach(ev => {
    if (!ev.isAllDayEvent()) {
      targetCal.createEvent(
        "[Busy from external calendar]",
        ev.getStartTime(),
        ev.getEndTime()
      );
    }
  });
}

Once the script is added in script.google.com, it can be set to run automatically every hour using a trigger. The result is a clean, self-updating reflection of your true availability inside the managed workspace.

What I Learned

  • Cross-domain calendar sync isn’t built in. Each Workspace is isolated unless the admins explicitly open sharing across domains.
  • Free/busy access isn’t enough for scripts. To read start and end times, you need “See all event details” access.
  • The script must run under the account that owns the writable calendar. That’s the only way to create events without admin privileges.
  • You don’t need external services or API credentials. It all works inside Google’s own environment.

Why This Matters

Working across organizations is becoming normal, but calendars haven’t caught up with that reality. When people rely on “Find a time” to schedule meetings, missing busy data from a second calendar creates friction and double bookings.

This small automation keeps everything aligned and respects security boundaries. It’s not fancy, but it works. Sometimes the best fixes are the simplest ones — a few lines of code that quietly make daily work a little smoother.