Notifications API

Notifications endpoints exposed by the Devotel CPaaS API Base path: /api/v1/notifications Endpoint count: 13

Worked sequences

The endpoint list below documents each operation with its parameters. These four sequences cover the read-and-triage loop that powers a notification center of your own: poll the badge, page through the filtered feed, clear it either selectively or in bulk, and set the toggles that decide which categories each member gets notified about. Every request uses your API key (X-API-Key) against https://api.orbit.devotel.io. For the operator-facing breakdown of kinds, delivery channels and the console workflow, see Triage the Notification Center.

Sequence 1 — poll the badge, then read the feed

The loop an external notification center runs on a cadence (the dashboard bell runs it every ~30 seconds per tab): check the counter, and only fetch the filtered list when the counter moved. Step 1 — check the unread counter.

cURL

curl "https://api.orbit.devotel.io/api/v1/notifications/unread-count" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": { "count": 3 },
  "meta": {
    "request_id": "req_badge_001",
    "timestamp": "2026-08-28T09:00:00Z"
  }
}

Step 2 — list the filtered feed. unread_only, kind, severity, source_pillar, and category combine on the query string, newest rows first. meta.pagination.has_more tells you whether another page exists; pass meta.pagination.cursor back as cursor and treat it as opaque, keeping the same filters across pages. A malformed filter value is ignored rather than rejected — the list loads unfiltered.

cURL

curl "https://api.orbit.devotel.io/api/v1/notifications/?unread_only=true&severity=warning&limit=5" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": {
    "data": [
      {
        "id": "notif_4f8c1d2a3b4e5f60718293a4b5c6d7e8",
        "user_id": "user_9f3a2b1c4d5e6f708192a0b1c2d3e4",
        "org_id": "org_01J8Z9K3P4Q5R6S7T8U9V0W1X2",
        "kind": "new_signin_from_new_device",
        "severity": "warning",
        "title": "New sign-in from an unrecognized device",
        "body": "Chrome on macOS — first seen 2 minutes ago.",
        "action_url": "/settings/security",
        "read_at": null,
        "created_at": "2026-08-28T08:59:11Z",
        "expires_at": null,
        "source_pillar": "system",
        "category": "security"
      }
    ],
    "pagination": { "cursor": null, "has_more": false }
  },
  "meta": {
    "request_id": "req_list_001",
    "timestamp": "2026-08-28T09:00:05Z"
  }
}

Here has_more is false, so this page is the whole result set — no cursor to pass. Neither this sequence nor the next has any write side effects, so the badge still reports 3 until Step 2 of Sequence 2 runs.

Sequence 2 — clear items, selectively or in bulk

Marking read and dismissing are addressed one row per request — there is no batch ids body on either. When you clear several rows at once (select-all in a notification UI, or a sync loop draining its backlog), loop over the ids and issue the per-row calls in parallel. For “clear everything”, prefer one call to read-all over N per-row calls. Step 1 — mark two rows read. PUT /{id}/read is idempotent, so a parallel-loop retry past the first success is safe; it returns the updated row with read_at populated.

cURL

curl -X PUT \
  "https://api.orbit.devotel.io/api/v1/notifications/notif_4f8c1d2a3b4e5f60718293a4b5c6d7e8/read" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": {
    "id": "notif_4f8c1d2a3b4e5f60718293a4b5c6d7e8",
    "user_id": "user_9f3a2b1c4d5e6f708192a0b1c2d3e4",
    "org_id": "org_01J8Z9K3P4Q5R6S7T8U9V0W1X2",
    "kind": "new_signin_from_new_device",
    "severity": "warning",
    "title": "New sign-in from an unrecognized device",
    "body": "Chrome on macOS — first seen 2 minutes ago.",
    "action_url": "/settings/security",
    "read_at": "2026-08-28T09:02:40Z",
    "created_at": "2026-08-28T08:59:11Z",
    "expires_at": null,
    "source_pillar": "system",
    "category": "security"
  },
  "meta": {
    "request_id": "req_mark_001",
    "timestamp": "2026-08-28T09:02:40Z"
  }
}

Step 2 — dismiss the other row. DELETE /{id} hides the row immediately for the caller. It takes a 404 NOT_FOUND when the row is org-wide (user_id: null) rather than addressed to you — those rows age out on their own expires_at clock instead of being dismissible.

cURL

curl -X DELETE \
  "https://api.orbit.devotel.io/api/v1/notifications/notif_8c2e9d3f4a5b6c7d8e9f0a1b2c3d4e" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": { "deleted": "notif_8c2e9d3f4a5b6c7d8e9f0a1b2c3d4e" },
  "meta": {
    "request_id": "req_dismiss_001",
    "timestamp": "2026-08-28T09:02:45Z"
  }
}

Step 3 — bulk-clear the rest. One call flips every remaining unread row to read and returns how many it touched. data.affected counts genuine unread→read transitions here — re-marking already-read rows returns zero.

cURL

curl -X POST \
  "https://api.orbit.devotel.io/api/v1/notifications/read-all" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": { "affected": 2 },
  "meta": {
    "request_id": "req_readall_001",
    "timestamp": "2026-08-28T09:02:46Z"
  }
}

The Node SDK’s notifications.list / notifications.markRead / notifications.markAllRead / notifications.archive helpers wrap these exact routes. For the routes it has no helper for — the unread counter, the org digest toggles below, the /{id}/read PUT — use the generic orbit.request escape hatch:

Node.js

import { Orbit } from "@devotel/sdk-node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY });

// The parse-only path: check the counter, and only pull rows that moved.
const { data: badge } = await orbit.request<{
  data: { count: number };
}>("GET", "/notifications/unread-count");
if (badge.count > 0) {
  const page = await orbit.notifications.list({
    status: "unread",
    limit: 50,
  });
  for (const n of page.data) {
    // One per-row call — the API has no batch ids body (see above).
    await orbit.notifications.markRead(n.id);
  }
  // …or clear the whole current page in one call:
  // await orbit.notifications.markAllRead();
}

Sequence 3 — read + tune the org digest toggles

The per-organization email digest is the corporate preference surface: which categories are emailed, on what cadence, and to which members. Owner/admin leaves configure it; members inherit it. Security-critical kinds (sign-in alerts, API-key mints, role changes) ignore mute settings and always mint a bell row. Step 1 — read the current digest settings.

cURL

curl "https://api.orbit.devotel.io/api/v1/notifications/digest/settings" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": {
    "organization_id": "org_01J8Z9K3P4Q5R6S7T8U9V0W1X2",
    "enabled": true,
    "frequency": "weekly",
    "categories": ["billing", "security"],
    "last_digest_at": "2026-08-21T09:00:00Z",
    "created_at": "2026-08-01T09:04:11Z",
    "updated_at": "2026-08-21T09:00:00Z"
  },
  "meta": {
    "request_id": "req_digread_001",
    "timestamp": "2026-08-28T09:05:00Z"
  }
}

categories: [] (empty array) means every category is emailed, not none. Step 2 — flip the toggles. PUT accepts any one of enabled, frequency (daily or weekly), or categories (from billing, security, messaging, campaigns, agents, system); it returns the full saved record so no follow-up GET is needed.

cURL

curl -X PUT \
  "https://api.orbit.devotel.io/api/v1/notifications/digest/settings" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{ "frequency": "daily", "categories": ["billing", "security", "messaging"] }'

200 OK

{
  "data": {
    "organization_id": "org_01J8Z9K3P4Q5R6S7T8U9V0W1X2",
    "enabled": true,
    "frequency": "daily",
    "categories": ["billing", "security", "messaging"],
    "last_digest_at": "2026-08-21T09:00:00Z",
    "created_at": "2026-08-01T09:04:11Z",
    "updated_at": "2026-08-28T09:05:12Z"
  },
  "meta": {
    "request_id": "req_digwrite_001",
    "timestamp": "2026-08-28T09:05:12Z"
  }
}

Step 3 — review who’s opted in.

cURL

curl "https://api.orbit.devotel.io/api/v1/notifications/digest/recipients" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": {
    "data": [
      {
        "id": "ndr_01J8Z9K3P4Q5R6S7T8U9V0W1X2",
        "organization_id": "org_01J8Z9K3P4Q5R6S7T8U9V0W1X2",
        "user_id": "user_9f3a2b1c4d5e6f708192a0b1c2d3e4",
        "email": "jordan@example.com",
        "name": "Jordan Lee",
        "role": "admin",
        "opted_in": true,
        "created_at": "2026-08-01T09:04:11Z",
        "updated_at": "2026-08-01T09:04:11Z"
      }
    ]
  },
  "meta": {
    "request_id": "req_digrecip_001",
    "timestamp": "2026-08-28T09:05:20Z"
  }
}

PATCH /digest/recipients/{user_id} flips one member’s flag (owner/admin):

cURL

curl -X PATCH \
  "https://api.orbit.devotel.io/api/v1/notifications/digest/recipients/user_9f3a2b1c4d5e6f708192a0b1c2d3e4" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{ "opted_in": false }'

Sequence 4 — mute a category for your own seat (user-level)

The org digest above is a corporate preference; the per-seat mute is yours alone. Muting lives on GET/PUT /api/v1/settings/preferences — a namespaced user-preferences blob the dashboard uses for theme, locale and notification toggles, not under /notifications itself. Each category sits under the notifications key; a muted category still mints an in-app bell row (only outbound email/push/webhook delivery is suppressed), and security-critical kinds (sign-in, API-key, role-change events) override the mute entirely.

cURL

curl "https://api.orbit.devotel.io/api/v1/settings/preferences" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": {
    "notifications": {
      "billing": { "email": true },
      "security": { "email": true },
      "messaging": { "email": false }
    },
    "theme": "system"
  },
  "meta": {
    "request_id": "req_prefs_001",
    "timestamp": "2026-08-28T09:08:00Z"
  }
}

Write back the whole map (unknown keys are preserved, so other surfaces’ theme block survives):

cURL

curl -X PUT \
  "https://api.orbit.devotel.io/api/v1/settings/preferences" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "notifications": {
      "billing": { "email": true },
      "security": { "email": true },
      "messaging": { "email": false }
    },
    "theme": "system"
  }'

200 OK

{
  "data": {
    "notifications": {
      "billing": { "email": true },
      "security": { "email": true },
      "messaging": { "email": false }
    },
    "theme": "system"
  },
  "meta": {
    "request_id": "req_prefs_002",
    "timestamp": "2026-08-28T09:08:04Z"
  }
}

The per-category toggles a member sets apply to their own outbound delivery only — the org digest loop (Sequence 3) still decides which categories the organization emails at all. Set both to agree: mute a row you never want, and expect the digest to follow.

Worked notification-channel samples

This page covers the second consumption shape of the notification stream. Sequences 1–4 above are the human-facing loop: pull the in-app bell feed, triage it, tune the digest. The samples below treat the same feed as a channel you program against — a service, not an operator, reading rows and applying filters. There are two consumption shapes on this page:

The dashboard-bell feed (list/read) — persistent rows you poll with GET /api/v1/notifications/ and clear with the mark-read and dismiss calls.
Subscription-based routing to outbound sinks — the per-user category subscription (Settings → notifications), the per-organization digest (/digest/settings), and the SSE stream (/stream) decide which rows leave the bell and land on email, push, or a live socket. Webhook endpoints (POST /api/v1/webhooks, event subscriptions documented under Webhooks) are the code-facing sibling: the same developer-failure kinds (dlq_alert, webhook_endpoint_disabled) that mint bell rows also fan out to your subscribed webhook endpoints. For the payload shape your webhook sink receives, see Consume webhooks; for verifying the X-Devotel-Signature HMAC on delivery, see Verify webhook signatures.

1. List the in-app feed

Read the feed the same way the dashboard bell does — newest first, with the query filters applied server-side. At its smallest the call is GET /api/v1/notifications/?unread_only=true; every other filter appends the same way. Every filter is optional; omitting one widens the feed rather than erroring.

cURL

curl "https://api.orbit.devotel.io/api/v1/notifications/?unread_only=true&severity=warning&source_pillar=cpaas&category=webhook_failure&kind=dlq_alert&limit=10" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": {
    "data": [
      {
        "id": "notif_1d7a9c3e5b204f81a6c2e9d4f7b0c8a1",
        "kind": "dlq_alert",
        "severity": "warning",
        "title": "Webhook deliveries backing up",
        "body": "1,204 events queued in the dead-letter queue on https://api.example.com/hooks.",
        "action_url": "/developer/webhooks",
        "read_at": null,
        "created_at": "2026-08-28T09:12:04Z",
        "source_pillar": "cpaas",
        "category": "webhook_failure"
      }
    ],
    "pagination": { "cursor": "notif_1d7a9c3e5b204f81a6c2e9d4f7b0c8a1", "has_more": true }
  },
  "meta": {
    "request_id": "req_list_201",
    "timestamp": "2026-08-28T09:12:05Z"
  }
}

Filter semantics, in short:

unread_only=true restricts to rows with read_at: null.
kind is the exact event type (the full kind catalog lives in the guide under kinds); severity is one of info | warning | error.
source_pillar is the product pillar that minted the row (cpaas, ucaas, ccaas, aiaas, cxaas, cspaas, naas, verify, system); category is the cross-pillar facet (sla_breach, webhook_failure, billing, security, compliance, system, …). Combine a pillar with a category to answer “every SLA breach in CCaaS” style queries.
pagination.has_more: true means pass pagination.cursor back as the cursor query parameter on the next call, keeping the same filters. The cursor excludes its own row, so the next page starts strictly after it.

2. Mark read and re-list

Clearing a row is one call per id — PUT /{id}/read returns the updated row with read_at set, and is idempotent so a retry after a timeout is safe.

cURL

curl -X PUT \
  "https://api.orbit.devotel.io/api/v1/notifications/notif_1d7a9c3e5b204f81a6c2e9d4f7b0c8a1/read" \
  -H "X-API-Key: dv_live_sk_your_key_here"

200 OK

{
  "data": {
    "id": "notif_1d7a9c3e5b204f81a6c2e9d4f7b0c8a1",
    "kind": "dlq_alert",
    "severity": "warning",
    "title": "Webhook deliveries backing up",
    "read_at": "2026-08-28T09:13:40Z",
    "created_at": "2026-08-28T09:12:04Z",
    "source_pillar": "cpaas",
    "category": "webhook_failure"
  },
  "meta": {
    "request_id": "req_mark_201",
    "timestamp": "2026-08-28T09:13:40Z"
  }
}

Re-run the same filtered list and the cleared row no longer matches unread_only=true — drop the flag or set it to false to see the row again:

cURL

curl "https://api.orbit.devotel.io/api/v1/notifications/?severity=warning&source_pillar=cpaas&category=webhook_failure&limit=10" \
  -H "X-API-Key: dv_live_sk_your_key_here"

To drain the feed without tracking ids, POST /api/v1/notifications/read-all flips every remaining unread row in one call and returns data.affected (see Sequence 2 above).

3. Wire an outbound subscription

There is no per-row subscription object: routing to a sink is a small set of configuration writes. Pick the sink, then enable it — the same filters you pass on the list are the ones the outbound surfaces apply for you. Email ingest per user — mind your own seat’s category subscription so the digest only carries what you act on:

cURL

curl -X PUT "https://api.orbit.devotel.io/api/v1/settings/preferences" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{ "notifications": { "billing": { "email": true }, "security": { "email": true } } }'

Organization digest — owner/admin subscribes the whole org to the categories that warrant email, on a daily or weekly cadence:

cURL

curl -X PUT "https://api.orbit.devotel.io/api/v1/notifications/digest/settings" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{ "enabled": true, "frequency": "daily", "categories": ["security", "billing"] }'

Both return the full saved record (200) so no follow-up GET is needed, and re-issuing the same write is idempotent — there is no duplicate-subscription conflict to handle. Live push channel — for near-real-time consumption without polling, mint a one-time token and open /stream; the rows that arrive match the same kind / severity / source_pillar / category facets you filter on the list:

cURL

TOKEN=$(curl -s -X POST "https://api.orbit.devotel.io/api/v1/notifications/sse-token" \
  -H "X-API-Key: dv_live_sk_your_key_here" | jq -r '.data.ot // .data.fallback')
curl -N "https://api.orbit.devotel.io/api/v1/notifications/stream?ot=${TOKEN}"

When the token store is unavailable, sse-token returns ot: null with a fallback hint — connect with the legacy ?token=<api-key> parameter instead (server-side callers may use it from the start).

4. Errors

A filter value the schema does not know degrades instead of failing. GET / parses its query leniently: an unknown kind or severity, an over-length cursor, or an off-range limit falls back to “no filter” and the list still loads unfiltered — it never answers 422. This protects the bell feed against stale web bundles and SDK callers, and it means you should treat a 422 from this endpoint as a bug report, not an expected case. Strict paths are the writes. A malformed path id on PUT /{id}/read is rejected before the read:

422

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Invalid notification id",
    "status": 422
  },
  "meta": {
    "request_id": "req_err_201",
    "timestamp": "2026-08-28T09:14:02Z"
  }
}

A well-formed id that does not belong to you returns 404. The endpoint never reveals whether the row exists elsewhere:

404

{
  "error": {
    "code": "NOT_FOUND",
    "message": "Notification 'notif_002f3a1b4c5d6e7f8a9b0c1d2e3f4a5b' not found",
    "status": 404
  },
  "meta": {
    "request_id": "req_err_202",
    "timestamp": "2026-08-28T09:14:02Z"
  }
}

When you consume the stream through webhooks rather than the bell feed, two more failure shapes matter — a dead-letter backlog (dlq_alert) and an endpoint the API auto-disabled after repeated failures (webhook_endpoint_disabled). Both mint a bell row AND a webhook event, so your sink sees the breakage even when nobody is watching the dashboard; the runbook for re-enabling the endpoint is under Webhook events.

List notifications

GET /api/v1/notifications

string (enum: true|false)

Sandbox opt-in for Clerk-session-authenticated requests. Set to true to route the call through the test-mode pipeline: no real provider delivery, no credits deducted, response meta.test_mode: true. Ignored for live API keys (dv_live_sk_*) — server-to-server clients must use a test-prefixed key (dv_test_sk_*) to exercise sandbox. Test-prefixed keys unconditionally enable sandbox regardless of this header.

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/notifications" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/notifications", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/notifications", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

List recipients

GET /api/v1/notifications/digest/recipients

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/notifications/digest/recipients" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/digest/recipients', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/notifications/digest/recipients", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/notifications/digest/recipients", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/digest/recipients')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/digest/recipients');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

List settings

GET /api/v1/notifications/digest/settings

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/notifications/digest/settings" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/digest/settings', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/notifications/digest/settings", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/notifications/digest/settings", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/digest/settings')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/digest/settings');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

List global

GET /api/v1/notifications/global

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/notifications/global" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/global', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/notifications/global", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/notifications/global", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/global')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/global');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

List stream

GET /api/v1/notifications/stream

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/notifications/stream" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/stream', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/notifications/stream", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/notifications/stream", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/stream')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/stream');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

List unread-count

GET /api/v1/notifications/unread-count

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/notifications/unread-count" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/unread-count', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/notifications/unread-count", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/notifications/unread-count", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/unread-count')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/unread-count');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Preview digest

POST /api/v1/notifications/digest/preview

string

Stripe-style idempotency token. Pass a stable, client-generated value (1-255 chars) to dedupe retries on transient timeouts. The same key+credential+path replays the original response for 24h on 2xx (5min on 4xx, 30s on 5xx). Returns 409 if a concurrent request with the same key is already in flight; replayed responses include the Idempotency-Replay: true response header.

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/notifications/digest/preview" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/digest/preview', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.post("https://api.orbit.devotel.io/api/v1/notifications/digest/preview", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/notifications/digest/preview", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/digest/preview')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/digest/preview');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Read-all notifications

POST /api/v1/notifications/read-all

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/notifications/read-all" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/read-all', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.post("https://api.orbit.devotel.io/api/v1/notifications/read-all", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/notifications/read-all", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/read-all')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/read-all');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Sse-token notifications

POST /api/v1/notifications/sse-token

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/notifications/sse-token" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/sse-token', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.post("https://api.orbit.devotel.io/api/v1/notifications/sse-token", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/notifications/sse-token", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/sse-token')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/sse-token');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Update read

PUT /api/v1/notifications/{id}/read

string

required

—

string

string (enum: true|false)

cURL

curl -X PUT "https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/read" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/read', {
  method: 'PUT',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.put("https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/read", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("PUT", "https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/read", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/read')
req = Net::HTTP::Put.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/read');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Update settings

PUT /api/v1/notifications/digest/settings

string

string (enum: true|false)

cURL

curl -X PUT "https://api.orbit.devotel.io/api/v1/notifications/digest/settings" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/digest/settings', {
  method: 'PUT',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.put("https://api.orbit.devotel.io/api/v1/notifications/digest/settings", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("PUT", "https://api.orbit.devotel.io/api/v1/notifications/digest/settings", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/digest/settings')
req = Net::HTTP::Put.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/digest/settings');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Patch recipients

PATCH /api/v1/notifications/digest/recipients/{user_id}

string

required

—

string (enum: true|false)

cURL

curl -X PATCH "https://api.orbit.devotel.io/api/v1/notifications/digest/recipients/{user_id}" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/digest/recipients/{user_id}', {
  method: 'PATCH',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.patch("https://api.orbit.devotel.io/api/v1/notifications/digest/recipients/{user_id}", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("PATCH", "https://api.orbit.devotel.io/api/v1/notifications/digest/recipients/{user_id}", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/digest/recipients/{user_id}')
req = Net::HTTP::Patch.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/digest/recipients/{user_id}');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PATCH');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Delete notifications

DELETE /api/v1/notifications/{id}

string

required

—

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

const orbit = new Orbit({
  apiKey: process.env.ORBIT_API_KEY!,
})

const res = await fetch('https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3', {
  method: 'DELETE',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.delete("https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3')
req = Net::HTTP::Delete.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/notifications/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{
  "data": {
    "ok": true
  },
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

API Reference

All Endpoints

Notifications API

Notifications API

Worked sequences

Sequence 1 — poll the badge, then read the feed

Sequence 2 — clear items, selectively or in bulk

Sequence 3 — read + tune the org digest toggles

Sequence 4 — mute a category for your own seat (user-level)

Worked notification-channel samples

1. List the in-app feed

2. Mark read and re-list

3. Wire an outbound subscription

4. Errors

List notifications

List recipients

List settings

List global

List stream

List unread-count

Preview digest

Read-all notifications

Sse-token notifications

Update read

Update settings

Patch recipients

Delete notifications

​Notifications API

​Worked sequences

​Sequence 1 — poll the badge, then read the feed

​Sequence 2 — clear items, selectively or in bulk

​Sequence 3 — read + tune the org digest toggles

​Sequence 4 — mute a category for your own seat (user-level)

​Worked notification-channel samples

​1. List the in-app feed

​2. Mark read and re-list

​3. Wire an outbound subscription

​4. Errors

​List notifications

​List recipients

​List settings

​List global

​List stream

​List unread-count

​Preview digest

​Read-all notifications

​Sse-token notifications

​Update read

​Update settings

​Patch recipients

​Delete notifications

Notifications API

Worked sequences

Sequence 1 — poll the badge, then read the feed

Sequence 2 — clear items, selectively or in bulk

Sequence 3 — read + tune the org digest toggles

Sequence 4 — mute a category for your own seat (user-level)

Worked notification-channel samples

1. List the in-app feed

2. Mark read and re-list

3. Wire an outbound subscription

4. Errors

List notifications

List recipients

List settings

List global

List stream

List unread-count

Preview digest

Read-all notifications

Sse-token notifications

Update read

Update settings

Patch recipients

Delete notifications