MCP App Store
by KeenEthics
Cerber icon

Cerber MCP Server for ChatGPT

By Cerber

Overview

TG Cerber for Business protects the Telegram accounts a company's employees use for work, and keeps an encrypted archive of their work conversations that the company controls. This plugin lets ChatGPT work with that archive and with the protection itself, inside one organization and only within what an administrator approves. When you connect, you sign in to TG Cerber, choose which accounts ChatGPT may read, and choose what it may do. Reading is the default. Acting on accounts, changing security settings, managing administrators and deleting archived data are separate permissions that are off unless you tick them, and ticking them asks for your console password. ChatGPT acts as you and can never do more than your role allows; every request is recorded in your organization's journal. With the archive permission ChatGPT can list chats and folders, read conversations page by page, search across accounts (including document text and voice transcripts), see who was in a group, see every earlier version of an edited message and messages that were deleted in Telegram, and open photos, voice notes and documents. With the organization permissions ChatGPT can report on accounts, Telegram sessions and their review deadlines, departments, administrators, the security journal and system status, and, if you allow it, approve or end sessions, pause protection, move accounts between departments, or start a backup. To read the archive, TG Cerber's server keeps your archive password with this connection and decrypts on ChatGPT's behalf; disconnecting deletes it. Organizations that need the password never to leave their computers can use the local mode described in the documentation.

How to connect

  1. ChatGPT: Open the Cerber listing in the ChatGPT app directory and choose Connect. ChatGPT listing Cerber exposes 85 tools here.

Tools

approve_session

ChatGPT
Approves one Telegram session signed in to the account: Cerber stops its review clock and withdraws a sign-out that was queued for it. Use it for a device the employee confirms is theirs. Side effects: the employee gets a receipt on their Telegram; the journal records session.approved. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. A session id the account's last listing does not show answers 400; Cerber's own monitoring session (0) cannot be reviewed. Scope: accounts:write.

cancel_account_connection

ChatGPT
Abandons the attempt and signs out the half-made Telegram authorization, if there is one. An attempt that is already installing or done is left to finish; an unknown or finished one is ignored. Confirm with the user before calling. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). Scope: accounts:write.

cancel_archive_cleanup

ChatGPT
Cancels a chat cleanup waiting in rewrite, or a cleanup that failed: the parts of the archive it had not yet deleted stay, and saving resumes for what was not deleted. A cleanup that is running or done cannot be cancelled (not_cancellable, 409). The journal records archive.cleanup_cancelled. Owner and superadmins only (superadmin_required, 403), as everything about deleting archive data is in the console. An unknown account answers resource_missing (404). Refused under a legal hold (legal_hold, 409) and on a deployment that cannot delete archive objects (archive_delete_unavailable, 503). Scope: archive:delete.

clear_takeover_lock

ChatGPT
Clears the takeover lock set on the account after a takeover attempt. Nothing else changes: sessions signed out stay signed out. The journal records security.tamper_cleared. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: security:write.

confirm_archive_cleanup

ChatGPT
Confirms a preview from preview_archive_cleanup and deletes what it listed, permanently. confirm_phrase must be the preview's confirm_phrase (the account's name), typed by the person — as in the console; anything else answers confirm_mismatch (400). With stop_saving (the default) the archive does not save the cleaned chats again; resume_chat_saving lifts that later. A whole-account cleanup runs on the server. A chat cleanup (needs_password: true) also re-seals parts of the archive with the archive password, which only the console holds: it is confirmed here and waits in state rewrite until someone finishes it in the console, or cancels it with cancel_archive_cleanup. Confirm with the user before calling. Errors: preview_not_found (404), preview_expired (410), policy_changed (409, the rules changed since the preview), archive_busy (409, a backup is running). Owner and superadmins only (superadmin_required, 403), as everything about deleting archive data is in the console. An unknown account answers resource_missing (404). Refused under a legal hold (legal_hold, 409) and on a deployment that cannot delete archive objects (archive_delete_unavailable, 503). Scope: archive:delete.

create_department

ChatGPT
Creates an empty department. File accounts under it with set_account_department or move_accounts_to_department, and grant it to scoped admins with set_admin_grants. Owner and superadmins only (department_create_forbidden, 403). Errors: department_exists (409), department_name (400), too_many_departments (400, at most 200). Scope: admins:write.

delete_account

ChatGPT
Deletes the account completely: protection ends, Cerber signs out of it, its whole archive is erased and the account disappears from the organization. The Telegram account itself is untouched. To keep the archive, use offboard_account instead. confirm_phrase must be the account's name or its phone number, typed by the person — as in the console; anything else answers confirm_mismatch (400). Side effects: the employee is told on Telegram; the journal records employee.deleted and keeps the account's name. Confirm with the user before calling. Owner, superadmin and admin roles (role_forbidden, 403, otherwise). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Refused under a legal hold (legal_hold, 409) and where archive objects cannot be deleted (archive_delete_unavailable, 503). Refused to a connection limited to some chats of the account (chat_not_allowed, 403). Scope: archive:delete.

delete_department

ChatGPT
Deletes the department. Admins and AI connections that reached accounts only through it lose them. A department that still has accounts is refused with department_not_empty (409, with how many accounts, admins and connections it affects) unless release_accounts is true, which leaves those accounts with no department. Confirm with the user before calling. Owner and superadmins only (department_delete_forbidden, 403). Errors: no_department (404). Scope: admins:write.

delete_whole_archive

ChatGPT
After a plan ends the archive is kept in closed storage until its deletion date. This deletes all of it now, for every account. Only while the archive is in closed storage (archive_not_closed, 409, otherwise). confirm_phrase must be the organization's name, typed by the person — as in the console; anything else answers confirm_mismatch (400). A second call while it runs answers the progress. Confirm with the user before calling. Owner and superadmins only (superadmin_required, 403). Refused under a legal hold (legal_hold, 409), and to a connection limited to some chats of any account (chat_not_allowed, 403). Scope: archive:delete.

disable_admin

ChatGPT
Disables the admin: their console sessions, API keys and AI connections stop working at their next request, and invitations they sent that are still pending are cancelled. Reversible with enable_admin. Confirm with the user before calling. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). An organization always keeps one active superadmin and its owner: demoting, disabling or removing either is refused (400). An admin of another organization, or none, answers resource_missing (404). Scope: admins:write.

disable_passkey

ChatGPT
Removes the Cerber-held passkey from the account; re-logins then need a login code again. Confirm with the user before calling. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). Scope: security:write.

disable_two_fa

ChatGPT
Removes the Cerber-held 2FA password from the account: anyone with a login code can then sign in to it again. Confirm with the user before calling. Side effects: the change is made on the employee's real Telegram account; the admins are notified by email; the journal records it. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). In the console this action needs a login confirmed within the last 10 minutes. Over the API the security:write scope is that step-up: it is granted (approving the AI connection, or creating the API key) only from a login confirmed within 10 minutes, so nothing more is sent here. Scope: security:write.

enable_admin

ChatGPT
Enables a disabled admin. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). An admin of another organization, or none, answers resource_missing (404). Scope: admins:write.

enable_passkey

ChatGPT
Registers a passkey on the Telegram account and keeps its private key sealed in Cerber's vault, so Cerber's session can be restored later without anybody relaying a login code. Telegram lets a session add a passkey only 24 hours after it signed in: before that the call still turns it on, Cerber adds the passkey once the session is old enough, and passkey_eligible_at in get_account_telegram_profile says from when. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). Scope: security:write.

enable_two_fa

ChatGPT
Cerber generates a strong Telegram 2FA (cloud) password, sets it on the account and keeps it sealed in its vault: nobody — the employee included — can then sign in to the account on a new device without Cerber. Refused (409) when the account already has a 2FA password Cerber did not set: use set_cloud_password with the current one instead. Confirm with the user before calling. Side effects: the change is made on the employee's real Telegram account; the admins are notified by email; the journal records it. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). In the console this action needs a login confirmed within the last 10 minutes. Over the API the security:write scope is that step-up: it is granted (approving the AI connection, or creating the API key) only from a login confirmed within 10 minutes, so nothing more is sent here. Scope: security:write.

get_account

ChatGPT
Returns one account with everything the console's account page shows: the protection status, the licence it uses, the archive summary and — for a role that manages devices (owner, superadmin, admin) — Cerber's monitoring of it, every Telegram session signed in to it with whether an admin approved it and when an unapproved one will be signed out (review_deadline), the sessions that ended recently, and the takeover and security locks. For the billing and archive roles those device fields are left out, as in the console. An admin or archive role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would, so the API never confirms that an account exists. Scope: org:read.

get_account_archive_rules

ChatGPT
Returns the rules that decide what the archive keeps of one account: the organization's, the account's own exceptions to them, and per chat the rule in force now, which rule decided it (source) and why (reason_code). Chats waiting for a decision have review: true. Owner, superadmin, admin and archive roles (role_forbidden, 403, for billing). An admin or archive role reaches only its granted accounts; any other account answers resource_missing (404). Scope: archive:read.

get_account_connection

ChatGPT
Reads a connection attempt: its status, the current qr_url (and over MCP a fresh QR image) while wait_qr, password_url while wait_password, and the account once done. A finished attempt is kept for about a minute. Errors: attempt_expired (409). Any role may read it, as in the console. Scope: accounts:write.

get_account_relogin

ChatGPT
Reads a re-login attempt: for a QR re-login the current qr_url (over MCP a fresh QR image) while wait_qr, and password_url while wait_password. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

get_account_telegram_profile

ChatGPT
Reads the account's profile from Telegram now, through Cerber's session on it: name, username, bio, profile photo, the masked login and recovery emails, whether a 2FA password and a passkey are set and whether Cerber manages them, and the state of Cerber's second (paired) session. Owner, superadmin and admin roles only (role_forbidden, 403, otherwise). An admin or archive role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would, so the API never confirms that an account exists. An account with no live Cerber session answers no_session (409). Scope: org:read.

get_activity

ChatGPT
The Overview's activity grid: for each account the caller may see, how many messages were saved per day, by the day they were sent, over the last days days (UTC). A day before the archive reached back is null, not zero. Answers an empty grid rather than waiting when the count takes too long. Owner, superadmin, admin and archive roles (role_forbidden, 403, for billing). Scope: org:read.

get_admin_grants

ChatGPT
Returns the accounts granted directly to one admin. Department grants are listed on the admin itself (granted_department_ids in list_admins); an admin also reaches every account filed under those departments. Owner and superadmins only (superadmin_required, 403). An admin of another organization, or none, answers resource_missing (404). Scope: org:read.

get_archive_cleanup_status

ChatGPT
Returns the ten latest cleanups of the account's archive — what each deleted or is deleting, how far it got, and why it failed if it did — together with the legal holds that stop any deletion, what past cleanups stop from being saved again (guard), and whether deleting is available on this deployment. Owner and superadmins only (superadmin_required, 403), as everything about deleting archive data is. Scope: archive:read.

get_archive_rules

ChatGPT
Returns the organization's archive rules: the default, and rules per chat, per Telegram folder and per chat category. The most specific rule naming a chat wins. A chat whose rule is none is not archived at all; the other modes keep every message and differ in which files they keep. With no rules set every chat is archived in full. Owner and superadmins only (superadmin_required, 403): the rules decide what the company will still have in a year. Scope: archive:read.

get_billing_accounts

ChatGPT
Lists every account that holds or held a seat with the licence tier it sits on (protect, archive, governance) and whether an admin chose that tier, plus the licences bought and free per tier. The owner, superadmins and the billing role only; any other role gets role_forbidden (403). Scope: org:read.

get_chat_messages

ChatGPT
Messages of one chat in chronological order, newest limit (1–500, default 50) by default; page back with before. The answer is {messages, count, more, nextBefore, nextAfter}: more says whether the chat holds messages beyond the returned window in the paging direction, nextBefore is the timestamp to pass as before for the next older page (null when nothing older exists), nextAfter likewise for after. With after alone the page is the OLDEST limit messages past that point and more looks forward. Messages sent within the same second (an album, for one) are never split across pages, so a page may hold more than limit messages by the size of that group. Each message carries its media facts (file name — never for photos —, MIME type, size, whether the file was saved, a voice transcript, a document's text length), deletedAt + deletedReason when Telegram deleted it (the archive keeps it), read (whether the account owner has read it; always true for messages they sent, where readByRecipient is the interesting one), and edits when earlier versions exist (see get_message_history). A sender Telegram no longer names carries lastKnownName / lastKnownUsername / lastKnownAt — the last identity the archive ever saw that id under, or three nulls when it never saw one. Unknown chat → tool result with isError.

get_department_access

ChatGPT
Returns every account filed under the department, the scoped admins granted the department (and how many of its accounts each also holds one by one, which they would keep if the department access went), and the AI connections scoped to it. Owner and superadmins only: anyone else gets department_access_forbidden (403). An unknown department answers resource_missing (404). Scope: org:read.

get_mail_preferences

ChatGPT
Returns the email address of the admin this credential acts as and which kinds of email they chose to receive: security (alerts about the accounts), storage, news and offers. Emails a person cannot turn off (sign-in codes, invoices to the payer) are not listed. Errors: mail_preferences_unavailable (409) for an admin who has no sign-in of their own yet. Scope: org:read.

get_media

ChatGPT
The file attached to one message. Always returns its facts (name, MIME type, size, saved or not, and sha256 — the hex SHA-256 of the plaintext bytes when they are returned, null otherwise). Returns a photo or sticker as an image, a voice message as audio plus its transcript, and a document as its extracted text (PDF, Word, Excel, plain text); other files come back as a binary resource when under 20 MB. A message without a file → tool result with isError.

get_message_history

ChatGPT
Every archived version of one message, oldest first, with when each was captured — what the text said before it was edited — plus the current version and its deletion time if Telegram deleted it. Versions exist only for edits the archive witnessed since 2026-09-10; an edited message with none says so in note.

get_notification_recipients

ChatGPT
Returns who the organization's notifications go to: owner (the owner alone) or owner_superadmins (the owner and every superadmin). Every role may read it; only the owner and superadmins change it in the console. Scope: org:read.

get_organization

ChatGPT
Returns the organization this credential was issued in — the only one it can ever reach. It says whether Cerber is protecting the accounts now (protection_active), the plan and licences in brief, how many seats are used and free, whether the archive password is set and what the plan allows the archive to do, and whether the takeover lockdown is on. Every role may call it. get_subscription has the full subscription, get_status the health of protection and saving. Errors: organization_closed (403) when the organization has been wound down. Scope: org:read.

get_saving_preferences

ChatGPT
Reads what the archive saves for the account, in the simple form the Lite interface uses. custom: true means the rules were set in the Pro console and do not fit; change them there or set new preferences. Any role that reads the archive. Scope: archive:read.

get_status

ChatGPT
The status page: whether protection is on, how many accounts Cerber's monitoring is getting through to, how archive runs are doing, and how many accounts are saving new messages — with the reasons for those that are not (saving.reasons). Computed from this organization's accounts, not from a global health flag: an organization whose every account has stalled reads as stopped whatever the rest of the fleet does. An admin or archive role sees the accounts granted to it. Storage (archive_pool) is included for the roles that manage billing. Scope: org:read.

get_status_summary

ChatGPT
The one-screen summary the console's Status card shows: an overall service level with the reasons for it, per component (console, monitoring, archive, mcp), accounts connected and monitored, what the archive holds, saving, storage, licences and active AI connections. Fields a role does not see in the console are null here (saved, storage, licences, ai); an admin or archive role sees its granted accounts, and scope.partial says so. Scope: org:read.

get_subscription

ChatGPT
Returns the subscription as the console's Subscription page shows it: the plan and period, licences per tier and how many are assigned, storage included and bought, a trial or a failed payment being retried, changes scheduled for the end of the period, and the archive's lifecycle (how long it stays readable after a plan ends, and when it would be deleted). Every role may read it. For roles that cannot change the subscription (anyone but the owner, superadmins and billing) the answer is reduced (reduced: true): no prices, payment method, payer, partner offer or payment in progress. This API changes no money: buying, upgrading, adding storage, paying and cancelling happen in the console, where the person signs off on the price themselves. That is deliberate — an AI connection executing payments is what Anthropic's connector directory policy (§4A) singles out — so get_billing_links answers the console pages to open instead. Scope: org:read.

get_whatsapp_account

ChatGPT
Whether Cerber's linked device on the WhatsApp account is connected, since when, how much history the phone shared and how much of it was saved, and how many messages wait to be saved. Read from Cerber's own records, not from WhatsApp. A WhatsApp account only (not_whatsapp, 409). Archive roles only. An admin or archive role reaches only the accounts granted to it; any other account answers resource_missing (404). Scope: archive:read.

get_whatsapp_contact

ChatGPT
The person's name as this account knows it, phone number, "about" line and, for a business account, its business profile. Only people Cerber already knows the WhatsApp id of (person_not_found, 404, otherwise). Read live from WhatsApp through Cerber's linked device on the account: nothing is sent and nothing changes in WhatsApp. Reads are paced, one every two seconds per account. An account whose link is down answers whatsapp_not_connected (409); a WhatsApp account only (not_whatsapp, 409, for a Telegram one). Archive roles only. An admin or archive role reaches only the accounts granted to it; any other account answers resource_missing (404). Scope: archive:read.

get_whatsapp_group

ChatGPT
The group's name, description, settings, owner and members with their roles. Members carry their archive id when the archive has seen them. Read live from WhatsApp through Cerber's linked device on the account: nothing is sent and nothing changes in WhatsApp. Reads are paced, one every two seconds per account. An account whose link is down answers whatsapp_not_connected (409); a WhatsApp account only (not_whatsapp, 409, for a Telegram one). Archive roles only. An admin or archive role reaches only the accounts granted to it; any other account answers resource_missing (404). Scope: archive:read.

get_whole_archive_deletion

ChatGPT
Reads the progress of delete_whole_archive. Every role may read it, as in the console. Scope: org:read.

invite_admin

ChatGPT
Creates an admin and emails them an invitation link (valid for 7 days) to set a password or sign in with Google. The role is superadmin (everything but ownership), admin (the accounts granted to it: devices, security, archive), billing (the subscription only) or archive (reads the archive of the accounts granted to it). For admin and archive, account_ids and department_ids say which accounts they reach. Side effects: an email goes to the address; the journal records admin.invited. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). Errors: an existing admin with that email (409), too many invitations pending (409), a deployment that cannot send email (503). Scope: admins:write.

list_accounts

ChatGPT
The Telegram accounts this connection can read, with each archive's state: message count, size, when it last received a message, and — while a sweep is filling it — how many chats of how many have been read. archive.messages and archive.media are the same counts list_chats reports, so they add up; archive.sealedObjects is the raw number of objects in the vault, which is larger because it counts every version of an edited message, member-list snapshots and service rows. archive.empty is true when nothing is stored for the account: it was never saved yet, or a cleanup deleted what was saved. Such an account is still in scope and listed, with 0 chats.

list_admins

ChatGPT
Lists the organization's admins in the order they were added: role, whether disabled or still invited, last sign-in, and for the admin and archive roles the accounts and departments granted to them. Owner and superadmins only: anyone else gets superadmin_required (403). Scope: org:read.

list_ai_connections

ChatGPT
Lists every credential that reaches this organization's data from outside the console: - connections — Developer MCP tokens and AI apps connected through the consent screen (Claude, ChatGPT, …), with the accounts each may read and whether the archive password is stored with it. A role that may not read the archive sees only the AI apps it connected itself. client.known names Claude or ChatGPT only when the code went to their official callback address; any other app is named by its host. - api_keys — API keys of this API, with their scopes. The owner and superadmins see every credential of the organization, with its owner's email; any other role sees its own. Revoked and expired credentials are listed too, with revoked_at and expires_at. No secret is ever returned. Scope: org:read.

list_chat_members

ChatGPT
Who is in a group chat — every member, the silent ones included — with name, username, id, role (owner / admin / member / restricted), when they joined and who invited them, as Telegram listed them at the account's last full check (capturedAt; a check runs every 24 h). Also former: people who were in an earlier list or whose leaving / removal the archive saw (with when and how), and changesSince: the joins and leaves witnessed after the snapshot, already applied to members. Groups and supergroups only; a private chat or a broadcast channel → tool result with isError. note explains a partial answer (no list recorded yet, or Telegram hides the members).

list_chats

ChatGPT
Chats in the archive, newest first, with message/media/deleted/edited counts, the oldest archived message, whether the history is complete back to the first message (historyComplete=false means the archive is still being filled for that chat) and, for groups, the member count of the last recorded member list (members, null when none is recorded yet). Also per chat: autoDelete — Telegram's disappearing-message timer ({enabled, seconds, seenAt}; {enabled:false} when off; null when the archive has never looked) — unread ({count, mentions, lastReadMsgId, lastReadAt, seenAt}, null when never looked), and mediaPolicy, how much of this chat's media the archive keeps. Optionally limited to one account, one folder, or chats with unread messages. Answers {content_notice, chats: [...]}.

list_departments

ChatGPT
The owner and superadmins get every department, with how many scoped admins and AI connections reach each through department access (access). An admin or archive role gets the departments granted to it, listing only the accounts it may see. The billing role gets an empty list. The list is short and comes in one page. Scope: org:read.

list_folders

ChatGPT
Folder names recorded in the sealed archive, with how many archived chats each holds. Folder names are no longer recorded for new archives, so the list is often empty.

list_invoices

ChatGPT
Lists invoices newest first, with the total, status and links to the hosted invoice and its PDF. Page with limit and starting_after (the last invoice id of the previous page). The owner, superadmins and the billing role only; any other role gets role_forbidden (403). A deployment that takes no payments answers billing_disabled (503). Scope: org:read.

list_journal_events

ChatGPT
Returns the journal newest first: sign-ins and approvals, sessions signed out, archive runs, admin and billing changes, AI connections. Page back with before_id (the id of the oldest event of the previous page), or start from a moment with before. What each role sees is what it sees in the console: the owner and superadmins everything; an admin or archive role the events of its accounts and the organization-wide events it caused itself; the archive role only archive, backup and AI-connection events; the billing role only billing and organization events, without operator notes. A change made through this API or an AI connection carries detail.credential — the kind and id of the credential and whether it came through REST or MCP. Scope: org:read.

list_protected_accounts

ChatGPT
Lists the Telegram accounts the organization has connected — protected, paused and offboarded ones alike — in the console's order, with each account's protection status and a summary of its archive. Filter by status or department_id; page with limit and starting_after (the last id of the previous page). An admin or archive role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would, so the API never confirms that an account exists. Not to be confused with the MCP archive tool list_accounts, which lists the accounts an AI connection may read in the archive. Scope: org:read.

list_topics

ChatGPT
The topics of a forum group (a chat list_chats marks forum=true): each topic's id, title, archived message count and last message time, newest first, with closed / pinned / hidden when Telegram said so. General is topic 1. unsorted counts the messages whose topic the archive cannot determine (topicId null on the messages; read them with topic: 0), and while there are any, countsComplete is false: per-topic counts cover only the messages whose topic is known. namesFrom says where titles come from: telegram (the topic list as Telegram gave it, at namesSeenAt), archive (the archived messages that created or renamed each topic) or null; a topic with no known title has title null. note explains any gap. A chat that is not a forum → tool result with isError.

list_whatsapp_groups

ChatGPT
Every group and community the WhatsApp account is a member of now, with its archive id when the archive has something from it. Read live from WhatsApp through Cerber's linked device on the account: nothing is sent and nothing changes in WhatsApp. Reads are paced, one every two seconds per account. An account whose link is down answers whatsapp_not_connected (409); a WhatsApp account only (not_whatsapp, 409, for a Telegram one). Archive roles only. An admin or archive role reaches only the accounts granted to it; any other account answers resource_missing (404). Scope: archive:read.

move_accounts_to_department

ChatGPT
Moves the accounts, as preview_department_move described. Send the preview's expected: if any account was moved by someone else since, nothing moves and the call answers department_changed (409) — preview again. Who reaches the accounts through department access changes with them; the journal records each move. Confirm with the user before calling. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

offboard_account

ChatGPT
Disconnects an employee's account: Cerber's sessions on it end, protection stops and the licence is freed. The archive is kept, untouched. Protecting the account again means connecting it anew. To stop protection for a while instead, use pause_protection; to delete the archive too, delete_account. Side effects: Cerber signs out of the employee's real Telegram account; the employee is told on Telegram; the journal records employee.offboarded. Confirm with the user before calling. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: security:write.

pause_protection

ChatGPT
Pauses protection of an active account: Cerber keeps its session on the account but stops reviewing sessions and signing anything out, and sends the employee nothing. The account keeps its licence. Resume with resume_protection — instantly, without a login. Not the same as offboard_account, which ends Cerber's session and frees the seat. Errors: not_active (409) for an account that is not active (already paused, offboarded). Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

preview_archive_cleanup

ChatGPT
Measures what a cleanup of the account's stored archive would delete — the whole archive of the account (all: true) or the chats listed in chat_ids — and answers a preview valid for a limited time with the confirm_phrase the person must type to confirm it. Nothing is deleted until confirm_archive_cleanup. Errors: cleanup_in_progress (409), cleanup_unfinished (409, an earlier cleanup failed: retry or cancel it first), chat_not_found (404), bad_scope (400). A connection limited to some chats of the account may clean only chats it may send to, never the whole account (chat_not_allowed, 403). Owner and superadmins only (superadmin_required, 403), as everything about deleting archive data is in the console. An unknown account answers resource_missing (404). Refused under a legal hold (legal_hold, 409) and on a deployment that cannot delete archive objects (archive_delete_unavailable, 503). Scope: archive:delete.

preview_department_move

ChatGPT
Says what move_accounts_to_department would do: each account's department before and after, and — for the owner and superadmins — how many scoped admins would gain, lose or keep access and how many AI connections are affected; for a scoped admin, whether it would lose access itself and whether anyone else is affected. Pass the answer's expected to the move as its guard: the move is refused if any account was moved by someone else in between. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

remove_admin

ChatGPT
Removes the admin from the organization for good: their access, grants, API keys and AI connections go with them, and invitations they sent that are still pending are cancelled. The journal keeps what they did. Nobody can remove themselves. Confirm with the user before calling. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). An organization always keeps one active superadmin and its owner: demoting, disabling or removing either is refused (400). An admin of another organization, or none, answers resource_missing (404). Scope: admins:write.

remove_paired_session

ChatGPT
Signs Cerber's second (paired) session out of the account. Protection then rests on the first session alone. Confirm with the user before calling. The journal records session.paired_removed. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). Scope: security:write.

rename_department

ChatGPT
Renames the department. Owner and superadmins only (department_rename_forbidden, 403). Errors: department_exists (409), no_department (404). Scope: admins:write.

request_account

ChatGPT
Files a request for Cerber to provide (rent) a Telegram number for a new employee. Nothing is created: support follows the request up by hand. The journal records account.requested. Any role may file one, as in the console. Scope: accounts:write.

request_integration

ChatGPT
Files a request for an integration: which service, and what should happen. A repeat with the same idempotency_key files nothing new. At most 10 requests per 10 minutes (429). Any role may file one. Scope: accounts:write.

request_support

ChatGPT
Files a support request and answers a one-time link to Cerber's support bot in Telegram that opens the conversation with this context (company, role, the section and error). Give the link to the user: support answers there, not through this API. The link works for 30 minutes. Any role may ask. Scope: accounts:write.

resend_admin_invite

ChatGPT
Sends the invitation of an admin who has not accepted yet again, with a new 7-day link; the old link stops working. Confirm with the user before calling. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). An admin of another organization, or none, answers resource_missing (404). Scope: admins:write.

resume_chat_saving

ChatGPT
A cleanup normally stops the archive from saving the cleaned chats again. This lets it save new messages from now on for one chat (chat_id) or for the whole account (chat_id: "all"); what was deleted stays deleted. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). Errors: cleanup_in_progress (409) while a cleanup of the account is running. Scope: accounts:write.

resume_protection

ChatGPT
Resumes a paused account: Cerber watches it again through the session it kept, with no login and no new licence. Errors: not_paused (409) for an account that is not paused. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

retry_archive_cleanup

ChatGPT
Puts a failed cleanup back in the queue; it then deletes what it was confirmed to delete and had not yet. A cleanup that has not failed is answered as it is. Errors: legacy_job and manifest_moved (409: cancel it and start again). Confirm with the user before calling. Owner and superadmins only (superadmin_required, 403), as everything about deleting archive data is in the console. An unknown account answers resource_missing (404). Refused under a legal hold (legal_hold, 409) and on a deployment that cannot delete archive objects (archive_delete_unavailable, 503). Scope: archive:delete.

rotate_two_fa

ChatGPT
Replaces the account's Cerber-held 2FA password with a newly generated one. Only for a password Cerber holds (two_fa_managed). Confirm with the user before calling. Side effects: the change is made on the employee's real Telegram account; the admins are notified by email; the journal records it. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). In the console this action needs a login confirmed within the last 10 minutes. Over the API the security:write scope is that step-up: it is granted (approving the AI connection, or creating the API key) only from a login confirmed within 10 minutes, so nothing more is sent here. Scope: security:write.

search_messages

ChatGPT
Case-insensitive substring search over message text and captions, sender names, file names, the extracted text of documents (PDF, Word, Excel, plain text) and voice transcripts; newest first, at most limit (1–200, default 30) hits. Each hit says where it matched (matchedIn) and shows a snippet. The result reports how many messages were examined and partial: true if the time budget ran out before all of them were — narrow by account, chat, folder, sender or dates, or repeat the query (opened messages stay cached).

set_account_archive_rules

ChatGPT
Replaces the account's exceptions to the organization's rules (the account part of get_account_archive_rules). Send an empty object to drop every exception, so the account follows the organization's rules. Per-chat changes are easier with set_account_chat_rules. Confirm with the user before calling. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). The lite block (Cerber Lite's saving switches) is taken back as get_account_archive_rules answers it; left out, the account keeps it. An unknown account answers resource_missing (404). A connection limited to some chats of the account may send only chats, and only those chats change: the rules of other chats, the default, folders and categories are kept; any other field answers chat_not_allowed (403). Scope: accounts:write.

set_account_chat_rules

ChatGPT
Sets a rule on each chat named (keyed by chat id), or clears it with null so the chat follows the account's and the organization's rules again. Other chats, and the same chat on other accounts, keep their rules. At most 500 chats per call. Confirm with the user before calling. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). Errors: bad_rules, bad_chat_id (400), resource_missing (404). Scope: accounts:write.

set_account_department

ChatGPT
Files the account under the department, or under none with department_id: null. Who reaches the account through department access changes with it: admins and AI connections scoped to the old department lose it, those of the new one gain it. Use preview_department_move first to see who. Confirm with the user before calling. The owner and superadmins move any account; a scoped admin only between departments granted to it, accounts it reaches (department_add_forbidden / department_remove_forbidden, 403), and a move that would widen anybody else's access needs the owner (department_move_needs_owner, 403). Unknown department: no_department (404). Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

set_account_role_label

ChatGPT
Sets the label the organization gives the account, at most 60 characters. Empty or null clears it. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

set_account_security_lock

ChatGPT
Turns the account's security lock on or off. The journal records a change. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: security:write.

set_admin_grants

ChatGPT
Replaces what a scoped admin reaches: the accounts granted one by one, and — when department_ids is sent — the departments. Left out, the department grants stay as they are. Their AI connections narrow with them at once. Only for the admin and archive roles (400 otherwise: the others see every account). Confirm with the user before calling. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). An admin of another organization, or none, answers resource_missing (404). Scope: admins:write.

set_admin_role

ChatGPT
Sets the admin's role: superadmin (everything but ownership), admin (the accounts granted to it: devices, security, archive), billing (the subscription only) or archive (reads the archive of the accounts granted to it). The owner's role cannot be changed (ownership is handed over with transfer_ownership), and nobody can be made owner here. Their next request already runs under the new role. Confirm with the user before calling. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). An organization always keeps one active superadmin and its owner: demoting, disabling or removing either is refused (400). An admin of another organization, or none, answers resource_missing (404). Scope: admins:write.

set_archive_rules

ChatGPT
Replaces the organization's whole rule set (read it first with get_archive_rules and send it back changed). The most specific rule naming a chat wins: chat, then folder, then category, then default. A chat whose rule is none is not archived at all from now on; what was archived before stays until a cleanup deletes it. With no rules every chat is archived in full. Confirm with the user before calling. Side effects: every account's rules are re-applied; the journal records archive.retention_changed. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). Malformed rules answer bad_rules (400) with what is wrong. These rules reach every chat, so a connection limited to some chats of any account gets chat_not_allowed (403). Scope: accounts:write.

set_mail_preferences

ChatGPT
Turns each optional kind of email on or off for the admin this credential acts as — never anybody else. All four are required, as the console sends them. Emails a person cannot turn off (sign-in codes, invoices to the payer) are not affected. Errors: mail_preferences_unavailable (409) for an admin who has no sign-in of their own yet. Scope: accounts:write.

set_notification_recipients

ChatGPT
Sets who receives the organization's notifications: owner or owner_superadmins. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). Scope: accounts:write.

set_takeover_lockdown

ChatGPT
Turns the organization-wide takeover lockdown on or off. On, when Cerber sees a takeover attempt on an account (the 2FA password or login email changed outside the console, Cerber's session removed) it signs every other session out and locks the account until an admin clears it; off, it alerts only. Confirm with the user before calling. Side effects: the admins are notified by email; the journal records it. Owner and superadmins only, as in the console: anyone else gets superadmin_required (403). Scope: security:write.

set_telegram_photo

ChatGPT
Sets a new Telegram profile photo on the account from an image sent as base64 in the body: PNG, JPEG or WebP, at most 5 MB of image (400 otherwise). The request body as a whole may be at most 12 MB. Telegram may still refuse an unusual image with its own error. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

set_telegram_username

ChatGPT
Sets the account's Telegram username, without the @; an empty string removes it. Telegram refuses a username that is taken or malformed, and the error says which. A username given up can be taken by someone else. Confirm with the user before calling. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

sign_out_session

ChatGPT
Withdraws the session's approval and signs it out of the account through Cerber's session. Telegram refuses sign-outs from a session younger than 24 hours: during the first 24 hours after the account was connected the call answers signed_out: false, queued: true, and Cerber keeps retrying until Telegram accepts. Side effects: the device is signed out of the employee's real Telegram account; the employee is told on Telegram (once, also when queued); the journal records session.kicked. Confirm with the user before calling. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. A malformed session id answers 400; an account Cerber does not monitor answers 400. Scope: security:write.

start_account_connection

ChatGPT
With method: qr (recommended from an AI connection) the answer is wait_qr with qr_page_url, qr_url, and over MCP a PNG image of the QR code. Give the user qr_page_url as a link: that one-time page shows the current QR code, redraws it as Telegram replaces it (about every 30 seconds), and asks for the two-step password if there is one. They scan it in Telegram on their phone (Settings → Devices → Link Desktop Device). Many AI apps never show a tool's image to the user, so the PNG is only a fallback. Poll get_account_connection every few seconds to learn the outcome. If the account has a two-step password the attempt reaches wait_password and carries password_url, a one-time page where the user types it (never ask for it in the conversation). protection chooses notify (Cerber alerts about new sessions and never signs them out) or enforce (unapproved sessions are signed out); the default is notify for a Lite organization, enforce otherwise. With method: code (the default over REST, needs phone): Telegram sends a login code to that account and the answer is wait_code with code_url. Over an AI connection give the user code_url: a one-time page where they type the code (and then the two-step password, if asked), so neither passes through the conversation; poll get_account_connection for the outcome. Over REST you may instead send the code with submit_account_connection_code, and the 2FA password with submit_account_connection_password if the account has one. When status is done the account is protected and account_id names it. The code comes from a person: Telegram sends it to the account itself (the Telegram app where it is signed in, or by SMS), so only the person holding that account can read it. In an AI conversation never ask for it: give the person code_url from the attempt, a one-time page where they type it. Never guess a code and never take one from archived messages. Refused before Telegram is asked: phone_invalid (400), organization_inactive (403), no_seats (403, every licence in use), number_in_other_organization and number_has_personal_plan (409), and rate limits (429). An attempt lives about 10 minutes. A scoped admin is granted the account it connects. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). Scope: accounts:write.

start_account_relogin

ChatGPT
With method: qr (recommended from an AI connection) the answer is wait_qr with qr_page_url, qr_url and, over MCP, a PNG image of the QR code. Give the user qr_page_url as a link: that one-time page shows the current QR code to scan in Telegram on their phone (Settings → Devices → Link Desktop Device) and asks for the two-step password if there is one; the PNG is only a fallback, since many AI apps never show a tool's image to the user. Poll get_account_relogin for the outcome. A two-step password is asked through password_url, a one-time page for the user; never ask for it in the conversation. With method: code (the default over REST): starts a new sign-in of Cerber's monitoring session on the account. With Cerber's held passkey (and its 2FA password) it completes on its own, via: passkey; otherwise Telegram sends a login code to the account (status: wait_code) and the answer carries code_url. Over an AI connection give the user code_url, a one-time page where they type the code (then the 2FA password if asked); over REST you may instead send it with submit_account_relogin_code, then the 2FA password if asked. The code comes from a person: Telegram sends it to the account itself (the Telegram app where it is signed in, or by SMS), so only the person holding that account can read it. In an AI conversation never ask for it: give the person code_url from the attempt, a one-time page where they type it. Never guess a code and never take one from archived messages. Errors: offboarded (409) for an offboarded account — connect it anew instead. Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

start_archive_backup

ChatGPT
Starts an incremental archive run of the account. started: false comes with a refusal instead of an error for the states that are not errors: no_session (no live Cerber session), no_archive_key (no archive password yet), not_configured (archiving is not set up on this server), already_running (a run is already in progress), resetting (the archive is being erased and read again by support; retrying before it is done gets the same answer), cleanup_running (a cleanup is deleting from the archive; try again when it is done). Owner, superadmin, admin and archive roles (role_forbidden, 403, for billing). The plan must allow archiving (archive_closed, otherwise) and storage must not be full (archive_write_paused, 409). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

update_telegram_profile

ChatGPT
Changes the account's own Telegram profile, as everyone in Telegram sees it. A field left out is left as it is. The bio is limited to bio_limit characters (70, or 140 with Telegram Premium); Telegram refuses a longer one. Side effects: the change is made on the employee's real Telegram account; the journal records it. Acts through Cerber's session on the account: an account with no live Cerber session answers no_session (409); re-login it first (start_account_relogin). Owner, superadmin and admin roles only, as in the console: billing and archive get role_forbidden (403). An admin role reaches only the accounts granted to it; any other account answers resource_missing (404), exactly as an id from another organization would. Scope: accounts:write.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/tg-cerber"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/tg-cerber)