Create Jira Tickets from Slack Emojis reactions

Hey team, Darian Vance here.

Let’s talk about a common problem. You’re in a busy Slack channel like `#dev-alerts` or `#customer-feedback`, and a critical message scrolls by. Someone notes it needs action, but it gets lost in the noise. Hours later, you’re scrolling back, trying to find it. I used to lose at least an hour a week just chasing these lost-in-the-shuffle action items.

This guide is about reclaiming that time. We’re going to build a simple but powerful Python script that scans a Slack channel for messages reacted to with a specific emoji (like a 🎫) and automatically creates a Jira ticket for it. No more context switching, no more manual copy-pasting. Just react and trust that it’s been logged.

Prerequisites

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

• A Slack Bot Token with the right permissions (we’ll cover scopes below).
• A Jira API Token and your email address associated with it.
• Your Jira Instance URL (e.g., `https://your-company.atlassian.net`).
• The Jira Project Key where tickets will be created (e.g., ‘DEV’).
• The Slack Channel ID you want to monitor.
• Python 3 installed on the machine where this will run.

The Guide: Step-by-Step

Step 1: Set Up Your Environment and Config

I’ll skip the standard virtual environment setup since you likely have your own workflow for that. The important part is to get the necessary Python libraries installed. In your activated environment, you’ll want to run a pip command to install `slack_sdk`, `jira`, and `python-dotenv`.

Next, let’s handle our secrets securely. Create a file in your project directory named config.env. Never commit this file to source control! Add it to your `.gitignore` immediately. This is where we’ll store our credentials.

# config.env - Your secret credentials
SLACK_BOT_TOKEN="xoxb-your-slack-bot-token"
JIRA_SERVER="https://your-company.atlassian.net"
JIRA_USERNAME="your-email@example.com"
JIRA_API_TOKEN="your-jira-api-token"
JIRA_PROJECT_KEY="DEV"
SLACK_CHANNEL_ID="C0123456789"

Step 2: The Python Script – Initialization and Authentication

Now for the fun part. Let’s create our Python script, which I’ll call slack_to_jira.py. We’ll start by importing the libraries and loading our credentials from the config.env file. This keeps our code clean and our secrets out of the script itself.

import os
from dotenv import load_dotenv
from slack_sdk import WebClient
from jira import JIRA

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

# --- CONFIGURATION ---
SLACK_TOKEN = os.getenv("SLACK_BOT_TOKEN")
JIRA_URL = os.getenv("JIRA_SERVER")
JIRA_USER = os.getenv("JIRA_USERNAME")
JIRA_TOKEN = os.getenv("JIRA_API_TOKEN")
JIRA_PROJECT = os.getenv("JIRA_PROJECT_KEY")
CHANNEL_ID = os.getenv("SLACK_CHANNEL_ID")

REACTION_TO_TRACK = "ticket" # The emoji name without the colons
PROCESSED_REACTION = "white_check_mark" # Emoji to show we're done

# --- INITIALIZE CLIENTS ---
try:
    slack_client = WebClient(token=SLACK_TOKEN)
    jira_client = JIRA(
        server=JIRA_URL,
        basic_auth=(JIRA_USER, JIRA_TOKEN)
    )
    print("Successfully connected to Slack and Jira.")
except Exception as e:
    print(f"Error connecting to services: {e}")
    # In a real script, you'd probably want to return here.

Step 3: Finding Messages That Need a Ticket

The core of our script is to fetch recent messages and check their reactions. We’ll use Slack’s conversations_history method. The logic is simple: iterate through messages, see if they have the 🎫 reaction, and if so, check if we’ve already processed it (to avoid creating duplicate tickets).

Pro Tip: The limit parameter in conversations_history is your friend. You don’t need to pull the entire channel history every time. Fetching the last 50-100 messages is usually sufficient if you run the script every 15-30 minutes.

def find_and_process_messages():
    try:
        # Get the last 50 messages from the channel
        result = slack_client.conversations_history(channel=CHANNEL_ID, limit=50)
        messages = result.get("messages", [])

        for message in messages:
            # Check if the message has reactions
            if "reactions" in message:
                reaction_names = [r["name"] for r in message["reactions"]]
                
                # Check for our target emoji and ensure it hasn't been processed
                if REACTION_TO_TRACK in reaction_names and PROCESSED_REACTION not in reaction_names:
                    print(f"Found a message to process: {message['text'][:30]}...")
                    create_jira_ticket(message)

    except Exception as e:
        print(f"An error occurred while fetching messages: {e}")

# We will define create_jira_ticket next

Step 4: Creating the Jira Ticket

Once we’ve identified a message, we create the Jira ticket. I like to format it nicely: the first line of the Slack message becomes the Jira summary, and the full text, plus a link back to the message, becomes the description. After successfully creating the ticket, we add a ✅ reaction to the Slack message. This is our “do not process again” flag.

def create_jira_ticket(message):
    message_ts = message["ts"]
    message_text = message.get("text", "No text content in message.")
    user_id = message.get("user", "UnknownUser")

    try:
        # Get a permalink to the Slack message
        permalink_response = slack_client.chat_getPermalink(channel=CHANNEL_ID, message_ts=message_ts)
        permalink = permalink_response["permalink"]

        # Format the Jira issue
        summary = f"Slack Request: {message_text.splitlines()[0][:80]}"
        description = (
            f"A new request was logged from Slack.\n\n"
            f"h2. Original Message:\n"
            f"{message_text}\n\n"
            f"h2. Slack Context:\n"
            f"*Reported by:* <@${user_id}>\n"
            f"*Link to message:* {permalink}"
        )

        issue_dict = {
            'project': {'key': JIRA_PROJECT},
            'summary': summary,
            'description': description,
            'issuetype': {'name': 'Task'},
        }

        # Create the issue
        new_issue = jira_client.create_issue(fields=issue_dict)
        print(f"Successfully created Jira ticket: {new_issue.key}")

        # Add a confirmation reaction to the Slack message
        slack_client.reactions_add(
            channel=CHANNEL_ID,
            name=PROCESSED_REACTION,
            timestamp=message_ts
        )

    except Exception as e:
        print(f"Failed to create Jira ticket or add reaction: {e}")

# --- Main execution block ---
if __name__ == "__main__":
    find_and_process_messages()

Step 5: Scheduling the Script

This script is only useful if it runs automatically. A cron job is the classic, reliable way to do this. To run the script every hour, you’d set up a cron job like this. Note that I’m using a relative path to the script; you’d adjust this based on where you run it from.

Example cron job to run every hour at the top of the hour:

0 * * * * python3 slack_to_jira.py

Common Pitfalls (Where I Usually Mess Up)

• Slack Bot Scopes: This is the #1 issue. Your Slack Bot Token needs the right permissions (scopes) to function. In your Slack App settings, under “OAuth & Permissions,” make sure your bot has:
  • channels:history (to read messages)
  • reactions:read (to see the emojis)
  • reactions:write (to add the ✅)
  • chat:write (not strictly needed for this script, but good to have)
  • users:read (to get user profile info, if you want to expand it)

  Remember to reinstall the app to your workspace after changing scopes!

• Emoji Names: Make sure the string for REACTION_TO_TRACK exactly matches the emoji’s shortcode in Slack (e.g., “ticket”, not “ticket_emoji”).
• Rate Limiting: If you’re in an extremely active channel and run the script too frequently (e.g., every minute), you might hit Slack’s API rate limits. For most use cases, running it every 15-30 minutes is perfectly fine and avoids any issues.

Conclusion

And that’s it. With a relatively simple Python script and a cron job, you’ve now built a bridge between your team’s conversations and your project management system. This isn’t just about saving a few clicks; it’s about creating a frictionless workflow that ensures actionable items are never lost. In my experience, small automations like this have a huge impact on team productivity and reduce a lot of silent frustration.

Feel free to expand on this. You could map different emojis to different Jira issue types (e.g., 🐛 for a Bug, 💡 for a Story) or even assign the ticket based on who reacted. The foundation is here—now make it your own.

– 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