How to integrate Telegram with Make

Make (formerly Integromat) is one of the most powerful no-code automation platforms for connecting Telegram with hundreds of other apps — from Google Sheets and CRMs to email marketing tools and databases. Integration works through Make's built-in Telegram modules that connect via the Bot API, allowing you to automate message sending, channel management, and data processing without writing a single line of code.

What Is Make and Why Use It with Telegram

Make is a visual automation platform that lets you build workflows (called scenarios) by connecting different apps through a drag-and-drop interface. Unlike simpler tools like Zapier, Make offers advanced features such as routers, iterators, error handlers, and complex data transformations — all while remaining accessible to non-developers.

When paired with Telegram, Make unlocks powerful automation possibilities:

  • Auto-posting content from RSS feeds, WordPress, or social media to your Telegram channel
  • Processing incoming messages and routing them to CRMs, spreadsheets, or support systems
  • Sending notifications triggered by events in other apps (new orders, form submissions, server alerts)
  • Managing subscribers by syncing Telegram user data with your database or email list

The key advantage over direct Bot API coding is speed — what takes hours of development can be set up in 15-20 minutes with Make.

Prerequisites Before You Start

Create a Telegram Bot

Every Make-Telegram integration requires a bot token. You cannot connect Make directly to your personal account.

  1. Open Telegram and find @BotFather
  2. Send the /newbot command
  3. Choose a display name (e.g., "My Channel Automation Bot")
  4. Choose a username ending in bot (e.g., mychannel_auto_bot)
  5. Copy the HTTP API token — you'll need it in Make

Add the Bot to Your Channel

If you plan to post to a channel or read channel messages:

  1. Open your Telegram channel settings
  2. Go to Administrators → Add Administrator
  3. Search for your bot by its username
  4. Grant it the necessary permissions — at minimum, Post Messages for sending content
  5. For reading messages, also enable Manage Messages

Create a Make Account

Sign up at make.com. The free plan allows 1,000 operations per month and 2 active scenarios, which is enough for basic automations. For higher-volume channels, you'll need a paid plan starting at around $9/month.

Step-by-Step: Building Your First Telegram Scenario

Step 1: Create a New Scenario

Log into Make, click Create a new scenario in the top-right corner. You'll see an empty canvas with a single circle — this is where you add your first module.

Step 2: Add the Telegram Bot Module

  1. Click the + icon on the canvas
  2. Search for Telegram Bot in the app list
  3. Choose your trigger or action module. Common options include:
    • Watch Updates — triggers when the bot receives any message
    • Send a Text Message or a Reply — sends a message to a chat or channel
    • Send a Photo / Document / Video — sends media files
    • Get Chat Member — retrieves user info
    • Edit Message Text — modifies existing messages

Step 3: Connect Your Bot

  1. Click Create a connection
  2. Give it a recognizable name (e.g., "My Channel Bot")
  3. Paste the Bot API token from BotFather
  4. Click Save

Make will verify the token and establish the connection. If it fails, double-check that the token is correct and the bot hasn't been revoked.

Step 4: Configure the Module

For a Watch Updates trigger, set:
- Limit: how many updates to process per execution (start with 10)
- Allowed Updates: filter by message type — message, channel_post, callback_query, etc.

For a Send a Text Message action, fill in:
- Chat ID: your channel's ID (e.g., @yourchannel or the numeric ID like -1001234567890)
- Text: the message content, which can include variables from previous modules
- Parse Mode: choose HTML or MarkdownV2 for formatted text

Step 5: Add Additional Modules

Click the + after your Telegram module to chain more actions. Popular combinations:

  • Google Sheets → Telegram Bot: Send Message (post data from a spreadsheet)
  • RSS → Telegram Bot: Send Message (auto-post new articles)
  • Telegram Bot: Watch Updates → Google Sheets: Add a Row (log incoming messages)
  • Telegram Bot: Watch Updates → HTTP: Make a Request (forward data to an external API)

Step 6: Use Routers for Complex Logic

Make's Router module lets you split the flow based on conditions. For example:

  • If an incoming message contains a keyword → send to a specific Google Sheet
  • If a message includes a photo → download and save to Google Drive
  • If the sender is an admin → process differently than a regular user

Add a router by right-clicking the connection line between modules and selecting Add a router.

Step 7: Set the Schedule and Activate

  1. Click the clock icon at the bottom of the canvas
  2. Set how often the scenario should run (e.g., every 15 minutes, every hour)
  3. Toggle the scenario ON in the bottom-left corner

Popular Integration Recipes

Auto-Post RSS to Telegram Channel

Modules: RSS → Telegram Bot: Send a Text Message

This is perfect for news channels. Every time your blog or news source publishes a new article, Make automatically sends it to your Telegram channel. Configure the message template to include the title, summary, and link. If you host your channel content on platforms like tgchannel.space, you can include a link back to the web version for better SEO coverage.

Forward Telegram Messages to Slack or Discord

Modules: Telegram Bot: Watch Updates → Slack: Send a Message

Useful for teams that monitor a Telegram channel but primarily communicate on Slack. Every new channel post gets forwarded automatically with the sender's name and timestamp.

Save Telegram Media to Google Drive

Modules: Telegram Bot: Watch Updates → HTTP: Get a File → Google Drive: Upload a File

When someone sends a photo or document to your bot, Make downloads the file via the Telegram API and uploads it to a specific Google Drive folder.

CRM Integration (HubSpot, Airtable)

Modules: Telegram Bot: Watch Updates → Airtable: Create a Record

Capture leads or feedback from Telegram messages and automatically create entries in your CRM or database.

Working with Telegram Data in Make

Parsing Chat IDs

Telegram uses different ID formats:
- Public channels: use @username format (e.g., @mytechblog)
- Private channels/groups: use numeric IDs (e.g., -1001234567890)
- Individual chats: use the user's numeric ID (e.g., 123456789)

To find a private channel's numeric ID, forward a message from the channel to @userinfobot or use the Watch Updates module and inspect the output.

Handling Message Formatting

When sending messages via Make, use the Parse Mode setting:

  • HTML: <b>bold</b>, <i>italic</i>, <a href="url">link</a>
  • MarkdownV2: *bold*, _italic_, [link](url) — but special characters like ., -, ( must be escaped with \

HTML parse mode is generally more reliable in Make because MarkdownV2's escaping rules are strict and can cause unexpected failures.

Using Webhooks Instead of Polling

For real-time responses, switch from Make's polling (Watch Updates) to Instant triggers using webhooks:

  1. In your scenario, select Telegram Bot: Watch Updates (Instant)
  2. Make will generate a webhook URL
  3. The Telegram API is automatically configured to send updates to this URL

This eliminates the delay between message receipt and processing — responses happen within seconds rather than waiting for the next polling cycle.

Tips & Best Practices

  • Start simple: Build a scenario with just 2-3 modules first. Test thoroughly before adding complexity. A working simple automation beats a broken complex one.
  • Use the "Run once" button: Before activating a scenario on schedule, click Run once to test with real data. Check each module's output bubble to verify the data flow.
  • Add error handlers: Right-click any module and select Add error handler. Use the Resume directive for non-critical failures or Break to pause the scenario and notify you.
  • Monitor operation usage: Each module execution counts as one operation. A scenario with 5 modules processing 10 messages uses 50 operations. Keep this in mind with free-plan limits.
  • Use filters between modules: Click the wrench icon on connection lines to add conditions. For example, only process messages that contain specific hashtags or come from specific users.
  • Store your bot token securely: In Make, use the Keys section under Team settings rather than hardcoding tokens in multiple scenarios.
  • Set up notifications for failures: Go to scenario settings → Notifications and enable email alerts for consecutive failures so you catch issues early.

Common Mistakes

Mistake 1: Using @channel instead of the actual Chat ID
Why it's wrong: @channel is not a valid Telegram username. You need the actual channel username like @mychannel or the numeric ID.
How to avoid: Always test the Send Message module with Run once before activating the scenario.

Mistake 2: Not granting the bot admin rights in the channel
Why it's wrong: Bots cannot post to channels unless they are added as administrators with posting permissions. The API will return a 403 Forbidden error.
How to avoid: Add the bot as a channel admin before configuring the Make scenario, and verify with a test message.

Mistake 3: Ignoring rate limits
Why it's wrong: Telegram's Bot API has rate limits — roughly 30 messages per second to different chats, and 20 messages per minute to the same group. Exceeding these causes 429 Too Many Requests errors.
How to avoid: Use Make's built-in Sleep module between bulk sends, or set the scenario to process fewer items per execution.

Mistake 4: Not handling media_group messages correctly
Why it's wrong: When a Telegram user sends multiple photos as an album, each photo arrives as a separate update sharing the same media_group_id. Processing them individually results in duplicate posts.
How to avoid: Add a filter or aggregator module that groups messages by media_group_id and processes the album as a single unit.

Mistake 5: Leaving test scenarios running on schedule
Why it's wrong: Forgotten active scenarios consume your monthly operations quota silently, especially polling-based ones that run every few minutes.
How to avoid: Deactivate scenarios immediately after testing. Use descriptive names like "TEST - RSS to Telegram" so you can identify them easily.

Frequently Asked Questions

Can I use Make to manage Telegram groups, not just channels?
Yes. The Telegram Bot modules work with groups, supergroups, and channels. For groups, the bot must be a member (not necessarily admin) to receive messages. For posting, it typically needs admin rights. Group management actions like banning users require specific admin permissions.

Is Make better than Zapier for Telegram integrations?
Make generally offers more flexibility for Telegram workflows. It has more Telegram-specific modules, supports routers and iterators natively, and its visual scenario builder makes complex flows easier to understand. Make's free tier also provides more operations (1,000 vs Zapier's 100 tasks). However, Zapier may be simpler for very basic two-step automations.

Can I send messages with inline buttons using Make?
Yes. Use the Send a Text Message module and configure the Reply Markup field with an inline keyboard JSON structure. You'll need to format it as a JSON object with inline_keyboard arrays containing button objects with text and either url or callback_data fields.

How do I handle bot commands (like /start) in Make?
Use the Watch Updates trigger and add a Router after it. Create separate routes with filters that check if the message text starts with /start, /help, etc. Each route can then lead to a different response action.

What happens if Make goes down — will I lose Telegram messages?
Telegram stores undelivered updates for approximately 24 hours. When Make's scenario runs again after an outage, it will retrieve pending updates from where it left off. However, for critical workflows, consider implementing a backup logging mechanism — for example, simultaneously archiving channel content via a web mirror on tgchannel.space to ensure no content is permanently lost.