# Jira MCP Server (`scraper_guru/jira-mcp-server`) Actor

A Model Context Protocol (MCP) server that enables AI assistants to interact with Jira Cloud. Create, search, update issues, manage sprints, and more — directly from Claude, Cursor, or any MCP client.

- **URL**: https://apify.com/scraper\_guru/jira-mcp-server.md
- **Developed by:** [LIAICHI MUSTAPHA](https://apify.com/scraper_guru) (community)
- **Categories:** MCP servers, Developer tools, AI
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $80.00 / 1,000 search issues

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Jira MCP Server

A Model Context Protocol (MCP) server that integrates with **Jira Cloud** for project management and issue tracking.

Connect your AI assistant (Claude, Cursor, VS Code, Windsurf) to Jira and manage projects, create issues, search with JQL, track sprints, and transition tickets — all through natural language.

> **About this MCP Server**: To understand how to connect to and use this MCP server, please refer to the official Model Context Protocol documentation at [mcp.apify.com](https://mcp.apify.com) ↗.

***

### ✨ Features

- 🔍 **JQL-powered issue search** — search across all projects using Jira Query Language
- 📋 **Full issue management** — create, read, update issues (Task, Bug, Story, Epic)
- 💬 **Comment threads** — add comments to issues from your AI assistant
- 🏃 **Sprint tracking** — list boards, view active/future sprints, check sprint goals
- 🔄 **Status transitions** — move issues through your workflow (To Do → In Progress → Done)
- 📊 **Project overview** — list all accessible projects with metadata
- 🔐 **Secure authentication** — uses Jira Cloud API tokens (never stored, provided per-user)

***

### 🔗 Connection URL

```
https://mcp-servers--jira-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```

Replace `YOUR_APIFY_TOKEN` with your [Apify API token](https://console.apify.com/account#/integrations).

***

### 🛠️ Available Tools

| Tool | Description |
|---|---|
| `list_projects` | List all Jira projects accessible to the authenticated user |
| `search_issues` | Search issues using JQL — supports all Jira query syntax |
| `get_issue` | Get full details of an issue including description, comments, and status |
| `create_issue` | Create a new issue (Task, Bug, Story, Epic) with description, priority, and labels |
| `update_issue` | Update issue fields — summary, description, priority, labels, assignee |
| `add_comment` | Add a comment to any issue |
| `list_sprints` | List sprints for a board — filter by active, future, or closed |
| `transition_issue` | Move an issue through workflow statuses (e.g., To Do → In Progress → Done) |

#### 🌳 Decision Tree — Which tool should I use?

```
Need to find issues?
├── General search → search_issues (JQL)
│   Examples: "status = 'In Progress'", "assignee = currentUser()"
├── Specific issue → get_issue (by key like PROJ-123)
└── List everything → list_projects + search_issues

Need to modify something?
├── New ticket → create_issue
├── Change fields → update_issue
├── Move status → transition_issue
└── Add note → add_comment

Need sprint info?
└── list_sprints (with optional board ID)
```

***

### 🚀 Installation

#### Prerequisites

Before connecting, you'll need:

1. **Jira Cloud account** — [Sign up for free](https://www.atlassian.com/software/jira/free)
2. **Jira API Token** — Generate one at [Atlassian API Tokens](https://id.atlassian.com/manage-profile/security/api-tokens)
3. **Apify account** — [Sign up](https://apify.com) (for hosted MCP)

#### 🖱️ Running on Cursor

Requires Cursor version 0.45.6+

For the most up-to-date configuration instructions, see [Cursor MCP Server Configuration Guide](https://docs.cursor.com/context/model-context-protocol) ↗.

**Cursor v0.48.6+:**

```json
{
  "mcpServers": {
    "jira-mcp-server": {
      "url": "https://mcp-servers--jira-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
```

**Cursor v0.45.6:**

1. Go to `Settings → Features → MCP Servers`
2. Click **Add New MCP Server**
3. Set the URL to the Connection URL above

#### 💻 Running on VS Code

Add to your `.vscode/mcp.json`:

```json
{
  "servers": {
    "jira-mcp-server": {
      "type": "http",
      "url": "https://mcp-servers--jira-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
```

#### 🌊 Running on Windsurf

Add to your `~/.codeium/windsurf/model_config.json`:

```json
{
  "mcpServers": {
    "jira-mcp-server": {
      "serverUrl": "https://mcp-servers--jira-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
```

#### 🤖 Running on Claude Desktop

Add to your Claude Desktop config:

**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`

```json
{
  "mcpServers": {
    "jira-mcp-server": {
      "url": "https://mcp-servers--jira-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
```

***

### 🔑 Setting Up Jira API Token

1. Go to <https://id.atlassian.com/manage-profile/security/api-tokens>
2. Click **Create API token**
3. Give it a label (e.g., "MCP Server")
4. Copy the token immediately — you won't see it again
5. Enter the token when starting the Actor on Apify Console

> **Note:** This server works with **Jira Cloud** only. Jira Server and Data Center are not supported.

***

### 💡 Example Prompts

Once connected to your AI assistant, try these:

| Prompt | Tool Used |
|---|---|
| *"List all my Jira projects"* | `list_projects` |
| *"Find all open bugs in project MYAPP"* | `search_issues` |
| *"Show me the details of MYAPP-42"* | `get_issue` |
| *"Create a new Task in MYAPP: Fix login page alignment"* | `create_issue` |
| *"Move MYAPP-42 to In Progress"* | `transition_issue` |
| *"What's in the current sprint?"* | `list_sprints` + `search_issues` |
| *"Add a comment to MYAPP-42: Investigated — this is a CSS issue"* | `add_comment` |
| *"Change the priority of MYAPP-42 to High"* | `update_issue` |

***

### 💰 Pricing

This Actor uses the **Pay per event** pricing model. Each tool call is charged individually:

| Event | Price per call |
|---|---|
| Actor start | $0.10 |
| `list_projects` | $0.05 |
| `search_issues` | $0.08 |
| `get_issue` | $0.05 |
| `create_issue` | $0.10 |
| `update_issue` | $0.08 |
| `add_comment` | $0.05 |
| `list_sprints` | $0.05 |
| `transition_issue` | $0.08 |

Plus standard [Apify platform usage costs](https://apify.com/pricing).

***

### 🔧 Local Development

If you want to run this server locally:

```bash
## Clone and install
git clone <repo-url>
cd jira-mcp-server
npm install

## Create local input
echo '{
  "jiraDomain": "your-site.atlassian.net",
  "jiraEmail": "your@email.com",
  "jiraApiToken": "your-api-token"
}' > .actor/INPUT.json

## Copy input to Apify local storage
mkdir -p storage/key_value_stores/default
cp .actor/INPUT.json storage/key_value_stores/default/INPUT.json

## Build and run
npm run build
node dist/main.js
```

Access at `http://localhost:8080/mcp`

***

### 🛡️ Security

- API tokens are **never stored** by the actor — they are provided per-user via Actor input
- Tokens are transmitted over HTTPS and used only for the duration of the Actor run
- The Actor runs in an isolated container on Apify's platform
- Your Jira data is never cached or shared

***

### 📚 References

- [Model Context Protocol](https://modelcontextprotocol.io/) — Official MCP specification
- [Jira Cloud REST API v3](https://developer.atlassian.com/cloud/jira/platform/rest/v3/) — Atlassian API docs
- [Apify MCP Server](https://mcp.apify.com) — Connect AI agents to Apify Actors
- [Atlassian MCP Server](https://github.com/atlassian/mcp-server-atlassian) — Original open-source implementation

***

**Built with ❤️ by [MuLIAICHI](https://apify.com/muliaichi)** | [Report an issue](https://github.com/MuLIAICHI/jira-mcp-server/issues)

# Actor input Schema

## `jiraDomain` (type: `string`):

Your Jira Cloud domain (e.g., mycompany.atlassian.net). Do NOT include https://

## `jiraEmail` (type: `string`):

Email address associated with your Atlassian/Jira account

## `jiraApiToken` (type: `string`):

API token from https://id.atlassian.com/manage-profile/security/api-tokens

## Actor input object example

```json
{
  "jiraDomain": "mycompany.atlassian.net"
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "jiraDomain": "mycompany.atlassian.net"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper_guru/jira-mcp-server").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "jiraDomain": "mycompany.atlassian.net" }

# Run the Actor and wait for it to finish
run = client.actor("scraper_guru/jira-mcp-server").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "jiraDomain": "mycompany.atlassian.net"
}' |
apify call scraper_guru/jira-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper_guru/jira-mcp-server"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gGnZYC2zVO0IUKQ7p/builds/gjVB6ZtJBs2Co2FwL/openapi.json