API v1

API documentation

Create your channels, manage members and offers, drive accounts and broadcast alerts from your own application. Everything the interface does goes through this API.

Base URL

https://api.realnotifygroup.com/api/v1

All responses are in English, whatever your interface language: your integrations therefore receive stable messages and codes. Identifiers are server-generated UUIDs — a client can never impose one.

Success response

{
  "success": true,
  "data": { … },
  "meta": { "page": 1, "total": 42 }
}

Error response

{
  "success": false,
  "error": {
    "code": "FORBIDDEN",
    "message": "…"
  }
}

Authentication

Every request carries an Authorization header. Two kinds of token travel there, and the choice matters.

Authorization: Bearer <token>

Account API key rng_live_…

One per account, created with it. It carries its holder’s rights: whatever they can do on screen, it can do through the API, across all their channels. Copy it from My profile → API key, and regenerate it in one gesture — the former key then stops working at once.

API username 8 caractères

Eight characters drawn at random, granted with the account. It is no secret: it names the account, the key authenticates it. It is only asked for when trading a key for an access token — an ordinary call needs the key alone. Like the key, it is copied from the profile and regenerates on its own: renewing the key leaves it untouched, and the other way round.

The email address no longer plays that part: an integration has no business knowing its holder’s address, and that address changes over a working life where a drawn username only moves on request.

User access token

Obtained via POST /auth/login for a human, or POST /auth/api-token for an integration — API username and key, no password. It carries the account’s rights and therefore allows administrative operations. It is short-lived; POST /auth/refresh renews it with the refreshToken, which rotates automatically.

curl -X POST .../auth/api-token \
  -H "Content-Type: application/json" \
  -d '{"username":"k7m2xq4b","apiKey":"rng_live_…"}'

A key can neither read nor regenerate itself: those gestures require a signed-in session. This is deliberate — a stray key must not be able to lock its owner out of their own account.

Realtime

A WebSocket tells you the moment something happens: no more polling the API to find out whether a message has arrived. It opens on the same host as the API, with the same token — API key or access token.

wss://api.realnotifygroup.com/ws?token=<token>

Every frame is a JSON object carrying a type field. An event announces, it does not carry: a message’s content depends on who reads it — expired member, hidden history — and that arbitration stays with the API. Once notified, your client fetches what it is entitled to, for instance GET /groups/{id}/messages?after=…

message.createdA message was published in a channel — groupId, messageId, priority, createdAt.
message.deletedA message was removed. The thread keeps its place, the content goes.
message.pinnedA message was pinned or unpinned — pinned is true or false.
reaction.updatedA message’s reactions changed — per-emoji totals travel with the event.
notification.createdA system notification is meant for you.

The connection is kept alive by a ping every thirty seconds. If it drops, reopen it with a growing backoff: nothing is lost, the full state stays available through the HTTP routes.

Managing channels

A channel gathers members and carries its own broadcasting rules. A single API key drives every channel you administer.

GET/groupsList your channels+
List your channels
Authorisation
Authenticated account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/groups" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

POST/groupsCreate a channel+

Create a channel

Authorisation: Authenticated account
Expected body: name, membersCanWrite
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/groups" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Équipe Sécurité",
  "membersCanWrite": false
}'

GET/groups/{id}Channel details+
Channel details
Authorisation
Authenticated account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/groups/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

PATCH/groups/{id}Update name, description or options+

Update name, description or options

Authorisation: Authenticated account
Expected body: name
Response: data

curl -X PATCH "https://api.realnotifygroup.com/api/v1/groups/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Équipe Sécurité Nord"
}'

DELETE/groups/{id}Delete — requires confirmName matching the exact name+
Delete — requires confirmName matching the exact name
Authorisation
Authenticated account
Expected body
confirmName
Response
data
```
curl -X DELETE "https://api.realnotifygroup.com/api/v1/groups/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "confirmName": "Équipe Sécurité"
}'
```
POST/groups/{id}/restoreRestore a deleted channel · admin+
Restore a deleted channel
Authorisation
Administrator
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/groups/{id}/restore" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

POST/groups/{id}/adminsAdd a channel administrator+

Add a channel administrator

Authorisation: Authenticated account
Expected body: email
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/groups/{id}/admins" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "email": "a.koffi@site.com"
}'

DELETE/groups/{id}/admins/{userId}Remove an administrator+
Remove an administrator
Authorisation
Authenticated account
Response
data
```
curl -X DELETE "https://api.realnotifygroup.com/api/v1/groups/{id}/admins/{userId}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

Your API credentials

One username and one key per account, granted with it. The username — eight characters drawn at random — names the account; the key authenticates it and carries its holder’s rights, across all their channels and nowhere else. Both are available from the profile and regenerate independently.

GET/users/me/api-keyRead your username and key+
Read your username and key
Authorisation
Authenticated account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/users/me/api-key" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/users/me/api-key/regenerateRegenerate your key — the former one stops working at once, the username stays+
Regenerate your key — the former one stops working at once, the username stays
Authorisation
Authenticated account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/users/me/api-key/regenerate" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/users/me/api-username/regenerateRegenerate your username — the key stays+
Regenerate your username — the key stays
Authorisation
Authenticated account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/users/me/api-username/regenerate" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
GET/users/{id}/api-keyRead a user’s credentials · super admin+
Read a user’s credentials
Authorisation
Super administrator
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/users/{id}/api-key" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/users/{id}/api-key/regenerateRegenerate a user’s key — they are notified · super admin+
Regenerate a user’s key — they are notified
Authorisation
Super administrator
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/users/{id}/api-key/regenerate" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/users/{id}/api-username/regenerateRegenerate a user’s username — they are notified · super admin+
Regenerate a user’s username — they are notified
Authorisation
Super administrator
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/users/{id}/api-username/regenerate" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

Managing members

Every member carries an expiry date. Provide an offer: its duration sets the deadline when adding them, and adds to the remaining time on renewal — a member never loses what they already paid for. Possible statuses: active, expired, deactivated, removed.

GET/members?groupId=&status=List, filter by channel and status+
List, filter by channel and status
Authorisation
Authenticated account
Response
data[], meta
```
curl -X GET "https://api.realnotifygroup.com/api/v1/members?groupId=&status=" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

POST/membersAdd — email and offerId (or expiresAt)+

Add — email and offerId (or expiresAt)

Authorisation: Authenticated account
Expected body: groupId, email, offerId
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/members" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "groupId": "…",
  "email": "a.koffi@site.com",
  "offerId": "…"
}'

GET/members/{id}Member details+
Member details
Authorisation
Authenticated account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/members/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
PATCH/members/{id}Update — offerId adds its duration to the expiry, expiresAt sets it as is+
Update — offerId adds its duration to the expiry, expiresAt sets it as is
Authorisation
Authenticated account
Expected body
nickname, offerId
Response
data
```
curl -X PATCH "https://api.realnotifygroup.com/api/v1/members/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "nickname": "A. Koffi",
  "offerId": "…"
}'
```
POST/members/{id}/renewRenew — the offer’s duration adds to the remaining time, and reactivates an expired member+
Renew — the offer’s duration adds to the remaining time, and reactivates an expired member
Authorisation
Authenticated account
Expected body
offerId
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/members/{id}/renew" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "offerId": "…"
}'
```
POST/members/{id}/suspendDeactivate — stays in the channel, receives nothing+
Deactivate — stays in the channel, receives nothing
Authorisation
Authenticated account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/members/{id}/suspend" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/members/{id}/activateReactivate a deactivated member+
Reactivate a deactivated member
Authorisation
Authenticated account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/members/{id}/activate" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/members/{id}/removeRemove from the channel+
Remove from the channel
Authorisation
Authenticated account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/members/{id}/remove" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/members/{id}/restoreRestore — offerId restarts its duration from today, or an explicit expiresAt+
Restore — offerId restarts its duration from today, or an explicit expiresAt
Authorisation
Authenticated account
Expected body
offerId
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/members/{id}/restore" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "offerId": "…"
}'
```

Managing offers

An offer describes a name, a duration in days and an amount. It determines a member’s expiry and underpins subscriptions.

GET/offers?isActive=trueList the catalogue+
List the catalogue
Authorisation
Authenticated account
Response
data[], meta
```
curl -X GET "https://api.realnotifygroup.com/api/v1/offers?isActive=true" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
GET/offers?available=trueOffers one can subscribe to — one’s own and those of channels one belongs to+
Offers one can subscribe to — one’s own and those of channels one belongs to
Authorisation
Authenticated account
Response
data[], meta
```
curl -X GET "https://api.realnotifygroup.com/api/v1/offers?available=true" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

POST/offersCreate — name, durationDays, amount, currency+

Create — name, durationDays, amount, currency

Authorisation: Authenticated account
Expected body: name, durationDays, amount, currency
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/offers" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Annuel",
  "durationDays": 365,
  "amount": 280,
  "currency": "USD"
}'

GET/offers/{id}Offer details+
Offer details
Authorisation
Authenticated account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/offers/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
PATCH/offers/{id}Update, activate or deactivate via isActive+
Update, activate or deactivate via isActive
Authorisation
Authenticated account
Expected body
isActive
Response
data
```
curl -X PATCH "https://api.realnotifygroup.com/api/v1/offers/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "isActive": false
}'
```
DELETE/offers/{id}Delete — deactivated instead if subscriptions are running+
Delete — deactivated instead if subscriptions are running
Authorisation
Authenticated account
Response
data
```
curl -X DELETE "https://api.realnotifygroup.com/api/v1/offers/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
GET/subscriptions?scope=mine|sold|allHistory — what you subscribed to, what was subscribed to your offers, or both+
History — what you subscribed to, what was subscribed to your offers, or both
Authorisation
Authenticated account
Response
data[], meta
```
curl -X GET "https://api.realnotifygroup.com/api/v1/subscriptions?scope=mine|sold|all" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/subscriptionsSubscribe — the period follows the current expiry, or starts today if none is running+
Subscribe — the period follows the current expiry, or starts today if none is running
Authorisation
Authenticated account
Expected body
offerId
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/subscriptions" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "offerId": "…"
}'
```

POST/subscriptions/{id}/renewRenew+

Renew

Authorisation: Authenticated account
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/subscriptions/{id}/renew" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"

POST/subscriptions/{id}/cancelCancel+

Cancel

Authorisation: Authenticated account
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/subscriptions/{id}/cancel" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"

Telegram Sub

Sell access to a Telegram channel, and take it back when the term ends. The path is imposed by Telegram, not by us: a bot cannot add someone to a channel, it can only invite whoever came to it first. So you register an address with an offer — its duration sets the expiry —, the response hands you a link to the bot, you pass it on, the person starts it. That is the one moment their Telegram identifier becomes knowable; the bot then opens the channel for them. At expiry it removes them by that same identifier, and tells them why.

POST/telegram/configsCreate a configuration — the bot and the channel it feeds. botToken and botId come from @BotFather, channelId from your channel. Setting botUsername avoids having to ask Telegram for it when building links · API key+
Create a configuration — the bot and the channel it feeds. botToken and botId come from @BotFather, channelId from your channel. Setting botUsername avoids having to ask Telegram for it when building links
Authorisation
API key or account
Expected body
botName, botUsername, botToken, botId, channelName, channelId
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/configs" \
  -H "Authorization: Bearer $RNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "botName": "Accès Premium",
  "botUsername": "acces_premium_bot",
  "botToken": "123456:ABC…",
  "botId": "123456",
  "channelName": "Signaux Premium",
  "channelId": "-1001234567890"
}'
```
GET/telegram/configsList your configurations · API key+
List your configurations
Authorisation
API key or account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/telegram/configs" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
GET/telegram/configs/{id}Configuration details · API key+
Configuration details
Authorisation
API key or account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/telegram/configs/{id}" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
PATCH/telegram/configs/{id}Update, or switch off via isActive — the bot still answers, the channel is no longer meant to broadcast · API key+
Update, or switch off via isActive — the bot still answers, the channel is no longer meant to broadcast
Authorisation
API key or account
Expected body
isActive
Response
data
```
curl -X PATCH "https://api.realnotifygroup.com/api/v1/telegram/configs/{id}" \
  -H "Authorization: Bearer $RNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "isActive": false
}'
```
GET/telegram/configs/{id}/webhookWebhook status, as Telegram declares it — not as you believe you set it · API key+
Webhook status, as Telegram declares it — not as you believe you set it
Authorisation
API key or account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/telegram/configs/{id}/webhook" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/telegram/configs/{id}/webhookRegister the webhook — it is set on creation and repaired every minute; this call forces it · API key+
Register the webhook — it is set on creation and repaired every minute; this call forces it
Authorisation
API key or account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/configs/{id}/webhook" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
DELETE/telegram/configs/{id}/webhookRemove the webhook — the server then fetches the bot’s messages itself, every minute · API key+
Remove the webhook — the server then fetches the bot’s messages itself, every minute
Authorisation
API key or account
Response
data
```
curl -X DELETE "https://api.realnotifygroup.com/api/v1/telegram/configs/{id}/webhook" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/telegram/membersAdd a member. The response carries inviteLink: the link to the bot, to hand to the person. It lasts seven days and serves once — it is a linking token, not a password · API key+
Add a member. The response carries inviteLink: the link to the bot, to hand to the person. It lasts seven days and serves once — it is a linking token, not a password
Authorisation
API key or account
Expected body
configId, email, nickname, offerId
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members" \
  -H "Authorization: Bearer $RNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "configId": "…",
  "email": "a.koffi@site.com",
  "nickname": "A. Koffi",
  "offerId": "…"
}'
```
GET/telegram/members?configId=&status=&search=List — statuses PENDING, ACTIVE, EXPIRED, SUSPENDED. search looks through address and nickname: that is how you find someone when all you have is their email · API key+
List — statuses PENDING, ACTIVE, EXPIRED, SUSPENDED. search looks through address and nickname: that is how you find someone when all you have is their email
Authorisation
API key or account
Response
data[], meta
```
curl -X GET "https://api.realnotifygroup.com/api/v1/telegram/members?configId=&status=&search=" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
GET/telegram/members/{id}Expiry and state — expiresAt, daysRemaining, status, telegramUserId, and inviteLink for as long as it is worth something · API key+
Expiry and state — expiresAt, daysRemaining, status, telegramUserId, and inviteLink for as long as it is worth something
Authorisation
API key or account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/telegram/members/{id}" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/telegram/members/{id}/renewRenew — the offer’s duration adds to the current expiry, or starts from today if it has passed. The bot announces the offer and the term, and hands a way back to whoever had left the channel · API key+
Renew — the offer’s duration adds to the current expiry, or starts from today if it has passed. The bot announces the offer and the term, and hands a way back to whoever had left the channel
Authorisation
API key or account
Expected body
offerId
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members/{id}/renew" \
  -H "Authorization: Bearer $RNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "offerId": "…"
}'
```
POST/telegram/members/{id}/remindSend a reminder — the bot states the expiry date and invites them to renew. No effect on the subscription; requires that the person has started the bot · API key+
Send a reminder — the bot states the expiry date and invites them to renew. No effect on the subscription; requires that the person has started the bot
Authorisation
API key or account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members/{id}/remind" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/telegram/members/{id}/deactivateDeactivate — removed from the channel and told so, but their expiry does not move · API key+
Deactivate — removed from the channel and told so, but their expiry does not move
Authorisation
API key or account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members/{id}/deactivate" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/telegram/members/{id}/activateReactivate — requires an expiry still ahead: an expired access is renewed, not switched back on · API key+
Reactivate — requires an expiry still ahead: an expired access is renewed, not switched back on
Authorisation
API key or account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members/{id}/activate" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/telegram/members/{id}/expireExpire at once — the expiry is moved to now, the person leaves the channel and learns why. An offer will be needed to start again · API key+
Expire at once — the expiry is moved to now, the person leaves the channel and learns why. An offer will be needed to start again
Authorisation
API key or account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members/{id}/expire" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/telegram/members/{id}/linkGenerate a fresh linking link — the original one is most likely expired · API key+
Generate a fresh linking link — the original one is most likely expired
Authorisation
API key or account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members/{id}/link" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/telegram/members/{id}/resolvePoll for starts and open the channel. Pointless when the webhook is registered: it does this on its own. Always answers 200 — “they have not clicked yet” is an answer, not a failure · API key+
Poll for starts and open the channel. Pointless when the webhook is registered: it does this on its own. Always answers 200 — “they have not clicked yet” is an answer, not a failure
Authorisation
API key or account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members/{id}/resolve" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
PATCH/telegram/members/{id}Update the nickname, or renew through offerId · API key+
Update the nickname, or renew through offerId
Authorisation
API key or account
Expected body
nickname
Response
data
```
curl -X PATCH "https://api.realnotifygroup.com/api/v1/telegram/members/{id}" \
  -H "Authorization: Bearer $RNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "nickname": "A. Koffi"
}'
```
PATCH/telegram/members/{id}Set the expiry by hand — absolute, where offerId adds a duration. It bypasses offers, and so the record of what was sold: super administrator only · super admin+
Set the expiry by hand — absolute, where offerId adds a duration. It bypasses offers, and so the record of what was sold: super administrator only
Authorisation
Super administrator
Expected body
expiresAt
Response
data
```
curl -X PATCH "https://api.realnotifygroup.com/api/v1/telegram/members/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "expiresAt": "2027-01-31T23:59:59.999Z"
}'
```
POST/telegram/members/expirationsSweep a channel: the expired leave, those whose term approaches get their reminder. The same pass runs on its own every hour — this route triggers it without waiting · API key+
Sweep a channel: the expired leave, those whose term approaches get their reminder. The same pass runs on its own every hour — this route triggers it without waiting
Authorisation
API key or account
Expected body
configId
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/telegram/members/expirations" \
  -H "Authorization: Bearer $RNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "configId": "…"
}'
```

Managing accounts

Administrators only. Creating an account is a super administrator prerogative, and no action is possible on an account whose role equals or outranks yours. The password is the one you supply: nothing is emailed, and the new account receives its API key in the same move.

GET/users?search=&role=&status=List, search, filter · admin+
List, search, filter
Authorisation
Administrator
Response
data[], meta
```
curl -X GET "https://api.realnotifygroup.com/api/v1/users?search=&role=&status=" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

POST/usersCreate — email, password, role, status · super admin+

Create — email, password, role, status

Authorisation: Super administrator
Expected body: email, password, role, status
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/users" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "email": "admin@site.com",
  "password": "…",
  "role": "ADMIN",
  "status": "ACTIVE"
}'

GET/users/{id}Account details · admin+
Account details
Authorisation
Administrator
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/users/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

PATCH/users/{id}Update personal details · admin+

Update personal details

Authorisation: Administrator
Expected body: firstName, lastName
Response: data

curl -X PATCH "https://api.realnotifygroup.com/api/v1/users/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "firstName": "Amine",
  "lastName": "Koffi"
}'

PATCH/users/{id}/roleChange the role · super admin+

Change the role

Authorisation: Super administrator
Expected body: role
Response: data

curl -X PATCH "https://api.realnotifygroup.com/api/v1/users/{id}/role" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "role": "GROUP_ADMIN"
}'

POST/users/{id}/activateActivate · admin+

Activate

Authorisation: Administrator
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/users/{id}/activate" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"

POST/users/{id}/deactivateDeactivate — revokes all sessions · admin+
Deactivate — revokes all sessions
Authorisation
Administrator
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/users/{id}/deactivate" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
DELETE/users/{id}Delete — reversible · admin+
Delete — reversible
Authorisation
Administrator
Response
data
```
curl -X DELETE "https://api.realnotifygroup.com/api/v1/users/{id}" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
POST/users/{id}/restoreRestore a deleted account · admin+
Restore a deleted account
Authorisation
Administrator
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/users/{id}/restore" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

Forgotten password

Two calls: request a code by email, then present it with the new password. The request answers the same whether the account exists or not — this route must not let anyone enumerate registered addresses. The code lives 15 minutes, tolerates 5 attempts, and opens no session: all it can do is change a password.

POST/auth/forgot-passwordRequest a reset code · no token+

Request a reset code

Authorisation: None
Expected body: email
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/auth/forgot-password" \
  -H "Content-Type: application/json" \
  -d '{
  "email": "vous@entreprise.com"
}'

POST/auth/reset-passwordReset — every open session is revoked · no token+
Reset — every open session is revoked
Authorisation
None
Expected body
email, code, newPassword
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/auth/reset-password" \
  -H "Content-Type: application/json" \
  -d '{
  "email": "vous@entreprise.com",
  "code": "12345678",
  "newPassword": "…"
}'
```

POST/auth/set-passwordChange your password while signed in+

Change your password while signed in

Authorisation: Authenticated account
Expected body: currentPassword, newPassword
Response: data

curl -X POST "https://api.realnotifygroup.com/api/v1/auth/set-password" \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
  "currentPassword": "…",
  "newPassword": "…"
}'

Broadcasting alerts

This is where the API key matters most: your system publishes under your name, in the channel you name — so groupId is always required.

POST/alertsPublish — groupId required, priority INFO, IMPORTANT or CRITICAL · API key+
Publish — groupId required, priority INFO, IMPORTANT or CRITICAL
Authorisation
API key or account
Expected body
groupId, priority, title, body, requireAck
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/alerts" \
  -H "Authorization: Bearer $RNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "groupId": "…",
  "priority": "CRITICAL",
  "title": "Intrusion",
  "body": "Zone B.",
  "requireAck": true
}'
```
GET/alerts?groupId=Channel history · API key+
Channel history
Authorisation
API key or account
Response
data[], meta
```
curl -X GET "https://api.realnotifygroup.com/api/v1/alerts?groupId=" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
GET/alerts/{id}/deliveriesDelivery and read statistics · API key+
Delivery and read statistics
Authorisation
API key or account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/alerts/{id}/deliveries" \
  -H "Authorization: Bearer $RNG_API_KEY"
```
POST/groups/{id}/messagesPublish with attachments (multipart)+
Publish with attachments (multipart)
Authorisation
Authenticated account
Response
data
```
curl -X POST "https://api.realnotifygroup.com/api/v1/groups/{id}/messages" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```
GET/groups/{id}/messagesChannel thread — before walks back, after returns only what is new+
Channel thread — before walks back, after returns only what is new
Authorisation
Authenticated account
Response
data
```
curl -X GET "https://api.realnotifygroup.com/api/v1/groups/{id}/messages" \
  -H "Authorization: Bearer $RNG_USER_TOKEN"
```

Broadcasting an alert

The same call, in six languages. Your API key is enough: it carries your rights, and publishes to the channel named by groupId.

curl -X POST https://api.realnotifygroup.com/api/v1/alerts \
  -H "Authorization: Bearer $RNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "groupId": "…",
  "priority": "CRITICAL",
    "title": "Intrusion — Site Nord",
    "body": "Déclenchement zone B.",
    "requireAck": true
  }'

Adding a member

The chosen offer sets the deadline: the server computes the date from its duration.

curl -X POST https://api.realnotifygroup.com/api/v1/members \
  -H "Authorization: Bearer $RNG_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "groupId": "…",
    "email": "a.koffi@site.com",
    "nickname": "A. Koffi",
    "offerId": "…"
  }'

Expired members stay notified, but content is hidden from them if the channel requires it.
A CRITICAL alert triggers call mode on active members’ phones.
Deletions are reversible: accounts, channels and members can be restored.

A question about integration? Write to us