How to Integrate Slack with GitLab

Your code gets merged. Your pipeline fails. A critical issue gets opened.

And nobody finds out for 40 minutes — because everyone is buried in their own tab.

That’s the problem Slack-GitLab integration solves.

When your development activity and your team communication live in two separate worlds, things fall through the cracks. Decisions get delayed. Bugs sit longer than they should. Deploys get missed.

According to a study by RescueTime, knowledge workers switch between apps and websites over 300 times a day — and developers are no exception. Every context switch costs time, and it takes an average of 23 minutes to fully regain focus after an interruption (University of California Irvine).

The fix is simple: bring GitLab into Slack, where your team already lives.

This guide walks you through exactly how to do it — step by step — so your team gets the right information, at the right time, without hunting for it.

Why Integrating Slack with GitLab Actually Matters

Before jumping into setup, it helps to understand what you’re actually solving.

GitLab is where your code lives — merge requests, pipelines, issues, deployments. Slack is where your team communicates — threads, decisions, quick questions. When these two tools work in silos, you create a coordination tax every developer pays every single day.

Here’s what the data says about teams that fix this:

• Teams using DevOps integrations deploy 208x more frequently than teams that don’t, according to DORA research published in the State of DevOps Report.
• 63% of software teams report that poor tool integration is one of their top collaboration challenges (GitLab DevSecOps Survey).
• Developers lose up to 4.8 hours per week just from context switching between disconnected tools (Qatalog & Cornell University study).

When Slack and GitLab are connected, your team gets pipeline alerts, merge request updates, issue assignments, and deployment notifications directly in the channels that matter — no tab-switching, no missed updates.

What You Can Do With the Slack-GitLab Integration

Once connected, here’s what becomes possible:

• Real-time pipeline notifications — Get alerted when a CI/CD pipeline passes, fails, or is skipped.
• Merge request alerts — Know the moment an MR is opened, reviewed, merged, or closed.
• Issue updates — Receive notifications when issues are created, assigned, or change status.
• Deployment tracking — See when a deployment starts or completes in any environment.
• Custom channel routing — Send different GitLab events to different Slack channels based on project or type.
• Slash commands — Use /gitlab commands directly in Slack to trigger actions without leaving the app.

Method One — Integrate Using GitLab’s Built-In Slack Integration

This is the easiest route. GitLab has a native Slack integration that handles the most common use cases without any third-party tools.

Step One: Create an Incoming Webhook in Slack

Before touching GitLab, you need a webhook URL from Slack.

Go to api.slack.com/apps and click Create New App. Choose From scratch, name it (e.g., “GitLab Notifications”), and select your workspace.

Once the app is created, click Incoming Webhooks in the left sidebar. Toggle it on, then click Add New Webhook to Workspace. Select the Slack channel where you want GitLab notifications to land, then click Allow.

Copy the webhook URL — it looks like: https://hooks.slack.com/services/TXXXXX/BXXXXX/XXXXXXX

Step Two: Add the Webhook to GitLab

Log in to your GitLab account and navigate to the project you want to integrate (you can also do this at the group level for broader coverage).

Go to Settings → Integrations → Slack notifications.

Paste the webhook URL you copied from Slack into the Webhook field.

Step Three: Configure Your Notification Triggers

This is where you customize exactly what gets sent to Slack.

GitLab lets you toggle notifications for:

• Push events — when someone pushes to a branch
• Issues — creation and updates
• Merge requests — opened, merged, or closed
• Tag pushes — when a tag is created or updated
• Pipeline events — success, failure, or skipped
• Deployment events — started or finished
• Alert events — when monitoring alerts trigger

Turn on the events relevant to your team. For most teams, pipeline events, merge requests, and deployment events are the highest value.

You can also set a Branch filter — so you only receive push notifications for specific branches like main or production.

Step Four: Test and Save

GitLab gives you a Test settings button before you save. Click it. If everything is configured correctly, you’ll see a test message appear in your chosen Slack channel.

Click Save changes and you’re live.

Method Two — Integrate Using the GitLab for Slack App

If you want deeper functionality — including slash commands and two-way interaction — use the official GitLab for Slack app.

Step One: Install the GitLab Slack App

In Slack, go to Apps and search for GitLab. Click the GitLab app from the search results, then click Add to Slack.

Follow the OAuth authorization flow to grant the necessary permissions. Slack will redirect you back once the app is installed.

Step Two: Connect GitLab to the App

Once the app is installed, open any Slack channel and type /gitlab connect. The app will prompt you to authenticate with your GitLab account via OAuth.

After authentication, the GitLab bot will confirm the connection.

Step Three: Subscribe Your Channels to GitLab Projects

In the Slack channel where you want notifications, type:

/gitlab subscribe [namespace/project-name]

For example:

/gitlab subscribe mycompany/backend-api

You’ll see a confirmation message listing the default events your channel is now subscribed to.

Step Four: Customize Subscriptions

By default, the app sends notifications for pushes, issues, MRs, tags, and pipelines. You can customize what you receive using the subscribe command with filters:

/gitlab subscribe mycompany/backend-api branches merges

Or unsubscribe from specific events:

/gitlab unsubscribe mycompany/backend-api issues

To see what your channel is currently subscribed to:

/gitlab subscriptions

Method Three — Use Webhooks for Custom or Advanced Setups

If you need fine-grained control over what data gets sent and how it’s formatted, GitLab’s system-level webhooks give you full flexibility.

Step One: Go to System Hooks (Admin) or Project Webhooks

For project-level webhooks: Settings → Webhooks

For system-level webhooks (affects all projects): Admin Area → System Hooks

Step Two: Enter the Webhook URL and Configure Events

Paste your Slack incoming webhook URL (created the same way as Method One). Then select the specific events you want to trigger the webhook.

You can also add a Secret Token for verification — GitLab sends this in the X-Gitlab-Token header so your receiving endpoint can confirm the request is authentic.

Step Three: Enable SSL Verification

Unless you’re using a self-hosted server without SSL, keep SSL verification enabled. This ensures your webhook traffic is encrypted in transit.

Click Add webhook and test the connection using the Test button next to any event type.

How to Route Notifications to Different Channels

One of the most powerful things about the Slack-GitLab integration is channel routing.

Instead of dumping every GitLab event into one noisy channel, you can send specific notifications to the teams that actually care about them.

Here’s a practical channel structure that works well for most teams:

To set this up, create separate Slack webhook endpoints for each channel, then configure different events in GitLab to point to different webhook URLs. With the GitLab Slack app, you simply run /gitlab subscribe in each respective channel for the relevant project.

Using GitLab Slash Commands in Slack

Once connected via the GitLab Slack app, your team can take GitLab actions directly from Slack — no need to open a browser tab.

Here are the most useful slash commands:

View open issues:

/gitlab [namespace/project] issue show [issue number]

Create an issue:

/gitlab [namespace/project] issue create

View a merge request:

/gitlab [namespace/project] merge_request show [MR number]**

Deploy:

/gitlab [namespace/project] deploy [from environment] to [to environment]

These commands are particularly useful for quick triage during incidents — your team can check issue status and kick off actions without ever leaving the Slack thread.

Troubleshooting Common Issues

Even with a straightforward setup, a few things can go wrong. Here’s how to fix the most common problems.

Notifications aren’t appearing in Slack

First, check that the webhook URL is still active in Slack. Webhooks can be deactivated if the Slack app is removed or permissions change. Go back to api.slack.com/apps and confirm your webhook is listed as active.

Then verify in GitLab that the correct events are toggled on under Settings → Integrations → Slack notifications.

The test message works but live events don’t trigger

This usually means the branch filter is too restrictive. Double-check that your active branch matches the branch name in your filter settings. A filter set to main won’t catch events on feature branches.

Getting too many notifications

Scale back the events you’ve subscribed to. Most teams find that pipeline events and MR updates are enough — push notifications for every branch commit tend to create noise quickly.

Slash commands return an error

Re-run /gitlab connect to refresh the OAuth connection. Tokens can expire, especially if there have been changes to the GitLab user account or permissions.

Webhook returns a 401 error

This means GitLab can’t authenticate with Slack. Regenerate your incoming webhook URL in Slack and update it in GitLab.

Best Practices to Get the Most Out of the Integration

Setting up the integration is only step one. Here’s how to actually make it useful for your team:

Keep notifications high signal. Only subscribe to events that require action or awareness. The goal is fewer interruptions, not more.

Use dedicated channels for different alert types. A #incidents channel for critical failures keeps urgent noise separate from routine updates.

Set up notification quieting in Slack. Use Slack’s Do Not Disturb settings so off-hours pipeline runs don’t ping people at 2 AM.

Review subscriptions quarterly. Teams evolve. Projects change. Set a reminder every three months to audit which channels are subscribed to what — dead subscriptions create confusion.

Combine with GitLab Review Apps links in notifications. If you’re using Review Apps, the merge request notification can include a direct link for reviewers to preview — paste this into the MR description and it surfaces in the Slack notification automatically.

Conclusion

Integrating Slack with GitLab is one of the highest-leverage things you can do for your development workflow.

The average developer loses nearly 5 hours a week to context switching between disconnected tools. Fixing that doesn’t require a new process or a reorganization — it requires a 10-minute setup that keeps your team informed where they already communicate.

Use GitLab’s built-in Slack integration for straightforward notifications. Use the GitLab Slack app if you want slash commands and two-way interaction. Use system webhooks if you need a custom setup or granular control.

Whichever method fits your workflow — the result is the same: your team spends less time hunting for information and more time shipping.

Set it up today. The first notification that saves you from a missed deploy will make it worth it.