| 1 | --- |
| 2 | title: Integrations |
| 3 | description: Connect the tools your team and you already use. Workspace integrations work for everyone in a workspace; personal ones work just for you, in every workspace. What is available today, what is coming, and how to ask for one. |
| 4 | --- |
| 5 | |
| 6 | g1t connects to the tools your work already lives in: where errors are |
| 7 | reported, where tickets are tracked, where code came from. Every |
| 8 | integration is listed in one directory, by category, whether it works |
| 9 | today or is still being built. The directory is **Integrations**, at |
| 10 | `g1t.sh/<workspace>/-/integrations`. |
| 11 | |
| 12 | The models g1t works with are not an integration. A workspace chooses |
| 13 | them, managed or self-hosted, under **AI**, its own setting: see |
| 14 | [AI providers](/guides/ai/). |
| 15 | |
| 16 | ## Workspace and personal |
| 17 | |
| 18 | There are two places to connect things, and they are for different people: |
| 19 | |
| 20 | | | Workspace integrations | Your integrations | |
| 21 | | --- | --- | --- | |
| 22 | | Where | **Integrations**, at `g1t.sh/<workspace>/-/integrations`, with each integration's setup page under it | **Your settings → Integrations**, at [`g1t.sh/settings/integrations`](https://g1t.sh/settings/integrations) | |
| 23 | | Who it is for | Everyone in that workspace | Just you, in every workspace you belong to | |
| 24 | | Who connects | Workspace owners. Members see what is connected. | You | |
| 25 | | Examples | Sentry, Jira, Linear, GitHub imports, webhooks | Signing in with GitHub, coding agents you connect through MCP, and soon your calendar | |
| 26 | |
| 27 | Some tools have both sides. GitHub, for instance: a workspace owner |
| 28 | installs g1t's GitHub App to import the team's repositories, and |
| 29 | you link your own GitHub account to sign in with it. Each card says when |
| 30 | the other side exists. |
| 31 | |
| 32 | ## The directory |
| 33 | |
| 34 | Both pages are the same directory: |
| 35 | |
| 36 | - **Categories** down the side (along the top on a phone): Code & CI, |
| 37 | Work & projects, Chat & meetings, Calendar & email, Docs & knowledge, |
| 38 | Monitoring & incidents, Cloud & deploy, AI & agents, Data & analytics, CRM & support, |
| 39 | Design, Security & identity, and Files & storage. Each shows how many |
| 40 | integrations it has. A link can open on one, with `?category=code` and |
| 41 | so on. |
| 42 | - **Search** finds an integration by name, by what it does ("in a meeting", |
| 43 | "opens work items"), or by a tag, across every category. |
| 44 | - **Connected** comes first: what is set up here, with a line about each |
| 45 | (the account, how many connections) and **Needs attention** when |
| 46 | something is wrong, such as a key that stopped working or a GitHub |
| 47 | installation that was suspended. Choose one to manage it. |
| 48 | - **Available** can be connected now. Choose one to open its setup page. |
| 49 | - **Soon** is being built. Each says what it will do, and **Ask for this** |
| 50 | tells g1t you want it (below). |
| 51 | |
| 52 | The tags on a card say what an integration lets g1t do: **Opens work items**, |
| 53 | **Writes back** (the other system hears when work lands), **Imports |
| 54 | repositories**, **Sets your status**, and so on. |
| 55 | |
| 56 | ## Available today |
| 57 | |
| 58 | | Category | Workspace | Personal | |
| 59 | | --- | --- | --- | |
| 60 | | Code & CI | [GitHub](/guides/github/) import, [webhooks](/guides/webhooks/) | [Signing in with GitHub](/guides/github/#link-and-unlink-github); [MCP clients](/guides/authentication/#signing-in-with-oauth): your [coding agent](/guides/bring-your-own-agent/), connected to g1t as you; [Claude Code plugin](/guides/claude-code-plugin/) | |
| 61 | | Work & projects | [Jira and Linear](#trackers) | | |
| 62 | | Monitoring & incidents | [Sentry, Datadog, and any system that sends a webhook](#alerts) | | |
| 63 | |
| 64 | Alerts and trackers each have a setup page under the directory: |
| 65 | `-/integrations/alerts` and `-/integrations/trackers`. GitHub and webhooks |
| 66 | keep their own pages; the directory links to them. |
| 67 | |
| 68 | Secrets are sealed when they are saved and never shown again, to anyone. |
| 69 | A setup page shows the last four characters of a key, so you can tell keys |
| 70 | apart. |
| 71 | |
| 72 | ## Coming soon |
| 73 | |
| 74 | Every category has integrations on the way, among them Slack, Microsoft |
| 75 | Teams, Google Docs, PagerDuty, AWS, Miro, Okta and Google Drive for |
| 76 | workspaces. For you: **Google Calendar** and **Outlook |
| 77 | Calendar** will set your [status](/guides/chat/#presence-and-status) to *In a meeting* while |
| 78 | you are in one; **Zoom** |
| 79 | and **Google Meet** will set it to *On a call*. A status you set by hand |
| 80 | always wins over one an integration sets. |
| 81 | |
| 82 | The directory lists them all. Nothing on a **Soon** card does anything |
| 83 | yet. |
| 84 | |
| 85 | ## Ask for an integration |
| 86 | |
| 87 | On any **Soon** card, **Ask for this** opens an email to g1t with the |
| 88 | integration and your workspace (or "for my own account") filled in. Add |
| 89 | what you would use it for and send it. Searching for something that is |
| 90 | not listed offers the same, for whatever you searched for. Requests decide |
| 91 | what is built next. |
| 92 | |
| 93 | ## Alerts |
| 94 | |
| 95 | An alert source opens [work items](/guides/work-items/) filed in one |
| 96 | repository, their origin. Each problem it reports is one work item: |
| 97 | |
| 98 | - **The first alert** opens a work item labelled `bug` (or the label you set) |
| 99 | and the provider's name, with what the provider said about the problem. |
| 100 | - **The same problem again** updates that work item instead of opening another. |
| 101 | The work item says so when the count passes 10, 100, 1,000 and so on. |
| 102 | - **The same problem after its work item was closed** reopens it, with a comment |
| 103 | linking the new occurrence. |
| 104 | - **A recovery** (Datadog) is noted on the work item. |
| 105 | |
| 106 | Text in an alert can include what your users typed, such as an error |
| 107 | message built from a request. Work items opened from alerts say so. |
| 108 | |
| 109 | Each alert connection shows its last five deliveries: what arrived, and |
| 110 | whether g1t opened, updated, reopened, ignored or refused it. |
| 111 | |
| 112 | ### Sentry |
| 113 | |
| 114 | 1. On the **Integrations** page, choose **Sentry**. Give your organization's |
| 115 | slug and the repository its work items are filed in, then **Connect**. |
| 116 | 2. In Sentry, open **Settings → Developer Settings → Custom Integrations** |
| 117 | and create an **internal integration**: |
| 118 | - **Webhook URL**: the address g1t shows on the connection, |
| 119 | `https://api.g1t.sh/hooks/<connection>`. |
| 120 | - Turn on **Alert Rule Action**, and under **Webhooks** tick **issue**. |
| 121 | - **Permissions**: Issue & Event, read and write. |
| 122 | 3. Save it. Paste its **client secret** into the connection on g1t, and its |
| 123 | **token** as the connection's auth token. |
| 124 | |
| 125 | Then: |
| 126 | |
| 127 | - New Sentry issues open g1t work items. So does any alert rule whose action |
| 128 | sends a notification to the integration. |
| 129 | - With the token, g1t adds the latest event's stack trace, in-app frames |
| 130 | first, so whoever picks it up starts at the failing line. |
| 131 | - When the fix merges, g1t resolves the Sentry issue and comments with the |
| 132 | pull request. If Sentry sees it again, the g1t work item reopens. |
| 133 | |
| 134 | Requests without a valid `Sentry-Hook-Signature` are refused. |
| 135 | |
| 136 | ### Datadog |
| 137 | |
| 138 | 1. On the **Integrations** page, choose **Datadog**, pick the repository, |
| 139 | and **Connect**. g1t shows a signing secret once; copy it. |
| 140 | 2. In Datadog, open **Integrations → Webhooks** and add a webhook named |
| 141 | `g1t`: |
| 142 | - **URL**: the connection's address. |
| 143 | - **Custom headers**: `{"Authorization": "Bearer <signing secret>"}` |
| 144 | - **Payload**: |
| 145 | |
| 146 | ```json |
| 147 | { |
| 148 | "id": "$ALERT_ID", |
| 149 | "title": "$EVENT_TITLE", |
| 150 | "body": "$EVENT_MSG", |
| 151 | "url": "$LINK", |
| 152 | "status": "$ALERT_TRANSITION", |
| 153 | "priority": "$PRIORITY" |
| 154 | } |
| 155 | ``` |
| 156 | |
| 157 | 3. Mention `@webhook-g1t` in the message of any monitor that should open |
| 158 | work items. |
| 159 | |
| 160 | A monitor that triggers opens a work item; `Recovered` is noted on it. |
| 161 | |
| 162 | ### Any other system |
| 163 | |
| 164 | The **Webhook** connection takes JSON from anything that can send it: |
| 165 | PagerDuty, Grafana, a deploy script. |
| 166 | |
| 167 | ```sh |
| 168 | body='{"id":"checkout-500","title":"Checkout returns 500 for empty carts","body":"POST /checkout fails."}' |
| 169 | curl -X POST https://api.g1t.sh/hooks/$CONNECTION \ |
| 170 | -H "Content-Type: application/json" \ |
| 171 | -H "X-G1t-Signature: sha256=$(printf '%s' "$body" | openssl dgst -sha256 -hmac "$SECRET" -hex | cut -d' ' -f2)" \ |
| 172 | -d "$body" |
| 173 | ``` |
| 174 | |
| 175 | Sign it either way: |
| 176 | |
| 177 | - `X-G1t-Signature: sha256=<hex HMAC-SHA256 of the body>`, with the signing |
| 178 | secret as the key, or |
| 179 | - `Authorization: Bearer <signing secret>`. |
| 180 | |
| 181 | g1t reads these fields, taking the first name present: |
| 182 | |
| 183 | | Field | Names | Notes | |
| 184 | | --- | --- | --- | |
| 185 | | Title | `title`, `event_title`, `summary`, `name` | Required. | |
| 186 | | Id | `id`, `alert_id`, `aggregate`, `incident_key`, `dedup_key` | Alerts with the same id are one work item. The title if missing. | |
| 187 | | Description | `body`, `message`, `event_msg`, `text`, `description` | Markdown. | |
| 188 | | Link | `url`, `link`, `html_url` | | |
| 189 | | State | `status`, `transition`, `alert_transition`, `state` | `recovered`, `resolved`, `ok` or `closed` means it stopped. | |
| 190 | | Priority | `priority`, `severity`, `level` | | |
| 191 | | Count | `count` | How many times it has happened. | |
| 192 | |
| 193 | g1t answers `202` once the request is verified and acts on it just after, |
| 194 | so a slow step never makes the sender retry. It answers `401` to a request |
| 195 | that is not signed, and `200` with the reason to one it ignores. |
| 196 | |
| 197 | ## Trackers |
| 198 | |
| 199 | Connect Jira or Linear and tickets become something people and your |
| 200 | coding agents can reach from g1t. |
| 201 | |
| 202 | ### Look up a ticket |
| 203 | |
| 204 | Give a ticket key or address (`TECH-1234`, |
| 205 | `https://acme.atlassian.net/browse/TECH-1234`, |
| 206 | `https://linear.app/acme/issue/ENG-42/…`, a Sentry issue's address) and |
| 207 | g1t fetches it from the system it lives in, with its title, status and |
| 208 | description as they are now. Your coding agent looks one up over MCP with |
| 209 | the `search` tool's `ticket` action, or through the API: |
| 210 | |
| 211 | ```sh |
| 212 | curl "https://api.g1t.sh/repos/acme/web/context?reference=TECH-1234" \ |
| 213 | -H "Authorization: Bearer $G1T_TOKEN" |
| 214 | ``` |
| 215 | |
| 216 | ### Import a ticket as a work item |
| 217 | |
| 218 | On the **New work item** page under **Work**, give a key or paste an |
| 219 | address under **Bring one in**. g1t opens a work item in the workspace |
| 220 | with the ticket's title and description, linked to it. Importing the same |
| 221 | ticket again opens the work item already made. |
| 222 | |
| 223 | From the API or MCP: |
| 224 | |
| 225 | ```sh |
| 226 | curl -X POST https://api.g1t.sh/workspaces/acme/work/import \ |
| 227 | -H "Authorization: Bearer $G1T_TOKEN" -H "Content-Type: application/json" \ |
| 228 | -d '{"reference": "TECH-1234"}' |
| 229 | ``` |
| 230 | |
| 231 | A work item tied to something outside g1t shows it under **From outside g1t**, |
| 232 | with a link to the original. |
| 233 | |
| 234 | ### Tickets hear back |
| 235 | |
| 236 | Unless you turn it off, g1t comments on the ticket when a pull request |
| 237 | opens for its work item, and again when the work item closes as done, with a link |
| 238 | to what merged. For Sentry, closing as done resolves the Sentry issue. |
| 239 | |
| 240 | ### Jira |
| 241 | |
| 242 | | Setting | | |
| 243 | | --- | --- | |
| 244 | | Site | Your Jira's address, such as `https://acme.atlassian.net`. | |
| 245 | | Email | The Atlassian account the API token belongs to. | |
| 246 | | API token | From id.atlassian.com, **Security → API tokens**. g1t sees what that account can see. | |
| 247 | | Project keys | Optional. The projects this connection answers for, such as `TECH, OPS`. Empty answers for any key. | |
| 248 | |
| 249 | ### Linear |
| 250 | |
| 251 | | Setting | | |
| 252 | | --- | --- | |
| 253 | | API key | From Linear, **Settings → Security & access → Personal API keys**. | |
| 254 | | Team keys | Optional, such as `ENG`. Empty answers for any key. | |
| 255 | |
| 256 | A key that matches several connections is looked up in the ones that name |
| 257 | its project first. |
| 258 | |
| 259 | ## From the API |
| 260 | |
| 261 | Owners can manage integrations through the API and MCP, with a person's |
| 262 | token (a workspace token cannot): |
| 263 | |
| 264 | | MCP tool and action | Route | |
| 265 | | --- | --- | |
| 266 | | `workspace` `list_integrations` | `GET /workspaces/{workspace}/integrations` | |
| 267 | | `workspace` `connect_integration` | `POST /workspaces/{workspace}/integrations` | |
| 268 | | `workspace` `update_integration` | `PATCH /workspaces/{workspace}/integrations/{id}` | |
| 269 | | `workspace` `test_integration` | `POST /workspaces/{workspace}/integrations/{id}/test` | |
| 270 | | `workspace` `disconnect_integration` | `DELETE /workspaces/{workspace}/integrations/{id}` | |
| 271 | | `search` `ticket` | `GET /repos/{owner}/{name}/context?reference=` | |
| 272 | | `work_item` `import` | `POST /workspaces/{workspace}/work/import` | |
| 273 | |
| 274 | ```sh |
| 275 | curl -X POST https://api.g1t.sh/workspaces/acme/integrations \ |
| 276 | -H "Authorization: Bearer $G1T_TOKEN" -H "Content-Type: application/json" \ |
| 277 | -d '{"provider": "jira", "config": {"site": "https://acme.atlassian.net", "email": "dev@acme.com", "keys": ["TECH"]}, "secret": "<api token>"}' |
| 278 | ``` |
| 279 | |
| 280 | `provider` is `sentry`, `datadog`, `webhook`, `jira` or `linear`. |
| 281 | `config` takes `repo`, `label`, `write_back`, `organization`, `site`, |
| 282 | `email` and `keys`; each provider uses the ones above. For `datadog` |
| 283 | and `webhook`, the response's `signing_secret` is the only time the secret |
| 284 | is shown. |
| 285 | |
| 286 | AI providers have operations of their own: see |
| 287 | [AI providers from the API](/guides/ai/#from-the-api). |