Syncing Team Vacation Calendar to Slack Status

Hey team, Darian here. A few months ago, I was deep in a production incident and pinged three different engineers for help, only to find out all of them were on vacation. It was a classic “check the calendar first” mistake, but in the heat of the moment, who remembers? That’s when I realized I was wasting time, both for myself and for my teammates who were getting pointless notifications on a beach somewhere. This little automation was born out of that frustration. It’s a simple script that reads our team’s OOO calendar and automatically sets the corresponding Slack statuses. It’s a “set it and forget it” solution that has saved us countless interruptions. Let’s build it.

Prerequisites

Before we dive in, make sure you have the following ready. This shouldn’t take more than a few minutes to gather.

• Python 3 installed on the machine where you’ll run the script.
• A shared Google Calendar that your team uses for vacation and out-of-office events.
• Admin permissions in your Slack workspace to create a new app.
• A way to map calendar names/emails to Slack Member IDs (we’ll cover this).

The Guide: Step-by-Step

Step 1: Create the Slack App and Get Your Token

First, we need to give our script permission to change user statuses in Slack. We do this by creating a lightweight Slack App.

1. Navigate to the Slack API page and click “Create New App”. Choose “From scratch”.
2. Name your app something clear, like “Vacation Status Sync”, and pick your workspace.
3. In the sidebar, go to “OAuth & Permissions”. Scroll down to the “Scopes” section.
4. Under “Bot Token Scopes”, click “Add an OAuth Scope” and add users.profile:write. This is the magic permission that lets us update a user’s status.
5. Scroll back up and click “Install to Workspace”. Authorize it.
6. After authorizing, you’ll see a “Bot User OAuth Token” that starts with xoxb-. Copy this token. This is our key to the kingdom, so keep it secret and keep it safe!

Pro Tip: In my production setups, I never hardcode secrets. We’ll use a config.env file to store this token securely. It’s a simple text file that our Python script will read from, and you can add it to your .gitignore to prevent it from ever being committed to source control.

Step 2: Get Your Google Calendar API Key and Calendar ID

Next, we need to allow our script to read the vacation calendar. We’ll use a simple API key for this, assuming your calendar’s visibility is set appropriately.

1. Go to the Google Cloud Console, create a new project if you don’t have one already.
2. Use the search bar to find and enable the “Google Calendar API”.
3. Navigate to “APIs & Services” > “Credentials”. Click “Create Credentials” and select “API key”. Copy this key and store it alongside your Slack token.
4. Now, find your Calendar ID. Go to your Google Calendar’s “Settings and sharing” page. Under the “Integrate calendar” section, you’ll find the Calendar ID. It usually looks like an email address.
5. Crucially: Make sure your calendar is visible to anyone with the link (at least for free/busy information). Otherwise, the API key won’t be able to see the events.

Step 3: The Python Script

Alright, time for the fun part. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Just make sure you install the necessary libraries. You’ll need requests to make API calls, python-dotenv to handle our secret keys, and `datetime` which is a standard library.

Here’s the logic behind the script:

1. Load the secret API keys and IDs from our config.env file.
2. Define a mapping of Google Calendar event names (or emails) to Slack Member IDs. This is the most reliable way to link a calendar event to a specific Slack user.
3. Fetch all events from the Google Calendar for the current day.
4. Loop through each event. If the event’s summary (the title) matches a name in our mapping, we’ll craft a status update.
5. Send a request to the Slack API to update that user’s status emoji and text.

Here’s the code. I’ve added comments to explain each part.

import os
import requests
from datetime import datetime, time, timedelta
from dotenv import load_dotenv

# --- Configuration ---
# Load variables from your config.env file
load_dotenv('config.env')
SLACK_BOT_TOKEN = os.getenv('SLACK_BOT_TOKEN')
GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
CALENDAR_ID = os.getenv('CALENDAR_ID')

# This is critical! You need to map the name in the calendar event
# to the person's Slack Member ID.
# Find the Member ID by clicking a user's profile in Slack -> "Copy Member ID".
USER_MAPPING = {
    'Darian Vance': 'U02ABCD1234',
    'Alex Chen': 'U03DEFG5678',
    'Maria Garcia': 'U04HIJK9012'
}

# --- Main Logic ---

def get_calendar_events():
    """Fetches events from Google Calendar for today."""
    now = datetime.utcnow()
    time_min = now.replace(hour=0, minute=0, second=0, microsecond=0).isoformat() + 'Z'
    time_max = (now + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0).isoformat() + 'Z'
    
    url = f"https://www.googleapis.com/calendar/v3/calendars/{CALENDAR_ID}/events"
    params = {
        'key': GOOGLE_API_KEY,
        'timeMin': time_min,
        'timeMax': time_max,
        'singleEvents': True,
        'orderBy': 'startTime'
    }
    
    try:
        response = requests.get(url, params=params)
        response.raise_for_status()  # This will raise an error for bad responses (4xx or 5xx)
        events = response.json().get('items', [])
        print(f"Found {len(events)} events for today.")
        return events
    except requests.exceptions.RequestException as e:
        print(f"Error fetching calendar events: {e}")
        return []

def update_slack_status(user_id, status_text, status_emoji):
    """Updates a user's Slack status."""
    url = 'https://slack.com/api/users.profile.set'
    headers = {
        'Authorization': f'Bearer {SLACK_BOT_TOKEN}',
        'Content-Type': 'application/json; charset=utf-8'
    }
    # Status expiration is set to 0 to make it stick until cleared.
    # We could build a more advanced version to auto-clear it.
    profile_data = {
        'profile': {
            'status_text': status_text,
            'status_emoji': status_emoji,
            'status_expiration': 0
        },
        'user': user_id
    }
    
    try:
        response = requests.post(url, headers=headers, json=profile_data)
        response.raise_for_status()
        result = response.json()
        if result.get('ok'):
            print(f"Successfully updated status for user {user_id}.")
        else:
            print(f"Failed to update status for {user_id}: {result.get('error')}")
    except requests.exceptions.RequestException as e:
        print(f"Error updating Slack status: {e}")
        return

def main():
    """Main function to run the sync process."""
    print("Starting vacation sync script...")
    events = get_calendar_events()
    
    if not events:
        print("No events today. Exiting.")
        return

    for event in events:
        # The 'summary' is the title of the calendar event.
        event_title = event.get('summary', '').strip()
        
        # Check if the event title matches someone in our mapping
        if event_title in USER_MAPPING:
            user_id = USER_MAPPING[event_title]
            print(f"Match found: '{event_title}' corresponds to user ID {user_id}.")
            update_slack_status(user_id, "On vacation", ":palm_tree:")
        else:
            print(f"No user mapping found for event: '{event_title}'. Skipping.")

if __name__ == "__main__":
    main()

Step 4: Schedule the Script

A script is only useful if it runs automatically. For a simple setup, a cron job on a reliable server is perfect. If you’re more comfortable with cloud services, an AWS Lambda or Google Cloud Function on a daily schedule is a more robust solution.

To run this every day at 2:00 AM, you’d set up a cron job like this. Note that I’m not using a full path to the interpreter to avoid common WAF issues, but in a real system, you’d want to be specific.

0 2 * * * python3 your_script_name.py

Common Pitfalls (Where I Usually Mess Up)

• Incorrect Slack Scopes: The most common error is forgetting to add the users.profile:write scope to the Slack App. If you get an “error: missing_scope”, this is your problem.
• Timezone Mismatches: A server in UTC fetching events for a calendar in PST can lead to statuses being set a day early or late. I recommend standardizing everything in UTC (as the script does with datetime.utcnow()) to avoid headaches.
• Brittle Name Matching: My first version tried to parse “Alex OOO” from the calendar. It broke the moment someone wrote “Alex out” or used a nickname. The USER_MAPPING dictionary is not optional—it’s the only reliable way to do this.
• API Rate Limits: If you run this script too frequently or for a massive team, you might hit Slack’s API rate limits. For a daily check, this is rarely an issue, but it’s something to be aware of.

Conclusion

And that’s it. With a simple Python script and a bit of configuration, you’ve created a resilient system that improves team-wide visibility and cuts down on unnecessary noise. It’s a small investment of time that pays off every single day someone on your team takes a well-deserved break. It’s a perfect example of how a little DevOps automation can make everyone’s life easier.

Happy automating!

– Darian

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions