Linear MCP Server

Official Linear MCP server for finding, creating, and updating issues, projects, initiatives, milestones, and comments via mcp.linear.app.

Collaboration by Linear OAuth2 active

Connect (Remote Server) Docs

Overview

Linear's official MCP server is a remote, centrally hosted server that lets AI agents read and write to a Linear workspace using natural language. It is built against the authenticated remote MCP specification and uses OAuth 2.1 with dynamic client registration, so users sign in to their Linear account once and the agent inherits the user's permissions. As an alternative, API keys or OAuth tokens can be passed via an Authorization: Bearer <token> header.

The server exposes tools for finding, creating, and updating the core Linear primitives: issues, projects, comments, teams, users, labels, and issue statuses. A 2026 update added product management coverage including initiatives, initiative updates, project milestones, project updates, project labels, image loading, and broad support for resolving Linear resources by URL. This makes it suitable both for engineering workflows (triage, status updates, branch context) and for product workflows (roadmap edits and progress communication).

Because Linear hosts the server itself, there is nothing to deploy or self-host. Clients like Claude (Connectors), Cursor, VS Code, Windsurf, and Zed connect either directly to the remote endpoint or via the mcp-remote shim for clients that only speak stdio.

Tools

Tool	Description
`list_issues`	List issues in the workspace with filtering by team, assignee, status, etc.
`get_issue`	Retrieve a single issue with full details including attachments and git branch name.
`create_issue`	Create a new Linear issue.
`update_issue`	Modify an existing issue's fields.
`list_my_issues`	List issues assigned to the authenticated user.
`list_projects`	List projects in the workspace.
`get_project`	Retrieve details for a single project.
`create_project`	Create a new project.
`update_project`	Update an existing project.
`list_teams`	List teams in the workspace.
`get_team`	Retrieve details for a specific team.
`list_users`	List users in the workspace.
`get_user`	Retrieve a single user's profile.
`list_comments`	List comments on an issue.
`create_comment`	Post a comment to an issue.
`list_issue_statuses`	List available workflow states for a team.
`get_issue_status`	Retrieve a specific workflow state.
`create_initiative`	Create a new initiative.
`update_initiative`	Edit an existing initiative.
`create_initiative_update`	Post a status update on an initiative.
`create_project_milestone`	Create a milestone on a project.
`update_project_milestone`	Edit an existing project milestone.
`create_project_update`	Post a project update communicating progress.
`update_project_update`	Edit an existing project update.
`manage_project_labels`	Create and manage labels scoped to projects.

Setup Guide

Prerequisites

A Linear account with access to the workspace you want to connect.
Node.js installed locally (only needed for clients that go through the mcp-remote shim).

Claude Desktop

Open Settings, go to Connectors, and add the Linear connector. Claude will open an OAuth flow to authorize access to your workspace. No JSON editing required.

Cursor

Use the one-click install link from the Linear docs, or search the MCP tools directory for Linear.

VS Code / Windsurf / Zed (via mcp-remote)

For clients that only support stdio MCP servers, use the mcp-remote adapter:

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

In VS Code: Ctrl/Cmd + P → MCP: Add Server → Command (stdio) and paste the npx mcp-remote https://mcp.linear.app/mcp command. On first run a browser window will open for OAuth.

Using a bearer token instead of OAuth

If you prefer headless auth (CI, scripts, server agents), pass a Linear API key or OAuth token directly:

Authorization: Bearer <your_linear_token>

Troubleshooting

If your client cannot launch npx, update Node.js.
Connection issues can often be resolved by clearing the cached auth state in ~/.mcp-auth.
On Windows WSL, configure the SSE transport rather than stdio.

Use Cases

Triage inbound bug reports by searching existing Linear issues, then creating or updating tickets with the right team, assignee, and labels.
Let an engineering agent fetch the next assigned issue, read its description and linked attachments, and post a status comment when work begins.
Sync roadmap changes from a chat or doc tool: create or edit initiatives, project milestones, and project updates without leaving the AI client.
Generate weekly project health updates by reading recent issue activity and posting a create_project_update with progress and health.
Resolve Linear URLs pasted into a chat (issues, projects, initiatives) and pull the full context into the agent's working memory.

Example Prompts

"Find all P1 issues assigned to me in the Backend team and summarize what's blocked."
"Create a Linear issue in the Growth team titled 'Investigate signup drop on /pricing' with the bug label and priority High."
"Add a comment to ENG-482 confirming the fix is deployed to staging."
"Update the Q2 Billing Revamp project: push the target date to June 30 and post a project update marking it on-track."
"Create a milestone called 'Public beta' on the Mobile App project for the end of next month."

Pros

Official, first-party server hosted and maintained by Linear, so no self-hosting or key rotation.
Broad coverage of both engineering primitives (issues, comments, statuses) and product primitives (initiatives, milestones, project updates).
Standards-based OAuth 2.1 with dynamic client registration, plus optional bearer token auth for scripted use.
Works out of the box with Claude Connectors and Cursor, and with any stdio MCP client via mcp-remote.

Limitations

The exact tool surface is not exhaustively documented on the public docs page, so available actions may shift as Linear ships updates.
Stdio-only clients (e.g. some VS Code setups, WSL) require the mcp-remote shim and Node.js, which adds setup friction.
No self-hosted option: workspaces with strict data residency or air-gapped requirements cannot run the server locally.

Alternatives

tacticlaunch/mcp-linear: community open-source Linear MCP server that wraps the Linear GraphQL API, useful if you want to self-host.
cline/linear-mcp: a private/community MCP server for Linear used by the Cline project.
Jira or Asana MCP servers if you need similar project management capabilities but use a different tracker.