Syncing Figma Comments to Slack for Better Design Ops

Hey there, Darian Vance here. Let me tell you about a sprint we had last quarter. A critical piece of feedback on a new UI component was missed for two full days because the right people just weren’t living inside Figma. By the time we saw it, we had to scramble. That’s when I decided to stop relying on manual checks and build a simple integration to pipe Figma comments directly into our team’s Slack channel. It turned a point of friction into a smooth, automated workflow, and it’s probably saved us dozens of hours since.

This isn’t about adding more noise to Slack; it’s about putting the right information in front of the right people at the right time. Let’s build it.

Prerequisites

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

• A Figma Personal Access Token: You’ll need this to let our script talk to the Figma API.
• A Slack Incoming Webhook URL: This is how our script will post messages to your chosen Slack channel.
• Python 3: The script is written in Python. I assume you have it installed.
• Your Figma File Key: This is the long string of characters in your Figma file’s URL.

The Guide: Step-by-Step

Step 1: Getting Your Credentials

First, we need to get our keys. In Figma, go to your account settings, find the ‘Personal access tokens’ section, and generate a new token with ‘File content’ read permissions. Copy this somewhere safe.

Next, in Slack, go to the App Directory, search for ‘Incoming Webhooks,’ and add it to your workspace. Choose the channel you want the notifications to go to and copy the generated Webhook URL.

Step 2: Setting Up the Project

I’ll skip the standard virtual environment setup, as you likely have your own workflow for that. Let’s focus on the files and dependencies. You’ll need to install a couple of Python libraries. You can do this by running a pip install command for ‘requests’ and ‘python-dotenv’.

Your project directory should have three files:

• sync_figma.py: Our main script.
• config.env: Where we’ll store our secret keys.
• last_run.txt: A simple text file to track the last time we checked for comments.

Create the config.env file and add your credentials like this:

FIGMA_TOKEN="your_figma_personal_access_token"
SLACK_WEBHOOK_URL="your_slack_webhook_url"
FIGMA_FILE_KEY="your_figma_file_key"

Step 3: The Python Script

Alright, let’s get to the core logic. Open up sync_figma.py and let’s build this piece by piece. The goal is simple: fetch comments created since our last check, format them nicely, and send them to Slack.

Here is the complete script. I’ve added comments to explain what each part does.

import os
import requests
import json
from datetime import datetime, timezone, timedelta
from dotenv import load_dotenv

# Load environment variables from config.env
load_dotenv('config.env')

FIGMA_TOKEN = os.getenv('FIGMA_TOKEN')
SLACK_WEBHOOK_URL = os.getenv('SLACK_WEBHOOK_URL')
FIGMA_FILE_KEY = os.getenv('FIGMA_FILE_KEY')
STATE_FILE = 'last_run.txt'

def get_last_run_timestamp():
    """Reads the timestamp from our state file."""
    try:
        with open(STATE_FILE, 'r') as f:
            return f.read().strip()
    except FileNotFoundError:
        # If the file doesn't exist, we'll check the last 24 hours.
        return (datetime.now(timezone.utc) - timedelta(hours=24)).isoformat()

def set_last_run_timestamp():
    """Writes the current UTC time to our state file."""
    with open(STATE_FILE, 'w') as f:
        f.write(datetime.now(timezone.utc).isoformat())

def fetch_figma_comments(since_timestamp):
    """Fetches new comments from the Figma API."""
    url = f"https://api.figma.com/v1/files/{FIGMA_FILE_KEY}/comments"
    headers = {'X-Figma-Token': FIGMA_TOKEN}
    
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status() # This will raise an error for bad responses (4xx or 5xx)
        all_comments = response.json().get('comments', [])
        
        # Filter comments to only include those created after our last run
        new_comments = [
            comment for comment in all_comments
            if comment['created_at'] > since_timestamp
        ]
        return new_comments
    except requests.exceptions.RequestException as e:
        print(f"Error fetching from Figma API: {e}")
        return []

def format_slack_message(comment):
    """Formats a Figma comment into a Slack-friendly message."""
    user = comment['user']['handle']
    message = comment['message']
    timestamp = comment['created_at']
    
    # Create a direct link to the Figma file
    file_url = f"https://www.figma.com/file/{FIGMA_FILE_KEY}"
    
    return {
        'text': f"New Figma Comment from *{user}*",
        'blocks': [
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f":figma: *New Comment in Figma from {user}*\n>{message}"
                }
            },
            {
                "type": "context",
                "elements": [
                    {
                        "type": "mrkdwn",
                        "text": f"Posted at: {timestamp} | <{file_url}|Open File>"
                    }
                ]
            }
        ]
    }

def post_to_slack(payload):
    """Sends the formatted message to our Slack channel."""
    try:
        response = requests.post(SLACK_WEBHOOK_URL, data=json.dumps(payload), headers={'Content-Type': 'application/json'})
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        print(f"Error posting to Slack: {e}")

def main():
    """Main function to orchestrate the sync."""
    print("Checking for new Figma comments...")
    last_run = get_last_run_timestamp()
    new_comments = fetch_figma_comments(last_run)
    
    if not new_comments:
        print("No new comments found.")
        return

    print(f"Found {len(new_comments)} new comments. Posting to Slack.")
    # We sort them to post in chronological order
    for comment in sorted(new_comments, key=lambda c: c['created_at']):
        slack_payload = format_slack_message(comment)
        post_to_slack(slack_payload)
    
    # Important: Update the timestamp only after successfully processing
    set_last_run_timestamp()
    print("Successfully synced comments and updated timestamp.")

if __name__ == "__main__":
    main()

Pro Tip: For my production setups, I don’t use a simple text file for the `last_run` state. I’d recommend a small SQLite database or even a cloud-based key-value store like AWS S3 or a Redis instance. But for getting started, a text file is perfectly fine and easy to debug.

Step 4: Scheduling the Script

The final step is to automate it. We don’t want to run this manually. A cron job is the classic way to handle this. You can set it up to run every 15 minutes, every hour, or whatever cadence makes sense for your team.

To run the script every hour, your cron entry would look something like this. Remember, do not include absolute paths that start with a slash.

0 * * * * python3 sync_figma.py

You’ll need to consult your system’s documentation for the best way to add this cron job. Make sure the command runs from within your project directory so it can find the script and config files.

Common Pitfalls

I’ve set this up a few times, and here’s where I usually trip up:

• Timezone Mismatches: The Figma API uses UTC (ISO 8601 format). My script is built to handle this, but if you modify it, be very careful with timezones. It’s the number one cause of missed or duplicate notifications.
• Incorrect Figma File Key: Double-check you’ve copied the entire key from the URL. If it’s wrong, the API will return a 404 Not Found error.
• Token Permissions: A 403 Forbidden error usually means your Figma token doesn’t have the required ‘file read’ permissions. Go back and generate a new one with the correct scope.
• State File Errors: If the script fails after posting to Slack but *before* updating `last_run.txt`, it will post duplicates on the next run. That’s why the `set_last_run_timestamp()` call is the very last thing we do in the main function.

Conclusion

And that’s it. With a simple Python script and a cron job, you’ve bridged a common communication gap between design and development. This kind of small-scale automation is what DevOps is all about—finding those little points of friction and smoothing them over so the team can focus on what they do best.

You’ve now got a reliable way to ensure design feedback is seen quickly, keeping your projects moving forward without anyone having to manually poll for updates. Give it a try and see how it improves your team’s workflow.

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