Linear MCP Server: Give Your AI Agent Direct Access to Your Issue Tracker

What It Does

Linear MCP server exposes your Linear workspace to AI coding agents through the Model Context Protocol. Instead of manually copying ticket descriptions into prompts, your agent reads Linear directly: issue title, description, priority, labels, assignee, linked issues, project context.

The result is a tighter loop between planning and implementation. You assign a ticket in Linear, tell your agent to work on it, and the agent pulls the requirements, finds the relevant code, makes the changes, and updates the ticket status. One command replaces five context switches.

Available Implementations

There are two categories of Linear MCP server: the official one from Linear (hosted, OAuth-based) and community implementations (local, API-token-based). The official server is the simplest to set up. Community servers offer more flexibility: multiple workspace support, custom tool prefixes, and sometimes additional tools.

For most developers, the official server is the right starting point. You get OAuth authentication (no API keys to manage), centralized hosting (no local process to keep running), and automatic updates as Linear adds new tools.

Reach for a community server if you need multiple workspaces, want to pin a specific version, or need tools the official server does not expose yet.

Setup: Official Linear MCP Server

Claude Code

One command. The OAuth flow handles authentication through your browser.

claude mcp add --transport http linear https://mcp.linear.app/mcp

After adding the server, run /mcp inside a Claude Code session to trigger the OAuth flow. Your browser opens, you authorize Linear, and the server is connected.

Claude Desktop

Add the following to your claude_desktop_config.json:

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.linear.app/mcp"]
    }
  }
}

Cursor

Go to Cursor Settings > Tools & Integrations, click New MCP Server, and search for "Linear" in the MCP tools page. Alternatively, add it to your .cursor/mcp.json:

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.linear.app/mcp"]
    }
  }
}

Windsurf

Press Ctrl/Cmd + P, search for MCP: Add Server, enter "Linear", then activate it via MCP: List Servers and click Start Server.

Setup: Community Servers (API Token)

Community servers use a personal API token instead of OAuth. To generate one: go to Linear Settings > API > Personal API Keys, click Create key, and copy the token. It starts with lin_api_.

@tacticlaunch/mcp-linear

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@tacticlaunch/mcp-linear"],
      "env": {
        "LINEAR_API_TOKEN": "lin_api_your_token_here"
      }
    }
  }
}

@touchlab/linear-mcp-integration

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["@touchlab/linear-mcp-integration"],
      "env": {
        "LINEAR_ACCESS_TOKEN": "lin_api_your_token_here"
      }
    }
  }
}

Multiple Workspaces (dvcrn/mcp-server-linear)

Add the server twice with different TOOL_PREFIX values. Each workspace gets its own set of tools with distinct names, so the agent knows which workspace to target.

{
  "mcpServers": {
    "linear-frontend": {
      "command": "npx",
      "args": ["-y", "mcp-server-linear"],
      "env": {
        "LINEAR_ACCESS_TOKEN": "lin_api_frontend_workspace_token",
        "TOOL_PREFIX": "frontend"
      }
    },
    "linear-backend": {
      "command": "npx",
      "args": ["-y", "mcp-server-linear"],
      "env": {
        "LINEAR_ACCESS_TOKEN": "lin_api_backend_workspace_token",
        "TOOL_PREFIX": "backend"
      }
    }
  }
}

Tools and Capabilities

The official Linear MCP server exposes tools for the core objects in Linear. The February 2026 update added initiatives, milestones, and project updates. Community servers vary in coverage, but most support the core issue and project operations.

Workflow Examples

1. Implement a ticket from your backlog

The most common use case. Your agent reads the ticket, understands the requirements, finds the relevant files, and writes the code.

Look at the highest-priority bug in the Billing project on Linear.
Read the ticket description, then find the relevant code and implement the fix.
When done, mark the issue as "Done" and add a comment with what you changed.

The agent calls the Linear MCP to search issues filtered by project and priority, reads the top result, then uses its code tools to find and edit files. After the fix, it calls the Linear MCP again to update the status and post a comment.

2. Triage new issues

Useful for teams that receive bug reports from users or other teams. The agent reads the issue, checks if the described behavior matches the code, and adds diagnostic information.

Search Linear for issues labeled "triage" in the API team.
For each one, read the description, search the codebase for the relevant code,
and add a comment with: which files are involved, whether the described behavior
matches the code, and a suggested priority level.

3. Create issues from code review findings

When reviewing a PR, the agent can create follow-up issues for problems it finds that are outside the scope of the current change.

Review the changes in the current branch.
For any code quality issues, missing tests, or tech debt you find,
create a Linear issue in the Frontend project with appropriate labels
and priority. Don't fix them now, just track them.

4. Sprint planning prep

Pull unresolved issues, sort by priority, and generate a summary for the planning meeting.

Search Linear for all open issues in the Platform team.
Group them by project, sort by priority, and give me a markdown summary
with issue counts per status and the top 10 items I should discuss
in sprint planning tomorrow.

Linear MCP + WarpGrep: Task Context Meets Code Context

Linear MCP gives your agent the "what" and "why" from your issue tracker. WarpGrep gives it the "where" from your codebase. Together, they close the gap between knowing what to build and knowing where to build it.

Without code search, an agent reads a Linear ticket that says "Fix the timezone bug in recurring billing" and then searches files one at a time, guessing at file names. With WarpGrep, it runs a semantic search for "recurring billing timezone" and gets the 3 relevant files in under 6 seconds across a 500K-line codebase.

Read Linear ticket ENG-1234.
Use WarpGrep to find all code related to the issue description.
Implement the fix following existing patterns in the codebase.
Update the Linear issue to "In Review" and comment with the file changes.

This combination works with Claude Code, Cursor, or any MCP-compatible client. Both servers run independently. Linear MCP provides ticket context. WarpGrep provides code context. The agent orchestrates between them.

Troubleshooting

Authentication failures (401/403)

• Official server: Re-run the OAuth flow. Tokens expire. In Claude Code, run /mcp and re-authenticate through Linear.
• Community servers: Verify your API key starts with lin_api_. Regenerate the key in Linear Settings > API if you see FORBIDDEN errors. Check that the key has access to the workspace you are targeting.

Rate limiting (429 errors)

• Authenticated requests get 250,000 complexity points per hour.
• Each query has a maximum complexity of 10,000 points. Queries exceeding that are rejected outright.
• Check X-RateLimit-Remaining headers to monitor usage.
• Implement exponential backoff when you hit 429 responses. Respect the Retry-After header.

"Failed to fetch teams"

This usually means the API key lacks the right permissions. Generate a new key with full workspace access in Linear Settings > API > Personal API Keys.

SSE endpoint deprecated

Linear deprecated the SSE transport. If your config uses https://mcp.linear.app/sse, change it to https://mcp.linear.app/mcp. SSE support is being fully removed.

Server not appearing in Claude Code

• Run claude mcp list to verify the server is registered.
• For community servers, make sure npx can resolve the package. Run npx -y @tacticlaunch/mcp-linear --help to test.
• Check that your Node.js version is 18+ (required by most MCP servers).

Frequently Asked Questions

What is a Linear MCP server?

A Linear MCP server connects Linear's issue tracking system to AI coding agents through the Model Context Protocol. It lets tools like Claude Code, Cursor, and Windsurf read, create, update, and search Linear issues, projects, and cycles directly from the editor.

How do I set up the official Linear MCP server in Claude Code?

Run claude mcp add --transport http linear https://mcp.linear.app/mcp in your terminal, then run /mcp inside a Claude Code session to complete the OAuth authentication flow. No API key required.

What is the difference between the official and community implementations?

The official server uses OAuth 2.1 authentication and is hosted by Linear. Community implementations like @tacticlaunch/mcp-linear and mcp-server-linear use personal API tokens, run locally via npx, and often expose additional tools or support multiple workspaces.

What are the Linear API rate limits?

Authenticated requests get 250,000 complexity points per hour. Each query has a maximum complexity of 10,000 points. Unauthenticated requests are limited to 10,000 points per hour. The API returns X-RateLimit headers so clients can track their usage.

Can I use Linear MCP with multiple workspaces?

The official server authenticates per workspace through OAuth. Community servers like dvcrn/mcp-server-linear support multiple workspaces by adding the server multiple times with different TOOL_PREFIX values. Each workspace gets its own set of distinctly named tools.

What can AI agents do with the Linear MCP server?

Agents can search issues with filters (assignee, priority, status, labels, dates), create and update issues, manage projects and milestones, add comments, create initiatives, track cycles, and update project health status. The February 2026 update added initiatives, milestones, and project updates.

Related Guides

• Claude Code MCP Servers
• Best MCP Servers for Coding
• Claude Code Best Practices
• Agentic Coding Tools