Resources · Make integration

Jenkins Make integrationAutomate Jenkins with Make.

A Jenkins job changes state, and Make hears about it right away. The Jenkins Make integration comes down to a single instant trigger: Jenkins calls Make through a webhook as soon as the status moves. This page shows where to plug it in and what to put behind it.

Try the Jenkins integration on MakeSee the 1 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Jenkins Make integration actually do?

It links your Jenkins account to Make once, then lets an automation start on its own when a job changes state. That automation is called a scenario: a chain of modules, where a module is one brick borrowed from one app. Jenkins lends exactly one brick to the chain, and that brick always sits at the front.

Three shapes come up again and again. The first one keeps people informed: Watch Job Status Notification catches the status change and the module you place next carries it to the channel where the team already talks. The second one keeps a record, feeding a spreadsheet row or a database entry so a failure leaves a readable trace instead of living in the console. The third one hands work over, opening a ticket or moving a card so whoever is on duty finds it without being told.

Worth knowing where the ceiling is. On the Jenkins side, Make offers that trigger and nothing else. There is no action module, so nothing in Make starts a job, stops one or reads a log for you. Everything that happens after the trigger belongs to the other apps in your scenario, and that is where the value gets built.

Jenkins also exists as a node in n8n. If the choice is still open, the n8n vs Make comparison lays out the criteria and the Jenkins n8n integration shows the other version. New to Make? The Make training walks through the editor, and Make troubleshooting is there for the day a scenario stops.

Connect

How do you connect Jenkins to Make?

  1. 01

    Get your credentials out first

    Make has to prove to Jenkins who you are, so keep an active Jenkins account at hand plus an API token (a key Jenkins generates so another tool can sign in) or the user credentials you normally log in with. The connection window asks for them straight away.

  2. 02

    Open the connection window

    In your scenario, add the Jenkins module and click Create a connection. That connection is your Jenkins account tied to Make once and reused by every Jenkins module after it. Naming it is optional, and handy if you plug in a second account later.

  3. 03

    Paste the token, then save

    Drop the API token or the user credentials into the window and click Save. Make keeps the connection on your account, so the next scenario that touches Jenkins picks it from a list instead of asking you again.

First scenario

Your first scenario, from empty canvas to live

GoalWhen a job changes state in Jenkins, Make picks it up and passes it to the next app.

  1. 01

    Create the scenario

    From the Scenarios page, start a new scenario and click the + to place the first module. That blank canvas is where the chain is going to live.

  2. 02

    Put the trigger down

    Search Jenkins by name, pick Watch Job Status Notification and click Create a connection to link the account. It goes first because it is what gives the starting signal.

  3. 03

    Add what comes next

    Click the + on the right of the trigger to add the module of the app that should receive the news, then map the data the trigger sends into the places that module expects it.

  4. 04

    Test with Run once

    Click Run once, then make a job change state on your side. The scenario runs one time and shows what each module received: one bundle, meaning one item travelling from module to module.

  5. 05

    Switch it on

    Save, then flip the scenario on. Because the trigger is instant, there is no interval to set on it: it waits for the call from Jenkins and runs again at every status change.

Triggers

What sets the scenario in motion

1 module starts a scenario when something happens in Jenkins. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Jenkins as soon as it happens.

Jenkins1Watch Job Status Notification

Watch Job Status Notification

Instant trigger

In Make“Triggers when a job status has been changed.”

This is the only Jenkins module available in Make, and it watches one thing: a job whose status has just changed. At that moment it hands the scenario one item carrying what Jenkins reported, and everything you placed behind it runs on that.

How it fires
instantly. Jenkins calls Make through a webhook as soon as it happens, so nothing sits waiting on an interval to hear the news.
When to use it
when a status has to reach a person, a channel or a ticket without anyone refreshing a dashboard.
Watch out
it reports, it does not act. Nothing here lets you start or stop a job from Make, so the rest of the chain gets built with other apps.
Need help

Need help automating Jenkins with Make?

A person reads every message.

FAQ

Questions that come up next

01Is the Jenkins Make integration free?
Yes. Jenkins is a standard app in Make, so it sits on every plan including Free, and the app itself costs nothing extra. What Free limits is the room around it: 2 active scenarios, 5 minutes of execution per run, files up to 5 MB and 512 MB of transfer. The 15-minute minimum interval people often quote applies to scheduled scenarios; this trigger is instant, so that is not what holds you back. Paid plans lift the cap on active scenarios and stretch execution to 40 minutes.
02What do you need to connect Jenkins to Make?
Three things: an active Jenkins account, an API token or your user credentials, and a Make account on any plan. The documentation lists no other prerequisite. The connection is created once and stays on your Make account, so you do not redo it for every scenario, and because all Jenkins modules share it there is only one place to update the day the token changes. If the Jenkins account you use needs a subscription of its own, that is settled on the Jenkins pricing page, not in Make.
03Does the trigger react in real time?
Yes. Watch Job Status Notification is an instant trigger: Jenkins calls Make as soon as a job status changes, which is exactly why there is no interval to configure on it. The practical consequence is that the scenario has to be switched on to hear that call, since nothing reaches Make while it sits off. Scheduled triggers work the other way around, with Make looking at regular intervals, 15 minutes minimum on the Free plan. Jenkins is not in that group.
04What if the module you need is missing?
Then you work around it. Jenkins has a single module in Make and no Make an API Call, the generic module some apps ship to reach any endpoint of their API. Without it, Make cannot send a request of your own design to Jenkins. Two ways out: give the missing step to another app in your scenario that does have the right module, or ask the team to look at the case with you. Either way the Jenkins trigger still works as a starting point.
05Make or n8n for Jenkins?
It depends on what happens after the trigger. Make gives you this one instant trigger and an editor where the chain is drawn module by module, which suits a short path: a status change goes out to a channel, a sheet or a ticket, and you leave it running. In n8n, Jenkins arrives as a node and fits better when that step is one piece of longer automations you already keep there. Neither is faster or cheaper for this job, so pick on the dull questions: where your automations already live, and who opens the editor when something breaks.
Hack'celeration Lab

Get our weekly automation tips.

No spam. Unsubscribe anytime.

Same platform

Other docs you might need on this stack.

Browse all integrations