# Jira Cloud MCP

> Jira Cloud MCP Server connects your AI client to the Jira Cloud API. It lets your agent read project details, search issues using JQL, list users, and track task statuses across your entire development portfolio. Instead of jumping between tabs, your AI client can find, analyze, and report on any task or bug in Jira.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** agile, issue-tracking, jql, task-management, workflow-automation, sprint-planning

## Description

**Jira Cloud MCP Server** connects your AI client straight to the Jira Cloud API. Your agent can read project details, search for issues using JQL, list users, and track task statuses across your whole development portfolio. You won't have to jump between tabs; your AI client can find, analyze, and report on any task or bug in Jira.

## Tools

### add_comment
The comment appears in the issue activity timeline visible to all project members.

Add a comment to a Jira issue

### assign_issue
Use list_users to discover account IDs. Pass an empty string to unassign.

Assign a Jira issue to a specific user

### create_issue
Requires the project key and a summary. Optionally set issue type (defaults to Task), description, and priority. Use list_issue_types and list_priorities to discover valid values for issuetype and priority names.

Create a new Jira issue (task, bug, story, etc.)

### get_issue
Retrieves all details, comments, and custom fields for a specific Jira issue key.

### get_myself
Gets the current user's identity and permissions within Jira.

### get_project
Retrieves the lead, issue types, and categories for a specific Jira project key or ID.

### list_dashboards
Lists all high-level reporting dashboards available to the authenticated user.

### list_issue_types
Provides a list of all issue types (like Bug, Epic, Story) available in the instance.

### list_priorities
Lists all defined issue priorities (e.g., High, Medium, Low) to help gauge task urgency.

### list_projects
Lists all project keys, names, and IDs across the entire Jira instance.

### list_sprints
Requires the board ID which can be found in the board URL.

List sprints for a Jira agile board

### list_statuses
Lists all possible issue statuses (e.g., To Do, In Progress) for mapping project workflows.

### list_transitions
Use this to find transition IDs before using transition_issue.

List available workflow transitions for an issue

### list_users
Lists all users in Jira by display name or account ID.

### search_issues
Searches for multiple issues using powerful filtering criteria defined by Jira Query Language (JQL).

### transition_issue
g., "To Do" → "In Progress" → "Done"). Requires a transition ID — use list_transitions to discover valid IDs for the current issue state.

Move a Jira issue to a different workflow status

### update_issue
Provide only the fields you want to change as a JSON string.

Update fields on an existing Jira issue

## Prompt Examples

**Prompt:** 
```
List all active projects in Jira.
```

**Response:** 
```
I'll fetch the list of all projects you have access to in Jira.
```

**Prompt:** 
```
Search for all issues assigned to 'user@example.com'.
```

**Response:** 
```
I'll use JQL to find all issues assigned to that specific user.
```

**Prompt:** 
```
Get details for issue 'PROJ-123'.
```

**Response:** 
```
I'll retrieve the full details, including status and priorities, for that Jira issue.
```

## Capabilities

### Get Full Issue Context
Retrieves a complete record for one specific issue, including its status, comments, and custom fields.

### Search Issues with JQL
Finds multiple issues across your Jira instance using complex search criteria defined by Jira Query Language.

### List All Projects and Scope
Returns a list of all available projects, allowing your AI client to understand the organizational scope.

### Map Workflow States
Lists all defined issue statuses (e.g., To Do, Done) and priorities (e.g., High, Low) for filtering and reporting.

### Identify Users and Assignees
Fetches a directory of all users in Jira, useful for assigning tasks or identifying owners.

### Analyze Project Configuration
Gathers details on a specific project, including its lead, issue types, and categories.

## Use Cases

### Auditing a Feature Launch
A PM needs to confirm all related tasks for 'Project Phoenix' are done. The agent calls `list_projects` to confirm the key, then uses `search_issues` with JQL: `project = Phoenix AND status = Done`. Finally, it calls `get_project` to verify the project lead. The PM gets a single, aggregated report.

### Investigating a Bug Report
A QA engineer receives a vague bug report. The agent uses `get_issue` on the provided key to pull the full context, checking comments for reproduction steps, and uses `list_issue_types` to confirm it's actually classified as a 'Bug'. The agent then reports the full context immediately.

### Identifying a Blocked Team Member
A Scrum Master needs to find out who is blocking a release. They use `list_users` to confirm team members and then use `search_issues` with JQL: `status = Blocked AND assignee = currentUser`. This immediately flags the person and the task.

### Understanding Project Scope
A new team member needs to know how a specific project is set up. They ask the agent to list the project details. The agent calls `get_project` to retrieve the lead, issue types, and categories, giving the new hire a full overview without manual navigation.

## Benefits

- Find the exact details on a single item. Use `get_issue` to pull everything on a key like 'PROJ-123', including comments, status, and custom fields. You don't have to click through the issue view.
- Search complex criteria instantly. Instead of writing a JQL query in the browser, your agent calls `search_issues` with criteria like 'project = X AND status = Open', getting an instant list of relevant tasks.
- Understand the scope of work. Call `list_projects` to see every project key in the organization, or use `list_issue_types` to confirm if the correct type (Bug vs. Epic) exists before searching.
- Audit team structure. Use `list_users` to get a clean list of every user, allowing your agent to find all issues assigned to a specific person without needing their email address.
- Map the workflow. Call `list_statuses` and `list_priorities` to get the valid state machine for a project, letting your agent know what status transitions are possible.
- Get project context. Use `get_project` to understand the foundational setup of a team's project, like its lead or available issue types, before running a detailed search.

## How It Works

The bottom line is that your AI client uses these tools to read the data and write the report; it doesn't change anything in Jira.

1. Your AI client determines the necessary action—for example, finding all 'Bug' issues in the 'CORE' project.
2. It calls the appropriate tool, like `search_issues`, passing the specific JQL query (`project = CORE AND issuetype = Bug`).
3. The MCP Server executes the query against Jira and returns a structured JSON list of issue keys, summaries, and statuses to your AI client.

## Frequently Asked Questions

**How do I use the `search_issues` tool in Jira Cloud MCP Server?**
You must provide a valid JQL query string. The tool uses Jira Query Language (JQL) to filter results, so a query like `project = MYPROJ AND status = Open` works best. This returns issue keys, summaries, and statuses.

**What information does `get_issue` retrieve?**
`get_issue` pulls a complete record for a single issue. This includes not only the summary and status but also all historical comments, priority level, and custom fields.

**Can I find out which projects are available using `list_projects`?**
Yes, `list_projects` returns a list of all project keys, names, and IDs that the current user has access to. This is useful for knowing the scope of your search.

**Is `get_project` better than `list_projects`?**
`list_projects` gives you a master list of every project. `get_project` is used when you already know the project key and need to know its specific configuration, like its lead or available issue types.

**How do I check permissions with `get_myself`?**
Calling `get_myself` returns the authenticated user's information and permissions, confirming what data the agent is allowed to read from your Jira instance.

**How do I list all available issue types using `list_issue_types`?**
It lists every issue type configured in your Jira instance. This helps you know exactly what types are valid for searching or creating content, like 'Bug' or 'Story'.

**What is the difference between `list_projects` and `get_project`?**
Use `list_projects` to get a master list of all project keys and names. Then, use `get_project` with a specific key or ID to get detailed scope information for one project.

**How can I check the status of all issues in a project using `search_issues`?**
You write a JQL query targeting the project and status. For example, `project = MYPROJ AND status = Open` pulls all open items from that specific project.

**How do I get Jira API credentials?**
You need your Jira instance domain (e.g., acme.atlassian.net), your account email, and an API Token. You can generate an API Token in your Atlassian Account Settings under Security > API Token.

**What is JQL?**
JQL (Jira Query Language) is a powerful tool that allows you to search for issues in Jira using a structured query syntax.

**Can I see private projects?**
Your AI agent will only be able to see projects and issues that your Atlassian account has permission to access.