How to Export Linear Issues to Markdown (2026 Guide)

Linear is fast and opinionated — exactly what engineering teams want. It’s also where you accumulate enormous amounts of institutional knowledge: bug repros, design decisions, retrospectives, customer reports. Getting that content out as Markdown unlocks AI workflows, doc generation, and archival.

This guide covers every practical method to export Linear content.

Why Export Linear to Markdown?

• AI-assisted triage — feed recent issues to Claude or ChatGPT and ask “what themes are recurring?”
• Release notes from closed issues — Linear’s native “Build changelog” is great but inflexible; Markdown lets you mix and match
• Post-mortems — pull the incident issue plus all linked parents/children into a single Markdown doc for the retro
• RAG knowledge base — ingest closed issues into a vector store so future incidents surface relevant past ones
• Portfolio review — export a project’s issues as a single file for a stakeholder update
• Backup — sleep easier knowing you can reconstruct anything if Linear goes down

Method 1: Save Chrome Extension (fastest for 1–20 issues)

Save converts any Linear issue, project, or document page to clean Markdown with one click.

What Save captures from Linear:

• Issue title, status, priority, assignee, cycle, project
• Full description body with headings, code blocks, lists, and embedded attachments
• Labels and due dates as frontmatter
• Comment thread in posting order, with author + timestamp per comment
• Reactions inline (e.g. [:tada: × 3])
• Linked-to issues (parent/child/blocks/blocked-by) as Markdown links
• Attachments (images, linked docs) as Markdown references

What Save strips:

• Linear sidebar, command bar, keyboard-shortcut hints
• Workspace chrome and account widgets

When it’s the right tool: pulling a handful of issues for a writeup, extracting an incident’s parent issue plus all children for a post-mortem, quick one-offs.

Method 2: Linear GraphQL API

For bulk exports or scripted integration, Linear’s GraphQL API is the canonical path.

Typical flow:

1. Create a personal API key from Linear → Settings → API
2. POST GraphQL queries to https://api.linear.app/graphql with header Authorization: <api-key>
3. Query issues, comments, attachments, and linked issues
4. Walk the response and emit Markdown

A starter query:

query {
  issues(first: 100, filter: { project: { id: { eq: "PROJECT_ID" } } }) {
    nodes {
      identifier
      title
      description
      state { name }
      assignee { name }
      priority
      labels { nodes { name } }
      comments { nodes { body user { name } createdAt } }
    }
  }
}

Pros: programmatic, supports filtering and pagination, perfect for recurring exports.

Cons: you write the Markdown serialiser; pagination for large projects.

Method 3: Linear CLI (@linear/cli)

Linear ships a CLI that wraps common GraphQL operations. Good for ad-hoc queries, less so for full Markdown exports.

Example:

npx @linear/cli issues list --project "Engineering Migration"

Output is plain text or JSON. Pipe through a converter (e.g. a small Node script or jq + template) to emit Markdown.

When it shines: quick scripted queries, CI jobs that don’t need full-fidelity export.

Method 4: Linear’s Built-in Export

Linear → Settings → Workspace → Export currently exports a CSV of issues. Useful for spreadsheet analysis; not Markdown. You’d still need to script the CSV-to-Markdown step.

The engineering-team workflow

Most Linear users fall into one of three buckets:

Bucket A: “I want this issue in my notes”

1. Open the issue in Linear
2. Click Save in your Chrome toolbar
3. Markdown file lands in your downloads → drag into Obsidian / Notion / your RAG system

Bucket B: “Generate a release note from closed issues this cycle”

Use the GraphQL API:

query {
  issues(filter: { cycle: { id: { eq: "CYCLE_ID" } }, state: { type: { eq: "completed" } } }) {
    nodes { identifier title description labels { nodes { name } } }
  }
}

Pipe to a Node script that emits a templated Markdown changelog. Open-source starter: linear-cli-tools.

Bucket C: “Pull a full project into a Markdown archive for a stakeholder”

• If it’s 20 or fewer issues: Save each one manually (fast).
• If it’s 100+: script the GraphQL API.

What AI agents want from Linear exports

When the goal is feeding the export to Claude or ChatGPT for synthesis:

• Keep the issue identifier (ENG-1234) — the LLM often needs to reference it back
• Preserve status transitions — “Backlog → In Progress → Done over 3 weeks” is more informative than just “Done”
• Flatten comment threads in chronological order — not grouped by author
• Include linked-issue titles, not just their IDs — “blocks ENG-1230 (broken onboarding flow)” is useful; “blocks ENG-1230” alone isn’t

Save’s extraction already does all of this — Linear is a tier-1 supported site and the output is tuned for LLM consumption.

The practical call

• Ad-hoc, 1–10 issues: Save. Free tier → 3/mo, Plus → unlimited for $5.99.
• Regular changelog generation: GraphQL API script, run from CI.
• Full workspace archival: GraphQL API + a serialisation script, one-time run.
• “Where did we decide X last quarter”: Save on the decision issue, drop into Claude with “summarise the thread’s decision” → answer in 5 seconds.

Linear is fast. Your exports should be too.