Darian Vance

Posted on Jan 24 • Originally published at wp.me

Solved: Archive Old Slack Channels Automatically using Python API

#devops #programming #tutorial #cloud

🚀 Executive Summary

TL;DR: Slack workspaces often become cluttered with inactive channels, hindering information discovery and impacting performance. This guide provides a Python script leveraging the Slack API to automatically identify and archive old, inactive channels, ensuring a consistently organized and efficient communication environment.

🎯 Key Takeaways

To automate Slack channel archiving, a Slack App requires a Bot User OAuth Token with channels:read, channels:join, and channels:archive scopes.
The Python script utilizes the slack\_sdk library for API interaction and python-dotenv for securely loading the SLACK\_BOT\_TOKEN from environment variables.
Channel eligibility for archiving is determined by comparing its updated timestamp (last activity) from conversations\_info against a CHANNEL\_AGE\_DAYS\_THRESHOLD, while exempting critical channels like general.
The ARCHIVE\_DRY\_RUN configuration is a crucial safety switch, allowing testing of channel identification logic without performing actual archival.
Automation can be achieved by scheduling the Python script to run periodically using a task scheduler like Cron on Linux systems.

Archive Old Slack Channels Automatically using Python API

Introduction

In the fast-paced world of DevOps and software development, Slack has become an indispensable communication tool. However, as teams grow and projects evolve, Slack workspaces can quickly become cluttered with inactive or obsolete channels. This digital detritus can make it difficult for users to find relevant information, create a sense of information overload, and even impact performance over time. Manually sifting through and archiving these channels is a tedious and time-consuming task.

Fortunately, the Slack API offers a robust solution for automation. This tutorial will guide SysAdmins, Developers, and DevOps Engineers through creating a Python script that automatically identifies and archives old, inactive Slack channels, ensuring your workspace remains organized, efficient, and clutter-free. By the end of this guide, you’ll have a scheduled process to keep your Slack instance tidy without manual intervention.

Prerequisites

Before we dive into the automation, ensure you have the following:

Slack Workspace with Admin/Owner Privileges: You’ll need the ability to create a Slack App and manage its permissions.
Slack API Token: A Bot User OAuth Token with specific permissions (scopes) to read and archive channels.
Python 3: Installed on your system.
Python Libraries: The slack_sdk library for interacting with the Slack API, and python-dotenv for managing environment variables.
Basic Python Knowledge: Familiarity with Python scripting and command-line execution.

Step-by-Step Guide

Step 1: Obtain Your Slack API Token and Set Up Your Environment

To interact with your Slack workspace, you need an API token. We’ll create a Slack App specifically for this purpose and grant it the necessary permissions.

Create a Slack App:
- Go to api.slack.com/apps and click “Create New App”.
- Choose “From scratch”, give your app a name (e.g., “Channel Archiver Bot”), and select your Slack workspace.
Add OAuth Scopes:
- In your app’s settings, navigate to “OAuth & Permissions” under “Features”.
- Scroll down to “Bot Token Scopes” and add the following scopes:
  - channels:read (to list channels)
  - channels:join (sometimes needed to read details of private channels, though not always strictly required for archiving)
  - channels:archive (to archive channels)
Install App to Workspace and Obtain Token:
- At the top of the “OAuth & Permissions” page, click “Install to Workspace”.
- Authorize the app.
- Once installed, you’ll see your “Bot User OAuth Token” (starts with xoxb-). Copy this token; it’s sensitive and should be kept secure.
Set Up Environment Variables:

It’s best practice to store your Slack token securely using environment variables or a configuration file. For local development, a config.env file is suitable.

Create a file named config.env in your script’s directory and add your token:

   SLACK_BOT_TOKEN="xoxb-[YOUR_SLACK_BOT_TOKEN_HERE]"

Replace [YOUR_SLACK_BOT_TOKEN_HERE] with the actual token you copied. Remember to add config.env to your .gitignore if using version control.

Install Python Libraries:

Open your terminal and install the required Python packages:

   python3 -m pip install slack_sdk python-dotenv

Step 2: Develop the Python Script for Archiving

Now, let’s write the Python script that will fetch channels, filter them, and perform the archiving.

Create a file named archive_slack_channels.py:

import os
from datetime import datetime, timedelta
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from dotenv import load_dotenv

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

# Slack Bot Token
SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")

if not SLACK_BOT_TOKEN:
    print("Error: SLACK_BOT_TOKEN not found in environment variables or config.env")
    exit(1)

client = WebClient(token=SLACK_BOT_TOKEN)

# Configuration
CHANNEL_AGE_DAYS_THRESHOLD = 90 # Archive channels inactive for 90 days
EXEMPT_CHANNELS = [
    "general",
    "random",
    "announcements",
    # Add other critical channels by name here
]
ARCHIVE_DRY_RUN = True # Set to False to actually archive channels

def get_all_channels():
    """Fetches all public and private channels."""
    all_channels = []
    cursor = None
    while True:
        try:
            response = client.conversations_list(
                types="public_channel,private_channel",
                exclude_archived=True,
                limit=200,
                cursor=cursor
            )
            all_channels.extend(response["channels"])
            cursor = response["response_metadata"].get("next_cursor")
            if not cursor:
                break
        except SlackApiError as e:
            print(f"Error fetching channels: {e.response['error']}")
            break
    return all_channels

def get_channel_info(channel_id):
    """Fetches detailed information for a specific channel."""
    try:
        response = client.conversations_info(channel=channel_id)
        return response["channel"]
    except SlackApiError as e:
        # Channels the bot is not in might raise 'channel_not_found' or 'not_in_channel'
        # Try joining if it's a private channel and we need more info
        if e.response['error'] == 'not_in_channel':
            print(f"Bot not in private channel {channel_id}. Attempting to join...")
            try:
                client.conversations_join(channel=channel_id)
                response = client.conversations_info(channel=channel_id)
                return response["channel"]
            except SlackApiError as join_e:
                print(f"Failed to join or get info for {channel_id}: {join_e.response['error']}")
                return None
        print(f"Error getting info for channel {channel_id}: {e.response['error']}")
        return None

def is_channel_eligible_for_archive(channel):
    """Checks if a channel should be archived based on its activity."""
    channel_name = channel.get("name", "unknown-channel").lower()
    channel_id = channel.get("id")

    if channel_name in EXEMPT_CHANNELS:
        print(f"Skipping exempt channel: #{channel_name}")
        return False

    # Check if the channel is already archived (should be excluded by conversations_list, but good to double check)
    if channel.get("is_archived"):
        print(f"Skipping already archived channel: #{channel_name}")
        return False

    # For public channels, last activity can often be derived from 'latest' message timestamp
    # For private channels, or if 'latest' is unreliable, conversations_history might be needed,
    # but that's expensive. We'll rely on 'updated' if 'latest' is not present or too old.

    # Use the 'updated' timestamp from conversations_info if available,
    # as 'latest' in conversations_list might only reflect messages seen by the bot,
    # or sometimes not be present for older channels.
    # The 'updated' field often reflects the last message activity, not just channel metadata updates.

    # Fetch detailed info to get a more reliable 'updated' timestamp
    detailed_channel_info = get_channel_info(channel_id)
    if not detailed_channel_info:
        print(f"Could not get detailed info for channel #{channel_name}, skipping.")
        return False

    last_activity_timestamp = detailed_channel_info.get("updated")

    if last_activity_timestamp:
        # Slack timestamps are floats (e.g., 1678886400.123456)
        last_activity_time = datetime.fromtimestamp(last_activity_timestamp)
        age_threshold_time = datetime.now() - timedelta(days=CHANNEL_AGE_DAYS_THRESHOLD)

        if last_activity_time < age_threshold_time:
            print(f"Channel #{channel_name} (ID: {channel_id}) was last active on {last_activity_time.strftime('%Y-%m-%d')}. Eligible for archive.")
            return True
        else:
            print(f"Channel #{channel_name} (ID: {channel_id}) was last active on {last_activity_time.strftime('%Y-%m-%d')}. Not old enough.")
            return False
    else:
        print(f"Could not determine last activity for channel #{channel_name} (ID: {channel_id}), skipping.")
        return False

def archive_channel(channel_id, channel_name):
    """Archives a given Slack channel."""
    if ARCHIVE_DRY_RUN:
        print(f"DRY RUN: Would archive channel #{channel_name} (ID: {channel_id})")
        return

    try:
        response = client.conversations_archive(channel=channel_id)
        if response["ok"]:
            print(f"Successfully archived channel: #{channel_name} (ID: {channel_id})")
        else:
            print(f"Failed to archive channel #{channel_name} (ID: {channel_id}): {response['error']}")
    except SlackApiError as e:
        print(f"Error archiving channel #{channel_name} (ID: {channel_id}): {e.response['error']}")

def main():
    print("Starting Slack channel archive process...")

    channels = get_all_channels()
    if not channels:
        print("No channels found or error retrieving channels. Exiting.")
        return

    print(f"Found {len(channels)} active channels.")

    for channel in channels:
        if is_channel_eligible_for_archive(channel):
            archive_channel(channel["id"], channel.get("name", "unknown"))

    print("Slack channel archive process completed.")
    if ARCHIVE_DRY_RUN:
        print("NOTE: This was a DRY RUN. No channels were actually archived. Set ARCHIVE_DRY_RUN = False to enable archiving.")

if __name__ == "__main__":
    main()

Code Logic Explanation:

Environment Variables: We use python-dotenv to load our SLACK_BOT_TOKEN from config.env, keeping sensitive information out of the main script.
Slack Client Initialization: WebClient(token=SLACK_BOT_TOKEN) creates an instance to interact with the Slack API.
Configuration:
- CHANNEL_AGE_DAYS_THRESHOLD: Defines how many days of inactivity make a channel eligible for archiving.
- EXEMPT_CHANNELS: A list of channel names (case-insensitive) that should never be archived, like #general.
- ARCHIVE_DRY_RUN: A critical safety switch. When True, the script will only print what it would do without actually archiving anything. Set it to False only when you are confident in your configuration and testing.
get_all_channels(): Uses client.conversations_list to retrieve all public and private channels, excluding those already archived. It handles pagination to ensure all channels are fetched.
get_channel_info(channel_id): Fetches detailed information about a specific channel. This is crucial because the conversations_list might not always provide the most up-to-date activity timestamp. For private channels the bot isn’t in, it attempts to join to gain access to its details.
is_channel_eligible_for_archive(channel): This is the core logic.
- It first checks if the channel is in the EXEMPT_CHANNELS list.
- It fetches detailed channel info and extracts the updated timestamp, which typically reflects the last message activity.
- It compares this timestamp with the current time minus the CHANNEL_AGE_DAYS_THRESHOLD to determine if the channel is old enough.
archive_channel(channel_id, channel_name): If ARCHIVE_DRY_RUN is False, this function calls client.conversations_archive to perform the actual archival.
main(): Orchestrates the process by getting all channels, iterating through them, checking eligibility, and archiving if appropriate.

Step 3: Test Your Script

Before automating, it’s vital to test your script thoroughly. Start with ARCHIVE_DRY_RUN = True to ensure it identifies the correct channels without making any changes.

Save the Python script as archive_slack_channels.py.
Ensure your config.env file is in the same directory.
Run the script from your terminal:

   python3 archive_slack_channels.py

Review the output carefully. It should list channels it would archive (in dry run mode) and channels it’s skipping, along with reasons.
Once you are confident the script identifies the correct channels, change ARCHIVE_DRY_RUN = True to ARCHIVE_DRY_RUN = False in your script.
Crucial: Create a few dummy channels in your Slack workspace, let them sit for a day or two, and then adjust CHANNEL_AGE_DAYS_THRESHOLD to a very low number (e.g., 1 or 2) for testing. Run the script again (with ARCHIVE_DRY_RUN = False) to confirm it archives these test channels.
After successful testing, revert CHANNEL_AGE_DAYS_THRESHOLD to your desired production value (e.g., 90 days).

Step 4: Automate with a Scheduler

To run this script regularly without manual intervention, we can use a task scheduler like Cron on Linux systems.

Prepare for Automation:

Ensure your archive_slack_channels.py script is in a stable location, for example, /home/user/scripts/archive_slack_channels.py.

For cron jobs, it’s often better to explicitly set environment variables within the cron entry or ensure the script itself loads them. Since we’re using python-dotenv, having config.env alongside your script is sufficient.

Create a Cron Job:

Open your cron editor:

   Open your cron editor

Add the following line to schedule the script to run every Monday at 3:00 AM:

   0 3 * * 1 python3 /home/user/scripts/archive_slack_channels.py

Let’s break down the cron syntax:

0: Minute (0 past the hour)
3: Hour (3 AM)
*: Day of month (every day)
*: Month (every month)
1: Day of week (Monday, where 0=Sunday, 1=Monday)

This entry tells Cron to execute your Python script using the python3 interpreter at the specified time. Ensure the path to your script is correct.

Verify Cron Job:

After saving your cron entry, you can verify it by listing your cron jobs:

   crontab -l

Monitor your Slack workspace and logs (if you add logging to the script) to ensure the script runs as expected on its first scheduled execution.

Common Pitfalls

Even with careful planning, issues can arise during automation:

Incorrect API Token Permissions: The most common issue. If your bot token lacks the necessary scopes (e.g., channels:archive), the script will fail with permission errors from the Slack API. Double-check your app’s “OAuth & Permissions” settings.
Channel Exemptions and Configuration Errors: Forgetting to add critical channels (like #general, #announcements, or specific incident management channels) to the EXEMPT_CHANNELS list can lead to unintended archival. Always test with ARCHIVE_DRY_RUN = True and review the output meticulously. Similarly, setting the CHANNEL_AGE_DAYS_THRESHOLD too low can cause active channels to be archived prematurely.
Private Channel Access: The bot needs to be a member of a private channel to fetch its detailed information or archive it. Our script attempts to join, but if there are specific restrictions on bot joining in your workspace, this might fail. Ensure your Slack App has the ability to join channels.

Conclusion

Automating the archival of old Slack channels is a significant step towards maintaining a clean, efficient, and user-friendly communication environment. By leveraging the Slack API and a simple Python script, you can prevent channel sprawl, reduce clutter, and improve information discoverability without constant manual oversight. This solution empowers your teams to focus on productive work, knowing that their digital workspace is being proactively managed.

Feel free to customize the script further – perhaps by adding robust logging, notification mechanisms (e.g., posting to an admin channel about archived channels), or integrating with a database to track channel activity more persistently. Embrace automation and keep your Slack workspace tidy!