Skip to main content
Telegram Notifications & Bot for ERPNext — A build-to-order Frappe app that pushes ERPNext document events to Telegram and ru — 1/1Illustrative preview

A build-to-order Frappe app that pushes ERPNext document events to Telegram and runs an interactive command bot for approvals, queries and broadcasts.

ECOSIRE scopes, builds, installs and supports it on your v15/v16 site.

What is Telegram Notifications & Bot for ERPNext?

A build-to-order Frappe app that pushes ERPNext document events to Telegram and runs an interactive command bot for approvals, queries and broadcasts. ECOSIRE scopes, builds, installs and supports it on your v15/v16 site. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Dedicated Frappe app and module (not loose server scripts) with versioned source, installed via bench on your ERPNext v15/v16 site
Outbound notifications wired through `hooks.py` doc events (`on_submit`, `on_update`, `after_insert`, `on_change`) plus `scheduler_events` for time-based digests
`Telegram Recipient` DocType mapping ERPNext Users, Customers, Suppliers and linked parties to Telegram chat IDs
Jinja-rendered message templates that quote live field values (order number, amount, party, status) and include a deep link back into the ERPNext document
Condition expressions per rule (same pattern as native ERPNext Notifications) so only matching records trigger a send
Group chat and channel broadcasting, including per-topic threads in Telegram supergroups
Interactive command bot via a secret-token-validated webhook (`@frappe.whitelist(allow_guest=True)`) — no long-polling daemon to maintain
Inline-keyboard approval buttons that write workflow actions (Approve/Reject) back through the Frappe workflow engine
Read-only query commands (e.g. `/orders`, `/stock`, `/invoice`) scoped by the requesting Telegram user's mapped ERPNext role profile and permissions
"Send to Telegram" form action added via client script for on-demand, ad-hoc document push
Delivery logging DocType recording chat, message ID, status and Telegram API errors for auditing and retries
Rate-limit-aware background sending via `frappe.enqueue` so large broadcasts never block the request or trip Telegram's 429 limits
Bot token, webhook secret and API settings stored in a single-DocType settings page (secrets kept out of source control)
Role and permission checks on every inbound command so unmapped or unauthorized Telegram accounts are rejected

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your ERPNext.

  3. 3

    Go live + support

    You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.

Technical Specifications

ERPNext Compatibility
—
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
MariaDB 10.6+

About this Product

Most teams already live in Telegram for day-to-day operations, but ERPNext has no idea it exists. ERPNext ships with email and system notifications, and the native Notification DocType can fire on document events, but it can only reach the channels ERPNext knows about — email inboxes and the in-app bell. When a Sales Order is submitted, a Payment Entry clears, a Stock Entry drops a warehouse below reorder level, or a Leave Application needs a manager's sign-off, the people who need to act are watching a Telegram group, not refreshing an ERPNext list view. The result is delayed approvals, missed stock alerts, and customers who never hear that their order shipped.

ECOSIRE builds a proper Frappe app — its own module with clean DocTypes, not a pile of loose server scripts — that connects ERPNext to the Telegram Bot API. On the outbound side, we wire hooks.py doc events (on_submit, on_update, on_change, after_insert) and scheduler_events so that the documents and conditions you care about push formatted messages to the right chats. Recipients are resolved dynamically: a Telegram Recipient DocType maps ERPNext Users, Customers, Suppliers, or any linked party to their Telegram chat IDs, and message templates are rendered with Jinja against the source document so an alert can quote the actual order number, amount, customer name, and a deep link back into ERPNext. Filtering runs through the same condition expressions you already use in ERPNext Notifications, so you decide exactly which records fire.

The interactive side is a bot that listens for commands and callback buttons. We register a whitelisted webhook endpoint (a @frappe.whitelist(allow_guest=True) method that validates Telegram's secret token) so incoming updates hit ERPNext directly — no polling daemon to babysit. From there the bot can run inline-keyboard approvals (Approve / Reject a Leave Application or Purchase Order straight from the chat, writing the workflow action back through the Frappe REST API), answer read-only queries (/orders, /stock ITEM-CODE, /invoice INV-0001) scoped by the requesting user's role profile and permissions, and broadcast operational updates to channels and groups. Every action respects ERPNext permissions — a user can only approve or query what their roles allow, and unmapped Telegram accounts are rejected. Add a "Send to Telegram" button on any form via a client script so staff can push a document to a chosen chat on demand.

Because this is build-to-order, nothing is a black box. We start with a short scoping call to pin down exactly which DocTypes, events, conditions, recipient mappings, and bot commands you need, then build against a copy of your configuration and target Frappe/ERPNext v15 or v16. You get the installable app source, deployment on your bench, UAT on a staging site, and the full git repository at handover — so your team (or ours, under a support window) can extend it later.

What you get

  • Installable Frappe app source code for your scoped version (ERPNext v15 or v16), built to spec
  • Deployment and configuration on your bench — bot setup, webhook registration, recipient mappings and notification rules
  • Technical documentation: DocType reference, hooks and event map, webhook contract, and settings guide
  • End-user guide plus a live training session for admins and bot users
  • UAT on a staging site with a documented test matrix and a rollback plan before go-live
  • Post-go-live support window for bug fixes and configuration tweaks
  • Full git repository handover with commit history so your team can maintain and extend the app
  • Source-controlled configuration export (notification rules, templates, recipient mappings) for reproducible reinstalls

Who this is for

Operations Manager

Runs daily operations through Telegram groups and needs ERPNext events — new orders, low stock, overdue tasks, failed payments — pushed to the team instantly, with conditions so only the relevant records ping the right channel.

ERPNext Administrator

Owns the site and wants a clean, permission-aware Frappe app rather than a tangle of ad-hoc server scripts. Needs source code, docs and a git handover so upgrades to v15/v16 stay maintainable.

Approvals-Heavy Team Lead

Approves leave, purchase orders and expenses on the move. Wants one-tap Approve/Reject inline buttons in Telegram that write back through the ERPNext workflow engine without opening the desk UI.

Customer Success / Community Manager

Uses a Telegram channel or group to keep customers and suppliers updated on order status, shipments and invoices, with each recipient resolved dynamically from their linked ERPNext party record.

How Telegram Notifications & Bot for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Delivery modelBuilt, installed and supported to your scopeYou hire and manage developersGeneric app, install yourselfNothing to deliver — not a feature
Telegram supportFull outbound + interactive command botWhatever you buildOften send-only, limited commandsNone — email and in-app bell only
Recipient resolutionDynamic from any DocType or linked partyBuild the mapping yourselfUsually fixed user/chat listsEmail recipients only
Interactive approvalsInline buttons write back to workflow engineSignificant bespoke effortRarely offeredNot available
Permission enforcementRole profile and doc permissions on every commandDepends on your implementationOften coarse or noneN/A
Fit to your workflowsScoped to your DocTypes, conditions and eventsFully bespoke but slow and costlyFixed feature set, limited configNative Notification DocType only
Source and handoverFull git repo + docs at handoverYou own it, you maintain itClosed source, vendor lock-inCore code, not yours to change
Upgrade pathStandalone app, v15/v16 tested, supportedYour team owns upgradesDepends on vendor cadenceMoves with ERPNext core

Frequently Asked Questions about Telegram Notifications & Bot

Is this a ready-made app I can download and install right now?

No. This is a build-to-order engagement. ECOSIRE scopes the exact DocTypes, events, recipient mappings and bot commands you need, then builds, installs and supports a Frappe app tailored to your ERPNext site. It is not an existing Frappe Cloud Marketplace download.

How long does delivery take?

Typical delivery is one working week from confirmed scope, depending on how many notification rules, recipient mappings and interactive bot commands you need. We agree the timeline in writing after the scoping call, and complex approval-workflow logic sits at the longer end of that range.

Which ERPNext versions do you support?

We target Frappe and ERPNext v15 and v16. During scoping we confirm your exact version and bench setup so the app is built and tested against the site it will actually run on, including your custom fields and workflows.

How do the interactive approvals and commands stay secure?

Inbound Telegram updates hit a whitelisted webhook that validates Telegram's secret token, and every command maps the sender to an ERPNext user and enforces that user's role profile and document permissions. Unmapped or unauthorized Telegram accounts are rejected, so a chat member can only see or approve what their ERPNext roles allow.

Can it send to private group chats and public channels, not just individual users?

Yes. Recipients can be individual users resolved from any linked party (Customer, Supplier, Employee), private groups, supergroup topics, or broadcast channels. Each notification rule targets whichever chat IDs you configure, rendered with a Jinja template so the message carries the live document details.

What about updates and ongoing support after go-live?

Every build includes a post-go-live support window for bug fixes and configuration tweaks. Because you receive the full git repository at handover, your team can maintain it, and we offer ongoing support or enhancement retainers — including version upgrades — if you would rather we keep it current for you.

Will it survive an ERPNext upgrade?

It is a proper standalone Frappe app using documented hooks and the public REST API, not core patches, which keeps it upgrade-friendly. We still recommend testing on staging before any major version jump; the delivered rollback plan and git history make that straightforward, and we can handle the upgrade under a support arrangement.

Request a quote

Telegram Notifications & Bot

A build-to-order Frappe app that pushes ERPNext document events to Telegram and runs an interactive command bot for approvals, queries and broadcasts. ECOSIRE scopes, builds, installs and supports it on your v15/v16 site.

  • Dedicated Frappe app and module (not loose server scripts) with versioned source, installed via bench on your ERPNext v15/v16 site
  • Outbound notifications wired through `hooks.py` doc events (`on_submit`, `on_update`, `after_insert`, `on_change`) plus `scheduler_events` for time-based digests
  • `Telegram Recipient` DocType mapping ERPNext Users, Customers, Suppliers and linked parties to Telegram chat IDs
  • Jinja-rendered message templates that quote live field values (order number, amount, party, status) and include a deep link back into the ERPNext document

Request a Quotation

Tell us about your Telegram Notifications & Bot requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.