A multi-agent shared WhatsApp inbox built natively inside ERPNext, with conversation assignment and routing, canned replies, tagging and SLA first-response tracking. ECOSIRE builds, installs and supports it for you as a proper Frappe app. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $299.00 USD; request a quote for a scoped proposal.

A multi-agent shared WhatsApp inbox built natively inside ERPNext, with conversation assignment and routing, canned replies, tagging and SLA first-response tracking. ECOSIRE builds, installs and supports it for you as a proper Frappe app.
अभी कोई भुगतान नहीं। यह हमारी टीम को एक कोटेशन अनुरोध भेजता है — हम कीमत और अगले चरणों के साथ ईमेल द्वारा संपर्क करेंगे।
High-volume WhatsApp support is where most ERPNext teams quietly lose the thread. Messages land on one shared phone or a single BSP number, several agents answer from the same screen, and there is no record of who replied, what was promised, or how long the customer waited. ERPNext ships CRM, Helpdesk and a generic Notification/Communication layer, but it has no concept of a live multi-agent WhatsApp queue: no per-conversation ownership, no first-response SLA clock, no quick-reply library, and no way to see the whole inbox as a workload you can distribute. Teams end up bolting on a third-party inbox that lives outside ERPNext, so the conversation history never reaches the Customer, Lead or Issue it belongs to.
Custom `whatsapp_team_inbox` Frappe app with `WhatsApp Conversation` parent DocType and child `WhatsApp Message` rows for full threaded history
Signature-verified inbound webhook via `@frappe.whitelist(allow_guest=True)` for Meta Cloud API or a BSP (Twilio/360dialog) with idempotent message ingestion
Real-time shared inbox list refreshed over `frappe.realtime`/socket.io so all agents see new messages and status changes without reloading
Round-robin and rule-based auto-assignment fired from `hooks.py` doc events (`after_insert`, `on_update`) using ERPNext `_assign`/`ToDo` ownership
Manual re-assignment and transfer between agents/teams, with a full audit trail of ownership changes
Canned Response DocType with per-team visibility and Jinja variable substitution (`{{ customer_name }}`, order refs) via a client-script quick-reply picker
We build a whatsapp_team_inbox Frappe app that puts the entire shared inbox inside ERPNext itself. Inbound messages arriving via your WhatsApp Business API provider (Meta Cloud API or a BSP such as Twilio/360dialog) hit a whitelisted webhook endpoint (@frappe.whitelist(allow_guest=True)) that verifies the provider signature and writes each message into a WhatsApp Conversation DocType with child WhatsApp Message rows. Conversations carry owner, status, tags, linked party (Customer/Lead/Contact via Dynamic Link) and SLA fields. A custom Desk workspace and a real-time list — refreshed over Frappe's frappe.realtime/socket.io channel — give agents a true shared inbox instead of a static report.
Assignment and routing are driven by ERPNext's own primitives. hooks.py doc events (after_insert, on_update) run server-side logic that auto-assigns new conversations by round-robin or by team/language rules, applies ToDo/_assign ownership so it shows in each agent's assignment panel, and stamps the SLA due timestamp. Canned replies are a Canned Response DocType with per-team visibility and variable substitution (e.g. {{ customer_name }}), surfaced through a client script slash-command in the reply box. A scheduler event (registered under scheduler_events in hooks.py) sweeps open conversations every few minutes, flags first-response and resolution SLA breaches, and escalates or notifies team leads. Everything respects ERPNext permissions: we ship dedicated roles and role profiles, so agents see only their team's queue while supervisors get the full board and the metrics. All conversation and message data is reachable through the standard Frappe REST API and additional whitelisted methods, so your reporting or a future dashboard can read it cleanly.
Because this is build-to-order, we tailor the routing rules, canned-reply library, SLA policy and party-linking to how your team actually works rather than shipping a rigid generic add-on. After a short scoping call we confirm the exact DocTypes, roles, provider integration and SLA definitions in writing, then build on a staging bench. Typical delivery is 2-4 weeks from confirmed scope, depending on how many teams, SLA tiers and provider quirks are in play. We install and configure it on your ERPNext v15 or v16 site, run UAT on staging with a rollback plan before touching production, hand over the full git repository and documentation, train your agents and supervisors, and stay on for a post-go-live support window. There is no instant download — this is a system we build, install and stand behind.
Runs a WhatsApp support desk and needs per-conversation ownership, first-response SLA timers and a supervisor board to see who is handling what and where the queue is backing up.
Handles high inbound WhatsApp lead volume and wants every conversation linked to the right ERPNext Lead/Customer, routed to the right rep, with canned replies to answer fast without losing context.
Owns the ERPNext site and wants a proper Frappe app with clean DocTypes, roles and REST access installed on v15/v16 rather than a disconnected third-party inbox, plus a git repo they can maintain.
Cares about measurable response times and consistent service, and needs SLA breach tracking, tagging and escalation reporting living inside the same ERPNext where the rest of the business runs.
Buy the license on ecosire.com and download the WhatsApp Shared Team Inbox for ERPNext app ZIP from your account dashboard.
Extract the ZIP into your bench's apps folder, or run `bench get-app` with the path to the extracted app.
Run `bench --site SITE_NAME install-app APP_NAME` followed by `bench migrate` to install WhatsApp Shared Team Inbox for ERPNext and apply its schema.
Open the ECOSIRE License settings on your site and activate your license key. Requires the free ecosire_connect and ecosire_license_client apps.
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Lives inside ERPNext | Native Frappe app; conversations linked to Customer/Lead/Issue | Depends on in-house skill; often stays partly external | Usually a generic add-on with shallow party linking | |
| Multi-agent assignment | Round-robin + rule-based routing via `hooks.py` doc events and `_assign` | Buildable but you design and test it yourself | Basic assignment, rarely rule-based | |
| SLA & first-response timers | Server-stamped SLA due times + scheduler breach sweep and escalation | Must be built and maintained from scratch | Limited or add-on-priced SLA features | |
| Canned replies | Canned Response DocType with team visibility and Jinja variables | Custom-built snippet system | Simple static snippets, little templating | |
| Fit to your workflow | Built to your scope: teams, SLA tiers, routing, provider | Fully bespoke but you own all the risk | Fixed feature set; you adapt to it | |
| Roles & permissions | Dedicated roles/role profiles; team-scoped queues, supervisor board | Whatever you configure yourself | Coarse permissions, often all-or-nothing | |
| Delivery & support | 2-4 weeks, install + UAT + training + support window | Timeline and support depend on internal capacity | Instant install, community/ticket support only | |
| Ownership & extensibility | Full git repo + docs handover for v15/v16 | You own it entirely | Vendor-locked; source rarely provided |
No. This is a build-to-order Frappe app that ECOSIRE builds, installs and supports for your ERPNext site. There is no instant marketplace download. After we confirm scope, we build it on a staging bench, run UAT, then install it on your production site and hand over the source and git repository.
Typical delivery is 2-4 weeks from confirmed scope. The exact timeline depends on how many teams and SLA tiers you need, your WhatsApp provider (Meta Cloud API or a BSP like Twilio/360dialog), and any custom routing or party-linking rules. We agree the scope in writing on a short scoping call before any build work starts.
It integrates with the official WhatsApp Business API through Meta Cloud API directly or a BSP such as Twilio or 360dialog. Inbound messages arrive via a signature-verified webhook and outbound replies (including template and media messages) route back through your provider. We confirm your specific provider during scoping and build the integration around it.
Yes. It is built for Frappe/ERPNext v15 and v16 as a proper Frappe app, and it ships dedicated roles and role profiles. Agents see only their team's queue while supervisors get the full board and SLA metrics, all enforced through standard ERPNext permission rules — not a bolt-on that bypasses them.
Conversations are `WhatsApp Conversation` DocTypes. `hooks.py` doc events auto-assign new threads by round-robin or team/language rules and stamp the SLA due timestamp server-side. A scheduler event sweeps open conversations on an interval to flag first-response and resolution breaches and escalate them, so nothing quietly slips past the deadline.
Every build includes a post-go-live support window for bug fixes and configuration adjustments. Because you receive the full git repository and source, your own team can maintain and extend it. Beyond the included window we offer ongoing support and enhancement retainers, including compatibility work for future ERPNext releases.
Yes. Each conversation uses a Dynamic Link to the relevant Customer, Lead, Contact or Issue, so the full WhatsApp thread lives against the right ERPNext party record. Message data is also reachable through the Frappe REST API and whitelisted methods for reporting or downstream integration.
A multi-agent shared WhatsApp inbox built natively inside ERPNext, with conversation assignment and routing, canned replies, tagging and SLA first-response tracking. ECOSIRE builds, installs and supports it for you as a proper Frappe app.