Telegram + bash-dash: send updates without app switching
Your day gets chopped up by tiny interruptions. You’re in the middle of work, you remember you need to tell someone something, and suddenly you’re unlocking your phone, finding the right chat, retyping the message, then trying to recover your focus.
This Telegram bash-dash updates setup hits agency owners and ops leads hard because they’re constantly sending quick status pings. But honestly, anyone doing deep work (founders, marketers, even solo consultants) feels the same drag. You type one short command and the update lands in the right Telegram chat.
This workflow turns your command line into a “message send” button. You’ll see how it works, what you need, and how to tweak it so it fits your day-to-day.
How This Automation Works
See how this solves the problem:
n8n Workflow Template: Telegram + bash-dash: send updates without app switching
flowchart LR
subgraph sg0["Flow 1"]
direction LR
n0["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/webhook.dark.svg' width='40' height='40' /></div><br/>Webhook"]
n1@{ icon: "mdi:swap-vertical", form: "rounded", label: "Set", pos: "b", h: 48 }
n2["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/telegram.svg' width='40' height='40' /></div><br/>Telegram"]
n0 --> n2
n2 --> n1
end
%% Styling
classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef disabled stroke-dasharray: 5 5,opacity: 0.5
class n0 api
classDef customIcon fill:none,stroke:none
class n0,n2 customIcon
The Challenge: Sending “quick” updates isn’t quick
Sending a simple Telegram update should take seconds, but the real cost is the context switch. You leave whatever you’re doing, open Telegram, search for the right chat, and type the message (often twice because you get interrupted). Then comes the hidden part: getting back into the work you were doing before. If you send even a handful of updates a day, those micro-pauses stack up into a chunk of time you never planned for. And if you’re doing client work or coordinating a team, “I’ll message them later” quietly turns into missed updates.
It adds up fast. Here’s where it breaks down in real life.
- You end up retyping the same kinds of messages (“running late”, “deployed”, “sent the file”) over and over.
- It’s easy to send to the wrong chat when you’re moving quickly between clients, projects, and threads.
- Phone notifications pull you into other conversations, so the “one message” becomes ten minutes of drift.
- When you’re heads-down in a terminal already, opening a separate app feels like friction you shouldn’t have to accept.
The Fix: Send Telegram messages from a bash-dash command
This workflow gives you a simple shortcut: a local command (via bash-dash) that hits an n8n webhook, which then posts your message into a specific Telegram chat. You type something like telegram I’ll be late, and the workflow takes that text, formats it if needed, and sends it where it belongs. No app switching. No hunting for the right thread. It’s also flexible: if you do not want to type the message at all, you can set a predefined message inside the workflow so the same command always sends the same update. Think “on my way”, “meeting started”, or “deployed to production”.
The workflow starts with an inbound webhook that bash-dash calls. Next, n8n passes the provided text through a simple “compose message” step. Finally, the Telegram node dispatches the message to your chosen chat, consistently, every time.
What Changes: Before vs. After
| What This Eliminates | Impact You’ll See |
|---|---|
|
|
Real-World Impact
Say you send 10 quick Telegram updates a day. Manually, it’s easy to spend about 2 minutes each between unlocking, switching apps, finding the chat, and snapping back to what you were doing. That’s roughly 20 minutes daily, and it often feels like more because the interruptions are scattered. With this workflow, sending the same update is a single command that takes maybe 10 seconds, so you’re down to a couple minutes total. Over a week, you’ve bought back about 90 minutes.
Requirements
- n8n instance (try n8n Cloud free)
- Self-hosting option if you prefer (Hostinger works well)
- bash-dash to run short CLI commands.
- Telegram to receive the messages in a chat.
- Telegram bot token (get it from BotFather in Telegram).
Skill level: Beginner. You’ll copy a webhook URL into bash-dash and connect Telegram once in n8n.
Need help implementing this? Talk to an automation expert (free 15-minute consultation).
The Workflow Flow
A webhook receives your command. bash-dash is configured so the telegram command calls your n8n webhook URL (for example, a local n8n running on port 5678). The text you type after the command gets passed along in the request.
The workflow builds the message. n8n takes the inbound text and prepares it for sending. If you prefer a fixed status update, this is also where you replace the “text expression” with a predefined message so the command always sends the same line.
Telegram sends it to the right place. The Telegram node posts the message to your chosen chat using your bot credentials, so you’re not relying on a personal device session or a brittle copy/paste routine.
You can keep it simple or extend it. Today it’s “send this text”. Tomorrow it can include a project name, a timestamp, or a short template. You can easily modify the message format to match your tone based on your needs. See the full implementation guide below for customization options.
Step-by-Step Implementation Guide
Step 1: Configure the Webhook Trigger
Set up the inbound webhook so external requests can start the workflow and pass the message text into the flow.
- Add and open Inbound Webhook Trigger.
- Set Path to
telegram. - Set Response Mode to
lastNode. - Under Options, set Response Property Name to
response.
Tip: Copy the webhook URL from Inbound Webhook Trigger after saving—this is the URL you’ll call to send messages into Telegram.
Step 2: Connect Telegram
Configure the Telegram node to send the incoming message text to your target chat.
- Add and open Telegram Message Dispatch.
- Set Text to
={{$node["Inbound Webhook Trigger"].json["query"]["parameter"]}}. - Set Chat ID to
[YOUR_ID](replace this with your actual Telegram chat ID). - Credential Required: Connect your telegramApi credentials.
⚠️ Common Pitfall: Leaving [YOUR_ID] unchanged will cause the Telegram send to fail. Replace it with your real chat ID.
Step 3: Set Up Response Formatting
Create a friendly response that confirms the message was sent and includes the recipient name and original text.
- Add and open Compose Response Text.
- Create a string field named response.
- Set its value to
=Sent message to {{$node["Telegram Message Dispatch"].json["result"]["chat"]["first_name"]}}: "{{$node["Telegram Message Dispatch"].parameter["text"]}}".
Step 4: Review Execution Flow
Confirm the node connections follow the intended order.
- Ensure Inbound Webhook Trigger connects to Telegram Message Dispatch.
- Ensure Telegram Message Dispatch connects to Compose Response Text.
- Note that Flowpast Branding is a sticky note for documentation and does not affect execution.
Step 5: Test and Activate Your Workflow
Run a manual test to verify Telegram delivery and webhook responses, then activate the workflow for production.
- Click Execute Workflow and send a test request to the Inbound Webhook Trigger URL with a query parameter named
parameter. - Confirm Telegram Message Dispatch sends the message to your chat.
- Check the last node output from Compose Response Text to see the formatted
response. - Toggle the workflow to Active to enable live webhook processing.
Watch Out For
- Telegram credentials can expire or the bot can lose access to a chat. If things break, check the bot token in your n8n Telegram credentials and confirm the bot is still a member of the target chat.
- If you’re calling a local webhook from bash-dash, “localhost” only works on the same machine. When you run n8n on a server, update bash-dash to use the server URL (and make sure the webhook port is reachable).
- Predefined messages are convenient, but they can confuse you later when you forget it’s hardcoded. Leave yourself a quick note in the Sticky Note node describing what the command sends and which chat it targets.
Common Questions
About 20 minutes if your Telegram bot is ready.
Yes, but someone needs to be comfortable editing a simple bash-dash command. Inside n8n, it’s mostly “paste webhook URL, connect Telegram, test”.
Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in Telegram bot usage (usually free for this kind of messaging).
Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.
You’ll usually edit the “Compose Response Text” step to change formatting, add a timestamp, or switch between a typed message and a predefined one. If you want different commands for different chats, duplicate the Telegram Message Dispatch node and point each one at a different chat ID, then route based on the webhook input. Some teams also create “templates” like telegram_deploy or telegram_late in bash-dash that all hit the same webhook with different default text.
Most of the time it’s an invalid bot token or the bot isn’t in the chat you’re trying to message. Update the Telegram credentials in n8n, then confirm the chat ID is correct and the bot has permission to post there.
For typical “one message at a time” usage, it’s effectively unlimited.
For command-line style messaging, n8n is usually the cleaner fit because webhooks are straightforward, you can self-host, and you’re not paying per tiny action once you scale. Zapier and Make can still do Telegram messages, but they’re not designed around “trigger from a terminal” as nicely, and you can end up building awkward workarounds. Also, keeping this local (or on your own VPS) is handy if you don’t want another third-party relay in the middle. If you already live in Zapier for everything else, it can work. Talk to an automation expert if you want a quick recommendation based on your stack.
This is a small automation with an outsized payoff. Set it up once, and your “quick updates” finally become quick again.
Need Help Setting This Up?
Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.
