Skip to main content
← Back to Articles
MCPCursor IDELinearproject managementengineeringAI codingissue tracking

Linear MCP Server Cursor IDE Setup 2026: Manage Issues from Your Editor

Connect Linear to Cursor IDE using MCP. Create issues, update cycles, and query your engineering backlog with AI — complete setup guide with API key config.

By Web MCP GuideApril 6, 20266 min read


Linear MCP Server Cursor IDE Setup 2026

Linear is the issue tracker built for engineering teams who care about speed. Connecting it to Cursor via MCP brings your issues, cycles, and projects directly into your AI coding workflow — no tab switching, no copy-pasting issue IDs. Here's the complete setup.

What This Integration Enables

With Linear MCP running in Cursor, you can:

  • Create issues from Composer with full metadata (title, description, priority, assignee, label)

  • Update issue status, priority, and cycle assignment

  • Search and retrieve issue details by keyword or ID

  • List your current cycle and what's in progress

  • Add comments to issues while staying in context

  • Link issues to each other (blocked by, relates to)

  • Query team backlogs with filters
  • Prerequisites


  • Cursor IDE 0.40+

  • Node.js 18+

  • Linear account with at least one workspace

  • Linear API key — generated in step 1
  • Step 1: Get Your Linear API Key

    1. Log in to Linear and open Settings (bottom-left).
    2. Navigate to API → Personal API Keys.
    3. Click Create new API key, give it a name like "Cursor MCP", and copy it.

    The key looks like lin_api_XXXXXXXXXXXXX. Keep it private — it has full access to your Linear workspace.

    Step 2: Get Your Team ID (Optional but Recommended)

    For scoped queries, grab your team's identifier:

    1. In Linear, go to Settings → Teams.
    2. Your team has a Key (e.g., ENG) and an ID.
    3. The team ID appears in the URL when viewing team settings.

    You can also discover this via the MCP server after setup using list_teams.

    Step 3: Install the Linear MCP Server

    Linear has an official MCP server:

    npm install -g @linear/mcp

    Or run it via npx without a global install:

    npx @linear/mcp --help

    Step 4: Configure Cursor

    Edit ~/.cursor/mcp.json (macOS/Linux) or %APPDATA%\Cursor\mcp.json (Windows):

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

    If you want to scope to a specific team by default, add:

    "LINEAR_TEAM_ID": "your_team_id"

    Step 5: Restart and Verify

    Quit Cursor fully and reopen. Go to Settings → Features → MCP — confirm "linear" appears with a green dot.

    Test in Composer:

    List my assigned Linear issues that are currently in progress

    A successful response means the integration is working.

    Real-World Use Cases

    Creating an Issue Mid-Coding

    You're implementing a feature and realize there's a dependency you need to track:

    Create a Linear issue in the Engineering team titled 
    "Migrate auth tokens to Redis" with priority Medium,
    label "Backend", and assign it to me

    Checking Your Current Cycle

    What's in my current Linear cycle? 
    Show me which issues I own and their status.

    Updating an Issue Status

    Update Linear issue ENG-241 status to "In Review"

    Adding Context to an Issue

    After a difficult debugging session:

    Add a comment to Linear issue ENG-198: 
    "Root cause identified — the race condition happens when two concurrent
    requests both hit the session creation endpoint before the first commit.
    Fix involves adding a distributed lock on session_id."

    Creating Issues from Code TODOs

    Paste a block of code with TODO comments into Composer:

    Review this code and create Linear issues for each TODO comment. 
    Use the Engineering team, label "Tech Debt", priority Low.
    [paste code block]

    Blocking and Relating Issues

    Mark Linear issue ENG-310 as blocked by ENG-287

    Troubleshooting

    API key returns 401


  • Verify the key starts with lin_api_ — if you accidentally copied a webhook secret or OAuth token, it won't work.

  • Regenerate the key in Linear Settings → API if you suspect it's been revoked.

  • Confirm your Linear workspace has API access enabled (Enterprise plans may have restrictions).
  • Issues not found despite correct ID


  • Linear issue IDs use team prefix format: ENG-123. Make sure you're using the full ID including the prefix.

  • The issue may be in an archived project or cycle. Check if it's accessible in the Linear web UI.
  • "Team not found" when creating issues


  • Your LINEAR_TEAM_ID may be the team key (e.g., ENG) rather than the UUID. Check which format your MCP server expects.

  • Some servers accept the team key, others require the UUID from the API. Try both formats.
  • Server connects but no tools appear


  • Clear the Cursor MCP cache: delete ~/.cursor/mcp-cache/ and restart.

  • Confirm you're running @linear/mcp and not an older community fork with different tool names.
  • Using Linear's GraphQL API Directly

    For power users, the Linear MCP server exposes a graphql_query tool that lets you run arbitrary Linear GraphQL:

    Run this Linear GraphQL query:
    {
    issues(filter: { assignee: { isMe: { eq: true } }, state: { type: { eq: "started" } } }) {
    nodes {
    identifier
    title
    priority
    updatedAt
    }
    }
    }

    This gives you full access to Linear's data model beyond what the pre-built tools expose.

    Combining with GitHub MCP

    Linear and GitHub are natural partners. A typical workflow:

    1. Query Linear for the issue you're working on and get full context.
    2. Write the code in Cursor with that context in Composer.
    3. GitHub MCP creates a branch named after the issue identifier.
    4. After your PR is merged, update the Linear issue status to Done.

    Get details for Linear issue ENG-341, 
    then create a GitHub branch called "eng-341-rate-limiting-fix"
    in the backend repo

    All in one Composer session.

    Security


  • Linear API keys grant full workspace read/write. Treat them like passwords.

  • Set chmod 600 ~/.cursor/mcp.json to restrict file access.

  • Don't commit mcp.json to any repository — add it to .gitignore.

  • Rotate the key in Linear Settings → API if you suspect it's been exposed.

  • Consider creating a dedicated "Cursor Integration" key with a recognizable name so you can revoke it independently.
  • More MCP Integrations

    Linear pairs well with GitHub, Notion, and Slack in Cursor. See the full MCP server directory to build out your engineering workflow.