Linear MCP Server: Engineering Backlog via Claude

Linear is the issue tracker that engineering teams actually enjoy using — clean, fast, and opinionated. The Linear MCP server takes that speed even further by letting Claude manage your backlog directly. Search for issues, triage bugs, update priorities, and get sprint summaries without switching tabs.

What is Linear?

Linear is a fast, modern issue tracker designed for engineering teams that want less friction and more focus. Unlike sprawling project management tools, Linear is deliberately opinionated: it uses cycles (time-boxed sprints), projects (goal-oriented groupings), and issues (the individual units of work). Its interface is keyboard-driven, its sync is near-instant, and its GitHub integration makes it a natural fit alongside pull request workflows. Linear's GraphQL API is one of the cleanest in the project management space, which makes it particularly well-suited for MCP server integration.

What the Linear MCP Server Does

The Linear MCP server acts as a bridge between Claude and the Linear GraphQL API. Once installed, Claude gains access to a set of tools it can invoke during your conversations. The core tools include:

• Search issues by query or label — find issues across your team by keyword, priority, status, or assignee.
• Create new issues — add issues to any team with a title, description, priority level, and assignee specified in natural language.
• Update issue status — move issues through your workflow states (e.g., Todo → In Progress → In Review → Done) without opening the app.
• List issues in a cycle or sprint — get a full picture of what is scoped to the current or past cycle.
• Get team roadmap view — retrieve the projects and initiatives planned for your team and their completion status.
• Add comments — post context or updates to an issue directly from Claude.

Under the hood, Claude decides which tool to call based on your natural-language request, passes the right parameters, and formats the response in a readable way. You never write GraphQL queries yourself. For a closer look at how tool invocation works, see our MCP security and trust levels guide.

Prerequisites

Before installing the Linear MCP server, make sure you have the following:

• Linear account — any plan works, including the free tier for small teams.
• Linear API key — go to linear.app/settings/api, click "Create key", give it a label, and copy the generated key. For write access (creating and updating issues), ensure the key has the appropriate scopes selected.
• Team ID — your team's identifier within Linear. You can find it in the URL when viewing your team's issues, or by querying the API after setup.
• Node.js 18 or higher — check with node --version in your terminal. Download from nodejs.org if needed.
• Claude Desktop — the MCP server connects via Claude Desktop's MCP integration.

How to Install the Linear MCP Server

1. Generate your API key in Linear settings. Navigate to linear.app/settings/api and create a new personal API key. Give it a descriptive name like "Claude MCP" and select the scopes you need — at minimum, read access for issues and teams; write access if you want Claude to create or update issues.
2. Note your team ID. Open Linear, navigate to your team's issue list, and look at the URL — the team identifier appears in the path. You can also retrieve it after setup by asking Claude to list your teams once the server is connected.
3. Open your Claude Desktop config file. This file is called claude_desktop_config.json. On macOS it lives at ~/Library/Application Support/Claude/claude_desktop_config.json; on Windows it is at %APPDATA%\Claude\claude_desktop_config.json. See our full claude_desktop_config.json guide for details.
4. Add the Linear server block using the config JSON below, replace the placeholder with your real API key, then save the file and restart Claude Desktop. The Linear server will appear in Claude's tool list within a few seconds of launch.

The Config JSON

Add this block to your claude_desktop_config.json. The npx command pulls the latest server version automatically — no manual installation required.

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-linear"],
      "env": {
        "LINEAR_API_KEY": "lin_api_your_key_here"
      }
    }
  }
}

If you are concerned about storing API keys in your config file, read our MCP security and trust levels guide. The key lives only in your local config file and is passed to the local server process — it does not travel to Anthropic's servers.

Real Use Cases

Once the server is connected, these are the kinds of requests Claude can handle immediately:

1. "Show me all P1 bugs in the current cycle." Claude queries Linear for all issues with priority set to Urgent or High that are scoped to the active cycle, and returns a list with status, assignee, and creation date.
2. "Create a new bug issue: 'Auth token expires too early', assigned to backend team, priority urgent." Claude creates the issue via the API with the correct priority enum, assigns it to the backend team, and returns the new issue ID (e.g., LIN-789) so you can reference it immediately.
3. "Move LIN-456 to In Review." Claude looks up the issue by its identifier and updates the workflow state to the matching "In Review" state in your team's configuration.
4. "What issues are blocking the mobile release?" Claude searches for issues labeled "blocking" or linked to the mobile release project that are not yet in a completed state, giving you a quick blocker report.
5. "Summarize what was completed in the last cycle." Claude retrieves all issues from the previous cycle with a completed status and summarizes them by area, giving you a concise sprint retrospective input.

Pros

• Linear's GraphQL API is fast and well-documented — queries resolve quickly and the API schema is stable, making the MCP server reliable for daily engineering use.
• Excellent for engineering teams — cycles, priorities, and issue identifiers map naturally to how engineering teams already think about their work.
• Pairs well with GitHub MCP for full dev workflow — combine the Linear MCP server with a GitHub MCP server to manage issues and pull requests in the same conversation.
• Team-level scoping works well — you can direct Claude to a specific team's backlog, keeping responses focused and relevant.

Cons / Limitations

• Linear-specific — the server is only useful if your team uses Linear. It is not a generic issue tracker adapter; if you use Jira or Asana, you need those servers instead.
• Complex filtering requires knowing Linear's data model — advanced queries involving custom views, labels, and project scoping work better when you understand how Linear organizes its data internally.
• API key scopes need attention for write access — read-only queries work with minimal permissions, but creating or updating issues requires write scopes that must be explicitly enabled when generating your API key.