Zoho Cliq and GitHub Integration: Developer Notifications and PR Alerts in Chat

Development teams that split their attention between GitHub and a team messaging app lose minutes on every context switch. A pull request sits unreviewed for hours because the assigned reviewer never saw the notification buried in email. A CI/CD pipeline fails on the main branch, and nobody catches it until the next developer tries to merge. Zoho Cliq and GitHub integration solves this by routing repository events, from PR reviews to deployment status updates, directly into the channels and bot conversations where your engineering team already works. This guide covers the full technical setup: configuring Cliq bots with incoming webhooks, selecting the right GitHub events, building actionable message cards, and creating slash commands that let developers interact with GitHub without leaving chat.

Why Connect Zoho Cliq with GitHub

Most development teams already use a chat tool for standups, quick questions, and incident response. GitHub notifications, on the other hand, default to email or the GitHub web UI, both of which sit outside the primary communication flow. This disconnect creates blind spots.

Connecting Zoho Cliq’s incoming webhook handlers with GitHub webhooks closes that gap. PR review requests appear in a dedicated channel seconds after they are created. Build failures surface immediately, with a button that opens the failed run in one click. Issue assignments ping the right person in their Cliq DM rather than sitting in an inbox.

The practical benefits for engineering teams include:

• Faster code review cycles because reviewers see requests in real time
• Reduced mean time to detection for broken builds
• Single-pane visibility across repositories without switching tabs
• Actionable notifications that link directly to the PR, issue, or deployment

If your team already uses Zoho Cliq for team messaging, adding GitHub integration is a natural next step that compounds the value of both tools.

Setting Up the Zoho Cliq Bot and Incoming Webhook

The foundation of this integration is a Cliq bot configured with an incoming webhook handler. This bot receives HTTP POST requests from GitHub and converts the raw JSON payload into formatted messages for your channels or direct conversations.

Step 1: Create a New Bot

Open Zoho Cliq and navigate to your profile picture, then select Bots and Tools. Click on Bots, then Create Bot. Give it a name like “GitHub Notify” and a description that clarifies its purpose. Save the bot to reach the handlers configuration page.

Step 2: Configure the Incoming Webhook Handler

In the bot handlers list, locate the Incoming Webhook Handler and click Edit Code. This handler fires every time an external service sends data to your bot’s webhook URL. The handler receives a parameter object containing headers and body from the incoming request. Write Deluge code that parses the GitHub event payload and returns a formatted message card.

A minimal handler that posts push event details looks like this:

response = Map();
body = payload.get("body");
event = headers.get("X-GitHub-Event");
if(event == "push")
{
    repo = body.get("repository").get("full_name");
    pusher = body.get("pusher").get("name");
    commits = body.get("commits");
    msg = pusher + " pushed " + commits.size() + " commit(s) to " + repo;
    response.put("text", msg);
}
return response;

Step 3: Generate a Webhook Token

Go to Bots and Tools, then Webhook Tokens. Click Generate New Token. Cliq allows a maximum of five active tokens at any time, so plan your allocation if you run multiple integrations. Copy the token, you will append it to the webhook URL when configuring GitHub.

The complete bot webhook URL follows this format: https://cliq.zoho.com/api/v2/bots/github-notify/incoming?zapikey=YOUR_TOKEN

Configuring GitHub Webhooks for Cliq

On the GitHub side, open the repository you want to connect. Navigate to Settings, then Webhooks, and click Add webhook. Paste the Cliq bot webhook URL in the Payload URL field. Set the content type to application/json. Leave the secret field empty unless you want to implement HMAC signature verification in your Deluge handler.

Selecting the Right Events

GitHub offers over 40 webhook event types. Subscribing to all of them floods your channel with noise. For a developer notification bot, these events cover the most common use cases:

Event	What It Covers	Typical Use
pull_request	PR opened, closed, merged, review requested	Review cycle tracking
pull_request_review	Review submitted (approved, changes requested)	Review status updates
issues	Issue opened, assigned, closed, labeled	Bug and task tracking
push	Commits pushed to any branch	Branch activity monitoring
check_run / check_suite	CI/CD build started, completed, failed	Build status alerts
deployment_status	Deployment succeeded or failed	Release monitoring
release	New release published	Version announcements

Select “Let me select individual events” and check only the events your team actually needs. You can always add more later without recreating the webhook.

Building Actionable Message Cards for PR Alerts

Plain text notifications get ignored. Message cards with structured data and clickable buttons drive action. Zoho Cliq’s message card format supports titles, themed layouts, and button arrays that open URLs or invoke server-side functions.

PR Review Request Card

When a pull_request event fires with the action “review_requested”, your handler can return a card that shows the PR title, author, branch, and a button linking directly to the review page. The Deluge response structure uses the card and buttons objects:

response = Map();
card = Map();
card.put("title", "Review Requested: " + pr_title);
card.put("theme", "modern-inline");
response.put("card", card);

buttons = list();
btn = Map();
btn.put("label", "Open PR");
btn.put("type", "+");
action = Map();
action.put("type", "open.url");
data = Map();
data.put("web", pr_url);
action.put("data", data);
btn.put("action", action);
buttons.add(btn);
response.put("buttons", buttons);
return response;

This pattern works for any GitHub event. Change the card title and button URL based on the event type and action field in the payload.

Routing Notifications to the Right Channel

Bot messages go to the user who installed the bot by default. To post to a specific channel, use the Cliq channel webhook endpoint instead of the bot endpoint. The URL format is https://cliq.zoho.com/api/v2/channelsbyname/CHANNEL_NAME/message?zapikey=YOUR_TOKEN. This lets you create dedicated channels like #frontend-prs, #backend-builds, or #deploys and route events based on repository or branch.

CI/CD Build Status Notifications

Failed builds on the main branch are high-priority events. The check_run and check_suite events from GitHub Actions, CircleCI, or any CI provider that integrates with GitHub’s Checks API provide the build status payload your Cliq bot needs.

When a check_run event arrives with conclusion set to “failure”, your handler should:

1. Extract the repository name, branch, commit SHA (first 7 characters), and the check run name
2. Build a message card with a red-themed alert showing the failed check details
3. Add two buttons: one to open the check run URL in GitHub, and one to open the commit diff
4. Post to the team’s build-alerts channel

For teams managing project workflows with Zoho Projects, you can extend this handler to create a Zoho Projects task whenever a critical build fails, ensuring the fix gets tracked alongside your sprint backlog.

Deployment Alerts and Approval Workflows

The deployment_status event fires when a GitHub deployment transitions between states: pending, in_progress, success, failure, or error. This is particularly useful for teams that use GitHub Environments with required reviewers.

A deployment notification card should include the environment name (staging, production), the deployed commit reference, the deployer, and the current status. For production deployments, add a button that opens the deployment log and another that links to your monitoring dashboard.

Approval Flows with Button Functions

Zoho Cliq button functions let you go beyond simple URL links. You can create a Cliq function that calls the GitHub API to approve a pending deployment review. When the deployment_status event shows a “waiting” state, your handler posts a card with an “Approve Deployment” button. Clicking it invokes a Cliq function that sends a POST request to GitHub’s deployment review API, completing the approval without the developer ever opening a browser tab.

This workflow is especially valuable for teams that practice continuous deployment with manual gates on production releases.

Creating Slash Commands for GitHub Queries

Notifications push information to developers. Slash commands let developers pull information on demand. Zoho Cliq supports custom slash commands that execute Deluge code and return formatted responses.

Useful Slash Commands for GitHub

Consider building these commands for your team:

• /prs [repo] fetches open pull requests for a repository using the GitHub REST API and returns them as a list with review status indicators
• /issues [repo] [label] queries open issues filtered by label, showing assignees and age
• /build [repo] checks the latest workflow run status on the default branch and returns pass/fail with a link
• /deploy [repo] [env] lists recent deployments for an environment with their status

Each command requires a GitHub personal access token stored as a Cliq connection or a secure parameter. Create the command under Bots and Tools, then Commands. Write the execution handler to call the GitHub API, parse the JSON response, and return a formatted message card.

Teams that use Zoho Flow for automation workflows can also trigger flows from slash commands, combining GitHub data with actions in other Zoho apps like creating a Zoho Projects issue from a GitHub issue summary.

Testing and Troubleshooting the Integration

Before rolling the integration out to your full team, test each event type individually. GitHub’s webhook settings page includes a “Recent Deliveries” tab that shows every payload sent, the response code from Cliq, and the response body. This is your primary debugging tool.

Common Issues and Fixes

Problem	Cause	Fix
Webhook shows 401 response	Invalid or expired Cliq token	Regenerate the token in Webhook Tokens and update the GitHub webhook URL
Messages not appearing in channel	Bot webhook used instead of channel webhook	Switch to the channel webhook endpoint URL format
Payload too large error	GitHub sends large diffs in push events	Reduce payload size by unchecking the “Send me everything” option and selecting specific events
Handler timeout	Deluge code makes slow external API calls	Move heavy processing to an async Cliq function and return the message immediately
Duplicate notifications	Multiple webhooks configured for overlapping events	Audit your webhook list in GitHub settings and remove duplicates

For teams already using Zoho CRM API and webhooks, the debugging workflow will feel familiar since the same principles of payload inspection, response code analysis, and handler logging apply.

Monitoring Webhook Health

GitHub automatically disables webhooks that return errors consistently. Check the webhook status in your repository settings weekly. Set up a simple Cliq scheduled function that pings your webhook endpoint daily and alerts you if the response is anything other than 200.

Zoho Flow vs Custom Webhooks: Which Approach to Choose

Zoho Flow offers a no-code path to connecting GitHub and Zoho Cliq. You select a trigger (new GitHub issue, new PR, new commit mention), map the fields, and Flow posts a message to your chosen Cliq channel. Setup takes under ten minutes.

Custom webhooks require more upfront work but provide capabilities Flow cannot match:

Capability	Zoho Flow	Custom Webhook Bot
Setup time	Under 10 minutes	1-3 hours
Message formatting	Basic text	Full card layout with buttons
Event filtering	Limited to Flow triggers	Any GitHub event, any field condition
Actionable buttons	Not supported	Open URL, invoke function, API call
Slash commands	Separate setup	Integrated with same bot
Approval workflows	Not available	Full support via button functions
Maintenance	Zoho-managed	Self-maintained Deluge code

For small teams that need basic PR and issue notifications, Zoho Flow is the faster option. For engineering teams that want CI/CD alerts, deployment approval workflows, and custom slash commands, the webhook bot approach gives you the control you need.

For a full overview of all available options, explore our complete guide to Zoho integrations.

A well-configured Zoho Cliq and GitHub integration removes the friction between code changes and team awareness. Start with the events that matter most to your team, build a clean message card format, and expand from there. The combination of incoming webhooks for push notifications and slash commands for on-demand queries gives your developers a complete GitHub interface inside the tool they already have open all day.