{% extends "zerver/portico.html" %} {# API information page #} {% block os_announcement %} {% if show_oss_announcement %}
Zulip balloon
Zulip has been released as open source software! Read the announcement or go to the Zulip open source project website.
{% endif %} {% endblock %} {% block portico_content %}
Integrations

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 {{ settings_html|safe }}. 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).

 Back to list
{% for integration in integrations_dict.values() %} {% if integration.is_enabled() %}
{% if integration.secondary_line_text %} {{ integration.display_name }} {{ integration.secondary_line_text }} {% else %} {{ integration.display_name}} {% endif %}
{% endif %} {% endfor %}
Integrations available via Hubot

The official Hubot integration provides an extension point for additional Zulip integrations.

A non-comprehensive list of integrations available through Hubot follows below:

{% for integration in hubot_lozenges_dict.values() %}
{{ integration.display_name}}
{% endfor %}
{% for integration in integrations_dict.values() %} {% if integration.is_enabled() %} {% if integration.doc %}
{% include integration.doc %}
{% endif %} {% endif %} {% endfor %}

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 {{ settings_html|safe }}, create an Asana bot. Please note the bot name and API key.

Then:

  1. 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/.

  2. 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_subdomain }}"{% endif %}

    If you are using a stream other than asana, set ZULIP_STREAM_NAME to the chosen stream name.

  3. Test your configuration by running the mirror with asana/zulip_asana_mirror. It will print some informational messages and process any recently created or completed tasks.

  4. 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_subdomain }}"{% 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.

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_subdomain }} \
{% endif %}    --stream commits --subject deployments || true"
  end
end

Some notes:

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!

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_subdomain }}"{% 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.

{% if email_integration_enabled %}

You can send emails to Zulip! This is useful:

To send an email to a Zulip stream:

  1. Visit your {{ subscriptions_html|safe }} and click on the stream row to expand it.
  2. Copy the stream email address (e.g. {{ email_gateway_example }}). If the stream name contains special characters, we've transformed the name so it is a safe email recipient.
  3. Send an email (To, CC, and BCC all work) to the stream email address. The email subject will become the stream topic, and the email body will become the Zulip message content.

Please note that it may take up to one minute for the message to show up in Zulip.

{% endif %}

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_subdomain }}"{% 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.

Get Google Calendar reminders in Zulip! This is a great way to see your reminders directly in your Zulip feed.

First 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, follow the instructions for Step 1 at this link to get a client_secret file. Save this file to your /~ directory instead of your working directory.

Next, install the latest Google API Client for Python by following the instructions on the Google Website.

Then go to your Zulip Settings by clicking on the cog in the top right corner, and then clicking on Settings.

Click on the tab that's labeled Your bots and click on Show/change your API key. Enter your password if prompted, and download the .zuliprc file. Save this file to your ~/ folder.

Run the get-google-credentials with this command: 

python /usr/local/share/zulip/integrations/google/get-google-credentials
It should open up a browser and ask you for certain permissions. Give Zulip access, and move on to the next step. If it doesn't open a browser, follow the instructions in the terminal window.

Now, all that's left to do is to run the gcal-bot script, in the same directory as the get-google-credentials script, with the necessary paramaters: 

python /usr/local/share/zulip/integrations/google/gcal-bot --user foo@zulip.com

The --user flag specifies the user to send the reminder to.
There are two optional flags that you can specify when running this script:

  1. --calendar: This flag specifies the calendar to watch from the user's Google Account. By default, this flag is set to a user's primary or default calendar. To specify a calendar, you need the calendar ID which can be obtained by going to Google Calendar and clicking on the wedge next to the calendar's name. Click on settings in Calendar settings in the drop down, and look for the Calendar Address section. Copy the Calendar ID from the right side of the page and use that as the value for this flag.

  2. --interval: This flag specifies the interval of time - in minutes - between receiving the reminder, and the actual event. For example, an interval of 30 minutes would mean that you would receive a reminder for an event 30 minutes before it is scheduled to occur.

Don't close the terminal window with the bot running. You will only get reminders if the bot is still running.

Congratulations! You're done!
You will get a Zulip private message, whenever you have a calendar event scheduled, that looks like this:

  1. 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.

  2. In your Hubot's directory, install the Zulip adapter. Run: 
    npm install --save hubot-zulip

  3. On your {{ settings_html|safe }}, create a bot account. Note its username, API key and full name; you will use them on the next step.

  4. To run Hubot locally, use: 
    HUBOT_ZULIP_SITE={{ external_api_path_subdomain }} 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.

Check out additional Zulip integrations available via Hubot

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 might be named "Humbug Plugin" in some places)

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

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 mechanism
Next, download and install our Python bindings and example scripts.

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 to Administration > System > Configure SSL and in the Import SSL Certificates field, enter {{ external_api_uri_subdomain }}. After clicking Save Certificates, follow the on-screen instructions and restart JIRA for it to recognize the proper certificates.

Zulip Integration

Copy the folder integrations/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 {{ settings_html|safe }}, create a Mercurial bot.

Then:

  1. Download and install our Python bindings on the server where the master Mercurial repository lives.

  2. 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_subdomain }}{% endif %}

That's all it takes for the basic setup! On the next hg push, you'll get a Zulip update for the changeset.

More configuration options

The Mercurial integration also supports:

Web repository links

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_subdomain }}{% endif %}

Branch whitelists and blacklists

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_subdomain }}{% 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
        }
Once you've done that, reload your Nagios configuration using /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.

Ths integration sends a notification every time a deployment is made in an OpenShift instance.

First, download our Python bindings and example scripts, and move it to your local copy of the application's repository.

Then, create a new commit including all the changes made to the repository, and push it to your app.

After that, connect to the application through SSH. If you don't know how to do this, log in to your OpenShift Online account, go to your application's dashboard, and click "Want to log in to your application?".
There you'll find the app's SSH user, address, and further information on SSH, in case you need it.

Once you have connected, install the Python bindings by running:

$ cd ~/app-root/repo/<python_bindings_path>
$ python setup.py install

Where <python_bindings_path> is the path where you saved the bindings in the first step.

Next, open integrations/openshift/zulip_openshift_config.py inside the SSH terminal with your favorite editor, and change the following lines to specify the email address and API key for your OpenShift integration:

ZULIP_USER = "openshift-bot@example.com"
ZULIP_API_KEY = "0123456789abcdef0123456789abcdef"
{% if api_site_required %}ZULIP_SITE = "{{ external_api_uri_subdomain }}"{% endif %}

You can also specify which pushes will result in notifications and to what stream the notifications will be sent by modifying the deployment_notice_destination function in zulip_openshift_config.py. By default, deployments triggered by commits pushed to the master and test-post-receive branches will result in a notification to stream deployments.

Save the file, and symlink $OPENSHIFT_PYTHON_DIR/virtenv/share/zulip/integrations/openshift/post-receive into the ~/app-root/repo/.openshift/action_hooks directory.

Next, create the stream you'd like to use for OpenShift notifications, and subscribe all interested parties to this stream. The integration will use the default stream deployments if no stream is supplied in the hook; you still need to create the stream even if you are using this default.

Congratulations! You're done!
Whenever you make a push to the master branch of your application's repository (or whichever branch you configured above), or if you force a deployment, the Zulip OpenShift 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.

Zulip supports integration with Perforce as a trigger that fires once a changelist is submitted and committed. To do this:

  1. Download and install our Python bindings on the server that hosts your Perforce depot. The Perforce trigger will be installed to a location like /usr/local/share/zulip/integrations/perforce
  2. Open integrations/perforce/zulip_perforce_config.py in your favorite editor, 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.
  3. You should also change ZULIP_SITE to {{ external_api_path_subdomain }}
  4. Edit your trigger table with p4 triggers and add an entry something like the following: 
    notify_zulip change-commit //depot/... "/usr/local/share/zulip/integrations/perforce/zulip_change-commit.py %change% %changeroot%"
  5. By default, this hook will send to streams of the form 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 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:

  1. Clone the Zulip Redmine plugin repository by running:

    git clone https://github.com/zulip/zulip-redmine-plugin

  2. 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:

    1. Copy the zulip_redmine directory to the plugins directory of your Redmine instance.

    2. 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

    3. Restart your Redmine instance.

    The Zulip plugin is now registered with Redmine!

  3. On your {{ settings_html|safe }}, create a new Redmine bot.

  4. 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 zulip server by {{ external_api_path_subdomain }}, the bot email address, and API key, and the Zulip stream that should receive notifications. Apply your changes.

  5. 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:

RSS

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 {{ settings_html|safe }}, 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:

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:

  1. Download and install our Python bindings on the server where the SVN repository lives.
  2. Install 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.
  3. Copy integrations/svn/zulip_svn_config.py and integrations/svn/post-commit from the API bindings directory to the hooks subdirectory of your SVN repository.

  4. 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_subdomain }}"{% endif %}
  5. The default stream used by this post-commit hook is 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:

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_subdomain }}"{% 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.

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:

  1. Log in to http://dev.twitter.com.
  2. In the menu under your username, click My Applications. From this page, create a new application.
  3. Click on the application you created and click "create my access token". Fill in the requested values.

To configure and deploy this bot:

  1. Create a ~/.zulip_twitterrc with the following contents: 
    [twitter]
consumer_key =
consumer_secret =
access_token_key =
access_token_secret =
  2. Test the script by running it manually: 
                /usr/local/share/zulip/integrations/twitter/twitter-search-bot --search="@nprnews,quantum physics" --site={{ external_api_uri_subdomain }}
    Note: twitter-search-bot may install to a different location on your operating system distribution.
  3. Configure a crontab entry for this script. A sample crontab entry that will process tweets every minute is: 
                * * * * * /usr/local/share/zulip/integrations/twitter/twitter-search-bot --search="@nprnews,quantum physics" --site={{ external_api_uri_subdomain }}

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.

{% endblock %} {% block customhead %} {{ super() }} {% endblock %}