# How to connect Linear to OpenClaw (no API keys)

> Connect Linear to OpenClaw with ClawLink in one click — 32 tools your AI agent can call from chat via hosted OAuth. No API keys, no manual setup.

Web version: https://claw-link.dev/openclaw/linear

The usual route to Linear access for OpenClaw is an MCP server you configure and keep running, plus your own OAuth app or API keys. ClawLink gives OpenClaw a more practical Linear setup: install one ClawHub skill, connect Linear in the browser, and OpenClaw can call real Linear actions from any chat surface with no auth, token refresh, or tool wiring to build yourself.

**Start here:** install the ClawLink plugin (`openclaw plugins install clawhub:clawlink-plugin`), pair it in the browser, then connect the app in the ClawLink dashboard. The interactive install prompt is on the web version of this page: https://claw-link.dev/openclaw/linear

## Setup

It takes three steps to connect OpenClaw to Linear.

1. **Install ClawLink** — add the plugin to OpenClaw once.
2. **Connect Linear** — one-click OAuth in the ClawLink dashboard.
3. **Use it from chat** — ask OpenClaw in plain English.

**Alternative for any agent (no plugin needed):** if the OpenClaw plugin route isn't available or doesn't work, any AI agent with shell access can use the ClawLink CLI instead:

```bash
npx -y @useclawlink/cli login          # sign in via browser — no API key to paste
npx -y @useclawlink/cli connect linear  # connect Linear (browser OAuth)
npx -y @useclawlink/cli actions linear  # list available actions
npx -y @useclawlink/cli run linear <action> --input '<json>'  # execute (add --confirm for writes)
```

### Install by command

The setup prompt above does all of this in one paste. By hand, it is one install command plus a browser approval:

```bash
openclaw plugins install clawhub:clawlink-plugin
```

Then ask OpenClaw to set up ClawLink. It starts browser pairing and prints an approval link — open it, approve the device, return to the chat, and say `done`. Finally, connect Linear in the [ClawLink dashboard](https://claw-link.dev/dashboard) — a one-click OAuth approval, no API keys.

Verify the connection by asking OpenClaw:

> Use linear_list_linear_teams to find my team, then linear_list_issues_by_team_id for everything open. Group by state and tell me which issues have had no update in two weeks. Do not change anything.

### Using a different agent?

The OpenClaw plugin is one client of ClawLink's MCP server. Claude Code, Cursor, Codex, or any agent that can run a shell command pairs with the same ClawLink account through the CLI:

```bash
npx -y @useclawlink/cli login
```

`login` opens the same browser approval and stores a credential locally. Once Linear is connected in the dashboard, that agent calls the same 32 Linear tools over MCP. Full setup for MCP clients and shell agents: [connect apps to any AI agent](https://claw-link.dev/learn/connect-apps-to-any-ai-agent).

## Linear MCP for OpenClaw

Looking for a Linear MCP server for OpenClaw? ClawLink connects Linear to OpenClaw and exposes 32 Linear tools your agent can call over [MCP](https://claw-link.dev/learn/what-is-an-mcp-server), with [hosted auth](https://claw-link.dev/learn/oauth-for-ai-agents) and nothing to run or maintain yourself. Using Hermes instead? The [Hermes Linear integration](https://claw-link.dev/hermes/linear) works the same way.

Linear now ships its own hosted MCP server, so the honest question is not whether you need an API key — neither route asks for one — but which shape fits what you are building. Linear's server gives Linear-aware clients Linear tools. ClawLink gives OpenClaw the 32 Linear tools below through the same connection that also holds your GitHub, Slack, and Google accounts, so a single instruction can read an issue, check the related pull request, and post the summary somewhere else without you wiring three integrations together. You connect once in the browser, nothing goes into `openclaw.json`, and the credential stays on the ClawLink server.

## What the OpenClaw Linear integration can do

32 Linear tools are ready for OpenClaw once the account is connected. The 30 below are the ones people reach for most; your agent can call all 32.

### 30 of 32 Linear tools for OpenClaw

| Tool | What it does |
|---|---|
| **Create attachment** `linear_create_attachment` | Creates a new attachment and associates it with a specific, existing Linear issue. |
| **Create comment reaction** `linear_create_comment_reaction` | Tool to add a reaction to an existing Linear comment. Use when you want to programmatically react to a comment on an issue. |
| **Create linear comment** `linear_create_linear_comment` | Creates a new comment on a specified Linear issue. This action modifies shared workspace data and is not reversible — confirm the target issue and comment content before executing. |
| **Create linear issue** `linear_create_linear_issue` | Creates a new issue in a specified Linear project and team, requiring team_id and title, and allowing optional properties like description, assignee, state, priority, cycle, and due date. |
| **Create linear issue relation** `linear_create_linear_issue_relation` | Create a relationship between two Linear issues using the issueRelationCreate mutation. Use this to establish connections like 'blocks', 'duplicate', or 'related' between issues. |
| **Create linear label** `linear_create_linear_label` | Creates a new label in Linear for a specified team, used to categorize and organize issues. Label names must be unique within each team. |
| **Create linear project** `linear_create_linear_project` | Creates a new Linear project with specified name and team associations. |
| **Create project milestone** `linear_create_project_milestone` | Tool to create a project milestone in Linear with a name and optional target date and sort order. Use when you need to add milestones to track progress within a project. |
| **Create project update** `linear_create_project_update` | Tool to create a project status update post for a Linear project. Use when you need to post progress updates, status reports, or announcements for a project. |
| **Get attachment** `linear_get_attachment` | Downloads a specific attachment from a Linear issue; the `file_name` must include the correct file extension. |
| **Get current user** `linear_get_current_user` | Gets the currently authenticated user's ID, name, email, and other profile information — this is the account behind the API token, which may be a bot or service account rather than a human user. |
| **Get cycles by team ID** `linear_get_cycles_by_team_id` | Retrieves all cycles for a specified Linear team ID; cycles are time-boxed work periods (like |
| **Get issue defaults** `linear_get_issue_defaults` | Fetches a Linear team's default issue estimate and state, useful for pre-filling new issue forms |
| **Get linear issue** `linear_get_linear_issue` | Retrieves an existing Linear issue's comprehensive details, including id, identifier, title |
| **Get linear project** `linear_get_linear_project` | Retrieves a single Linear project by its unique identifier |
| **List issue drafts** `linear_list_issue_drafts` | List issue drafts |
| **List issues by team ID** `linear_list_issues_by_team_id` | List all issues for a specific Linear team, scoped by team ID |
| **List linear cycles** `linear_list_linear_cycles` | Retrieves all cycles (time-boxed sprint iterations) org-wide from the Linear account; no |
| **List linear issues** `linear_list_linear_issues` | Lists non-archived Linear issues; if project_id is not specified, issues from all accessible |
| **List linear labels** `linear_list_linear_labels` | Retrieves labels from Linear |
| **List linear projects** `linear_list_linear_projects` | Retrieves all projects from the Linear account |
| **List linear states** `linear_list_linear_states` | Retrieves all workflow states for a specified team in Linear, representing the stages an issue |
| **List linear teams** `linear_list_linear_teams` | Retrieves all teams with their members and projects |
| **List linear users** `linear_list_linear_users` | Lists all workspace users (not team-scoped) with their IDs, names, emails, and active status |
| **Search issues** `linear_search_issues` | Search Linear issues using full-text search across identifier, title, and description |
| **Update issue** `linear_update_issue` | Updates an existing Linear issue using its `issue_id`; requires at least one other attribute |
| **Update linear comment** `linear_update_linear_comment` | Update an existing Linear comment's body text |
| **Update linear project** `linear_update_linear_project` | Update an existing Linear project |
| **Remove issue label** `linear_remove_issue_label` | Removes a specified label from an existing Linear issue using their IDs; successful even if the |
| **Remove reaction** `linear_remove_reaction` | Remove a reaction on a comment |

## Example prompts

**Triage my team's open issues**

> Use linear_list_linear_teams to find my team, then linear_list_issues_by_team_id for everything open. Group by state and tell me which issues have had no update in two weeks. Do not change anything.

**File an issue with the right defaults**

> Check linear_get_issue_defaults for team \<team>, then create an issue with linear_create_linear_issue titled "\<title>", description from the error above, and priority high. Show me the payload before you create it.

**Comment and link related work**

> Find issue \ with linear_search_issues, add a comment with linear_create_linear_comment summarising the fix, and attach the PR link with linear_create_attachment.

**Write a project update from the issue list**

> Pull the issues in project "\<project>" with linear_get_linear_project and linear_list_linear_issues, then draft a project update covering what shipped and what slipped. Show it to me before posting with linear_create_project_update.

## How the Linear tools take their arguments

Details from the manifest that decide whether a Linear prompt works first time.

- **Everything is scoped by team.** `linear_list_linear_teams` returns the team ids that `linear_list_issues_by_team_id`, `linear_list_linear_states`, and `linear_get_cycles_by_team_id` all depend on. Resolve the team before anything else.
- **Ids are UUIDs, not the ENG-123 keys people say out loud.** `linear_search_issues` is how you turn a human reference into an id. A key passed where an id belongs is the most common silent failure here.
- **`linear_get_issue_defaults` previews a create.** It reports what a new issue on that team will default to, which is the cheapest way to avoid filing something with the wrong state or assignee.
- **States and labels must exist before you set them.** `linear_list_linear_states` and `linear_list_linear_labels` enumerate what the team actually has; `linear_create_linear_label` adds to the workspace, so only use it when a new label is genuinely intended.
- **Attachments are how external work gets linked.** `linear_create_attachment` ties a pull request, document, or dashboard to an issue, which is usually more useful than pasting the URL into a comment.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for OpenClaw. That is fine if you want to build and maintain the integration yourself. Most teams just want Linear working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Connection flow** | Register a Linear app, configure redirect URLs, manage consent details, and reconnect users when auth settings drift. | Users connect Linear through the hosted browser flow and ClawLink keeps the token lifecycle out of your app code. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for Linear. | ClawLink handles the repetitive integration plumbing so your team can focus on the workflow instead of the infrastructure. |
| **Agent usability** | You still need to expose the right Linear actions to the runtime in a format your agent can reliably use. | 32 tools for Linear are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Linear to AI agents. It is developer infrastructure: Python and TypeScript SDKs, an MCP server, and a catalog past 1,000 apps, aimed at teams shipping agent products. ClawLink is built for OpenClaw users instead. You install the plugin once, connect Linear in the browser, and the 32 tools above work from chat. There is no SDK, no config file, and no API key handling. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### OpenClaw installed the Linear skill but can't call the tools
The ClawHub skill teaches OpenClaw about Linear, but the calls run through the ClawLink plugin and your connected account. Make sure Linear is connected in the dashboard, then start a fresh chat so OpenClaw reloads the tool catalog. If OpenClaw runs as a persistent gateway, restart it so the new tools register.

### Connection succeeds but no tools appear
Reconnect Linear from the dashboard, then start a fresh chat if the runtime still has the old tool catalog loaded.

### "Tool schema not loaded yet" error when calling Linear tools
Linear tool schemas load on demand the first time a tool runs and are cached after that, so this error usually clears on its own: wait a few seconds and retry the same request. If every Linear call keeps failing with it in a fresh chat, reconnect from the dashboard, and contact support if it still persists — that pattern points to a configuration problem on our side, not something you can fix by reconnecting again.

### Linear returns 403 or "permission denied" on one action while others work
Two usual causes. The connected account may not have access to the specific workspace, inbox, store, or project in the request — check that first. If access looks right, the agent may have sent a placeholder value (like "YOUR_ID" or an example id from documentation) instead of a real one: ask it to run a list or search tool first, then retry the action with a real id from those results. Most failures at this stage are one of these two, not ClawLink bugs.

### Linear returns 403 or an authentication error on one action while reads work
Start with what the connection can see rather than with scopes. Run linear_get_current_user and linear_list_linear_teams: if the account is not a member of the team that owns the issue, reads of public data can succeed while writes fail, and the fix is team membership in Linear rather than anything in ClawLink. The second cause is a partial approval on the consent screen, which leaves a connection that reads but cannot write — reconnect from the dashboard and accept the full set. The third, which no search result covers, is a placeholder identifier: Linear ids are UUIDs, and an agent that passes an example id from documentation, or an issue key it invented rather than looked up, gets a permission-shaped error rather than a clean not-found.

Ask the agent to diagnose it:

```text
Call linear_get_current_user and linear_list_linear_teams, and tell me exactly which account is connected and which teams it belongs to. Do not retry the failed call yet.
```

### Linear issue search returns nothing although the issue exists
Two causes. First, team scope: linear_list_issues_by_team_id needs a real team id, and linear_search_issues only reaches what the connected account can see, so an issue in a private team the account is not in is genuinely invisible. Second, identifier confusion: humans refer to issues as ENG-123, but the tools address them by id, so an agent that passes the human key where an id belongs finds nothing. Ask it to search by text first with linear_search_issues and use the id from the result for anything that follows.

Ask the agent to diagnose it:

```text
Use linear_search_issues for a distinctive word from the title and show me the full result including ids. Then tell me which team each match belongs to.
```

### The agent sets a status that does not exist on this team
Linear workflow states are defined per team, so "Done" on one team may be "Shipped" or "Completed" on another, and an update that names a state the team does not have fails rather than being mapped to the nearest thing. Have the agent list the real states with linear_list_linear_states for that team before it updates anything, and use the state id from that list. The same applies to labels: linear_list_linear_labels returns what actually exists, and linear_create_linear_label is what you want only if you genuinely intend to add a new one to the workspace.

Ask the agent to diagnose it:

```text
Run linear_list_linear_states for the team that owns this issue and show me every available state with its id. Then tell me which one you were trying to set.
```

### OAuth finished in the browser but the account is still missing
Try reconnecting Linear and complete the consent flow in the same browser session. Partial OAuth approvals or switching accounts mid-flow can leave the connection incomplete.

### Is there a OpenClaw Linear integration?
Yes. ClawLink is the fastest way to connect OpenClaw to Linear: link your Linear account once in the browser and OpenClaw can call the Linear API through 32 ready-made tools — no custom code or token handling.

### How do I add Linear to OpenClaw with ClawLink?
Paste the setup prompt from this page into OpenClaw. It installs the ClawLink Linear skill from ClawHub, then you click Connect in the dashboard to authorize Linear. OpenClaw calls the tools from the next message — no config files or API keys to manage.

### How long does it take to connect Linear to OpenClaw?
About two minutes. Sign in, click Connect next to Linear in the dashboard, authenticate, and OpenClaw can use it from the next chat message.

### Why use ClawLink instead of wiring Linear up myself?
The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for OpenClaw. That is fine if you want to build and maintain the integration yourself. Most teams just want Linear working from chat.

### How is this different from Linear's own MCP server?
Linear's remote MCP server is a good product and it is the right answer if Linear is the only thing your agent needs to touch. The difference is scope. It exposes Linear to a client that speaks MCP; this connection puts Linear alongside every other integration you have connected in the same dashboard, with one pairing step for the agent and one place to revoke access. The workflows that benefit are the cross-product ones — turning a Slack thread into an issue, or attaching a deployment to the ticket that caused it — because the agent already holds all of those connections rather than one server per tool.

### Do I need a Linear API key or my own OAuth app?
Neither. You approve the connection on Linear's own consent screen and the credential lives on the ClawLink server, so there is no personal API key to generate in Linear's settings and no OAuth application to register. Your Linear permissions are unchanged: the agent sees the teams and projects your account can see, and Linear's own workspace rules apply on every call.

### Can the agent create and update issues, or only read them?
Both. It can create issues, comments, labels, projects, project milestones, project updates, attachments, and issue relations, and it can update issues, comments, and projects. The read side covers issues, projects, cycles, teams, users, states, labels, and search. The practical caution is on the write side: Linear issues are visible to your team immediately, so ask the agent to show you what it intends to create before it creates it, particularly for anything that notifies people.

### How do I stop the agent filing issues on the wrong team?
Name the team, and have the agent resolve it rather than guess. Linear scopes issues to teams, and almost everything else — cycles, states, labels — is scoped by team too, so an agent that picks a team implicitly will also pick that team's workflow states. Ask it to run linear_list_linear_teams first and confirm the team id it is going to use. linear_get_issue_defaults is the other useful step, because it reports what a new issue on that team will default to before anything is created.

### OpenClaw installed the Linear skill but can't call the tools
The ClawHub skill teaches OpenClaw about Linear, but the calls run through the ClawLink plugin and your connected account. Make sure Linear is connected in the dashboard, then start a fresh chat so OpenClaw reloads the tool catalog. If OpenClaw runs as a persistent gateway, restart it so the new tools register.

## Related

- [Connect GitHub](https://claw-link.dev/openclaw/github) — Manage repositories, issues, pull requests, and workflows
- [PagerDuty](https://claw-link.dev/openclaw/pagerduty) — Manage incidents, on-call schedules, and services
- [SafetyCulture](https://claw-link.dev/openclaw/safetyculture) — SafetyCulture (formerly iAuditor) is a workplace operations platform that enables teams to conduct digital inspections, manage audits, track issues, schedule tasks, and maintain compliance through mobile and web applications.