Team and accountIntegrations
Integrations
Post deploy, domain and member events to Slack or a Microsoft Teams channel, or send them to your own endpoint as signed webhooks. One place, Team › Integrations, for every tool your team connects.
The Integrations page
Team › Integrations has two tabs:
- Browse: what you can connect, each with Install or Installed.
- Installed: what the team has connected, with a one-line summary ("Posts to #deploys and #alerts"), its scope (All projects or the ones picked), when it was installed and by whom.
Anyone in the team can see the page. Owners and admins install, change and remove integrations. API tokens can list integrations but can't change them.
This page covers Slack, Microsoft Teams and webhooks. GitHub, GitLab and Bitbucket, where Orbits pulls your code from, are on Git providers.
Slack
Install
- On Browse, pick Slack and press Install.
- Slack asks you to add Orbits to a workspace. Orbits asks to post messages, to post in public channels without being invited, and to list channels for the picker. It can't read your messages.
- Approve, and you're back on Orbits with Slack connected.
On a first install, each event is pointed at a starting channel if the workspace has it: failed deploys and domain problems at #alerts, production deploys at #deploys, new members at #general, otherwise #general.
Choose channels and projects
Slack's page in Integrations says where each event goes:
| Event | Channel |
|---|---|
| Deploy failed | Any public channel, or none |
| Promoted to production | |
| Domain verified or misconfigured | |
| New member joined |
and which projects send events: all, or the ones you pick. Changes save on their own. Only public, unarchived channels are offered.
Team › Settings › Notifications says whether each event goes to Slack, with its Slack switch (see notifications). An event is posted when its Slack switch is on, it has a channel here, and its project is in scope. The weekly summary is posted too when its Slack switch is on.
When it needs attention
If someone removes the Orbits app from the Slack workspace, the integration shows that it needs attention and Orbits stops posting. Press Reconnect and approve again: your channels and projects are kept.
Uninstall stops posting and revokes Orbits' access in Slack. Messages still waiting to go are dropped.
Microsoft Teams
Teams connects through a workflow in the channel, not a Microsoft sign-in. There is no app to approve and no tenant admin to ask; messages show as coming from Workflows.
Install
- In Microsoft Teams, open the channel and add the workflow Post to a channel when a webhook request is received.
- Copy the workflow's URL.
- In Orbits, on Browse, pick Microsoft Teams and press Install.
- Paste the URL and pick which events to post: a deploy failing, a production deploy going live, a domain verified or misconfigured, someone joining. Pick at least one.
- Save.
Only workflow URLs on *.logic.azure.com or *.api.powerplatform.com are accepted. Orbits keeps the URL encrypted and afterwards shows only its host: the URL works like a password, so anyone who has it can post to your channel.
Orbits posts a card for each event, with what happened, the facts and a button to open it in Orbits. Teams' page shows who installed it and how many messages went this month.
To change the events or the channel, uninstall and install again. Uninstall makes Orbits forget the URL and stop posting; the workflow stays in Teams until you remove it there.
Webhooks
Send events to your own endpoint, signed so you can check they came from Orbits. A team has one webhook.
Add one
- On Browse, pick Webhooks and press Install.
- Enter the endpoint's address:
https, on the public internet. - Pick the events to send (at least one) and the projects that send them.
- Copy the signing secret the dialog shows,
whsec_and a string of letters and digits, into your receiver. If you add the webhook through the API without a secret, Orbits makes one and returns it in that answer only. - Save.
To change the address, events or projects, remove the webhook and add it again. Remove stops sending; deliveries still waiting are dropped. The page shows the secret's last four characters and how many deliveries went this month.
Events
| Event | Sent when | data holds |
|---|---|---|
deployment.created | A deploy is queued | deployment |
deployment.ready | Any deploy is ready, production or preview | deployment |
deployment.failed | A deploy fails | deployment |
domain.updated | A domain changes, including when it's verified or stops pointing at Orbits | domain |
member.joined | Someone joins the team (not the person who created it) | member |
project.created | A project is created | project |
deployment is the deployment as the API returns it from GET /v1/teams/{team}/projects/{project}/deployments/{id}.
What a request looks like
POST /orbits-hook HTTP/1.1
Content-Type: application/json
User-Agent: Orbits-Webhooks/1
X-Orbits-Event: deployment.ready
X-Delivery-Id: idl_…
Orbits-Signature: sha256=5d41402abc4b2a76b9719d911017c592…
X-Signature-256: sha256=5d41402abc4b2a76b9719d911017c592…{
"id": "evt_…",
"type": "deployment.ready",
"created_at": "2026-11-02T08:30:00Z",
"team": { "id": "team_…", "slug": "acme" },
"data": { "deployment": { "id": "dpl_…" } },
"delivery_id": "idl_…"
}| Header | |
|---|---|
X-Orbits-Event | The event's type |
X-Delivery-Id | The same on every retry of one delivery (it's also in the body), so you can drop a repeat |
Orbits-Signature | sha256= and the hex HMAC-SHA256 of the raw body, keyed with the whole secret, whsec_ included |
X-Signature-256 | The same value, as alert webhooks send it, so one receiver can check both |
Answer with any 2xx within 10 seconds. Anything else, or no answer, is tried again: five tries in all, over about half an hour. Redirects aren't followed, and addresses that aren't on the public internet are refused. Events more than an hour old aren't sent.
Verify the signature
Work out the HMAC over the raw bytes of the body, exactly as they arrived, before any JSON parsing, and compare it in constant time.
import { createHmac, timingSafeEqual } from "node:crypto";
export function verifyOrbits(rawBody: Buffer, header: string | undefined, secret: string): boolean {
if (!header?.startsWith("sha256=")) return false;
const expected = "sha256=" + createHmac("sha256", secret).update(rawBody).digest("hex");
const a = Buffer.from(header);
const b = Buffer.from(expected);
return a.length === b.length && timingSafeEqual(a, b);
}With Express, take the body raw on the webhook's route:
import express from "express";
import { verifyOrbits } from "./verify";
const app = express();
const seen = new Set<string>();
app.post("/orbits-hook", express.raw({ type: "application/json" }), (req, res) => {
if (!verifyOrbits(req.body, req.get("Orbits-Signature"), process.env.WEBHOOK_SECRET!)) {
return res.status(401).end();
}
const delivery = req.get("X-Delivery-Id")!;
if (!seen.has(delivery)) {
seen.add(delivery);
const event = JSON.parse(req.body.toString("utf8"));
console.log(event.type, event.data);
}
res.status(204).end();
});
app.listen(3000);import hashlib
import hmac
def verify_orbits(raw_body: bytes, header: str | None, secret: str) -> bool:
if not header or not header.startswith("sha256="):
return False
expected = "sha256=" + hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest()
return hmac.compare_digest(header, expected)With Flask:
import json
import os
from flask import Flask, request
from verify import verify_orbits
app = Flask(__name__)
@app.post("/orbits-hook")
def orbits_hook():
if not verify_orbits(request.get_data(), request.headers.get("Orbits-Signature"), os.environ["WEBHOOK_SECRET"]):
return "", 401
event = json.loads(request.get_data())
print(event["type"], event["data"])
return "", 204Keep a record of the X-Delivery-Id values you've handled (in a database, not memory, in production), so a retry of something you already processed is dropped.
Not here yet
A test button and a delivery log for Slack, Teams and webhooks aren't available yet. To test a receiver, use the alert webhook's Send test event, which is signed the same way.
From the API
| Call | Who |
|---|---|
GET /v1/teams/{team}/integrations | Any member. Everything, with what's installed |
GET, PATCH, DELETE .../integrations/slack | GET any member; changes owners and admins |
POST .../integrations/slack/install | Owners and admins. Slack's "add to workspace" address |
GET .../integrations/slack/channels | Owners and admins. The channel picker |
GET, POST, DELETE .../integrations/teams | POST takes url and alerts |
GET, POST, DELETE .../integrations/webhooks | POST takes url, events, optionally secret and scope |
See API › Integrations.