The connection: account level
The credential itself: the Slack webhook URL, the Telegram bot token and the chat you picked, your endpoint. Entered once on the account’s Integrations page, and reusable everywhere.
Channels reach your team collectively, where they already work. Where email and in-app preferences are per user, a channel is a shared destination: a Slack channel, a Telegram chat, a Microsoft Teams channel, or your own signed webhook. uMarker posts a project’s activity there as events occur, with no uMarker login required to see them.
Channels are additive to personal notifications. They don’t replace them; they broadcast the same events to a place the whole team can see.
uMarker splits a channel into two things, and it’s worth understanding the split before you set one up:
The connection: account level
The credential itself: the Slack webhook URL, the Telegram bot token and the chat you picked, your endpoint. Entered once on the account’s Integrations page, and reusable everywhere.
The route: project level
Which project sends to it, and which events. Added from that project’s Distribution tab. One connection can serve any number of projects.
That means an agency pastes a Slack URL once and then attaches it to ten client projects with different event selections, rather than re-pasting the same credential per project. It also means disconnecting a credential warns you by name which projects lose their routing — with one limit that matters if you use more than one space.
| Kind | What uMarker sends | Included from |
|---|---|---|
| Generic signed webhook | A structured, signed JSON payload | Free (every plan) |
| Slack (incoming webhook) | A readable message with a link | Starter (99 ) |
| Telegram (your bot, posting to a chat you pick) | The same readable message | Starter (99 ) |
| Microsoft Teams (Workflows webhook) | The same readable message | Professional (249 ) |
A kind your plan doesn’t include is shown on the Integrations page locked, naming the plan that unlocks it, never hidden. There’s also a cap on how many connections an account holds at once, and channels share it with issue trackers: 1 on Free, 3 on Starter, 10 on Professional, 25 on Agency, counted account-wide across both kinds. A connected GitHub uses one of them — so on Free you have room for a tracker or a channel, not both.
A route subscribes to any of these seven:
| Event | Fires when |
|---|---|
new_feedback |
New feedback is submitted to the project |
assigned |
A report is assigned to a member |
mentioned |
A member is @mentioned in a comment |
status_change |
A report’s status changes |
priority |
A report’s priority changes |
resolved |
A report is resolved, or a pin in its thread is |
issue_linked |
A report is linked to an external tracker issue |
Each route also has an Enabled switch. Disable it to stop delivery without deleting the routing; re-enable to resume.
On the account’s Integrations page, press Connect on the tool’s card. A guided panel opens, the same shape for every tool:
How to connect. Numbered steps, each with a direct link that opens the right page in the other service, and the fields you fill in right there in the step that asks for them. You’re only asked for what that service needs: uMarker fills in any fixed address itself, so you never assemble an API URL by hand.
Test. Press Send test message. uMarker delivers a real message, clearly labelled as a test, to exactly what is on screen. Check that it arrived.
Save. Connect turns on once a test passes. If you change anything after the test, the panel says so and asks you to test again before saving.
If the destination is down right now and you want to save it anyway, Save without a passing test is there, named for what it does. A Slack, Teams or webhook URL must still be a public https address (see Endpoint safety).
When a test or a save is refused, the panel tells you why in your language, as a cause and a What to do: line. The service’s own text sits folded under Details from the service, with any secret scrubbed out of it.
Once saved, the credential is encrypted at rest and never shown back to you. For a generic webhook, uMarker also mints a 40-character signing secret, which you see after connecting.
What you do in each service:
https://hooks.slack.com/…) and paste it into Endpoint URL.uMarker posts a Block Kit message: the headline, the report’s details as fields, and buttons to open it (see What a message looks like). No app install, bot, or OAuth is involved; the webhook URL is the whole integration.
That URL is a bearer credential in disguise: anyone holding it can post into your channel. That is why uMarker encrypts it at rest and never shows it back.
You don’t build a Telegram URL. You give uMarker your bot’s token and pick the chat; uMarker works out the rest.
Open BotFather in Telegram (the step links straight to it) and send /newbot. Pick a name, and a username that ends in bot. BotFather replies with a token.
Paste the token into Bot token and press Check token. A correct token shows Token is valid — bot followed by your bot’s name. A wrong token is refused here, before anything is saved.
Open your bot and press Start. A bot cannot write to anyone who hasn’t. The link to your bot (t.me/<yourbot>) appears in this step once the token is checked.
Or, for a group: add the bot to it with the step’s link (t.me/<yourbot>?startgroup=1) and send a message there. If the group’s privacy mode hides ordinary messages from the bot, send /start. For a channel, make the bot an admin.
Press Find my chats. The panel lists the private chats, groups and channels the bot can see; pick where reports should go. In a group with topics you can also pick the topic. General — no topic is the default.
If the list is empty, the panel says Your bot has no chats yet: do step 3, then press Find my chats again. Telegram only lists messages from the last 24 hours, so if you started the bot earlier than that, send it a fresh message.
Press Send test message, see it arrive, then Connect.
uMarker posts a formatted Telegram message with an Open report button (see What a message looks like). The token is a credential: it’s encrypted at rest and never shown back.
uMarker posts an Adaptive Card with the headline, the report’s details and an Open report button (see What a message looks like). As with Slack, it’s webhook-only: no bot and no two-way interaction.
Teams accepts a message before it posts it, so a passing Send test message only proves Teams took the request. Look in the channel itself to confirm it arrived.
POST, signed with a secret.Use this for automation, a custom bridge, or a service uMarker doesn’t integrate with directly. Each request carries an X-uMarker-Signature header so your receiver can verify it genuinely came from uMarker and wasn’t altered in flight. The full payload shape and a step-by-step verification recipe live in the Outbound webhooks reference.
Each channel gets the message in its own platform’s format, so a triager can decide priority and owner without opening the report:
https address, so on a platform without one the link is written into the text instead.message field for convenience.Every message carries what happened and who did it, the report’s headline, and the project, status, priority, assignee, reporter, page, device and browser, number of pins, and labels when there are any. Empty fields are left out, not shown as blanks. Then the event itself:
| Event | What the message adds |
|---|---|
status_change |
The status, from → to |
priority |
The priority, from → to |
mentioned |
The comment, quoted, and its author |
assigned |
Who it’s assigned to |
issue_linked |
The tracker and issue key, with an Open … in … button (for example “Open MD-45 in Jira”) |
Messages are written in your account’s language, right-to-left for Arabic, and anything a person typed is escaped so it can’t break the formatting. Long text is shortened to fit each platform’s limit. Send test message uses the same renderer with a sample report, so the test shows exactly what real messages will look like.
Open the project and go to its Distribution tab.
Attach the connection you just made.
Tick the events this project should forward through it.
Save. It starts posting on the next matching event.
Press Test on the route to confirm the wiring before you rely on it. It delivers a real message, labelled as a test, without needing an existing report.
Repeat for each project. The same connection can carry different event selections in different projects: reports from a client site going to that client’s channel, mentions only, and so on.
The generic webhook is the one you wire into your own systems, so it’s signed. uMarker POSTs a JSON body and includes a signature over the exact bytes it sends, together with a timestamp, in the header:
X-uMarker-Signature: t=<unix-ts>,v1=HMAC_SHA256(<t>.<raw-body>, secret)Your receiver recomputes the same HMAC-SHA256 with the shared secret and compares: a match proves authenticity and integrity; a tampered body won’t match. For the payload fields and a copy-paste verification example, see Outbound webhooks.
If a secret leaks, rotate it. Rotate secret on the connection replaces it with a fresh 40-character value. It needs the integrations.rotatechannel permission, which is also what decides whether the secret is shown back to you: on the Integrations page, only a role holding it sees the signing secret under Manage. Without it the connection shows its endpoint and no secret.
uMarker validates every channel URL you paste (Slack, Teams, generic webhook) when you test or save it. The endpoint must use https, and its host must resolve only to public addresses. Anything that resolves to a private, loopback, link-local, or otherwise reserved range is rejected:
The endpoint must be a public https URL — private or internal addresses are not allowed.
This is an SSRF guard: it stops a channel from being pointed at localhost, an internal service, or the cloud metadata endpoint (169.254.169.254). A host that won’t resolve at all is refused too: the check fails closed. As defence in depth, delivery refuses to follow redirects and resolves IPv4 only, so a public URL can’t 302 its way to an internal address, or slip an unvetted IPv6 record past the guard, at send time. See Security & privacy overview.
Every post is dispatched to a queue, so it never blocks the action that triggered it, and each destination is delivered independently: one channel failing never affects another channel, your email, or other recipients.
Delivery uses a 10-second timeout, and what happens next depends on whether your destination answered.
If it still can’t deliver, the connection is flagged:
Disconnecting removes the stored credential. If projects in the space you’re currently in route through it, uMarker refuses the first attempt and names them, so you find out before their notifications go quiet rather than after. Confirm, and the connection and all of its routes are deleted together — including routes in your other spaces, which the warning does not name.
To stop one project without touching the others, disable or remove that project’s route instead, from its Distribution tab.