This is going to be extensive and important for you if you want to extend Jira software functionalities with Python. Jira is a powerful project management tool, but its built-in features can sometimes be limited for advanced use cases. By integrating Python with Jira, you can automate workflows, extract custom reports, and extend Jira’s capabilities. In this guide, we’ll explore how to connect Python to Jira using the jira library and implement custom functionalities.
Table of Contents
Step 1: Setting Up Jira API Access.
Step 2: Connecting Python to Jira.
Step 5: Updating an Existing Issue.
Step 6: Generating Custom Reports.
Step 7: Automating Workflows with Webhooks.
Setting Up the Webhook in Jira.
Jira Kanban Board KPI Dashboard with Streamlit
Step 2: Fetch Issues from Kanban Board.
Step 3: Calculate Time Spent in Each Column.
Step 4: Build the Streamlit Dashboard.
Advanced Jira Kanban Analytics Dashboard with Streamlit
Prerequisites
Before proceeding, ensure you have:
- A Jira instance (Cloud or Server) with admin access.
- Python 3.6+ installed.
- Required libraries:
pip install jira pandas matplotlib
Step 1: Setting Up Jira API Access
To interact with Jira via Python, you need an API token (for Jira Cloud) or username/password (for Jira Server).
For Jira Cloud:
- Go to Atlassian Account Settings.
- Create an API token.
For Jira Server:
Use your Jira username and password directly.
Step 2: Connecting Python to Jira
Use the jira library to establish a connection.
from jira import JIRA
# Jira Cloud Connection
jira_cloud = JIRA(
   server="https://your-domain.atlassian.net",
   basic_auth=("your-email@example.com", "your-api-token")
)
# Jira Server Connection (if using local Jira)
jira_server = JIRA(
   server="http://your-jira-server.com",
   basic_auth=("username", "password")
)
print("Successfully connected to Jira!")
Step 3: Fetching Jira Issues
Retrieve issues from a specific project or using JQL (Jira Query Language).
# Get all issues from a project
issues = jira_cloud.search_issues('project=PROJECT_KEY')
# Get unresolved bugs with high priority
high_priority_bugs = jira_cloud.search_issues(
   'project=PROJECT_KEY AND type=Bug AND priority=High AND status!=Closed'
)
for issue in high_priority_bugs:
   print(f"Issue: {issue.key} - {issue.fields.summary}")
Step 4: Creating a New Issue
Automate issue creation using Python.
new_issue = jira_cloud.create_issue(
   project="PROJECT_KEY",
   summary="Fix authentication bug",
   description="User login fails intermittently",
   issuetype={"name": "Bug"},
   priority={"name": "High"}
)
print(f"Created issue: {new_issue.key}")Step 5: Updating an Existing Issue
Modify issue fields (status, assignee, labels, etc.).
issue = jira_cloud.issue("PROJECT-123")
# Update summary and assignee
issue.update(
   summary="Updated: Fix login issue",
   assignee={"name": "developer@example.com"}
)
# Transition issue status (e.g., "In Progress" → "Done")
jira_cloud.transition_issue(
   issue,
   transition="Done",
   comment="Issue resolved via Python script"
)Step 6: Generating Custom Reports
Use pandas and matplotlib to analyze Jira data.
import pandas as pd
import matplotlib.pyplot as plt
# Fetch issues and convert to DataFrame
issues = jira_cloud.search_issues('project=PROJECT_KEY', maxResults=100)
data = []
for issue in issues:
   data.append({
       "Key": issue.key,
       "Summary": issue.fields.summary,
       "Status": issue.fields.status.name,
       "Assignee": getattr(issue.fields.assignee, "displayName", "Unassigned"),
       "Created": issue.fields.created[:10]
   })
df = pd.DataFrame(data)
# Generate a bar chart of issues by status
status_counts = df["Status"].value_counts()
status_counts.plot(kind="bar", title="Issues by Status")
plt.xlabel("Status")
plt.ylabel("Count")
plt.show()
Step 7: Automating Workflows with Webhooks
Trigger Python scripts when Jira events occur (e.g., issue created/updated).
Using Flask to Handle Webhooks:
from flask import Flask, request
app = Flask(__name__)
@app.route("/jira-webhook", methods=["POST"])
def handle_webhook():
   data = request.json
   issue_key = data["issue"]["key"]
   print(f"New Jira event detected: {issue_key}")
   # Add custom logic (e.g., send Slack notification)
   return "OK", 200
if __name__ == "__main__":
   app.run(port=5000)Setting Up the Webhook in Jira
- Go to Jira Settings → System → Webhooks.
- Add a new webhook pointing to your Flask server (e.g., http://your-server:5000/jira-webhook).
Jira Kanban Board KPI Dashboard with Streamlit
This Streamlit dashboard tracks how long issues have been in each column of a Jira Kanban board, helping teams identify bottlenecks and improve workflow efficiency.
Features
- Fetches issues from a Jira Kanban board
- Calculates time spent in each column (status)
- Displays KPIs in an interactive dashboard
- Visualizes bottlenecks using bar charts
Prerequisites
- Python 3.6+
- Required libraries:
pip install streamlit jira pandas matplotlib
Step 1: Connect to Jira
First, set up a connection to Jira using the jira library.
from jira import JIRA
import pandas as pd
import streamlit as st
from datetime import datetime
# Initialize Jira connection
def connect_to_jira():
   jira = JIRA(
       server="https://your-domain.atlassian.net", # Replace with your Jira URL
       basic_auth=("your-email@example.com", "your-api-token") # Cloud: API Token | Server: Username/Password
   )
   return jira
jira = connect_to_jira()
Step 2: Fetch Issues from Kanban Board
Retrieve issues from a specific project and filter by Kanban columns (statuses).
def fetch_kanban_issues(project_key, kanban_columns):
   issues = jira.search_issues(
       f'project={project_key} AND status in ({", ".join(kanban_columns)})',
       maxResults=1000,
       expand="changelog"
   )
   return issuesStep 3: Calculate Time Spent in Each Column
Extract changelog data to determine how long an issue has been in each status.
def calculate_time_in_columns(issue):
   changelog = issue.changelog
   status_changes = []
   for history in changelog.histories:
       for item in history.items:
           if item.field == "status":
               status_changes.append({
                   "from": item.fromString,
                   "to": item.toString,
                   "time": history.created
               })
   # Sort changes chronologically
   status_changes.sort(key=lambda x: x["time"])
   # Calculate time spent in each status
   time_in_status = {}
   for i in range(len(status_changes)):
       if i + 1 < len(status_changes):
           start_time = datetime.strptime(status_changes[i]["time"], "%Y-%m-%dT%H:%M:%S.%f%z")
           end_time = datetime.strptime(status_changes[i+1]["time"], "%Y-%m-%dT%H:%M:%S.%f%z")
           duration = (end_time - start_time).total_seconds() / 3600 # Convert to hours
           status = status_changes[i]["to"]
           if status in time_in_status:
               time_in_status[status] += duration
           else:
               time_in_status[status] = duration
   # Add current status time (now - last change)
   if status_changes:
       last_status = status_changes[-1]["to"]
       last_change_time = datetime.strptime(status_changes[-1]["time"], "%Y-%m-%dT%H:%M:%S.%f%z")
       current_time = datetime.now(last_change_time.tzinfo)
       current_duration = (current_time - last_change_time).total_seconds() / 3600
       if last_status in time_in_status:
           time_in_status[last_status] += current_duration
       else:
           time_in_status[last_status] = current_duration
   return time_in_status
Step 4: Build the Streamlit Dashboard
Display KPIs, charts, and issue details in an interactive dashboard.
def main():
   st.title("Jira Kanban Board KPI Dashboard")
   st.markdown("Track how long issues stay in each Kanban column.")
   # Input fields
   project_key = st.text_input("Jira Project Key", "YOUR_PROJECT_KEY")
   kanban_columns = st.text_input("Kanban Columns (comma-separated)", "To Do, In Progress, Review, Done").split(", ")
   if st.button("Fetch Data"):
       issues = fetch_kanban_issues(project_key, kanban_columns)
       # Process data
       data = []
       for issue in issues:
           time_in_status = calculate_time_in_columns(issue)
           for status, hours in time_in_status.items():
               data.append({
                   "Issue Key": issue.key,
                   "Status": status,
                   "Hours in Status": hours,
                   "Summary": issue.fields.summary
               })
       df = pd.DataFrame(data)
       # Display KPIs
       st.subheader("Key Metrics")
       avg_time_per_status = df.groupby("Status")["Hours in Status"].mean().round(2)
       st.write("Average Time in Each Status (Hours):")
       st.dataframe(avg_time_per_status)
       # Bar chart visualization
       st.subheader("Time Spent in Each Kanban Column")
       st.bar_chart(df.groupby("Status")["Hours in Status"].sum())
       # Raw data table
       st.subheader("Detailed Issue Data")
       st.dataframe(df)
if __name__ == "__main__":
   main()Step 5: Run the Dashboard
Execute the Streamlit app:
streamlit run jira_kanban_dashboard.py
Expected Output
The dashboard will show:
✅ Average time per status (e.g., “In Progress: 24.5 hours”)
✅ Bar chart of total time spent in each column
✅ Detailed table of issues with time breakdown
Enhancements (Optional)
- Slack Alerts for bottlenecks (slack_sdk)
- Automated Reports (PDF/Excel export)
- Trend Analysis (compare historical data)
This dashboard helps teams:
🔹 Identify bottlenecks (e.g., issues stuck in “Review” too long)
🔹 Improve workflow efficiency by analyzing cycle times
🔹 Make data-driven decisions for process optimization
Advanced Jira Kanban Analytics Dashboard with Streamlit
This enhanced dashboard tracks multiple KPIs including cycle time, lead time, throughput, velocity, and resource workload to provide comprehensive insights into your team’s performance.
Enhanced Features
- ✅ Lead time (from creation to completion)
- ✅ Cycle time (from “In Progress” to “Done”)
- ✅ Throughput (issues completed per time period)
- ✅ Velocity (story points completed per sprint)
- ✅ Resource workload (issues assigned per team member)
- ✅ Interactive date filters for trend analysis
Complete Code Implementation
import streamlit as st
from jira import JIRA
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
import numpy as np
# Initialize Jira connection
@st.cache_resource
def connect_to_jira():
   jira = JIRA(
       server="https://your-domain.atlassian.net",
       basic_auth=("your-email@example.com", "your-api-token")
   )
   return jira
jira = connect_to_jira()
# Date range selector
def get_date_range():
   today = datetime.now()
   default_start = today - timedelta(days=30)
   start_date = st.sidebar.date_input("Start date", default_start)
   end_date = st.sidebar.date_input("End date", today)
   return start_date, end_date
# Fetch issues with changelog
@st.cache_data(ttl=3600)
def fetch_issues(project_key, start_date, end_date):
   jql = f'project = {project_key} AND created >= "{start_date}" AND created <= "{end_date}"'
   issues = jira.search_issues(
       jql,
       maxResults=1000,
       expand="changelog,issuetype,assignee"
   )
   return issues
# Calculate all metrics
def calculate_metrics(issues, kanban_columns):
   metrics = []
   sprint_data = {}
   assignee_workload = {}
   for issue in issues:
       # Lead Time (Creation to Resolution)
       created = datetime.strptime(issue.fields.created[:19], "%Y-%m-%dT%H:%M:%S")
       resolved = datetime.strptime(issue.fields.resolutiondate[:19], "%Y-%m-%dT%H:%M:%S") if issue.fields.resolutiondate else None
       lead_time = (resolved - created).total_seconds() / 86400 if resolved else None
       # Cycle Time (First In Progress to Done)
       changelog = issue.changelog
       in_progress_time = None
       done_time = None
       for history in changelog.histories:
           for item in history.items:
               if item.field == "status":
                   change_time = datetime.strptime(history.created[:19], "%Y-%m-%dT%H:%M:%S")
                   if item.toString == "In Progress" and not in_progress_time:
                       in_progress_time = change_time
                   if item.toString == "Done":
                       done_time = change_time
       cycle_time = (done_time - in_progress_time).total_seconds() / 86400 if (in_progress_time and done_time) else None
       # Story Points
       story_points = getattr(issue.fields, 'customfield_10016', 0) or 0
       # Sprint Information
       sprint = getattr(issue.fields, 'customfield_10020', [{}])[0].get('name', 'No Sprint') if hasattr(issue.fields, 'customfield_10020') else 'No Sprint'
       # Assignee Workload
       assignee = getattr(issue.fields.assignee, 'displayName', 'Unassigned')
       if assignee in assignee_workload:
           assignee_workload[assignee] += 1
       else:
           assignee_workload[assignee] = 1
       # Sprint Velocity Tracking
       if sprint != 'No Sprint' and resolved:
           if sprint not in sprint_data:
               sprint_data[sprint] = {'points': 0, 'count': 0}
           sprint_data[sprint]['points'] += story_points
           sprint_data[sprint]['count'] += 1
       metrics.append({
           "Key": issue.key,
           "Type": issue.fields.issuetype.name,
           "Status": issue.fields.status.name,
           "Assignee": assignee,
           "Created": created,
           "Resolved": resolved,
           "Lead Time (days)": lead_time,
           "Cycle Time (days)": cycle_time,
           "Story Points": story_points,
           "Sprint": sprint
       })
   return pd.DataFrame(metrics), sprint_data, assignee_workload
# Main dashboard
def main():
   st.set_page_config(layout="wide")
   st.title("🚀 Advanced Jira Kanban Analytics Dashboard")
   # Sidebar controls
   st.sidebar.header("Filters")
   project_key = st.sidebar.text_input("Project Key", "YOURPROJECT")
   start_date, end_date = get_date_range()
   # Fetch data
   issues = fetch_issues(project_key, start_date, end_date)
   if not issues:
       st.warning("No issues found for the selected criteria")
       return
   kanban_columns = ["To Do", "In Progress", "Review", "Done"]
   df, sprint_data, assignee_workload = calculate_metrics(issues, kanban_columns)
   # Dashboard layout
   col1, col2, col3, col4 = st.columns(4)
   with col1:
       avg_lead_time = df['Lead Time (days)'].mean()
       st.metric("Average Lead Time", f"{avg_lead_time:.1f} days")
   with col2:
       avg_cycle_time = df['Cycle Time (days)'].mean()
       st.metric("Average Cycle Time", f"{avg_cycle_time:.1f} days")
   with col3:
       throughput = len(df[df['Status'] == 'Done'])
       st.metric("Throughput", f"{throughput} issues")
   with col4:
       total_points = df[df['Status'] == 'Done']['Story Points'].sum()
       st.metric("Completed Story Points", total_points)
   # Row 2: Charts
   st.subheader("Performance Trends")
   # Throughput over time
   fig1, ax1 = plt.subplots()
   df_done = df[df['Status'] == 'Done']
   if not df_done.empty:
       throughput_trend = df_done.groupby(df_done['Resolved'].dt.to_period('W')).size()
       throughput_trend.plot(kind='line', ax=ax1, title='Weekly Throughput')
       st.pyplot(fig1)
   # Velocity by sprint
   if sprint_data:
       fig2, ax2 = plt.subplots()
       sprints = list(sprint_data.keys())
       points = [sprint_data[s]['points'] for s in sprints]
       ax2.bar(sprints, points)
       ax2.set_title('Velocity by Sprint (Story Points)')
       ax2.tick_params(axis='x', rotation=45)
       st.pyplot(fig2)
   # Resource workload
   st.subheader("Team Workload Distribution")
   if assignee_workload:
       fig3, ax3 = plt.subplots()
       ax3.bar(assignee_workload.keys(), assignee_workload.values())
       ax3.set_title('Issues Assigned per Team Member')
       ax3.tick_params(axis='x', rotation=45)
       st.pyplot(fig3)
   # Raw data
   st.subheader("Detailed Issue Data")
   st.dataframe(df)
if __name__ == "__main__":
   main()Key Metrics Explained
- Lead Time:
- Time from ticket creation to resolution
- Measures overall process efficiency
- Cycle Time:
- Time from “In Progress” to “Done”
- Focuses on actual work time
- Throughput:
- Number of issues completed in time period
- Indicates team capacity
- Velocity:
- Story points completed per sprint
- Helps with sprint planning
- Resource Workload:
- Issues assigned per team member
- Identifies over/under utilized team members
How to Use This Dashboard
- Set your Jira credentials in the connection function
- Adjust the project key to match your Jira project
- Customize status columns to match your workflow
- Filter by date range to analyze specific periods
- Monitor trends in the interactive charts
Advanced Customizations
- Add CFD (Cumulative Flow Diagram) by tracking daily status counts
- Implement WIP (Work in Progress) limits analysis
- Add forecasting based on historical velocity
- Connect to Slack/Teams for automated alerts
This dashboard provides engineering managers and Scrum masters with powerful insights to optimize their team’s performance and identify improvement opportunities in their workflow.
Conclusion
By integrating Python with Jira, you can:
✔ Automate repetitive tasks
✔ Extract and visualize custom reports
✔ Extend Jira’s functionality beyond standard features
The jira Python library provides a seamless way to interact with Jira’s REST API, enabling endless customization possibilities.
