Syncing Monday.com Status Updates to Microsoft Teams Channel

Alright, let’s talk about connecting the dots. For a while, our project tracking in Monday.com felt disconnected from our real-time comms in Microsoft Teams. I was manually cross-referencing board statuses before our daily stand-ups, and frankly, it was a time sink. I realized I was wasting at least a couple of hours a week just on that manual check. This guide is the result of automating that process. We’re going to build a simple but robust Python script that polls a Monday.com board for status changes and pushes a neat, formatted notification to a Teams channel. It’s a classic “set it and forget it” solution that brings crucial updates directly into your team’s workflow.

Prerequisites

Before we dive in, make sure you have the following ready to go:

• Monday.com API Key: You’ll need a v2 API key. You can get this from the “Developers” section in your Monday.com avatar menu.
• Monday.com Board ID & Column ID: You need the ID of the board you want to track and the specific ID of the status column. To find the board ID, just look at the URL when you have the board open. The column ID is a bit trickier; you can find it using the API playground in the Developers section.
• Microsoft Teams Incoming Webhook URL: In the Teams channel you want to post to, go to “Connectors,” search for “Incoming Webhook,” and configure one. It’ll give you a unique URL. Guard this URL; it’s a secret.
• Python 3 Environment: I’m assuming you have Python 3 installed. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Let’s jump straight to the logic. You will need to install a couple of libraries, which you can do by running python3 -m pip install requests python-dotenv in your terminal.

The Guide: Step-by-Step

Step 1: Secure Your Credentials

First things first, let’s get our secrets in order. Create a project directory. Inside, we’ll make two files: one for our Python script and one for our environment variables. I call my configuration file config.env to avoid issues with some deployment tools that treat `.env` files specially.

Your config.env file should look like this. Just paste your credentials in here.

# Monday.com Credentials
MONDAY_API_KEY="your_actual_monday_api_key_here"
MONDAY_BOARD_ID="1234567890"
MONDAY_COLUMN_ID="status" # e.g., "status", "status4", etc.

# Microsoft Teams Credentials
TEAMS_WEBHOOK_URL="your_teams_webhook_url_here"

Step 2: The Python Script Logic

Now for the main event. Create a file named sync_updates.py. We’ll build this out function by function to keep it clean. The goal is simple: fetch data from Monday, check for items with a specific status, format a message, and post it to Teams.

Here’s the full script. I’ll break down what each part does below.

import os
import requests
import json
from dotenv import load_dotenv

def load_configuration():
    """Loads environment variables from config.env."""
    load_dotenv('config.env')
    config = {
        "api_key": os.getenv("MONDAY_API_KEY"),
        "board_id": os.getenv("MONDAY_BOARD_ID"),
        "column_id": os.getenv("MONDAY_COLUMN_ID"),
        "teams_webhook": os.getenv("TEAMS_WEBHOOK_URL")
    }
    # Basic validation
    for key, value in config.items():
        if not value:
            print(f"Error: Missing configuration for {key.upper()} in config.env")
            return None
    return config

def get_monday_items_by_status(config, status_value):
    """Fetches items from a Monday.com board that match a specific status."""
    api_url = "https://api.monday.com/v2"
    headers = {"Authorization": config["api_key"]}
    
    # GraphQL query to get items where the status column matches our target value
    query = f'''
    query {{
        items_by_column_values (
            board_id: {config["board_id"]}, 
            column_id: "{config["column_id"]}", 
            column_value: "{status_value}"
        ) {{
            id
            name
            updates(limit: 1) {{
                body
            }}
        }}
    }}
    '''
    
    data = {'query': query}
    
    try:
        response = requests.post(url=api_url, json=data, headers=headers)
        response.raise_for_status() # Raise an exception for bad status codes
        return response.json().get('data', {}).get('items_by_column_values', [])
    except requests.exceptions.RequestException as e:
        print(f"Error fetching data from Monday.com: {e}")
        return []

def format_teams_message(items):
    """Formats the list of items into a Microsoft Teams Adaptive Card."""
    if not items:
        return None

    facts = []
    for item in items:
        # Get the latest update text, default to 'No recent update.'
        latest_update = "No recent update."
        if item.get('updates'):
            # The body is HTML, so we need to strip tags for a clean look
            update_body = item['updates'][0].get('body', '')
            # A simple way to strip HTML for this example
            clean_body = update_body.replace('<p>', '').replace('</p>', '').replace('<br />', ' ')
            latest_update = clean_body if clean_body else "Update body was empty."

        facts.append({
            "title": f"Item: {item['name']}",
            "value": f"Latest Update: {latest_update}"
        })

    message = {
        "@type": "MessageCard",
        "@context": "http://schema.org/extensions",
        "themeColor": "0076D7", # A nice blue
        "summary": "Monday.com Status Update",
        "sections": [{
            "activityTitle": "Monday.com Items Requiring Attention!",
            "activitySubtitle": "The following items have been marked as 'Needs Review'",
            "facts": facts,
            "markdown": True
        }]
    }
    return message

def post_to_teams(webhook_url, message):
    """Posts the formatted message to the Teams webhook."""
    if not message:
        print("No message to post. Skipping Teams notification.")
        return

    headers = {"Content-Type": "application/json"}
    try:
        response = requests.post(webhook_url, data=json.dumps(message), headers=headers)
        response.raise_for_status()
        print("Successfully posted update to Teams.")
    except requests.exceptions.RequestException as e:
        print(f"Error posting to Teams: {e}")

def main():
    """Main execution function."""
    print("Starting Monday.com to Teams sync process...")
    config = load_configuration()
    if not config:
        print("Halting execution due to missing configuration.")
        return

    # Define the status you're looking for. e.g., "Stuck", "Needs Review", etc.
    target_status = "Needs Review" 
    
    items = get_monday_items_by_status(config, target_status)
    
    if not items:
        print(f"No items found with status '{target_status}'. All good!")
        return
        
    print(f"Found {len(items)} items with status '{target_status}'.")
    teams_message = format_teams_message(items)
    post_to_teams(config["teams_webhook"], teams_message)
    print("Sync process finished.")

if __name__ == "__main__":
    main()

Pro Tip: The GraphQL query is the heart of this script. In my production setups, I often make it more complex. For instance, you can filter by group or query multiple column values at once. The Monday.com API playground is your best friend for building and testing these queries before putting them into the code.

Step 3: Breaking Down the Logic

• load_configuration(): This is straightforward. It uses python-dotenv to load the variables from our config.env file. I added some basic validation to ensure we don’t run the script with missing keys.
• get_monday_items_by_status(): This function sends the GraphQL query to the Monday.com API. We’re using the items_by_column_values query, which is perfect for this use case. It returns only the items where the status column matches our target value (e.g., “Needs Review”). I also included basic error handling for network issues.
• format_teams_message(): Raw JSON data isn’t very readable. This function takes the list of items from Monday and transforms it into a nicely formatted Microsoft Teams “Adaptive Card”. It creates a clear summary with a title and a value for each item found.
• post_to_teams(): This simply takes the formatted message and sends an HTTP POST request to the Teams webhook URL you provided.
• main(): This is the conductor. It calls the other functions in order, defines the target status you want to search for, and prints some helpful status messages to the console.

Step 4: Scheduling the Automation

You don’t want to run this manually. The whole point is automation. The simplest way on a Linux-based system is a cron job. You could set it to run every morning at 8 AM, for instance.

A basic cron entry would look like this. Remember, in production, you’d likely use a more sophisticated orchestrator like Airflow, Prefect, or a serverless function (AWS Lambda, Azure Functions), but cron is perfect for getting started.

0 8 * * * python3 /path/to/your/project/sync_updates.py

Just make sure the path to the script is correct for your system.

Common Pitfalls

I’ve set this up a few times, and here’s where I usually mess up, so you can avoid it:

• Incorrect Board/Column ID: This is the most common error. Double-check them. A quick way to verify is to use the Monday.com API playground to run a simple query for your board’s columns to see their real IDs.
• API Key Permissions: Ensure your API key has the necessary read permissions for the board you’re trying to access. If it doesn’t, the API will just return empty or error responses.
• Teams Webhook JSON Is Malformed: Teams is picky about the JSON it receives. If you modify the `format_teams_message` function, test your new JSON structure in the Adaptive Card Designer first. It saves a lot of headaches.
• Firewall/Proxy Issues: In corporate environments, outbound requests can sometimes be blocked. If your script can’t reach the Monday.com or Teams URLs, check with your network team. It’s a classic “is it plugged in?” problem that can be easy to overlook.

Conclusion

And that’s it. You now have a reliable, automated bridge between your project management tool and your communication hub. This script is a solid foundation. You can easily extend it to handle different statuses, post to different channels, or even include links back to the Monday.com items in the Teams message. The real win here is reclaiming your time and keeping your team informed without the manual busywork. Happy automating!

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