Skip to content
Back to search

mcp-linear

MCP server that enables AI assistants to interact with Linear project management system through natural language, allowing users to retrieve, create, and update issues, projects, and teams.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/tacticlaunch/mcp-linear with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/tacticlaunch/mcp-linear'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/tacticlaunch--mcp-linear/badge.svg)](/listings/tacticlaunch--mcp-linear)

HTML

<a href="/listings/tacticlaunch--mcp-linear"><img src="/api/listings/tacticlaunch--mcp-linear/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Authentication

Personal API key (default)

1. Log in to your Linear account at [linear.app](https://linear.app) 2. Click on your organization avatar (top-left corner) 3. Select **Settings** 4. Navigate to **Security & access** in the left sidebar 5. Under **Personal API Keys** click **New API Key** 6. Give your key a name (e.g., `MCP Linear Integration`) 7. Copy the generated API token and store it securely — you won't be able to see it again

Personal API keys support the normal Linear and workspace-webhook tools. They cannot call Linear's alpha managed-child-OAuth-application API because that API requires the caller itself to be an OAuth application. With a personal API key, `linear_generateOAuthApplicationSetup` still prepares an official manifest and pre-filled Linear setup URL for an administrator to confirm.

OAuth access token (managed OAuth applications)

To let MCP actually create and manage child OAuth applications, authenticate it with an access token belonging to a Linear OAuth application that is eligible to manage those child applications:

export LINEAR_OAUTH_ACCESS_TOKEN=YOUR_OAUTH_ACCESS_TOKEN
mcp-linear

Or pass `--oauth-token YOUR_OAUTH_ACCESS_TOKEN`. Explicit command-line credentials take precedence over environment variables; when both environment credential types are present, OAuth authentication is selected. See Linear's [OAuth documentation](https://linear.app/developers/oauth-2-0-authentication) and [OAuth application manifests](https://linear.app/developers/oauth-app-manifests).

Each MCP server process uses one Linear credential. If the managing app token uses `actor=app` (which cannot receive `admin`) and you also need admin-scoped workspace-webhook tools, configure two MCP server entries: one with the managing OAuth token for child-app operations and one with a workspace administrator's personal API key for workspace webhooks. A user-actor OAuth token carrying `admin` can cover the webhook side instead.

OAuth scopes are selected when an authorization URL or client-credentials token is requested; they are not mutable fields on an OAuth application. The MCP validates current Linear scopes, prepares authorization URLs, and can issue app-actor tokens with `linear_createOAuthClientCredentialsToken`. For GitHub-hosted pipelines, enable the `client_credentials` grant and request the narrowest useful scope, such as `issues:create`.

Client-credentials tokens normally expire after 30 days and have no refresh token. Linear permits multiple active tokens only while they use the same scope set; requesting a different scope set revokes the application's existing app-actor tokens. The token tool therefore requires both `confirmSecretExposure: true` and `confirmScopeChangeRisk: true`.

Creating an OAuth app and rotating OAuth or webhook secrets returns one-time secret material through MCP. Those tools require `confirmSecretExposure: true`; move returned values directly into a secret manager such as GitHub Actions secrets and do not paste them into source control or logs.

Webhook URLs must be publicly reachable HTTPS endpoints. Validation rejects credentials in URLs and obvious loopback, private-network, link-local, and local-hostname destinations.

Installing via [add-mcp](https://github.com/neondatabase/add-mcp) (Recommended)

`add-mcp` installs the server into Claude Code, Cursor, Codex, VS Code, Claude Desktop, and many other MCP-aware agents with a single command:

npx add-mcp @tacticlaunch/mcp-linear --env LINEAR_API_TOKEN=YOUR_LINEAR_API_TOKEN

Add `-g` to install globally instead of into the current project. See the [add-mcp docs](https://github.com/neondatabase/add-mcp) for the full agent list and flags.

Manual configuration

Add the following to your MCP settings file:

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

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 192 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="https://github.com/tacticlaunch/mcp-linear/blob/main/docs/linear-app-icon.png?raw=true" alt="Linear App Icon" width="250" height="250">
  3. </p>
  4. # MCP Linear
  5. A Model Context Protocol (MCP) server for the Linear GraphQL API, built for real project-management workflows — not just basic issue CRUD.
  6. ![MCP Linear](https://img.shields.io/badge/MCP-Linear-blue)
  7. [![npm version](https://img.shields.io/npm/v/@tacticlaunch/mcp-linear.svg)](https://www.npmjs.com/package/@tacticlaunch/mcp-linear)
  8. <a href="https://glama.ai/mcp/servers/@tacticlaunch/mcp-linear">
  9. <img width="380" height="200" src="https://glama.ai/mcp/servers/@tacticlaunch/mcp-linear/badge" />
  10. </a>
  11. ## Features
  12. MCP Linear bridges AI assistants and Linear by implementing the MCP protocol. With it you can:
  13. - Retrieve issues, projects, teams, cycles, milestones, roadmaps, customers, customer needs, and workspace/project/initiative/team/issue/release/cycle documents
  14. - Create and update issues, change status, assign, and comment
  15. - Manage projects, full diff-aware project and initiative update lifecycles, milestones, roadmaps, saved views, and favorites
  16. - Create and manage workspace webhooks, including updates and signing-secret rotation
  17. - Prepare OAuth app manifests and authorization URLs, issue scoped client-credentials tokens, or manage child OAuth apps when authenticated as a managing OAuth application
  18. - Work with templates, custom fields, and attachments
  19. - Work with customer records, customer statuses/tiers, and customer needs linked to issues or projects
  20. - Read notifications, subscriptions, sessions, audits, and integrations without leaving MCP
  21. - Inspect rate-limit and server health before running heavy planning sessions
  22. See [`TOOLS.md`](./TOOLS.md) for the full inventory.
  23. ### MCP-native resources and prompts
  24. The server exposes MCP resources and prompts in addition to tools, including:
  25. - Resources: `linear://viewer`, `linear://organization`, `linear://teams`, `linear://projects`, `linear://project/{id}`, `linear://project/{id}/issues`, `linear://project/{id}/documents`, `linear://issue/{id}`, `linear://document/{id}`, `linear://roadmap/{id}`, `linear://milestone/{id}`, `linear://rate-limit`
  26. - Prompts: `summarize-project-status`, `draft-project-update`, `triage-issue`, `summarize-document`
  27. ## Example prompts
  28. Once connected, you can use prompts like:
  29. - "Show me all my Linear issues"
  30. - "Create a new issue titled 'Fix login bug' in the Frontend team"
  31. - "Change the status of issue FE-123 to 'In Progress'"
  32. - "Assign issue BE-456 to John Smith"
  33. - "Show all open issues in this project grouped by milestone and cycle"
  34. - "Draft a weekly project update from the current Linear state"
  35. - "Find the newest documents related to a project and summarize the key decisions"
  36. - "Show the pinned documents and links on this team's home page"
  37. - "Create a document for ENG-123 with resource ordering metadata"
  38. - "Get the latest project update diff and archive an outdated update"
  39. - "Show customer needs for this project and mark the important ones"
  40. - "Create an initiative update and hide the generated diff from the update body"
  41. - "Prepare a private OAuth app for my GitHub issue pipeline with client credentials enabled"
  42. - "Issue a narrowly scoped client-credentials token for that GitHub pipeline"
  43. - "Create a webhook for Issue and Comment events, then rotate its signing secret"
  44. ## Installation
  45. ### Authentication
  46. #### Personal API key (default)
  47. 1. Log in to your Linear account at [linear.app](https://linear.app)
  48. 2. Click on your organization avatar (top-left corner)
  49. 3. Select **Settings**
  50. 4. Navigate to **Security & access** in the left sidebar
  51. 5. Under **Personal API Keys** click **New API Key**
  52. 6. Give your key a name (e.g., `MCP Linear Integration`)
  53. 7. Copy the generated API token and store it securely — you won't be able to see it again
  54. Personal API keys support the normal Linear and workspace-webhook tools. They cannot call Linear's alpha managed-child-OAuth-application API because that API requires the caller itself to be an OAuth application. With a personal API key, `linear_generateOAuthApplicationSetup` still prepares an official manifest and pre-filled Linear setup URL for an administrator to confirm.
  55. #### OAuth access token (managed OAuth applications)
  56. To let MCP actually create and manage child OAuth applications, authenticate it with an access token belonging to a Linear OAuth application that is eligible to manage those child applications:
  57. ```bash
  58. export LINEAR_OAUTH_ACCESS_TOKEN=YOUR_OAUTH_ACCESS_TOKEN
  59. mcp-linear
  60. ```
  61. Or pass `--oauth-token YOUR_OAUTH_ACCESS_TOKEN`. Explicit command-line credentials take precedence over environment variables; when both environment credential types are present, OAuth authentication is selected. See Linear's [OAuth documentation](https://linear.app/developers/oauth-2-0-authentication) and [OAuth application manifests](https://linear.app/developers/oauth-app-manifests).
  62. Each MCP server process uses one Linear credential. If the managing app token uses `actor=app` (which cannot receive `admin`) and you also need admin-scoped workspace-webhook tools, configure two MCP server entries: one with the managing OAuth token for child-app operations and one with a workspace administrator's personal API key for workspace webhooks. A user-actor OAuth token carrying `admin` can cover the webhook side instead.
  63. OAuth scopes are selected when an authorization URL or client-credentials token is requested; they are not mutable fields on an OAuth application. The MCP validates current Linear scopes, prepares authorization URLs, and can issue app-actor tokens with `linear_createOAuthClientCredentialsToken`. For GitHub-hosted pipelines, enable the `client_credentials` grant and request the narrowest useful scope, such as `issues:create`.
  64. Client-credentials tokens normally expire after 30 days and have no refresh token. Linear permits multiple active tokens only while they use the same scope set; requesting a different scope set revokes the application's existing app-actor tokens. The token tool therefore requires both `confirmSecretExposure: true` and `confirmScopeChangeRisk: true`.
  65. Creating an OAuth app and rotating OAuth or webhook secrets returns one-time secret material through MCP. Those tools require `confirmSecretExposure: true`; move returned values directly into a secret manager such as GitHub Actions secrets and do not paste them into source control or logs.
  66. Webhook URLs must be publicly reachable HTTPS endpoints. Validation rejects credentials in URLs and obvious loopback, private-network, link-local, and local-hostname destinations.
  67. ### Installing via [add-mcp](https://github.com/neondatabase/add-mcp) (Recommended)
  68. `add-mcp` installs the server into Claude Code, Cursor, Codex, VS Code, Claude Desktop, and many other MCP-aware agents with a single command:
  69. ```bash
  70. npx add-mcp @tacticlaunch/mcp-linear --env LINEAR_API_TOKEN=YOUR_LINEAR_API_TOKEN
  71. ```
  72. Add `-g` to install globally instead of into the current project. See the [add-mcp docs](https://github.com/neondatabase/add-mcp) for the full agent list and flags.
  73. ### Manual configuration
  74. Add the following to your MCP settings file:
  75. ```json
  76. {
  77. "mcpServers": {
  78. "linear": {
  79. "command": "npx",
  80. "args": ["-y", "@tacticlaunch/mcp-linear"],
  81. "env": {
  82. "LINEAR_API_TOKEN": "<YOUR_TOKEN>"
  83. }
  84. }
  85. }
  86. }
  87. ```
  88. #### Client-specific configuration locations
  89. - Cursor: `~/.cursor/mcp.json`
  90. - Claude Desktop: `~/Library/Application Support/Claude/claude_desktop_config.json`
  91. - Claude VSCode Extension: `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
  92. - GoMCP: `~/.config/gomcp/config.yaml`
  93. ### Manual run
  94. Prerequisites:
  95. - Node.js (v20+)
  96. - NPM or Yarn
  97. - Linear personal API key or OAuth access token
  98. ```bash
  99. # Install globally
  100. npm install -g @tacticlaunch/mcp-linear
  101. # Or clone and install locally
  102. git clone https://github.com/tacticlaunch/mcp-linear.git
  103. cd mcp-linear
  104. npm install
  105. npm link # Makes the package available globally
  106. ```
  107. #### Running the server
  108. Run the server with your Linear API token:
  109. ```bash
  110. mcp-linear --token YOUR_LINEAR_API_TOKEN
  111. ```
  112. Or with a managing OAuth application's access token:
  113. ```bash
  114. mcp-linear --oauth-token YOUR_OAUTH_ACCESS_TOKEN
  115. ```
  116. Or set the token in your environment and run without arguments:
  117. ```bash
  118. export LINEAR_API_TOKEN=YOUR_LINEAR_API_TOKEN
  119. mcp-linear
  120. ```
  121. ## Validation
  122. The default validation path is:
  123. ```bash
  124. npm test
  125. npm run build
  126. ```
  127. `npm test` runs Jest unit tests and an official MCP SDK smoke test against the built stdio server, covering tool, resource, and prompt registration plus host-compatible schema emission.
  128. ## Development
  129. See [`DEVELOPMENT.md`](./DEVELOPMENT.md) for local development details.
  130. ## Links
  131. [tacticlaunch/cursor-memory-bank](https://github.com/tacticlaunch/cursor-memory-bank) — If you are a developer seeking to enhance your workflow with Cursor, consider giving it a try.
  132. ## License
  133. This project is licensed under the MIT License — see the [`LICENSE`](./LICENSE) file for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.