Skip to main content
WhatsApp Shared Team Inbox for ERPNext — A multi-agent shared WhatsApp inbox built natively inside ERPNext, with conversation — 1/1Illustrative preview

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.

What is WhatsApp Shared Team Inbox for ERPNext?

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 $999.00 USD; request a quote for a scoped proposal.

Key Features

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
Conversation tagging, labels and status workflow (Open, Pending, Snoozed, Resolved) driven by a Frappe Workflow with permitted transitions
First-response and resolution SLA timers with due timestamps stamped server-side and a `scheduler_events` sweep that flags and escalates breaches
Dynamic Link to Customer, Lead, Contact or Issue so every WhatsApp thread is attached to the right ERPNext party record
Dedicated roles and role profiles so agents see only their team queue while supervisors get the full board and SLA metrics
Whitelisted server methods plus standard Frappe REST API access for outbound send, reporting and integration
Custom Desk workspace with saved list views, filters by owner/status/SLA, and a supervisor board of open workload
Outbound reply, media and template-message support routed back through your BSP with delivery/read status written to the message row
Compatible with Frappe/ERPNext v15 and v16, packaged as a versioned app installable via `bench get-app` / `bench install-app`

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

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.

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 one working week 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.

What you get

  • Installable source code for your build, delivered as a versioned Frappe app (`bench get-app`/`bench install-app` ready) for ERPNext v15 or v16
  • Installation and configuration on your ERPNext site, including provider (Meta Cloud API/BSP) webhook wiring and SLA policy setup
  • Technical documentation: DocType schema, `hooks.py` events, whitelisted methods, roles/permissions and webhook contract
  • End-user guide plus a live training session for agents and supervisors on the inbox, assignment, canned replies and SLA board
  • UAT on a staging bench with a documented rollback plan before any production change
  • Git repository handover with full commit history and README for your team to self-host and extend
  • Post-go-live support window for bug fixes and configuration adjustments after launch

Who this is for

Customer support team lead

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.

Inside-sales manager

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.

ERPNext system administrator

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.

Head of customer experience

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.

How WhatsApp Shared Team Inbox for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Lives inside ERPNextNative Frappe app; conversations linked to Customer/Lead/IssueDepends on in-house skill; often stays partly externalUsually a generic add-on with shallow party linkingNo shared WhatsApp inbox concept at all
Multi-agent assignmentRound-robin + rule-based routing via `hooks.py` doc events and `_assign`Buildable but you design and test it yourselfBasic assignment, rarely rule-basedNo per-conversation ownership for WhatsApp
SLA & first-response timersServer-stamped SLA due times + scheduler breach sweep and escalationMust be built and maintained from scratchLimited or add-on-priced SLA featuresNone for messaging
Canned repliesCanned Response DocType with team visibility and Jinja variablesCustom-built snippet systemSimple static snippets, little templatingNot available
Fit to your workflowBuilt to your scope: teams, SLA tiers, routing, providerFully bespoke but you own all the riskFixed feature set; you adapt to itNot applicable
Roles & permissionsDedicated roles/role profiles; team-scoped queues, supervisor boardWhatever you configure yourselfCoarse permissions, often all-or-nothingStandard ERPNext perms, no inbox model
Delivery & supportone working week, install + UAT + training + support windowTimeline and support depend on internal capacityInstant install, community/ticket support onlyIncluded in ERPNext, no build needed
Ownership & extensibilityFull git repo + docs handover for v15/v16You own it entirelyVendor-locked; source rarely providedCore code, not tailored to this use case

Frequently Asked Questions about WhatsApp Shared Team Inbox

Is this an existing app I can download and install today?

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.

How long does delivery take?

Typical delivery is one working week 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.

Which WhatsApp providers does it work with?

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.

Does it work with our ERPNext version and respect our permissions?

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.

How does SLA and assignment tracking actually work?

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.

What about support and updates after go-live?

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.

Will our WhatsApp history be linked to customer records in ERPNext?

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.

Request a quote

WhatsApp Shared Team Inbox

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.

  • 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

Request a Quotation

Tell us about your WhatsApp Shared Team Inbox 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.