Resources · Make integration

Redmine Make integrationAutomate Redmine with Make.

Can Make keep Redmine issues, projects and logged hours moving without copy and paste? The Redmine Make integration gives you 22 modules: 6 triggers, 13 actions and 3 searches. This guide links your account, builds a first scenario with you and explains every module.

Try the Redmine integration on MakeSee the 22 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can you automate with the Redmine Make integration?

The Redmine Make integration links your Redmine account to Make, a no-code tool where you build a scenario: an automation made of modules, each one a brick that watches, creates, reads or changes something. Redmine can start the scenario when a new issue, project or time entry shows up, or receive the work other apps hand to it.

A ready project from day one. Watch Projects notices each new project, then Create an Issue opens the first tickets inside it, so nobody starts from an empty board.

Hours that land where finance reads them. Watch Time Entries picks up each entry a developer logs; the next module passes each entry to a spreadsheet or a billing app. When an entry is tied to a ticket, Get an Issue can add that ticket's details along the way.

Tickets opened from outside Redmine. A form, an email or a CRM record can end in Create an Issue, and Update an Issue changes the same ticket when the source moves on.

Every trigger here is scheduled: Make checks Redmine on the scenario's clock, so nothing fires the second an issue appears. The official doc is also flagged as AI-generated, so confirm details in Redmine itself. The Make review helps you judge the tool as a whole, and n8n vs Make sets out the criteria if your team hesitates between the two. For a hand on larger builds, see the Make agency.

Connect

How do you connect Redmine to Make?

  1. 01

    Copy your API key in Redmine

    You need an active Redmine account. Open My account in the top menu, scroll down to the API access key section and copy the key shown there. That key is what lets Make act on your behalf.

  2. 02

    Add a Redmine module in Make

    In your scenario, add any Redmine module and click Create a connection. A connection is your Redmine account linked to Make once. The Connection name field is optional, but a clear name helps later.

  3. 03

    Paste the credentials and save

    Enter the credentials you copied from Redmine, or follow the instructions Make shows on screen. Once saved, the connection appears in the list and every other Redmine module can reuse it.

First scenario

Build your first scenario with Redmine

GoalWhen a new project appears in Redmine, Make opens a kickoff issue in it.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the + in the middle of the editor. That empty circle is where your first module goes.

  2. 02

    Pick Watch Projects

    Search for Redmine, choose Watch Projects and select the connection you made earlier. This trigger is scheduled, which means Make checks Redmine for new projects each time the scenario runs.

  3. 03

    Add Create an Issue

    Click the + on the right of the trigger and add Create an Issue. Fill the issue fields and map data from the previous bundle, the item Watch Projects passes along, so the ticket lands in the new project.

  4. 04

    Test with Run once

    Create a test project in Redmine, then click Run once. Open the bubbles above each module to read the bundles they received and check that the issue landed in the right project.

  5. 05

    Schedule and switch it on

    Click the clock on Watch Projects to set the schedule. A new scenario runs every 15 minutes by default. Then turn the scenario on so it keeps working without you.

Triggers

Redmine triggers: what starts a scenario

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

Redmine1Watch Time Entries

Watch Time Entries

Scheduled trigger

In Make“Triggers when you add a new time entry.”

Each time someone logs hours in Redmine, this trigger hands the new time entry to your scenario, ready to send to a timesheet, an invoice draft or a report.

How it fires
scheduled. Make checks Redmine on the scenario's schedule, so entries arrive in batches at each check rather than one by one as they are saved.
When to use it
when the people who bill or plan need logged hours outside Redmine without asking the team for an export.
Watch out
every entry found is a bundle, and each module after it spends one operation per bundle.
Redmine2Watch Issue Priorities

Watch Issue Priorities

Scheduled trigger

In Make“Triggers when you add a new issue priority.”

When an admin adds a new priority level to Redmine, this trigger passes it to your scenario at the next check, so the tools that mirror your ticket setup can pick it up too.

How it fires
scheduled. Make asks Redmine for new priorities at each run of the scenario.
When to use it
when a help desk, a dashboard or a shared sheet keeps its own copy of your priority list and must stay aligned with Redmine.
Watch out
it reacts to a priority being added to the list, not to an existing issue changing priority, so it will not flag a ticket that becomes urgent.
Redmine3Watch Issues

Watch Issues

Scheduled trigger

In Make“Triggers when you add a new issue.”

Every new issue in Redmine becomes a bundle you can route to a chat channel, a CRM or a follow-up list.

How it fires
scheduled. Make looks for new issues on the scenario's schedule, every 15 minutes by default.
When to use it
when a new bug or request should reach someone who does not live in Redmine, such as an account manager or a support lead.
Watch out
if the same scenario also runs Create an Issue, it can pick up its own tickets on the next check.
Redmine4Watch Projects

Watch Projects

Scheduled trigger

In Make“Triggers when you add a new project.”

A new project in Redmine is often the start of real work elsewhere; this trigger passes that project to your scenario so the rest can be set up around it.

How it fires
scheduled. At each run, Make asks Redmine which projects were added since the last check.
When to use it
to open a shared folder, a client channel or kickoff tickets as soon as a project exists, without a manual checklist.
Watch out
on the Free plan, 15 minutes is the shortest gap between two checks, so allow for that delay before the rest happens.
Redmine5Watch Trackers

Watch Trackers

Scheduled trigger

In Make“Triggers when you add a new tracker.”

When your Redmine gains a new tracker, the category a ticket belongs to, this trigger tells the scenario so other tools can learn the new category.

How it fires
scheduled. Make polls Redmine for new trackers each time the scenario runs.
When to use it
when reporting or a form outside Redmine offers a list of ticket types that must match what admins configure.
Watch out
it only reports trackers being added; renaming or removing one does not start the scenario, so tidy those changes by hand.
Redmine6Watch Users

Watch Users

Scheduled trigger

In Make“Triggers when you add a new user.”

Every new person added to Redmine reaches your scenario, which lets you run the rest of onboarding from one place instead of several admin screens.

How it fires
scheduled. Make checks Redmine for new users on the scenario's schedule.
When to use it
when a new developer or client account should also get a welcome message, a spot in a team list or an alert to their manager.
Watch out
this trigger only sees accounts being added; someone who leaves or changes role does not start the scenario.
Modules

Redmine modules: what Make can do in your account

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

Redmine1

Create an Issue

Action

In Make“Creates an issue.”

Opens a new ticket in Redmine from whatever reached your scenario, so requests from a form, an email or a CRM land in the right project without retyping.

When to use it
when work arrives outside Redmine and your team still wants to track it there.
Watch out
keep it away from a scenario that starts on Watch Issues, or tickets can breed tickets.
Redmine2

Create a Project

Action

In Make“Creates a project.”

Sets up a Redmine project for you from an event elsewhere, like a deal marked won in your CRM or a signed quote, so the team gets a place to work straight away.

When to use it
when every new client or contract gets its own project and someone currently creates it by hand.
Watch out
test with Run once on a dummy record first, then remove the test project it made.
Redmine3

Create a Time Entry

Action

In Make“Creates a time entry.”

Logs hours in Redmine on behalf of a person, so time tracked in another tool or entered in a form still counts where your projects live.

When to use it
when part of the team records time outside Redmine and the totals there keep coming up short.
Watch out
run a single test entry and check it in Redmine before switching the scenario on, since doubled hours are hard to spot later.
Redmine4

Delete an Issue

Action

In Make“Deletes an issue.”

Removes a ticket from Redmine for good, which keeps the tracker clean when the same request has been closed or withdrawn in the tool it came from.

When to use it
for test or duplicate tickets your scenarios create, or requests cancelled upstream before anyone worked on them.
Watch out
a delete cannot be taken back from Make; add a filter before it so only the right issues reach this module.
Redmine5

Delete a Project

Action

In Make“Deletes a project.”

Erases a whole Redmine project from a scenario, along with the space your team worked in, so use it for clean-up rather than day-to-day flows.

When to use it
to remove sandbox projects spun up for tests or demos once they have served their purpose.
Watch out
nothing in Make brings a deleted project back; run it once by hand on a single project before any schedule touches it.
Redmine6

Delete a Time Entry

Action

In Make“Deletes a time entry.”

Takes a logged time entry out of Redmine, which fixes hours that were recorded twice or booked against the wrong task by another scenario.

When to use it
when a sync from another time tool has pushed an entry that should not be there and you want the fix to be automatic.
Watch out
the entry is gone once the module runs, so point it at one precise entry mapped from an earlier module.
Redmine7

Get an Issue

Action

In Make“Gets an issue.”

Fetches one Redmine issue with its details, so a later module can quote them in a message or a report.

When to use it
when your scenario only knows which issue is involved, from a time entry for example, and needs the full ticket to go further.
Watch out
it reads a single issue; to scan several, List Issues is the better choice.
Redmine8

Get a Project

Action

In Make“Gets a project.”

Reads one Redmine project and hands its details to the next module, handy when a notification or a document should carry the project's details.

When to use it
after a trigger that gives you a project reference but not everything you want to show a client or a manager.
Watch out
this module changes nothing; pair it with Update a Project when you need to edit what you read.
Redmine9

Get a Time Entry

Action

In Make“Gets a time entry.”

Pulls a single time entry from Redmine so your scenario can check it before sending it on to billing or reporting.

When to use it
when another app stores a Redmine entry reference and you want the current version rather than an old copy.
Watch out
one module, one entry; for a period or a whole project, List Time Entries returns them all as separate bundles.
Redmine10

Make an API Call

Action

In Make“Performs an arbitrary authorized API call.”

Reaches any endpoint of the Redmine API with the connection you already have, which covers what the other modules on this page leave out.

When to use it
once your need reaches past issues, projects and time entries, which are all the ready-made modules cover.
Watch out
you write the request yourself, so keep the Redmine API documentation open and test with Run once before going further.
Redmine11

Update an Issue

Action

In Make“Updates an issue.”

Changes an existing Redmine ticket from outside, so the ticket follows what happened in another tool without anyone editing it.

When to use it
when a customer reply, a merged change or a CRM update should move the related issue forward.
Watch out
map the issue from an earlier module instead of typing it by hand, otherwise every run edits the same ticket.
Redmine12

Update a Project

Action

In Make“Updates a project.”

Edits an existing Redmine project, which keeps it aligned with the client record or contract that lives in another app.

When to use it
when a client is renamed or a contract changes and the project in Redmine should reflect it without an admin stepping in.
Watch out
run it once on a test project and compare the result in Redmine before letting a schedule loose on real ones.
Redmine13

Update a Time Entry

Action

In Make“Updates a time entry.”

Corrects a time entry already in Redmine, so an adjustment made in a timesheet tool or approved by a manager also reaches the original record.

When to use it
when hours get reviewed after they are logged and the fixed figure must replace the first one instead of being added next to it.
Watch out
compare with Create a Time Entry: updating keeps a single record, creating adds a second one.
Redmine14

List Issues

Search

In Make“Lists issues.”

Returns a set of Redmine issues in one step, each coming out as its own bundle, which suits digests, reports and bulk updates.

When to use it
when your scenario needs every open ticket of a project, not just the newest one Watch Issues would catch.
Watch out
a search can return zero, one or many bundles, and each module after it runs once per bundle, which adds up in operations.
Redmine15

List Projects

Search

In Make“Lists projects.”

Brings back the Redmine projects your connection can see, one bundle per project, so a scenario can loop over all of them.

When to use it
to build a project overview in a spreadsheet or to run the same check on every active project.
Watch out
with many projects, the next modules run many times; add a filter right after it to keep only the ones that matter.
Redmine16

List Time Entries

Search

In Make“Lists time entries.”

Collects existing time entries from Redmine as separate bundles, a good base for a timesheet summary or an export to your billing tool.

When to use it
when you need hours already logged, before your scenario existed or outside what Watch Time Entries has seen.
Watch out
if nothing matches, the search returns zero bundles and the modules after it simply do not run.
Need help

Need help automating Redmine with Make?

A person reads every message.

FAQ

Redmine and Make: common questions

01Is the Redmine Make integration free?
Yes, Redmine is a standard app in Make, so its modules work on the Free plan. That plan allows 2 active scenarios, at least 15 minutes between two scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) lower the interval to 1 minute and remove the cap on active scenarios. Usage is counted in operations, one per module per bundle. Your Redmine subscription is a separate matter handled on the Redmine side.
02What do you need to connect Redmine to Make?
An active Redmine account and its API key. In Redmine, open your account page from the top menu, scroll to the API access key section and copy the key. In Make, add any Redmine module, click Create a connection, optionally fill in Connection name, then enter the credentials you copied or follow the instructions on screen. The connection is saved once and every Redmine module in your scenarios can reuse it, whether it watches, creates or lists.
03Do Redmine triggers in Make fire in real time?
No. All 6 Redmine triggers are scheduled: Make checks Redmine on the scenario's schedule instead of being called the moment something happens. A new scenario runs every 15 minutes by default. On the Free plan, 15 minutes is also the shortest possible interval; paid plans go down to 1 minute. So a new issue, project or time entry reaches your scenario at the next check. Anything found then is processed together, one bundle per item.
04What if the Redmine module you need is missing?
Use Make an API Call. It calls any endpoint of the Redmine API with the same connection as the other modules, which covers objects and actions the 22 ready-made modules leave out, since those focus on issues, projects and time entries. You write the request yourself, so test it with Run once. Also keep in mind that the official Make doc for Redmine is flagged as AI-generated, so verify important details in Redmine itself before building on them.
05Make or n8n for Redmine?
It depends on the tool your team already builds in. This page covers what Make offers for Redmine: 22 modules, 6 scheduled triggers, a guided connection with an API key and Make an API Call for the rest. The same app often has an n8n node too, so if n8n is already your standard, check the Redmine node there before moving tools. Compare on the modules you need and on who will maintain the scenario, rather than on the brand.
Same platform

Other docs you might need on this stack.

Browse all integrations