text:
{% extends "zerver/portico.html" %}

{# API information page #}

{% block os_announcement %}
  {% if show_oss_announcement %}

         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 %}

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 {{ settings_html|safe }}, create an Airbrake bot.  Construct the URL for
    the Airbrake bot using the API key and stream name:
      {{ external_api_uri_subdomain }}/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:

    Receive user reviews from your tracked apps on AppFolllow in Zulip
    using the Zulip AppFollow plugin!

    First, create the stream you'd like to use for AppFollow notifications, and
    subscribe all interested parties to this stream. We recommend the
    name appfollow.

Next, on your {{ settings_html|safe }}, create an AppFollow bot.

Then, log into your account on appfollow.io, and:

        Click on the app for which you'd like to receive reviews.
        Click on Integrations and then go to the Others tab.

        In the Webhook URL field, enter the following URL, replacing the bot API key
        and Zulip stream with the appropriate information.

{{ external_api_uri_subdomain }}/v1/external/appfollow?api_key=test_api_key&stream=appfollow

    Save changes –  all done!

    New reviews for your app will be delivered to your Zulip stream.

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:

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

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

Some notes:

If you prefer not to use --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.

You may need to change the 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_subdomain }}/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_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.

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_subdomain }}/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_subdomain }}/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:

        Zulip supports integration with Delighted and can notify you
        about updates in feedback responses organized by Delighted.

        First, create the stream you'd like to use for Delighted notifications,
        and subscribe all interested parties to this stream. We
        recommend the name delighted. Next, create a bot named Delighted
        and retrive the API key of the bot and place it into the API parameter in the URL below.

{{ external_api_uri_subdomain }}/v1/external/delighted?api_key=abcdefgh&stream=delighted

        Modify the parameters of the URL above, where api_key is the API key of your Zulip bot,
        and stream is the stream name you want the
        notifications sent to.

        Go to your Delighted Webhook Integration settings panel.
        Under Send webhook notifications for:: input the above URL with the modifications into
        the URL textbox and press Save and turn on to finish.

        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:

Name: Zulip

Authentication Method: Basic Auth

URL: {{ external_api_uri_subdomain }}/v1/external/deskdotcom

User name: your bot's user name, e.g. desk-bot@yourdomain.com

Password: your bot's API key

Click Create to save your settings. From the next screen, click Add
      Action add a new action. You'll do this for every action you want a
      notification on Zulip for. (To add another action later, look for your
      custom action on the Apps page under "Installed Apps."

Let's say you want a notification each time a case is updated. Put
      in a descriptive name like "Announce case update", select "POST a string to a URL"
      for Action Type, and copy-paste this to the "Appended URL path":

      {% raw %}

?stream=desk&topic={{case.id}}:+{{case.subject}}

      {% endraw %}

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, although you may if you wish. All
      the funny-looking stuff inside {{ and }}
      will be filled in by Desk.com for each event. The dialog should look
      like this:

      {% endraw %}

Click Add Action to save, and then on the next screen click the slider
      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, "Inbound Interaction".

Select the types of interaction you want your rule to apply to,
      such as Chat. Specify the name and click on "Add Rule."

In the next screen, provide the details. First, click Add Actions to
      display the rule actions. Select "Trigger an App Action" in the dropdown, and
      then the name of the custom action you created earlier when the the second
      dropdown appears. You can add additional "All" or "Any" conditions if desired.
      Also select when the rule should run (if not "Anytime") and enable it.

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:

{% if email_integration_enabled %}

You can send emails to Zulip! This is useful:

If you use a service that can send emails but does not easily lend
        itself to more direct integration

If you have an email that you want to discuss on Zulip

As a structured, searchable, commentable archive for mailing list
        traffic

To send an email to a Zulip stream:

Visit your {{ subscriptions_html|safe }} and click on the stream row to expand it.

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.

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 %}

Freshdesk

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

Part 1: Zulip notifications for new Freshdesk tickets

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_subdomain }}/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.

Part 2: Zulip notifications on ticket changes

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_subdomain }}/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_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.

        This webhook bases on deprecated concept that is
        GitHub Services

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:

First, create the stream you'd like to use for GitHub Webhook notifications,
      and subscribe all interested parties to this stream. The integration will
      use the default stream github 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":

Click "Add webhook".

Authorize yourself and configure your webhook.

In the "Payload URL" field, enter a URL constructed like this:

{{ external_api_uri_subdomain }}/v1/external/github?api_key=abcdefgh&stream=github

where api_key is the API key of your Zulip
        bot. Select the actions that you want to result in a
        Zulip notification and click Add Webhook.

Congratulations! You're done!

      Your messages will look like this:

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

Next, go to your repository page and click gear icon.
      From there, select Webhooks:

In the URL field, enter a URL constructed like this:

{{ external_api_uri_subdomain }}/v1/external/gitlab?api_key=abcdefgh&stream=gitlab

where api_key is the API key of your Zulip
        bot.
  Select the actions that you want to result in a
        Zulip notification and click Add Webhook.

Congratulations! You're done!

      Your messages will look like this:

        First, create a stream for GoSquared for where you would like to receive GoSquared notifications
        and subscribe all interested parties to the stream. The integration will automatically
        use the default stream gosquared if no stream is supplied, though you will
        still need to create the stream manually even though it's the default.

        Next, go to the Zulip settings page and create a bot named GoSquared. Go to the account settings page of
        your GoSquared account and under Project Settings > Services > Webhook > Add New.
        Add the below URL under the section 'Enter a URL to receive requests:' and name the integration, Zulip.

{{ external_api_uri_subdomain }}/v1/external/gosquared?api_key=abcdefgh&stream=gosquared

        Note: api_key must be reconfigured to be the API key of your Zulip bot.

        If you want to change the stream default that receives notifications, change stream= in the URL.

        To change the topic displayed by the bot, simply append &topic=name to the end of the above URL.
        Where name is your topic.

        Under notifications of your GoSquared account page, press Add New Notification and select when and why you
        want to be notified through Zulip. After you're done, remember to check the box of the webhook corresponding to Zulip.

        Congratulations! You're all set

        Your messages should look like this:

        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:

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

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

        Configuring the HelloSign integration is easy. First, create a stream
        (we recommend a name like "hellosign").

        Next, go to the Zulip settings page and create a Zulip bot bot
        for the HelloSign integration.  Note the bot API key and add
        it to the URL below as api_key, and including the
        name of the stream you'd like to receive the notifications
        as stream= in the URL.  If you'd like to hardcode
        the topic used by the bot, simply append
        &topic=topic_name to the end of the above URL, where
        topic_name is your topic.

{{ external_api_uri_subdomain }}/v1/external/hellosign?api_key=abcdefgh&stream=stream_name

        Go to the account settings page of your HelloSign account and
        under the Integrations tab, go to API and Account Callback.
        Add the above URL with your modifications under the section 'Account Callback'.

        Congratulations! You're all set.

        Your messages should look 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 {{ settings_html|safe }}, create a Hello World bot.  Construct the URL for
        the Hello World bot using the API key and stream name:
          {{ external_api_uri_subdomain }}/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:

        Receive notifications in Zulip whenever a new version of an app is pushed to Heroku
        using the Zulip Heroku plugin!

        First, create the stream you'd like to use for Heroku notifications, and
        subscribe all interested parties to this stream. We recommend the
        name heroku.

Next, on your {{ settings_html|safe }}, create a Heroku bot.

Then, log into your account on heroku.com, and:

            Visit the page for the project for which you'd like to generate
            Zulip notifications. Click the "Resources" tab, and add the "Deploy Hooks" addon.
            Choose the "HTTP Post Hook" plan, and click "Provision".

            Click on the "Deploy Hooks" add-on that you just added.
            You should be redirected to a page that looks like this:

            Enter the following webhook URI, replacing the bot API key
            and Zulip stream with the appropriate information.

{{ external_uri_scheme }}{{ external_api_path_subdomain }}/v1/external/heroku?api_key=test_api_key&stream=heroku

        Congratulations! You're done!

        When you deploy to Heroku, the team can see these updates in real time in Zulip:

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.

In your Hubot's directory, install the Zulip adapter. Run:

npm install --save hubot-zulip

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.

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

Did you set up a post-build action for your project?

Does the stream you picked (e.g. jenkins) already exist? If not, add yourself to it and try again.

Are your access key and email address correct? Test them using our curl API.

Still stuck? Email zulip-devel@googlegroups.com.

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_subdomain }}/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 above

method is POST

Content Type is application/json

Finally, 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_subdomain }}/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 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:

Script Runner Plugin

SSL Plugin

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 for your Librato alerts or snapshots!

First, create the stream you'd like to use for Librato notifications, and
    subscribe all interested parties to this stream. We recommend the
    name librato.

Next, on your Zulip settings
    page, create a Librato bot. Please note the bot name and API key. Then:

Alerts configuration

1. Login into your Librato account and switch to the integrations page:

2. From there, select "Webhook" integration:

3. Fill in the title and URL fields using your bot's API key

The default stream name is librato and default topic name is Alert alert_name.

      URL = {{ external_api_uri }}/v1/external/librato?api_key=your_api_key

You can customize the stream name and topic name:

      URL = {{ external_api_uri }}/v1/external/librato?stream=your_stream_name&topic=your_topic_name&api_key=your_api_key

4. Next, go to your alerts page:

5. Choose the alert conditions and enable the your new
      webhook under "Notification Services":

        Congratulations! You're done!

        When an alert triggers, you'll get a Zulip notification that looks like this:

Snapshot configuration

        Because of limitations in Librato's API, you need to use the
        Slack integration to get Librato snapshots sent into Zulip.

Default stream name is librato and default topic name is snapshots.

        To send a snapshot, just click at one of your chart, use
        the send a snapshot option and add the proper
        integration.

        Congratulations! You're done!

        When a snapshot comes, you'll get a Zulip notification that looks like this:

First, create the stream you'd like to use for Mention Webhook notifications,
      and subscribe all interested parties to this stream. The integration will
      use the default stream mention 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 Mention feed and click on your profile in the top right corner,
      click on Settings in the drop down menu:

From there, select Integrations:

Select the Zapier integration, and click Explore Mention on Zapier!:

Search for "webhooks" in the search bar, and click on Webhooks by Zapier.

      Scroll down and look for Add Webhooks posts for new Mentions and click on
      Use this Zap:

Select your Mention account Id and the alert that should trigger mentions
      from the respective drop down menus, and click Continue

Select POST on the page that says Webhooks by Zapier Action, and click
       Continue.

In the URL field, enter a URL constructed like this:

{{ external_api_uri_subdomain }}/v1/external/mention?api_key=abcdefgh&stream=mention

where abcdefgh should be replaced with the API key of your Zulip
        bot. Select JSON for Payload Type and click Continue:

Congratulations! You're done!

      Your messages will look like this:

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:

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_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:

linking to changelog and revision URLs for your repository's web
        UI

branch whitelists and blacklists

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.

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_subdomain }}/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:

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.

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:

Name: Zulip

Endpoint URL: {{ external_api_uri_subdomain }}/v1/external/pagerduty?api_key=abcdefgh&stream=pagerduty

        Zulip supports integration with Papertrail as a
        Webhook
        that fires upon finding a certain log. To do this:

        First, create the stream you'd like to use for Papertrail
        notifications, and subscribe all interested parties to this stream. We
        recommend the stream name be papertrail. After create a bot named
        Papertrail and note the API key.

        Next, log into your Papertrail Account and browse through your logs.
        Search for logs you want to get alerts for and press the Save Search
        to open up a modal window, then fill out the details and press the
        Save & Setup an alert button.

        Go to the Create an alert section, press the Webhooks
        link and place the below URL into the Webhook URL section. Be sure to set
        the frequency to either minute, hour or day.

{{ external_api_uri_subdomain }}/v1/external/papertrail?api_key=abcdefgh&stream=papertrail

        Note: 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 Papertrail notifications will
        appear in Zulip:

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

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

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.

You should also change ZULIP_SITE to {{ external_api_path_subdomain }}

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%"

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 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_subdomain }}/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_subdomain }}/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 {{ settings_html|safe }}, 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 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.

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:

Semaphore

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

Zulip supports integration with Sentry and can notify you of
          issues that occurred in your project.

First, create the stream you'd like to use for Sentry notifications,
          and subscribe all interested parties to this stream. We
          recommend the name sentry.  Then, construct
          the Sentry webhook URL as follows:

{{ external_api_uri_subdomain }}/v1/external/sentry?api_key=abcdefgh&stream=sentry

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 Sentry dashboard choose your project.

From the menu on the right, choose Settings

On the settings page, from the menu on the left, choose Notifications

      In the Inactive Integrations section, choose WEBHOOKS

In the WebHooks box, insert the above webhook
      URL into the Callback URLs* field.

And click Save changes

Congratulations! You're done!
 You will receive Zulip notifications
      like this whenever a new Sentry alert is triggered:

        First, create the stream you'd like to use for Solano Labs CI Build notifications, and
        subscribe all interested parties to this stream. The integration will use the default
        stream solano labs if no stream is supplied in the hook; you still need
        to create the stream even if you are using this default.

        Next, setup a bot that you would like to use with this integration. You will need its
        API key.

        Next, follow
        these instructions for Outgoing Web Hooks to configure a webhook for your Solano
        Labs Organization and choose the repositories that should trigger a webhook a notification.

Enter a url of the following format into the URL field:

{{ external_api_uri_subdomain }}/v1/external/solano?api_key=abcdefgh&stream=solano_labs

Where abcdefgh should be replaced with the API key of the bot you
        created earlier.

Leave the Username and Password fields blank and click Add Web Hook

Congratulations! You're Done!

Your messages will look like this:

Stash

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

        You can choose to be notified whenever certain events are triggered on Stripe
        by adding a webhook to your Stripe account. First, create a stream where the events
        are to be sent.

Next, on your {{ settings_html|safe }}, create a Stripe bot.

        Add a webhook to your Stripe account by going to "Your account"->"Account
        settings"->"Webhooks"->"Add Endpoint" and adding the following URL,
        replacing the bot email address (with the @sign escaped to %40),
        bot API key, Zulip stream, and Zulip topic with the appropriate values:

e.g.

sales-bot%40example.com instead of stripe-bot%40example.com

abcdef0123 instead of api_key

finance instead of sales

transactions instead of Stripe

      {{ external_uri_scheme }}stripe-bot%40example.com:api_key@{{ external_api_path_subdomain }}/v1/external/stripe?stream=sales%26topic=Stripe

        {%if 'http:' in external_uri_scheme %}
        Note that Stripe will only accept https webhooks!
        {%endif%}

        To set up different topics for different events, create separate webhooks
        for those events, customizing the URL stream and topic for each.

        Congratulations!

        You will now receive notifications for the events you have chosen.
        Zulip currently supports the following events:

Charge Dispute Closed

Charge Dispute Created

Charge Failed

Charge Succeeded

Customer Created

Customer Deleted

Customer Subscription Created

Customer Subsciption Deleted

Customer Subscription Trial Will End

Invoice Payment Failed

Order Payment Failed

Order Payment Succeeded

Order Updated

Transfer Failed

Transfer Paid

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:

Download and install our Python bindings on the
        server where the SVN repository lives.

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.

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.

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 %}

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:

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

                Name - to recognize this service, preferably Zulip

                URL -

{{ external_api_uri_subdomain }}/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).

                Secret key - once again the API key created in Zulip.

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.

        There are two different ways you may want to consider
        when organizing your Taiga - Zulip integration:

          Use special Zulip stream for Taiga messages - name
          it Taiga. (Make sure to create this stream
          first!) For every integrated project, provide a new topic.

STREAM_NAME = Taiga
TOPIC = Project

          If you already have a Zulip stream for managing a project,
          you can also use this existing stream and add Taiga
          notifications using special topic.(Remember about
          substituting spaces with %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_subdomain }}/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_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.

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_subdomain }}/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:
    - {{ external_api_uri_subdomain }}/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=&ltAPPLICATION_KEY&gt&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/&ltTRELLO_BOARD_SHORT_ID&gt?key=&ltAPPLICATION_KEY&gt&token=&ltUserToken&gt

        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/&ltUserToken&gt/webhooks/?key=&ltAPPLICATION_KEY&gt

{
  "description": "Webhook for Zulip integration",
  "callbackURL": "&ltURL_TO_ZULIP_WEBHOOK_FROM_SECOND_STEP&gt",
  "idModel": "&ltID_MODEL&gt",
}

        You can use curl to do this:

curl 'https://api.trello.com/1/tokens/&ltUserToken&gt/webhooks/?key=&ltAPPLICATION_KEY&gt'
-H 'Content-Type: application/json' -H 'Accept: application/json'
--data-binary $'{\n  "description": "Webhook for Zulip integration",\n  "callbackURL": "&ltURL_TO_ZULIP_WEBHOOK_FROM_SECOND_STEP&gt",\n  "idModel": "&ltID_MODEL&gt"\n}'
--compressed

        The response from Trello should look like:

{
  "id": "&ltWEBHOOK_ID&gt",
  "description": "Webhook for Zulip integration",
  "idModel": "&ltID_MODEL&gt",
  "callbackURL": "&ltURL_TO_ZULIP_WEBHOOK_FROM_SECOND_STEP&gt",
  "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:

          Log in to http://dev.twitter.com.

          In the menu under your username,
          click My Applications. From
          this page, create a new application.

          Click on the application you created and click "create my access
          token". Fill in the requested values.

To configure and deploy this bot:

          Create a ~/.zulip_twitterrc with the following
          contents:

[twitter]
consumer_key =
consumer_secret =
access_token_key =
access_token_secret =

          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.

          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.

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_subdomain }}/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.

Get notifications from every event supported by Zapier.

First, create the stream you'd like to use for Zapier notifications,
          and subscribe all interested parties to this stream.

{{ external_api_uri_subdomain }}/v1/external/zapier?api_key=abcdefgh&stream=zapier

        Next, create a ZAP, picking the service you'd like
        to receive notifications from as Trigger (Step 1)

and Webhook as Action (Step 2).

As Step 2 action please choose POST

       Configure Set up Webhooks by Zapier POST as follows:

URL is the url we created above

Payload Type set to JSON

        Finally, configure Data.
        You have to add 2 fields:

subject is field corresponding to a subject of the message

content is field corresponding to a content of the message

Example configuration:

You're done! Example message:

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:

Title: Zulip

URL: {{ external_api_uri_subdomain }}{% raw %}/v1/external/zendesk?ticket_title={{ticket.title}}&ticket_id={{ticket.id}}&stream=zendesk{% endraw %}

Method: POST

Attribute Name: message

Username: your bot's user name, e.g. zendesk-bot@yourdomain.com

Password: your bot's API key

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}}
```

      {% endraw %}

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:

{% endblock %}

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

{% endblock %}

redpajama_set_name: RedPajamaGithub


The Maryland Historical Society invites applications for its Lord Baltimore Research Fellowship program. The society offers fellowships each year designed to promote scholarship in Maryland history and culture through research in its library collections. Applications will be welcomed from independent scholars, graduate students, or university faculty in any discipline appropriate to the society's collections.
Between six and twelve fellowships will be awarded. Fellows will be provided access to computers with Internet connections, expanded access to the library, and a free parking permit. These fellowships are non-stipendiary.
The terms of a fellowship may be from one week to one year during the period from June 1, 2018, to May 31, 2019. Fellows are expected to be in residence at the society during their fellowship term, make use of the society's collections in their research, and participate in the intellectual life of the society. Fellows are required to present their research-in-progress in informal presentations at the society, write a post on their research for the library's blog, and to submit an annotated bibliography to the library director at the conclusion of their term of residency. Fellows are encouraged to submit their finished work for possible publication in the Maryland Historical Magazine.


Nashville, TN -- March 25, 2013 -- Don Rigsby's life-long passion for the music of Dr. Ralph Stanley comes to full boil in his forthcoming album from Rebel Records, Doctor's Orders: A Tribute to Ralph Stanley. Rigsby salutes his chief inspiration with this new album which includes bluegrass and mountain music legend Ralph Stanley and the clinch Mountain Boys alumni as guest artists.
Stanley has been referred to as Dr. Ralph Stanley since receiving his honorary doctorate in music from Lincoln Memorial University in 1976.
The first single from the album, "The Mountain Doctor," will be made available for digital purchase as a special pre-album promotion next Tuesday, April 2 via iTunes, Amazon, eMusic and other digital outlets. The full album Doctor's Orders: A Tribute to Ralph Stanley will be released May 21.


text:
HP Expands Liquid Cooling Availability Inside Z820 Workstations
Tweet Tuesday, May 14, 2013
Z820 With Asetek Liquid Cooling Offers Quieter Computing for Engineers, Designers and Animators
Asetek® today announced that HP has expanded the availability of Asetek liquid cooling to include single processor Z820 workstations. Previously only available in dual CPU configurations, the more affordable single CPU Z820 with Asetek's integrated sealed loop liquid cooling provides reduced system noise and increased productivity. The design win is expected to translate into an 8-10% increase in Asetek's workstation business and is a key element in the company's goal to increase its overall desktop division revenue by 10% in 2013.
Professionals in Mechanical Computer Aided Design (MCAD) and Digital Media and Entertainment (DME) rely on HP workstations to deliver high performance and reliability. The innovative liquid cooling solution in the Z820 adds a quieter computing experience to those advantages, increasing productivity and creativity for users of professional applications.
Built for high-end computing and visualization, the HP Z820 Workstation delivers outstanding performance, award-winning industrial design, and tool-free serviceability in the industry's most expandable chassis.
"HP has always been on the cutting edge of workstation technology," said Scott Chambers, Senior Director of Marketing at Asetek. "The expansion of Asetek liquid cooling within the Z820 line further validates Asetek liquid cooling as a valuable addition for improved productivity".
Asetek liquid cooling has been available in HP workstations since the Z400 and Z800 were introduced in 2009. Factory filled and sealed for maximum reliability and ease-of-use, Asetek's patented liquid coolers have been thoroughly tested and certified to operate without maintenance for over 50,000 hours. For more information on the HP Z820 Workstation with Asetek liquid cooling, visit http://www.hp.com/

redpajama_set_name: RedPajamaCommonCrawl


i am a very descriptive and personal writer. i love writing and have been writing off and on my entire life. i write from political to fictional stories/articles. it is not my sole source of income but it is something that allows me to make money while i do some i love. i am interested in writing blogs, articles, sort stories or just small adds. anything that will allow me to show me talents will suffice.


It's DAY 11 of our 28 Day Yoga Challenge and I'm feeling very grateful for my life exactly as it is. It's amazing that depending on our perspective, we can be deeply content or absolutely distraught, with the conditions of our life being exactly the same.
I watched Oprah's Lifeclass last night featuring Sean Penn's charitable work in Haiti. I was incredibly touched and reminded to be thankful for all I have.
If you are looking for a focus for your meditation today, try incorporating this hasta mudra with an intention on abundance and giving (to yourself or someone else).
The translation for pushpaputa is "a handful of flowers" which is àpropos for this lovely symbol of giving to another.
Pushpaputa is a gesture of offering. This beautiful mudra signifies openness and acceptance — of ourselves, others and the gifts of life. This gesture can help you remember the wealth the Universe has to offer and allow you to connect with abundance. It allows you to be receptive in receiving. You can also use this mudra to meditate on sending an offering to someone else.
The palms are open in the gesture of giving. Rest the back of your hands on your thighs. The thumbs and fingers are relaxed. The fingertips point slightly towards each other.


text:
Foxes in Fiction comes to the Great American Music Hall
The first Foxes in Fiction album I ever listened to was 2010's Swung from The Branches. The songs––a mixture of field recordings and ambient noises––served as my bedroom soundtrack that summer in my tiny, windowless Sunset apartment.
After obsessing over the album for months, I became increasingly curious about this mysterious Canadian experimentalist. With some research I discovered that this particular album was frontman Warren Hildebrand's attempt to deal with the loss of his younger brother, whose age and birthday fell just a few days short of mine. The track "8/29/91" is deeply personal, with a sample of Bukowski reading a journal entry on the day of Hildebrand's brother's birthday.
These songs resonated with me, and ever since I have been a fan of both Foxes in Fiction as well as Hildebrand's label, Orchid Tapes.
Foxes in Fiction have announced a tour in support of his forthcoming full length album, Ontario Gothic. The title track, a layering of delicate vocals and harmonies, is relaxing as it is therapeutic. Beautifully done dream-pop, the track builds and crashes into itself with synth, strings, and keyboards all morphing into one another.
Owen Pallett, Avi Buffalo, Foxes in Fiction
the Great American Music Hall
9 p.m., $21
By Ruby Perez|August 19, 2014|Tags: Foxes in Fiction|
About the Author: Ruby Perez
Originating from Reagan Country, Ruby Perez made her great escape to San Francisco in late 2009. She's obsessive about all things music and often gets depressed when she encounters multiple Barbra Streisand records at thrift stores. She owns a 1980 Peugeot named Baby Roy.