Resources · Make integration

Linear Make integrationAutomate Linear with Make.

Can Make act on your Linear issues without you copying anything by hand? Yes. The Linear Make integration gives you 13 modules, including 3 instant triggers, for issues and comments. This guide connects your account and walks you through a first working scenario.

Try the Linear integration on MakeSee the 13 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Linear Make integration do for you?

The Linear Make integration links your Linear workspace to Make, a no-code tool where you build a scenario: an automation made of modules, each module being one brick that watches, creates, reads or deletes something. With Linear, those bricks react to new issues and comments, and they write, update or remove them for you.

Turn a comment into follow-up work. Watch Comment Created fires when someone comments, and Create an Issue opens a separate ticket from it, so a remark buried in a thread becomes a tracked task.

Keep other tools in step with your board. Watch Issue Updated tells Make when an issue changes, and the next module of the scenario can pass that change to whatever app your team reads.

Pull data for a report. List Issues and List Comments return many items at once, each one a bundle (a single item passed from one module to the next), ready to feed a spreadsheet.

What the integration does not offer: a generic Make an API Call module. Its escape hatch is Execute a GraphQL Query, where you write the request to Linear yourself. If you already compare tools, the Linear n8n integration covers the same app on the other platform, and n8n vs Make lays out the differences. New to the editor? The Make training starts from zero.

Connect

How do you connect your Linear account to Make?

  1. 01

    Add a Linear module

    In your scenario, add any Linear module and click Create a connection. A connection is your Linear account linked to Make once, then reused by every Linear module you add later. If the module is instant, click Create a webhook first.

  2. 02

    Name the connection

    The Connection name field is optional. Filling it still helps: a name like the workspace it points to saves you from guessing later, once several connections sit in the same list.

  3. 03

    Paste your credentials

    Enter the credentials you copied from Linear, either a personal API key or an OAuth2 access token, or follow the instructions Make shows on screen. You need an active Linear account for this step.

First scenario

Build your first scenario with Linear

GoalWhen someone comments in Linear, Make opens a new issue that carries the comment.

  1. 01

    Start a blank scenario

    From the Scenarios page, create a new scenario and click the big + to place the first module. That first module decides when everything runs.

  2. 02

    Pick Watch Comment Created

    Search for Linear, choose Watch Comment Created, click Create a webhook, then Create a connection. From now on, Linear warns Make whenever a comment appears.

  3. 03

    Add Create an Issue

    Click the + on the right of the trigger and pick Create an Issue. Fill its fields and map the comment text from the first module into the issue, so each new ticket quotes what was said.

  4. 04

    Test with Run once

    Click Run once, then post a comment in Linear. Open the bubble above each module to read the bundle it received and check the issue that Make created.

  5. 05

    Switch it on

    Turn the scenario on. Because the trigger is instant, Linear calls Make through the webhook as soon as a comment is posted, with no schedule to wait for.

Triggers

Which Linear events can start a scenario?

3 modules start a scenario when something happens in Linear. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Linear as soon as it happens.

Linear1Watch Comment Created

Watch Comment Created

Instant trigger

In Make“Triggers when a new comment is created.”

Starts your scenario each time someone writes a new comment in Linear, and hands Make that comment as a bundle for the next modules to use.

How it fires
instant. Linear calls Make through a webhook as soon as the comment exists, so there is no polling interval to set.
When to use it
a customer-facing team wants every remark on a ticket echoed somewhere else, or turned into its own piece of work.
Watch out
it catches every new comment, not only the ones you care about. Plan what the scenario should do with each one before switching it on.
Linear2Watch Issue Created

Watch Issue Created

Instant trigger

In Make“Triggers when an issue is created.”

Reacts the moment a new issue lands in Linear, whether a teammate typed it or another tool created it, and passes that issue down the scenario.

How it fires
instant. Linear warns Make through a webhook right when the issue is created.
When to use it
you want a fresh bug report greeted with a standard first comment, or copied to the app where support tracks incoming problems.
Watch out
if the same scenario also runs Create an Issue, each issue it opens fires this trigger again and the scenario feeds itself. Keep creation and watching in separate scenarios.
Linear3Watch Issue Updated

Watch Issue Updated

Instant trigger

In Make“Triggers when an issue is updated.”

Fires when an existing issue changes, which makes it the trigger for everything that should follow the life of a ticket rather than its birth.

How it fires
instant. Linear sends the updated issue to Make through a webhook as soon as the change is saved.
When to use it
a product lead wants the sales team told when an issue linked to a deal moves forward.
Watch out
never pair it with a module that edits the same issue in that scenario. The edit counts as an update, which starts the scenario again, and each run spends operations, the unit Make counts on your plan.
Modules

What can Make do inside Linear?

Linear gives you 10 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Linear1

Create a Comment

Action

In Make“Creates a new comment.”

Posts a new comment on an issue for you, so information coming from another app shows up right where the team is already reading.

When to use it
a payment failed or a form was submitted elsewhere, and the related ticket should say so without anyone pasting it in.
Watch out
avoid it in a scenario started by Watch Comment Created, or every comment it writes will start another run.
Linear2

Create an Issue

Action

In Make“Creates a new issue.”

Opens a brand new Linear issue from data gathered earlier in the scenario, so the work lands on the board without anyone retyping it.

When to use it
a support form, an alert or a flagged email should turn into a ticket instead of waiting in an inbox.
Watch out
run a test with Run once on a single input first, since a trigger that returns many bundles opens as many issues.
Linear3

Delete a Comment

Action

In Make“Deletes an existing comment.”

Removes an existing comment from Linear. It exists mostly for cleanup, when a scenario posted something that no longer belongs in the thread.

When to use it
an automated status note became outdated and you would rather drop it than stack a correction under it.
Watch out
a delete cannot be undone from Make, so map the comment you target carefully and test on a throwaway issue.
Linear4

Delete an Issue

Action

In Make“Deletes an existing issue.”

Deletes an existing issue outright. Few scenarios need it, but it helps when an automation created tickets that should never have existed.

When to use it
a test run filled your board with sample issues and you want the scenario itself to tidy up.
Watch out
treat it as final. Put it at the end of the flow, after the module that identifies exactly which issue goes, never on a whole list.
Linear5

Execute a GraphQL Query

Action

In Make“Performs an arbitrary authorized GraphQL query.”

Lets you write your own request to Linear in GraphQL, a short text that names what to read or change. Reach for it when no ready-made module covers your need.

When to use it
you need a Linear object or a change that the twelve other modules do not handle, and someone on the team can write a query.
Watch out
it is the only technical module here. Without GraphQL knowledge, ask for help rather than guessing a query.
Linear6

Get a Comment

Action

In Make“Retrieves an existing comment.”

Fetches one specific comment you already know, and returns its content to the scenario so the following modules can reuse it.

When to use it
an earlier step gave you only a reference to the comment, and the next step needs what it actually says.
Watch out
it reads a single comment. To go through every comment, List Comments is the right choice.
Linear7

Get an Issue

Action

In Make“Retrieves an existing issue.”

Retrieves one existing issue so the rest of the scenario works with the full issue rather than a partial reference.

When to use it
a trigger from another app points to a Linear ticket, and you want the full issue before writing a message or updating a spreadsheet.
Watch out
each call is one operation. Fetch the issue once and map it downstream instead of repeating the module.
Linear8

Update a Comment

Action

In Make“Updates an existing comment.”

Edits a comment that already exists instead of posting a new one, which keeps a thread readable when the same status changes several times.

When to use it
a scenario keeps a single progress note on an issue and refreshes it at each step of a deployment or an order.
Watch out
store the comment reference when you first create it, since this module needs to know which comment to change.
Linear9

List Comments

Search

In Make“Retrieves a list of comments from account.”

Returns comments from your account as a series of bundles. One comment, one bundle, and the scenario handles them in turn.

When to use it
you want every comment exported to a sheet to review feedback, or scanned for a keyword the team agreed on.
Watch out
a search can return zero, one or many bundles, and every module placed after it runs once per bundle, spending operations each time.
Linear10

List Issues

Search

In Make“Retrieves a list of issues from account.”

Pulls a list of issues from your account, each arriving as its own bundle, which makes it the starting point of most reporting scenarios.

When to use it
a manager wants the open issues copied into a spreadsheet or a dashboard without logging into Linear.
Watch out
check with Run once what it really returns before you plug in the next modules, especially when the list is long.
Need help

Need help automating Linear with Make?

A person reads every message.

FAQ

Questions people ask about Linear and Make

01Is the Linear Make integration free?
Yes, Linear is a standard app in Make, so you can use it on the Free plan. That plan keeps you to 2 active scenarios, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Every module execution counts as an operation against your monthly credits. Paid plans (Core, Pro, Teams and Enterprise) lift the scenario cap and allow 40 minutes of execution. Your Linear subscription is a separate matter handled on Linear's side.
02What does it take to connect Linear to Make?
You need an active Linear account and one of two credentials: a personal API key or an OAuth2 access token. In Make, add a Linear module, click Create a connection, optionally name it, then paste the credentials or follow the on-screen instructions. For the OAuth2 route, create a New OAuth2 Application in Linear's API settings with the callback URI https://www.integromat.com/oauth/cb/linear, then copy the Client ID and the Client secret it shows.
03Do the Linear triggers in Make react in real time?
Yes. All three Linear triggers are instant: Watch Comment Created, Watch Issue Created and Watch Issue Updated. Linear calls Make through a webhook as soon as the event happens, instead of Make checking at an interval. That is why adding one of them asks you to click Create a webhook before Create a connection. Scheduled polling, every 15 minutes by default on a new scenario, applies to apps whose triggers are scheduled, not to these three.
04What if a Linear module is missing in Make?
It depends on your comfort with code. Linear has no generic Make an API Call module, but it offers Execute a GraphQL Query. Think of it as a blank module: instead of filling ready-made fields, you type a short request in GraphQL, the language Linear understands, saying what to read or change. It covers what the twelve other modules skip, but someone has to write that request. If that is out of reach, another app in your scenario can sometimes carry the step, or the team at Hack'celeration can build the query with you.
05Make or n8n: which one fits Linear better?
It depends on the tool you already run, since Linear has a node in n8n as well as its 13 modules in Make. In Make you get three instant triggers for issues and comments, ready-made actions for creating, updating and deleting, and a GraphQL module for the rest. If your other automations already live in Make, stay there. If they live in n8n, look at what the Linear node offers there before switching tools.
Same platform

Other docs you might need on this stack.

Browse all integrations