← All Telegram MCP connectors

Make.com · Celonis

Make.com Telegram MCP — visual Telegram automation

Wire Entergram’s MCP endpoint into your Make scenarios and automate your real Telegram account — surface the messages you missed, chase leads that went cold, and route client feedback visually.

MCP server URL https://mcp.entergram.com/mcp

Make.com scenarios can call external MCP servers directly. Connect Entergram's and every module can read and act on your real personal Telegram account — visually, over OAuth, with no bot and nothing to code.

Paste-ready configuration

Make → MCP module → Endpoint URL
https://mcp.entergram.com/mcp

Scenarios worth building

With your personal account connected, Make can watch and act on your chats. For example:

  • Run a scenario each morning that flags chats waiting more than 24 hours.
  • Route incoming questions to different owners based on the chat's pipeline stage.
  • When a ticket's priority changes, notify the assignee in Telegram.
  • On a weekly timer, compile ticket counts and push them to a spreadsheet.
  • Filter for chats mentioning refunds and escalate them automatically.
  • Catch scenario errors and post a failure alert into an internal channel.

Connect Make in 3 steps

Works with Make.com scenarios.

  1. 01

    Copy your MCP URL in Entergram

    Open Settings → Workspace → Connectors → MCP inside Entergram and copy the server URL. Make attaches it to a connection that all of your scenarios can share.

  2. 02

    Add the MCP module in Make

    In your Make scenario, add the MCP module and paste the Entergram MCP URL: https://mcp.entergram.com/mcp.

  3. 03

    Authorize and automate

    Click Connect, log in with your Entergram account, and click Allow access, then connect Telegram triggers and actions to the rest of your scenario.

Three shapes a Telegram scenario can take

Scheduled scenario

The workhorse. One MCP module reads from Entergram on a clock — every fifteen minutes, every morning at eight, the first of the month — and the rest of the scenario decides what to do with the bundles it returns. No trigger app, no webhook to register, and the run history gives you a per-execution record of exactly what was read and written. Start every build here, in manual-run mode, before you switch the schedule on.

Router with filters

Where Make earns its keep against a code-first tool. Feed one read module into a router, then attach a filter to each branch: urgent items go one way, everything else goes another, and a fallback route catches whatever matches nothing. Editing the routing rules is a matter of changing a dropdown, which means the person who owns the process can maintain it without opening a repository.

https://mcp.entergram.com/mcp

Scenario with error handlers

Attach an error handler route to any module that writes back to Telegram. Resume lets the scenario substitute a fallback bundle and carry on, Break parks the execution as incomplete so you can retry it once the cause is fixed, and Ignore is for the calls you genuinely do not care about. Unattended automation without error routes is how a single expired credential turns into a week of missing follow-ups.

Six scenarios you can build this afternoon

Make is not asking Telegram questions in a chat window — it is running a scenario on a clock and moving the answers into the tools your team already lives in. Each example lists the goal, the Entergram modules that carry it, and what your colleagues see when the run completes. Nobody has to be logged in for any of them to fire, which is the difference between a helpful assistant and an operational process.

The scenario

Every Monday at 09:00, refresh the deal spreadsheet with the current pipeline stage of every active client conversation.

Modules called

entergram_list_workspace_chatsentergram_list_custom_column_optionsentergram_get_chat_custom_fields

The run produces

The options module gives you the human-readable labels behind each stored value, so the sheet reads Negotiation rather than an opaque key. Sales opens one tab on Monday morning and sees the same picture the account managers see in Telegram.

The scenario

Poll the ticket queue every ten minutes and route by severity — critical to on-call, everything else to the team channel.

Modules called

entergram_list_ticketsentergram_list_ticket_custom_columnsentergram_get_ticket

The run produces

The schema module supplies the real option values so your filter compares keys instead of display text, which is the single most common reason a router branch silently matches nothing. Critical tickets reach a phone in minutes; the rest accumulate quietly.

The scenario

When a new contact appears, enrich them from your marketing platform and write the result back onto the conversation.

Modules called

entergram_list_contactsentergram_get_contactentergram_patch_chat_custom_fields

The run produces

A filter drops anyone already enriched so the scenario is safe to run on a tight schedule. Company size, source and lifecycle stage land on the chat record, and the next person to open that conversation sees context nobody typed by hand. Run it once over your back catalogue with the schedule off, then leave it running forward.

The scenario

When a deal is marked Won in your CRM, spin up a shared onboarding group and bring the account team in.

Modules called

entergram_create_group_chatentergram_invite_chat_membersentergram_update_chat_info

The run produces

Group creation, invitations and a naming convention applied to the title and description, all from the webhook that fired when the deal closed. Onboarding starts the same hour the contract is signed instead of whenever someone gets round to it, and every client group ends up named the same way, which is worth more than it sounds when you have two hundred of them.

The scenario

Outside business hours, acknowledge inbound client messages and tell them when a human will pick it up.

Modules called

entergram_list_live_chatsentergram_set_message_reactionsentergram_send_message

The run produces

A time filter gates the whole branch, the reaction gives an instant visual acknowledgement, and the reply sets an expectation instead of leaving silence. Restrict the branch to conversations you have tagged as clients unless you want your friends receiving office-hours notices.

The scenario

On the first of each month, deliver the performance report to every retainer client as a document in their own chat.

Modules called

entergram_list_accountsentergram_list_chatsentergram_send_media_message

The run produces

The account module resolves which connected identity sends, the chat list narrows to the retainer conversations, and the media module attaches the PDF your reporting scenario generated upstream. Twenty client reports go out in one run and the history log proves each delivery, which is a better answer than searching your own outbox when a client says they never received it.

What Make can do with your Telegram

  • Drive Telegram steps from a visual scenario, no code
  • Schedule a scenario to sweep your inbox overnight
  • Branch on chat or ticket state with routers and filters
  • Write pipeline fields from any upstream module
  • Catch and reroute failures with error handlers
  • Share one authorized connection across every scenario

Modules available in every scenario

A single Entergram connection unlocks 70 tools grouped into 9 areas, each selectable from the module dropdown once the connection is authorized. Read modules are safe to place anywhere; write modules deserve a filter in front of them and an error handler behind them.

Accounts & workspace

5 tools

Identity and scope discovery. Every message call needs an account_id from list_accounts first — an AI client that skips this step will address the wrong Telegram account.

  • entergram_get_me
  • entergram_list_accounts
  • entergram_get_workspace
  • entergram_get_member
  • entergram_list_members

Chats & discovery

8 tools

Finding conversations. The workspace views carry CRM state (tickets, comments, custom fields); the live views carry current Telegram transport state and unread counts.

  • entergram_list_chats
  • entergram_get_chat
  • entergram_list_live_chats
  • entergram_get_live_chat
  • entergram_list_workspace_chats
  • entergram_get_workspace_chat
  • entergram_update_workspace_chat
  • entergram_get_chat_management

Messages

9 tools

Reading and writing message history, including edits, forwards and reactions. Sending is scoped per account, so nothing is global across your connected accounts.

  • entergram_list_messages
  • entergram_get_message
  • entergram_send_message
  • entergram_send_media_message
  • entergram_edit_message
  • entergram_delete_message
  • entergram_forward_messages
  • entergram_get_message_reactions
  • entergram_set_message_reactions

Contacts

3 tools

Who you are talking to, and where else you overlap with them. Shared-groups lookup is what makes questions like “which of my leads are in the same community?” answerable.

  • entergram_list_contacts
  • entergram_get_contact
  • entergram_list_contact_shared_groups

Tickets

10 tools

Full support-desk control: open, assign, prioritise, comment and close. Tickets link back to the chat they came from, so an AI client can move from conversation to queue in one step.

  • entergram_list_tickets
  • entergram_get_ticket
  • entergram_create_ticket
  • entergram_update_ticket
  • entergram_delete_ticket
  • entergram_list_chat_tickets
  • entergram_list_ticket_comments
  • entergram_create_ticket_comment
  • entergram_update_ticket_comment
  • entergram_delete_ticket_comment

CRM custom fields

11 tools

Your pipeline schema. Read the columns before writing values — checkboxes take booleans, multiselects take arrays of option values, dates take ISO 8601 strings.

  • entergram_list_custom_columns
  • entergram_get_custom_column
  • entergram_create_custom_column
  • entergram_update_custom_column
  • entergram_delete_custom_column
  • entergram_list_custom_column_options
  • entergram_create_custom_column_option
  • entergram_update_custom_column_option
  • entergram_delete_custom_column_option
  • entergram_get_chat_custom_fields
  • entergram_patch_chat_custom_fields

Ticket custom fields

9 tools

The same schema control for the ticket side — categories, severities, SLA tiers and anything else your desk tracks beyond status and priority.

  • entergram_list_ticket_custom_columns
  • entergram_get_ticket_custom_column
  • entergram_create_ticket_custom_column
  • entergram_update_ticket_custom_column
  • entergram_delete_ticket_custom_column
  • entergram_list_ticket_custom_column_options
  • entergram_create_ticket_custom_column_option
  • entergram_update_ticket_custom_column_option
  • entergram_delete_ticket_custom_column_option

Internal notes

4 tools

Comments on a chat that your customer never sees. Useful for letting an AI client leave its reasoning behind for a human teammate to pick up.

  • entergram_list_chat_comments
  • entergram_create_chat_comment
  • entergram_update_chat_comment
  • entergram_delete_chat_comment

Groups & channels

11 tools

Creating and administering Telegram groups and channels — membership, permissions, privacy and info — plus a raw command escape hatch for the rest.

  • entergram_list_groups
  • entergram_get_group
  • entergram_list_group_members
  • entergram_create_group_chat
  • entergram_create_channel
  • entergram_invite_chat_members
  • entergram_remove_chat_member
  • entergram_update_chat_info
  • entergram_update_chat_permissions
  • entergram_update_chat_privacy
  • entergram_run_chat_command

What the connection is allowed to do

Authorizing is an OAuth login through Entergram's consent screen, and the resulting connection is reusable across every scenario in your Make organisation — including scenarios other people build. Choose the access level with that sharing in mind. Your Telegram phone number and session never reach Make.

Personal agent
Any member of the workspace can create one, and it is deliberately narrow: reading workspace, accounts, contacts, chats, messages and tickets, plus writing custom fields on your own chats. Perfect for the reporting and dashboard scenarios that make up most of what teams build first, and a sensible default while you are still learning which modules return what.
Workspace connector
Owner or admin only, and it carries the complete scope set — sending, writing fields on any conversation, creating and administering groups. Every scenario that talks back to a customer needs this tier, so treat the connection itself as a shared operational asset rather than a personal login.
Revocation
Go to Settings → Workspace → Connectors → MCP in Entergram and revoke, and the connection stops working immediately for every scenario referencing it. That is a blunt instrument by design: one action stops all automation, which is what you want during an incident.

What to check before you switch a scenario on

Automation runs while nobody is watching, so the honest constraints matter more here than they would in a chat tool.

  • A Pro plan is required for MCP access. The connection will authorize regardless, and the shortfall surfaces as failing modules once a scenario is live.
  • Entergram does not push events into Make. Instant triggers are not part of the picture, so scenarios read on a schedule and your polling interval sets both the responsiveness and the operation count.
  • Every module execution consumes an operation. A scenario that loops over hundreds of conversations every ten minutes will consume your plan faster than expected — filter early, before the loop, not after it.
  • There is no human between the scenario and the customer. Anything that sends should be scoped by a filter you have tested against real data in a manual run, and ideally kept inactive until you have watched a full cycle in the history log.
  • Half-finished runs stay half-finished. Messages already sent cannot be recalled by rolling the scenario back, so design branches that can be re-run safely and lean on incomplete executions rather than blind retries.
  • The connection expires eventually and will need reauthorizing. Without an error handler routing to a notification, the only symptom is a scenario that stopped producing output, so build the alert before you build the automation.

Make.com connector troubleshooting

The connection saves but modules return no data
Run the module once manually and inspect the output bundle before wiring anything downstream. An empty result is usually a filter above it that never passed anything, not a broken connection — Make will happily execute the rest of a scenario against zero bundles and report a successful run.
A router branch never matches
Filters compare stored values, and those are option keys rather than the labels shown in the interface. Add the relevant schema module before the router, read the real option values from its output, and rebuild the condition against those.
Modules fail with 403
Read-only work needs a personal agent; sending, group administration and cross-chat field writes need a workspace connector, which only an owner or admin can create. Confirm the plan includes MCP access before assuming the scenario is at fault.
Messages arrive from an unexpected Telegram identity
Sending is bound to a specific connected account. Put the accounts module at the start of the scenario, map the identity you want explicitly into every send module, and never leave that field to be inferred.
Executions pile up as incomplete
Something is erroring without a handler attached. Open one incomplete execution, read the module that failed, then attach an error route — Resume with a fallback for cosmetic failures, Break for anything that must be retried once fixed.
The scenario burns through operations
Reading everything and filtering afterwards costs an operation per bundle. Narrow the source module with search parameters, place filters immediately after it, and drop the schedule frequency for anything that does not genuinely need ten-minute latency.

Make + Telegram FAQ

Is this a Telegram bot?
No. Entergram connects your real personal Telegram account via a hosted MCP server, so Make automates on your actual chats.
Do I need code?
No. You add the MCP module and authorize via OAuth — everything else is visual in Make.
Can it flag leads that went cold?
Yes. Build a scenario that detects leads with no follow-up and creates a task or reminder automatically.
Is it secure?
Yes. OAuth 2.0 with scoped permissions; you control access and can revoke it at any time.

Make.com Telegram MCP — visual Telegram automation