Zulip has been released as open source software!
Read the announcement or go to the Zulip open source project website.
With Zulip integrations, your team can stay up-to-date on code changes, issue tickets, build system results, tweets about your project, and much more.
Many of these integrations require creating a Zulip bot. You can do so on your Zulip settings page. Be sure to note its username and API key.
If an integration you want isn't available yet, you can contribute an integration or open an issue on GitHub and tag it with the "integrations" label (so you can get notified when that integration becomes available).
The official Hubot integration provides an extension point for additional Zulip integrations.
A non-comprehensive list of integrations available through Hubot follows below:
Get Zulip notifications for your Airbrake bug tracker!
First, create the stream you'd like to use for Airbrake notifications, and
subscribe all interested parties to this stream. We recommend the
name airbrake.
Next, on your Zulip
settings page, create an Airbrake bot. Construct the URL for
the Airbrake bot using the API key and stream name:
{{ external_api_uri }}/v1/external/airbrake?api_key=abcdefgh&stream=airbrake
Now, go to your project's settings on the Airbrake site. Click
on the Integration section.
Choose Webhook, provide the above URL,
check Enabled, and save. Your Webhook
configuration should look similar to:
Congratulations! You're done!
Your messages may look like:
Get Zulip notifications for your Asana tasks!
First, create the stream you'd like to use for Asana notifications, and
subscribe all interested parties to this stream. We recommend the
name asana.
Next, on your Zulip settings page, create an Asana bot. Please note the bot name and API key.
Then:
Download and install our Python bindings on the
server where the Asana mirroring script will live. The Asana
integration will be installed to a location
like /usr/local/share/zulip/integrations/asana/.
Visit your Asana account settings page and retrieve your API key.
Edit asana/zulip_asana_config.py and
change the following lines to configure the integration:
ASANA_API_KEY = 0123456789abcdef0123456789abcdef ZULIP_USER = "asana-bot@example.com" ZULIP_API_KEY = "0123456789abcdef0123456789abcdef" {% if api_site_required %}ZULIP_SITE = "{{ external_api_uri }}"{% endif %}
If you are using a stream other than asana,
set ZULIP_STREAM_NAME to the chosen stream name.
Test your configuration by running the mirror with
python asana/zulip_asana_mirror. It will print
some informational messages and process any recently created
or completed tasks.
This mirror is intended to be a long-running processing and should be
hooked into your infrastructure for keeping services running (for
example, auto-restarting through supervisord).
Please contact zulip-devel@googlegroups.com if you'd like assistance with maintaining this integration.
Congratulations! You're done!
When team members create and
complete tasks in Asana, you'll get a Zulip notification that looks like
this:
First, create the stream you'd like to use for Basecamp notifications,
and subscribe all interested parties to this stream. We recommend the
name basecamp.
Next, download and install our Python bindings and example scripts on the computer you'd like to run this mirroring script from.
You will need your Basecamp account ID. You can find it as a sequence of numbers in the URL when you log in:
Edit the Basecamp and Zulip credentials in integrations/basecamp/zulip_basecamp_config.py using
your favorite editor:
BASECAMP_ACCOUNT_ID = "1234567" BASECAMP_USERNAME = "foo@example.com" BASECAMP_PASSWORD = "p455w0rd" ZULIP_USER = "basecamp-bot@example.com" ZULIP_API_KEY = "0123456789abcdef0123456789abcdef" {% if api_site_required %}ZULIP_SITE = "{{ external_api_uri }}"{% endif %}
Before your first run of the script, you may optionally choose to configure it to mirror some number of hours of Basecamp activity:
BASECAMP_INITIAL_HISTORY_HOURS = 10
Now, simply run the api/integrations/basecamp/zulip_basecamp_mirror script.
If needed, this script may be restarted, and it will automatically resume from when
it was last running.
Congratulations! You're done!
Whenever you create a new project,
calendar event, comment, message, or more, you'll get a notification in your selected stream
with the project or calendar as the topic.
Zulip supports both SVN and Git notifications from Beanstalk.
First, create the stream commits and subscribe all
interested parties to this stream.
Next, in the Beanstalk web application, go to the Setup page and choose the Integrations tab.
Choose the Webhooks integration from the list presented. Make sure to replace the @ in the bot's email address with %40,
as Beanstalk's website will incorrectly refuse to parse a username containing a @.
In the URL field, enter {{ external_uri_scheme }}bot_email:bot_api_key@{{ external_api_path }}/v1/external/beanstalk:
Congratulations! You're done!
Whenever you do a
deployment, you'll get an automated notification that looks like
this:
Zulip supports both Git and Mercurial notifications from Bitbucket. This integration is for the old-style Bitbucket webhooks used by Bitbucket Enterprise.
First, create the stream you'd like to use for Bitbucket notifications,
and subscribe all interested parties to this stream. The integration will
use the default stream commits if no stream is supplied in the
hook; you still need to create the stream even if you are using this
default.
Next, from your repository's web page, go to the Administration page and choose Hooks on the left-hand side.
Choose the POST hook from the list presented and click "Add hook." Make sure to replace the @ in the bot's email address with %40,
as Bitbucket will not execute the hook if the username contains a @.
In the URL field, enter {{ external_uri_scheme }}bot_email:bot_api_key@{{ external_api_path }}/v1/external/bitbucket:
By default, notifications are sent to the commits stream.
To send notifications to a different stream,
append ?stream=stream_name to
the URL.
Congratulations! You're done!
Whenever you push code to your repository,
you'll get an automated notification that looks like this:
Zulip supports both Git and Mercurial notifications from Bitbucket. This integration is for the new-style Bitbucket webhooks used by the Bitbucket SAAS service.
First, create the stream you'd like to use for Bitbucket notifications,
and subscribe all interested parties to this stream. The integration will
use the default stream bitbucket if no stream is supplied in the
hook; you still need to create the stream even if you are using this
default.
The URL you create will be in the following format:
{{ external_api_uri }}/v1/external/bitbucket2?api_key=abcdefgh&stream=bitbucket
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Next, from your repository's web page, go to the Settings page and choose Webhooks on the left-hand side.
Click Add webhook, set URL to the URL you created above. Remember to click the 'active' checkbox.
Click Save.
Congratulations! You're done!
Example message:
First, download and install our Python
bindings and example scripts on your Capistrano server.
Once you've done that, you'll use the zulip-send
utility to notify you when certain events happen.
Here's some example code for sending a Zulip notification after a deployment has completed:
after 'deploy', 'notify:humbug' namespace :notify do desc "Post a message to Zulip that we've deployed" task :humbug do # this will post to Zulip as the user defined in # ~/.zuliprc if you omit --user and --api-key run_locally "echo ':beers: I just deployed to #{stage}! :beers:' | zulip-send \ --user capistrano-bot@example.com --api-key a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5 \ {% if api_site_required %} --site={{ external_api_uri }} \ {% endif %} --stream commits --subject deployments || true" end end
Some notes:
--user and --api-key above, you can fill out ~/.zuliprc on your Capistrano
machine. For instructions on how to write that file, see the API page.deploy above to
another step of your deployment process, if you'd like the
notification to fire at a different time.Congratulations! You're done!
Whenever you do a
deployment, you'll get an automated notification that looks like
this:
Thanks to Wes of TurboVote for submitting this integration!
Zulip supports integration with CircleCI and can notify you of your build statuses.
First, create the stream you'd like to use for CircleCI notifications,
and subscribe all interested parties to this stream. We
recommend the name circleci.
{{ external_api_uri }}/v1/external/circleci?api_key=abcdefgh&stream=circleci
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Next, modify your circle.yml as described
here.
Congratulations! You're done!
When a build is done,
you'll get a notification like this:
First, create the streams you'd like to use for Codebase notifications. There will be two types of
messages: commit-related updates and issue-related updates. After creating these streams (we suggest naming
them codebase commits and codebase issues), make sure to subscribe all interested parties.
Next, download and install our Python bindings and example scripts on the computer you'd like to run this mirroring script from.
You will need your Codebase API Username. You can find it in the settings page of your account, under
API Credentials.
Edit the Codebase and Zulip credentials in integrations/codebase/zulip_codebase_config.py using
your favorite editor:
CODEBASE_API_USERNAME = "zulip-inc/leo-franchi-15" CODEBASE_API_KEY = 0123456789abcdef0123456789abcdef ZULIP_USER = "codebase-bot@example.com" ZULIP_API_KEY = "0123456789abcdef0123456789abcdef" {% if api_site_required %}ZULIP_SITE = "{{ external_api_uri }}"{% endif %}
Before your first run of the script, you may optionally choose to configure it to mirror some number of hours of prior Codebase activity:
CODEBASE_INITIAL_HISTORY_HOURS = 10
Now, simply run the api/integrations/codebase/zulip_codebase_mirror script.
If needed, this script may be restarted, and it will automatically resume from when
it was last running.
Congratulations! You're done!
Whenever you create a new project,
commit, issue, deployment, or more, you'll get notifications in your selected streams
with the associated information.
Zulip supports integration with Codeship and can notify you of your build statuses.
First, create the stream you'd like to use for Codeship notifications,
and subscribe all interested parties to this stream. We
recommend the name codeship.
{{ external_api_uri }}/v1/external/codeship?api_key=abcdefgh&stream=codeship
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Next, go to your project settings - notification settings page. The url should look like the following:
https://codeship.com/projects/PROJECT_ID/configure_notifications
where PROJECT_ID is the id of your project in Codeship.
Scroll to the Webhook section and fill out the form as follows:
Congratulations! You're done!
When a build is
triggered, you'll get a notification like this:
Zulip supports integration with Crashlytics and can notify you about Crashlytics issues.
First, create the stream you'd like to use for Crashlytics notifications,
and subscribe all interested parties to this stream. We
recommend the name crashlytics.
{{ external_api_uri }}/v1/external/crashlytics?api_key=abcdefgh&stream=crashlytics
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Click on the app in
your Crashlytics settings panel.
Next, on the integrations subpage, click “Web Hook,” enter the URL we created above and click
Verify.
Congratulations! You're done!
When an issue occurs,
you'll get a notification like this:
First, create the stream you'd like to use for Desk.com notifications,
and subscribe all interested parties to this stream. We recommend the
stream name desk. Keep in mind you still need to
create the stream first even if you are using this recommendation.
Next, in Desk.com, open your Admin view via the top-left corner dropdown. In the Admin view, click on Apps, then click Install under "Custom Action":
From there, click "Install Custom Action" and accept the terms. Fill in the form like this:
{{ external_api_uri }}/v1/external/deskdesk-bot@yourdomain.com
From here, add a new action. You'll do this for every action you want a notification on Zulip for:
Let's say you want a notification each time a case is updated. Put in a descriptive name like "Announce case update", and copy-paste this to the "Appended URL path":
{% raw %}?stream=desk&topic={{case.id}}:+{{case.subject}}
The "appended URL path" will be the same for every notification — it makes sure the notification goes to the appropriate stream and topic within Zulip. Next, copy this template Zulip message into "Message to POST":
{% raw %}Case [{{case.id}}, {{case.subject}}]({{case.direct_url}}), was updated.
* Status: {{case.status.name}}
* Priority: {{case.priority}}
* Customer: {{customer.name}}
* Company: {{customer.company}}
* Description: {{case.description}}You don't need to edit that. All the funny-looking stuff inside
{{ and }}
will be filled in by Desk.com for each event. The dialog should look
like this:
Save it, and then click "On" next to the action to enable it. This is important — actions are turned off by default!
Now you need to create a rule that triggers this action. Desk.com's support center has a lengthy article on rules, but in short, click on "Cases" up at the top, "Rules" on the left side, and then the specific event you want to notify on — in our example, "Case Updated". Add a rule with a name like "Notify Zulip of case update". Click on "Add Action", select "Trigger an App Action", and select "Zulip: Announce case update". Set "Enabled" to "Yes". The rule should look like this:
Finally, click Update.
Congratulations! You're done!
When a case is updated,
you'll see a notification like the following, to the stream
desk, with a topic that matches the case's subject name:
You can send emails to Zulip! This is useful:
To send an email to a Zulip stream:
{{ email_gateway_example }}). If the stream
name contains special characters, we've transformed the name so it is a
safe email recipient.Please note that it may take up to one minute for the message to show up in Zulip.
See customer support interactions right in Zulip, with our Freshdesk integration! Note that this integration must be set up by an administrator for your Freshdesk instance.
First, create the stream you'd like to use for Freshdesk notifications,
and subscribe all interested parties to this stream. We recommend the
stream name freshdesk.
Next, on your Zulip settings page, create a Freshdesk bot.
Now we can set up the Freshdesk events that will trigger Zulips. Freshdesk provides separate triggering mechanisms for ticket creation and ticket changes, so we'll set up these triggers in two parts.
Visit your Freshdesk admin page. Under the "Helpdesk Productivity" section, click the "Dispatch'r" icon:
Click the "New rule" button to create a new Dispatch'r rule that will send notifications to Zulip when Freshdesk tickets are opened.
On the Dispatch'r rule creation page, give the rule a name and description. Next, we need to specify the conditions under which to trigger Zulip notifications. There isn't a shortcut for "always generate a notification on ticket creation", so we'll instead fake it by picking two complementary conditions: when the source is email, and when the source is not email:
In the "Action" section, add a new action of type "Trigger Webhook". Set the "Request Type" to "POST". Set the following "Callback URL", replacing the Zulip stream with your desired stream:
{{ external_api_uri }}/v1/external/freshdesk?stream=freshdesk
Check the "Requires Authentication" box, and supply the bot e-mail address and API key.
The Action section should look like this so far:
Select "JSON" for the "Encoding". Under the encoding, select "Advanced". Paste the following JSON into the "Content" box:
{"freshdesk_webhook":
{
"triggered_event":"{{triggered_event}}",
"ticket_id":"{{ticket.id}}",
"ticket_url":"{{ticket.url}}",
"ticket_type":"{{ticket.ticket_type}}",
"ticket_subject":"{{ticket.subject}}",
"ticket_description":"{{ticket.description}}",
"ticket_status":"{{ticket.status}}",
"ticket_priority":"{{ticket.priority}}",
"requester_name":"{{ticket.requester.name}}",
"requester_email":"{{ticket.requester.email}}",
}
}
These ticket details are what will be forwarded to Zulip. The pasted JSON should look like this:
Save your new Dispatch'r rule. The next time a Freshdesk ticket is opened, the team will get a notification in Zulip!
If you only want to receive Zulip notifications on ticket creation, stop here, you're done! If you also want notifications on important ticket changes, please continue to the next section.
Visit your Freshdesk admin page. Under the "Helpdesk Productivity" section, click the "Observer" icon:
Click the "New rule" button to create a new Observer rule that will send notifications to Zulip when Freshdesk tickets are updated.
On the Observer rule creation page, give the rule a name and description. Under "When Any Of These Events Occur", create these new rules:
Priority is changed, from Any Priority, to Any Priority
Status is changed, from Any Status, to Any Status
Note is added, Type Any
If you do not want to receive Zulip notifications on one or more of these events, leave out the rule for that event.
Under "And The Events Are Performed By", select "Anyone".
So far, the rule should look like this:
Next, we need to specify the types of tickets that will trigger Zulip notifications. There isn't a shortcut for "always generate a notification on ticket update", so as before we'll instead fake it by picking two complementary conditions: when the source is email, and when the source is not email:
Under "Perform These Actions", add a new action of type "Trigger Webhook". Set the "Request Type" to "POST". Set the following "Callback URL", replacing the Zulip stream with your desired stream:
{{ external_api_uri }}/v1/external/freshdesk?stream=freshdesk
Check the "Requires Authentication" box, and supply the bot e-mail address and API key.
The Action section should look like this so far:
Select "JSON" for the "Encoding". Under the encoding, select "Advanced". Paste the following JSON into the "Content" box:
{"freshdesk_webhook":
{
"triggered_event":"{{triggered_event}}",
"ticket_id":"{{ticket.id}}",
"ticket_url":"{{ticket.url}}",
"ticket_type":"{{ticket.ticket_type}}",
"ticket_subject":"{{ticket.subject}}",
"ticket_description":"{{ticket.description}}",
"ticket_status":"{{ticket.status}}",
"ticket_priority":"{{ticket.priority}}",
"requester_name":"{{ticket.requester.name}}",
"requester_email":"{{ticket.requester.email}}",
}
}
These ticket details are what will be forwarded to Zulip. The pasted JSON should look like this:
Save your new Observer rule. The next time a Freshdesk ticket is updated, the team will get a notification in Zulip!
Congratulations! You're done!
You'll now see support
progress in real time in Zulip:
First, download and install our Python bindings and example scripts on your Git server.
Next, create the stream you'd like to use for Git notifications, and
subscribe all interested parties to this stream. The integration will use
the default stream commits if no stream is supplied in the
hook; you still need to create the stream even if you are using this
default.
Next, open integrations/git/zulip_git_config.py
in your favorite editor, and change the following lines to
specify the email address and API key for your Git bot:
ZULIP_USER = "git-bot@example.com" ZULIP_API_KEY = "0123456789abcdef0123456789abcdef" {% if api_site_required %}ZULIP_SITE = "{{ external_api_uri }}"{% endif %}
You can also specify which pushes will result in
notifications and to what stream the notifications will be sent
by modifying the commit_notice_destination function
in zulip_git_config.py. By default, pushes to
the master and test-post-receive
branches will result in a notification to
stream commits.
Save integrations/git/zulip_git_config.py to
the .git/hooks directory of your git
repository.
Symlink
/usr/local/share/zulip/integrations/git/post-receive
into the .git/hooks directory of your git repository.
Congratulations! You're done!
Whenever you make
a push to the master branch of your git repository
(or whatever you configured above), the Zulip git plugin will
send an automated notification that looks like this:
Testing
You can test the plugin without changing
your master branch by pushing to
the test-post-receive branch.
First, create the stream you'd like to use for GitHub notifications,
and subscribe all interested parties to this stream. The integration will
use the default stream commits if no stream is supplied in
the hook; you still need to create the stream even if you are using this
default.
Next, go to your repository page and click "Settings":
From there, select "Webhooks & Services":
To find the Zulip hook, you have to click on Configure services.
Select "Zulip" from the list of service hooks. Fill in
the API key and email address for your bot and check
the "active" checkbox. Specify
{{ external_api_uri_subdomain }}/v1/external/github as the "Alternative
endpoint". You can optionally supply the Zulip stream (the
default is commits) and restrict Zulip
notifications to a specified set of branches.
Further configuration is possible. By default, commits traffic (pushes, commit comments), Github issues traffic, and pull requests are enabled. You can exclude certain types of traffic via the checkboxes. If you want commit traffic, issue traffic, and pull requests to go to different places, you can use the Commit Stream and Issue Stream overrides; otherwise, it is safe to leave these fields blank and just have it default to the Stream setting.
Click the "Update settings" button to complete the configuration:
Congratulations! You're done!
When team members push to
your repository, you'll get a Zulip notification that looks like this:
Learn how Zulip integrations work with this simple Hello World example!
The Hello World webhook will use the test stream, which is
created by default in the Zulip dev environment. If you are running
Zulip in production, you should make sure this stream exists.
Next, on your Zulip
settings page, create a Hello World bot. Construct the URL for
the Hello World bot using the API key and stream name:
{{ external_api_uri }}/v1/external/helloworld?api_key=abcdefgh&stream=test
To trigger a notication using this webhook, use `send_webhook_fixture_message` from the Zulip command line:
(zulip-venv)vagrant@vagrant-ubuntu-trusty-64:/srv/zulip$ ./manage.py send_webhook_fixture_message \ > --fixture=zerver/fixtures/helloworld/helloworld_hello.json \ > '--url=http://localhost:9991/api/v1/external/helloworld?api_key=<api_key>'
Or, use curl:
curl -X POST -H "Content-Type: application/json" -d '{ "featured_title":"Marilyn Monroe", "featured_url":"https://en.wikipedia.org/wiki/Marilyn_Monroe" }' http://localhost:9991/api/v1/external/helloworld\?api_key\=<api_key>
Congratulations! You're done!
Your messages may look like:
Follow the "Getting Started with Hubot" section of the Hubot README to create your Hubot. You'll have a new directory from which bin/hubot starts a vanilla Hubot instance with the shell backend.
npm install --save hubot-zulipOn your Zulip settings page, create a bot account. Note its username, API key and full name; you will use them on the next step.
HUBOT_ZULIP_BOT=hubot-bot@example.com HUBOT_ZULIP_API_KEY=your_key bin/hubot --adapter zulip --name "myhubot"The bot account email address and API key are passed to Hubot via environment variables HUBOT_ZULIP_BOT and HUBOT_ZULIP_API_KEY. The --name parameter must match the name you gave the bot on the settings page.
Hubot will automatically listen for commands on all public streams. You can also invite Hubot to invite-only streams.
To test your Hubot installation, send it an @-notification with a basic command, for example @Hubot pug me, which should produce a result like this:
Source code for the hubot-zulip adapter is available on GitHub.
First, create the stream you'd like to use for Jenkins or Hudson
notifications, and subscribe all interested parties to this stream. We
recommend the name jenkins or hudson.
Install the plugin
Install the "Zulip"
plugin by going to Manage Jenkins > Manage Plugins >
Available, typing in "Zulip", and clicking "Install
without restart". (For historical reasons, the plugin will be
named "Humbug Plugin")
Configure the plugin
Once the plugin
is installed, configure it by going to Manage Jenkins >
Configure System. Scroll to the section labeled "Zulip
Notification Settings", and specify your bot's email address,
API key, the stream receiving the notifications, and whether you'd
like a notification on every build, or only when the build fails
(Smart Notification).
(If you don't see this option, you may first need to restart Jenkins.)
Configure a post-build action for your project
Once you've done that, it's time to configure one of your
projects to use the Zulip notification plugin. From your
project page, click "Configure" on the left sidebar. Scroll to
the bottom until you find the section labeled "Post-build
Actions". Click the dropdown and select "Zulip
Notification". It should look as below. Then click "Save".
Congratulations! You're done!
When your builds
fail or succeed, you'll see a commit message like the following
with a topic that matches the project name (in this case
"SecretProject"):
Troubleshooting
jenkins) already exist? If not, add yourself to it and try again.Get notifications from every event supported by IFTTT.
First, create the stream you'd like to use for IFTTT notifications, and subscribe all interested parties to this stream.
{{ external_api_uri }}/v1/external/ifttt?api_key=abcdefgh&stream=ifttt
Next, create an IFTTT recipe, picking the service you'd like
to receive notifications from as this,
and Maker as that.
Choose the Make a web request action, and
configure it as follows:
URL is the url we created abovemethod is POSTContent Type is application/jsonFinally, configure the request body. You need to construct a JSON
object with two parameters: content
and subject.
Example:
{"content": "message content", "subject": "message subject"}
You will most likely want to specify some IFTTT
"Ingredients" (click the beaker to see the available
options) to customize the subject and content of your
messages; the below screenshot uses ingredients available
if this is IFTTT's incoming email service.
Example configuration:
You're done! Example message:
If you are running JIRA version 5.2 or greater, or if you are using the hosted JIRA provided by Atlassian, you can use the built-in web-hook support to connect to Zulip — read on. For older, self-hosted JIRA installs, you can use our JIRA Plugin.
First, create the stream you'd like to use for JIRA notifications, and
subscribe all interested parties to this stream. We recommend the
name jira.
In your JIRA administration control panel, go to the Webhooks page. If you are using the OnDemand hosted JIRA, follow the instructions on the Atlassian wiki for locating the Webhook UI.
Give your new web hook a name, and for the URL provide the following:
{{ external_api_uri }}/v1/external/jira?api_key=abcdefgh&stream=jira
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Next, go back to Zulip and set up a stream called "jira," if it does not already exist. (If you prefer your JIRA notifications to go to a stream other than "jira," then change the URL above to match it.)
Congratulations! You're done!
Updates from JIRA will be sent to the Zulip stream you specified in the JIRA web-hook.
If you are running JIRA version 5.2 or greater, or using the hosted JIRA provided by Atlassian, we recommend using the web-hook method above instead. This plugin supports older versions of JIRA.
First, create the stream you'd like to use for JIRA notifications, and
subscribe all interested parties to this stream. We recommend the
name jira.
Plugin Installation
The JIRA integration plugin requires two JIRA plugins. Please install the following plugins using the Universal Plugin Manager in your JIRA installation:SSL Setup
As Zulip is using a StartCOM SSL certificate that is not recognized by default in the Java installation shipped with JIRA, you will need to tell JIRA about the certificate. Navigate toAdministration > System > Configure SSL and in
the Import SSL Certificates field, enter {{ external_api_uri }}. After clicking Save Certificates,
follow the on-screen instructions and restart JIRA for it to recognize the proper certificates.
Zulip Integration
Copy the folderintegrations/jira/org/ (from the tarball you downloaded above) to your JIRA classes folder.
For self-contained JIRA installations, this will be atlassian-jira/WEB-INF/classes/, but this may be different in your deployment.
Edit the constants at the top of org/zulip/jira/ZulipListener.groovy
and fill them with the appropriate values:
String zulipEmail = "jira-notifications-bot@example.com" String zulipAPIKey = "0123456789abcdef0123456789abcdef" String zulipStream = "JIRA" String issueBaseUrl = "https://jira.COMPANY.com/browse/"
In the Administrators page, navigate to Plugins > Other > Script Listeners. In the Add Listener section, click on
the Custom Listener option. Select the events you wish the Zulip integration to fire for, and the projects you wish Zulip to be notified for.
In the Name of groovy class field, enter org.zulip.jira.ZulipListener.
Click Add Listener, and JIRA will now notify your Zulip of changes to your issues!
Congratulations! You're done!
Updates from JIRA will be sent to the stream you've configured, as below.
Get Zulip notifications when you hg push!
First, create the stream you'd like to use for Mercurial notifications,
and subscribe all interested parties to this stream. We recommend the
name commits.
Next, on your Zulip settings page, create a Mercurial bot.
Then:
Download and install our Python bindings on the server where the master Mercurial repository lives.
Edit the hg/.hgrc configuration file for this master
Mercurial repository and add the following sections, using the
credentials for your Mercurial bot and setting the appropriate path to
the integration hook if it installs in a different location on this
system:
[hooks]
changegroup = python:/usr/local/share/zulip/integrations/hg/zulip-changegroup.py:hook
[zulip]
email = "hg-bot@example.com"
api_key = "0123456789abcdefg"
stream = "commits"
{% if api_site_required %}site = {{ external_api_uri }}{% endif %}
That's all it takes for the basic setup! On the next hg
push, you'll get a Zulip update for the changeset.
The Mercurial integration also supports:
If you've set up your repository to
be browsable
via the web, add a web_url configuration option to
the zulip section of your master .hg/hgrc to get
changelog and revision links in your Zulip notifications:
[zulip]
email = "hg-bot@example.com"
api_key = "0123456789abcdefg"
stream = "commits"
web_url = "http://hg.example.com:8000/"
{% if api_site_required %}site = {{ external_api_uri }}{% endif %}
By default, this integration will send Zulip notifications for
changegroup events for all branches. If you'd prefer to only receive Zulip
notifications for specified branches, add a branches
configuration option to the zulip section of your
master .hg/hgrc, containing a comma-separated list of the
branches that should produce notifications:
[zulip] email = "hg-bot@example.com" api_key = "0123456789abcdefg" stream = "commits" branches = "prod,master"
You can also exclude branches that you don't want to cause
notifications. To do so, add an ignore_branches configuration
option to the zulip section of your
master .hg/hgrc, containing a comma-separated list of the
branches that should be ignored:
[zulip] email = "hg-bot@example.com" api_key = "0123456789abcdefg" stream = "commits" ignore_branches = "noisy,even-more-noisy"
Congratulations! You're done!
When team members push new
changesets with hg push, you'll get a Zulip notification that
looks like this:
First, create the stream you'd like to use for Nagios notifications,
and subscribe all interested parties to this stream. The integration will
use the default stream nagios if no stream is supplied in the
configuration; you still need to create the stream even if you are using
this default.
Next, download and install our Python bindings and example scripts on your Nagios server.
Next, open integrations/nagios/zuliprc.example
in your favorite editor, and change the following lines to
specify the email address and API key for your Nagios bot,
saving it to /etc/nagios3/zuliprc on your Nagios
server:
[api]
email = NAGIOS_BOT_EMAIL_ADDRESS
key = NAGIOS_BOT_API_KEY
{% if api_site_required %}site = {{ external_api_uri }}{% endif %}Copy integrations/nagios/zulip_nagios.cfg
to /etc/nagios3/conf.d on your Nagios server.
Finally, add zulip to the members
list for one or more of the contact groups in the CONTACT
GROUPS section
of /etc/nagios3/conf.d/contacts.cfg, doing
something like:
define contactgroup{
contactgroup_name admins
alias Nagios Administrators
members monitoring, zulip
}
/etc/init.d/nagios3 reload.
Congratulations! You're done!
When your Nagios
system makes an alert, you'll see a message like the following,
to the stream nagios (to change this, edit the
arguments to nagios-notify-zulip
in /etc/nagios3/conf.d/zulip_nagios.cfg) with a
topic indicating the service with an issue:
Testing
If you
have external
commands enabled in Nagios, you can generate a test notice
from your Nagios instance by visiting using the Send
custom service notification command in
the Service Commands section of any individual
service's page on your Nagios instance.
Troubleshooting
You can confirm whether you've
correctly configured Nagios to run the Zulip plugin by looking
for SERVICE NOTIFICATION lines mentioning zulip
in /var/log/nagios3/nagios.log. You can confirm
whether you've configured the Zulip plugin code correctly by
running /usr/local/share/zulip/integrations/nagios/nagios-notify-zulip
directly.
New Relic can send messages to a Zulip stream for alerts and deploys.
First, create the stream you'd like to use for New Relic
notifications, and subscribe all interested parties to this stream. We
recommend the name newrelic.
Next, in your New Relic Account Settings page, click "Integrations", then "Alerting notifications". On the "Webhook" tab, enter the following webhook URL:
{{ external_api_uri }}/v1/external/newrelic?api_key=abcdefgh&stream=newrelic
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Congratulations! You're done!
Your New Relic events will
appear in Zulip:
First, create the stream you'd like to use for Pagerduty notifications,
and subscribe all interested parties to this stream. We recommend the
stream name pagerduty. Keep in mind you still need to create
the stream first even if you are using this recommendation.
Next, in Pagerduty, select Services under Configuration on the top of the page.
Now navigate to the service you want to integrate with Zulip. From there, click "Add a webhook". Fill in the form like this:
{{ external_api_uri }}/v1/external/pagerduty?api_key=abcdefgh&stream=pagerduty
Zulip supports integration with Perforce as a trigger that fires once a changelist is submitted and committed. To do this:
/usr/local/share/zulip/integrations/perforceintegrations/perforce/zulip_perforce_config.py in
your favorite editor and change the ZULIP_USER and
ZULIP_API_KEY variables at the top of the file to the
credentials for the bot you'd like to use for this integration.p4 triggers and add an entry something like the
following:
notify_zulip change-commit //depot/... "python /usr/local/share/zulip/integrations/perforce/zulip_change-commit.py %change% %changeroot%"
depot_subdirectory-commits. So, a changelist that modifies
files in //depot/foo/bar/baz will result in a message to
stream foo-commits. Messages about changelists that modify
files in the depot root or files in multiple direct subdirectories of
the depot root will be sent to depot-commits. If you'd
prefer different behavior, such as all commits across your depot going
to one stream, change it now in zulip_perforce_config.py.
Make sure that everyone interested in getting these post-commit Zulips
is subscribed to the relevant streams!Congratulations! You're done!
When you commit to your
Perforce depot the team can see updates in real time in
Zulip:
Zulip supports integration with Phabricator and can notify you of the latest items in your Phabricator feed.
You can follow the instructions at https://github.com/zulip/phabricator-to-zulip to get it set up.
Zulip supports integration with Pingdom and can notify you of uptime status changes from your Pingdom dashboard.
First, create the stream you'd like to use for Pingdom notifications,
and subscribe all interested parties to this stream. We
recommend the name pingdom.
{{ external_api_uri }}/v1/external/pingdom?api_key=abcdefgh&stream=pingdom
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Next, under following url:
https://my.pingdom.com/reports/integration/settings
create your integration by clicking on Add Integration button and filling form as following:
Last, during creating or editing your check, scroll down to Connect Integrations
section and ensure your integration is checked
Congratulations! You're done!
Example Zulip notification
looks like this:
Zulip supports integration with Pivotal Tracker and can notify you of changes to the stories in your Pivotal Tracker project.
First, create the stream you'd like to use for Pivotal Tracker
notifications, and subscribe all interested parties to this stream. We
recommend the name pivotal.
Next, in the Settings page for your project, choose the Integrations
tab. Scroll down to the Activity Web Hook section, and enter
the following url:
{{ external_api_uri }}/v1/external/pivotal?api_key=abcdefgh&stream=pivotal
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Choose version 5 of the API. Zulip supports both version 3 and version 5, but version 5 contains more information that lets Zulip format more useful messages.
Congratulations! You're done!
When you make changes in Pivotal Tracker they will be reflected in Zulip:
Zulip supports Puppet integration and can notify you when Puppet runs fail (or when they happen at all).
You can follow the instructions at https://forge.puppetlabs.com/mbarr/puppet_zulip to get it set up.
Thanks to Matt from Kensho for submitting this integration!
Get information on new or updated Redmine issues right in Zulip with our Zulip Redmine plugin! Note: this setup must be done by a Redmine Administrator.
First, create the stream you'd like to use for Redmine notifications,
and subscribe all interested parties to this stream. We recommend the
name redmine.
Then:
Clone the Zulip Redmine plugin repository by running:
git clone https://github.com/zulip/zulip-redmine-plugin
Follow
the Redmine
plugin installation guide to install
the zulip_redmine plugin directory, which is a
subdirectory of the zulip-redmine-plugin repository
directory. In a nutshell, the steps are:
Copy the zulip_redmine directory to
the plugins directory of your Redmine
instance.
Update the Redmine database by running (for Rake 2.X, see the guide for instructions for older versions):
rake redmine:plugins:migrate RAILS_ENV=production
Restart your Redmine instance.
The Zulip plugin is now registered with Redmine!
On your Zulip settings page, create a new Redmine bot.
To configure Zulip notification settings that apply to many projects in one go, in Redmine click the "Administration" link in the top left. Click the "Plugins" link on the Administration page, and click the "Configure" link to the right of the Zulip plugin description. In the "Projects" section, select all projects to which you want these settings to apply.
To configure Zulip notifications for a particular Redmine project, visit the project's Settings page.
In either case, fill out the bot email address and API key, and the Zulip stream that should receive notifications. Apply your changes.
To test the plugin, create an issue or update an existing issue in a Redmine project that has Zulip notifications configured (any project, if you've configured global settings).
Congratulations! You're done!
When you update issues in
Redmine, the team can see these updates in real time in Zulip:
Get service alerts, news, and new blog posts right in Zulip with our RSS integration!
First, create the stream you'd like to use for RSS notifications, and
subscribe all interested parties to this stream. We recommend the
name rss.
Next, on your Zulip settings page, create an RSS bot.
Then, download and install our Python bindings on
the server where the RSS bot will live. The RSS integration will be
installed to a location
like /usr/local/share/zulip/integrations/rss/rss-bot.
Follow the instructions in the rss-bot script for
configuring the bot, adding your subscriptions, and setting up a cron job
to run the bot.
Congratulations! You're done!
When new items appear in
your feeds, the team can see these updates in real time in Zulip:
See build and deploy statuses on Semaphore right in Zulip with the Zulip Semaphore plugin!
First, create the stream you'd like to use for Semaphore notifications, and
subscribe all interested parties to this stream. We recommend the
name builds.
Next, on your Zulip settings page, create a Semaphore bot.
Then, log into your account on semaphoreci.com, and:
Visit the "Project Settings" page for the project for which you'd like to generate Zulip notifications. Click the "Notifications" tab in the left sidebar, click on "Webhooks" in the resulting menu, and then click on "+ Add Webhook".
You should now see a form that looks like this:
Enter the following webhook URI, replacing the bot email address,
bot API key, and Zulip stream with the appropriate
information. Note: the @-sign in the bot e-mail
address must be escaped to %40:
{{ external_uri_scheme }}semaphore-bot%40example.com:api_key@{{ external_api_path }}/v1/external/semaphore?stream=builds
Congratulations! You're done!
When you push to Semaphore, the
team can see these updates in real time in Zulip:
See what the team is committing to Stash right in Zulip with the Zulip Stash plugin!
First, create the stream you'd like to use for Stash notifications, and
subscribe all interested parties to this stream. We recommend the
name commits.
Next, on your Zulip settings page, create a Stash bot.
Then:
Visit the Settings page for the Project that you'd like to generate Zulip notifications. Click the "Hooks" option in the left sidebar, and click "Add Hook" on the resulting page. Click the "Search for hook plugins" link:
On the search results page, look for and install the "Post-Receive WebHook for Stash" plugin:
Return to the Settings page for this Project and click the "Hooks" option in the left sidebar. The newly-installed post-receive webhook plugin is now listed in the "Post-receive" hooks section. Click the edit icon next to the hook to configure it:
Supply the following webhook URL, replacing the bot email address,
bot API key, and Zulip stream with the appropriate
information. Note: the @-sign in the bot e-mail
address must be escaped to %40:
{{ external_uri_scheme }}stash-bot%40example.com:api_key@{{ external_api_path }}/v1/external/stash?stream=commits
Congratulations! You're done!
When you push to Stash, the
team can see these updates in real time in Zulip:
It is easy to send Zulips on SVN commits, by configuring a post-commit hook. To do this:
First, create the stream you'd like to use for SVN commit
notifications, and subscribe all interested parties to this stream. The
integration will use the default stream commits if no stream
is supplied in the hook; you still need to create the stream even if you
are using this default.
Then:
pysvn. On Linux, you can install
the python-svn package. On other platforms, you can install
a binary or from source following
the instructions
on the pysvn website.integrations/svn/zulip_svn_config.py
and integrations/svn/post-commit from the API bindings
directory to the hooks subdirectory of your SVN
repository.Next, open integrations/git/zulip_svn_config.py
in your favorite editor, and change the following lines to
configure your SVN integration:
ZULIP_USER = "svn-bot@example.com" ZULIP_API_KEY = "0123456789abcdef0123456789abcdef" {% if api_site_required %}ZULIP_SITE = "{{ external_api_uri }}"{% endif %}
commits; if you'd prefer a different stream, change it
now in zulip_svn_config.py. Make sure that everyone
interested in getting these post-commit Zulips is subscribed to that
stream!Congratulations! You're done!
When you commit to this SVN
repository, the team can see these updates in real time in Zulip:
Go on your Zulip settings page, create a Taiga bot. Please note the bot name and API key.
Since Taiga allows you to integrate services on a per project basis, you have to perform the following steps for every project that you want to send notifications to Zulip.
Go to Admin > Integration > Webhooks menu.
Click Add a new webhook.
Fill out the form by following the instructions:
Zulip
{{ external_api_uri }}/v1/external/taiga?stream=STREAM_NAME&topic=TOPIC_NAME&api_key=BOT_API_KEY
STREAM_NAME - The url-encoded name of
stream which you want to receive notifications.
You can use an existing Zulip stream or create a
new one for this.
TOPIC_NAME - The url-encoded
topic where your Taiga notifications will be
posted. (Read the notes below.)BOT_API_KEY - API key created in Zulip.Remember to url-encode the stream and topic
names. E.g. spaces need to be replaced
with %20 (e.g. so if you want your stream
to be called "My awesome project", STREAM_NAME
should be My%20awesome%20project).
Click Save once you've finished filling out the form.
That's it! Your actions on Taiga should now cause
notifications on the Zulip stream you specified above.
Taiga. (Make sure to create this stream
first!) For every integrated project, provide a new topic.
STREAM_NAME = Taiga TOPIC = Project
%20).STREAM_NAME = My%20existing%20Zulip%20stream TOPIC = Taiga
See your Teamcity build status in Zulip!
First, create the stream you'd like to use for Teamcity
notifications, and subscribe all interested parties to this stream. We
recommend the name teamcity.
Next, set up a bot for the integration. You'll need the bot's API key to construct a URL for Teamcity.
Next, install the tcWebHooks plugin onto your Teamcity server. Follow the plugin instructions in your Teamcity documentation, or refer to the online Teamcity documentation.
Next, in your Teamcity project overview page, click the "Webhooks" tab, and add a new project webhook. Enter the following URL:
{{ external_api_uri }}/v1/external/teamcity?api_key=abcdefgh&stream=teamcity
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Uncheck all "Trigger on Events" options, and check "Trigger when build is Successful" and "Trigger when build Fails". Optionally, check "Only trigger when build changes from Failure to Success" and "Only trigger when build changes from Success to Failure".
Set the Payload Format to "JSON" and save your webhook.
Congratulations! You're done!
Your Teamcity build
notifications will appear in Zulip:
Personal Builds
When a user runs a personal build, if Zulip can
map their Teamcity username to a Zulip user, that Zulip user will receive a
private message with the result of their personal build.
First, create the stream you'd like to use for Trac notifications, and
subscribe all interested parties to this stream. The integration will use
the default stream trac if no stream is supplied in the
hook; you still need to create the stream even if you are using this
default.
Next, download and install our Python bindings and example scripts on your Trac server.
Next, open integrations/trac/zulip_trac_config.py in
your favorite editor, and change the following lines to specify
your bot's email address, API key, and where you'd like your
notification messages to go (by default,
stream trac):
ZULIP_USER = "trac-notifications-bot@example.com" ZULIP_API_KEY = "0123456789abcdef0123456789abcdef" STREAM_FOR_NOTIFICATIONS = "trac" TRAC_BASE_TICKET_URL = "https://trac.example.com/ticket" {% if api_site_required %}ZULIP_SITE = "{{ external_api_uri }}"{% endif %}
Copy integrations/trac/zulip_trac.py
and integrations/trac/zulip_trac_config.py into
your Trac installation's plugins/
subdirectory. Once you've done that, edit your Trac
installation's conf/trac.ini to
add zulip_trac to the [components]
section, as follows:
[components] zulip_trac = enabled
You may then need to restart Trac (or Apache) so that Trac will load our plugin.
Congratulations! You're done!
When people open
new tickets (or edit existing tickets), you'll see a message
like the following, to the stream trac (or whatever
you configured above) with a topic that matches the ticket
name:
Additional trac configuration
After using the plugin
for a while, you may want to customize which changes to tickets
result in a Zulip notification using
the TRAC_NOTIFY_FIELDS setting
in zulip_trac_config.py.
First, create the stream you'd like to use for Transifex
notifications, and subscribe all interested parties to this stream. We
recommend the name transifex.
Next, set up a bot for the integration. You'll need the bot's API key to construct a URL for Transifex.
{{ external_api_uri }}/v1/external/transifex?api_key=abcdefgh&stream=transifex
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the
notifications sent to.
Next, in Transifex, go to your project settings page: Project Details → Manage → Edit Project and scroll down to WEB HOOK URL. Paste the URL you constructed into the box and save your changes.
Congratulations! You're done!
Example message:
See your Travis CI build notifications in Zulip!
First, create the stream you'd like to use for notifications, and subscribe
all interested parties to this stream. We recommend the name travis.
Next, set up a bot for the integration. You'll need the bot's API key to construct a URL for Travis CI.
Finally, set up a webhook in your .travis.yml file:
notifications:
webhooks:
- https://zulip.example.com/api/v1/external/travis?stream=travis&topic=build-status&api_key=abcdefgh
Congratulations! You're done!
When a code build occurs,
you're receive a notification on the specified stream and topic.
This webhook integration for Trello is the recommended way to integrate with Trello, and should support all the features of the legacy Trello cron-based integration.
First, create the stream you'd like to use for Trello notifications,
and subscribe all interested parties to this stream. We recommend the
name trello.
Your webhook URL is:
{{ external_api_uri_subdomain }}/v1/external/trello?api_key=abcdefgh&stream=trello
where api_key is the API key of your Zulip bot,
and stream is the stream name you want the notifications sent to.
Before you create a webhook, you'll need to follow the steps below to get an APPLICATION_KEY, and a UserToken, and to fetch the board's idModel.
To generate the APPLICATION_KEY, open this URL in your web browser:
https://trello.com/1/appkey/generate.
To generate a read access token, fill in and open this URL in the browser while logged into your Trello account:
https://trello.com/1/authorize?key=<APPLICATION_KEY>&name=Issue+Manager&expiration=never&response_type=token&scope=read
You will receive your UserToken. Note it.
Within the the board URL, you can find the TRELLO_BOARD_SHORT_ID.
The Trello URL format is:
https://trello.com/b/TRELLO_BOARD_SHORT_ID/boardName.
Now you have the APPLICATION_KEY, UserToken and TRELLO_BOARD_SHORT_ID.
Construct this URL and open it in your web browser:
https://api.trello.com/1/board/<TRELLO_BOARD_SHORT_ID>?key=<APPLICATION_KEY>&token=<UserToken>
You'll receive some JSON. Within that, find the id value. That's your idModel; note it.
Now you have the ingredients to create your webhook.
Send a POST request to this URL with this data:
https://api.trello.com/1/tokens/<UserToken>/webhooks/?key=<APPLICATION_KEY>
{
"description": "Webhook for Zulip integration",
"callbackURL": "<URL_TO_ZULIP_WEBHOOK_FROM_SECOND_STEP>",
"idModel": "<ID_MODEL>",
}
You can use curl to do this:curl 'https://api.trello.com/1/tokens/<UserToken>/webhooks/?key=<APPLICATION_KEY>'
-H 'Content-Type: application/json' -H 'Accept: application/json'
--data-binary $'{\n "description": "Webhook for Zulip integration",\n "callbackURL": "<URL_TO_ZULIP_WEBHOOK_FROM_SECOND_STEP>",\n "idModel": "<ID_MODEL>"\n}'
--compressed
The response from Trello should look like:{
"id": "<WEBHOOK_ID>",
"description": "Webhook for Zulip integration",
"idModel": "<ID_MODEL>",
"callbackURL": "<URL_TO_ZULIP_WEBHOOK_FROM_SECOND_STEP>",
"active": true
}
Congratulations! You've created a webhook and your integration is live.
When you make changes in on this board in Trello, you will receive Zulip notifications like this:
This legacy integration for Trello works by running a script that communicates with the Trello API in a cron job. We recommend the new Trello webhook integration (which will eventually replace this entirely). Please report any issues which cause you to prefer this integration over the webhook integration.
First, create the stream you'd like to use for Trello notifications,
and subscribe all interested parties to this stream. We recommend the
name trello.
Next, download a copy
of trello-to-zulip
and follow the instructions in README.md. When you
make changes in Trello, they will be reflected in Zulip:
Thanks to Nathan from FoundationDB for submitting this integration!
See Twitter search results in Zulip! This is great for seeing and discussing who is talking about you, friends, competitors, or important topics in real time.
First, create the stream you'd like to use for tweets, and subscribe
all interested parties to this stream. We recommend the
name twitter.
Next, download and install our Python bindings and example scripts. This bot should be set up on a trusted machine, because your API key is visible to local users through the command line or config file.
Next, install version 1.0 or later of
the twitter-python library. If your operating system
distribution doesn't package a new enough version, you can install the
library from source
from the GitHub
repository.
Next, set up Twitter authentication. This bot uses OAuth to authenticate with Twitter, and in order to obtain a consumer key & secret, you must register a new application under your Twitter account:
To configure and deploy this bot:
~/.zulip_twitterrc with the following
contents:
[twitter] consumer_key = consumer_secret = access_token_key = access_token_secret =
/usr/local/share/zulip/integrations/twitter/twitter-search-bot --search="@nprnews,quantum physics"Note:
twitter-search-bot may install to a different
location on your operating system distribution.
* * * * * /usr/local/share/zulip/integrations/twitter/twitter-search-bot --search="@nprnews,quantum physics"
Congratulations! You're done!
When someone tweets a
message containing one of your search terms, you'll get a Zulip on your
specified stream, with the search term as the topic.
Note that the twitter search bot integration just sends
links to tweets; the pretty inline previews of tweets are
generated by the Twitter card rendering integration configured
in /etc/zulip/settings.py on the Zulip server.
See Updown reports in Zulip! This is great to be up to date with downtime in the services you monitor with Updown!
First, create the stream you'd like to use for updown
notifications, and subscribe all interested parties to this
stream. We recommend the name updown.
Go to your Updown
settings page and in WEBHOOKS section, enter
the following as the URL:
{{ external_api_uri }}/v1/external/updown?api_key=abcdefgh&stream=updown
Congratulations! You're done!
Now you'll receive Updown notifications for your service in Zulip.
See your Yo App notifications in Zulip!
Go to your Zulip settings and set up a Zulip bot for the integration. You'll need the bot's API key to construct a URL for Yo App Callback.
You will receive your notifications as a private message between you and the bot.
Create a URL using your bot's API key and the email address associated with your Zulip account:
{{ external_api_uri_subdomain }}/api/v1/external/yo?email=awesome@zulip.example.com&api_key=abcdefgh
Copy the URL created and go to yoapi.justyo.co.
Sign in using your username and password and go to Edit Profile.
Paste the URL in the Callback field and click on Update.
Congratulations! You're done!
When someone sends your username a Yo,
you'll receive a notification as a private message from the bot
like this:
Multiple users can use the same Yo bot; each user should use their own Zulip account email in the webhook URL.
First, create the stream you'd like to use for Zendesk notifications,
and subscribe all interested parties to this stream. We recommend the
stream name zendesk. Keep in mind you still need to create
the stream first even if you are using this recommendation.
Next, in Zendesk, open your Admin view via gear in the bottom-left corner. In the Admin view, click on Extensions, then click "add target".
From there, click "URL target". Fill in the form like this:
{{ external_api_uri }}{% raw %}/v1/external/zendesk?ticket_title={{ticket.title}}&ticket_id={{ticket.id}}&stream=zendesk{% endraw %}zendesk-bot@yourdomain.com
Now select "Test Target" and click Submit. A test message should appear in the zendesk stream. If the message was received, save the target by selecting "Create target" and clicking Submit.
From here, add a new trigger. You'll do this for every action you want to create a Zulip notification. Triggers are added by selecting Triggers in the left menu and then clicking "add trigger" in the top right.
Let's say you want a notification each time a ticket is updated. Put in a descriptive title like "Announce ticket update". Under "Meet all of the folllowing conditions" select "Ticket: is..." and then select Updated. In the "Perform these actions" section select "Notification: Notify target" then select Zulip.
Next we need need to enter the message body into Message. You can use Zulip markdown and the Zendesk placeholders when creating your message. You can copy this example template:
{% raw %}Ticket [#{{ticket.id}}: {{ticket.title}}]({{ticket.link}}), was updated by {{current_user.name}}
* Status: {{ticket.status}}
* Priority: {{ticket.priority}}
* Type: {{ticket.ticket_type}}
* Assignee: {{ticket.assignee.name}}
* Tags: {{ticket.tags}}
* Description:
``` quote
{{ticket.description}}
``` 
Finally, click Submit.
Congratulations! You're Done!
When a ticket is updated
you will see a notification like the following, to the stream
zendesk, with a topic that matches the ticket's subject
name:
