A build-to-order Frappe app that plugs ERPNext into any WhatsApp Business Solution Provider — 360dialog, Gupshup, WATI, Interakt, or Twilio — behind one unified send/receive layer, so switching providers or supporting clients on different BSPs never means rewriting your integration. ECOSIRE builds, installs, and supports it after we agree scope. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $349.00 USD; request a quote for a scoped proposal.

A build-to-order Frappe app that plugs ERPNext into any WhatsApp Business Solution Provider — 360dialog, Gupshup, WATI, Interakt, or Twilio — behind one unified send/receive layer, so switching providers or supporting clients on different BSPs never means rewriting your integration. ECOSIRE builds, installs, and supports it after we agree scope.
ابھی کوئی ادائیگی نہیں۔ یہ ہماری ٹیم کو قیمت کی درخواست بھیجتا ہے — ہم قیمت اور اگلے اقدامات کے ساتھ ای میل کے ذریعے رابطہ کریں گے۔
Every ERPNext partner who sells WhatsApp messaging hits the same wall: each client has already chosen a different Business Solution Provider. One is on 360dialog, another on Gupshup, a third on WATI or Interakt, and a fourth is routing through Twilio. ERPNext core has no WhatsApp abstraction at all — the closest native piece is generic Notification and Email Queue plumbing — so teams end up hard-coding one vendor's REST calls into custom server scripts. The moment a client renegotiates pricing, hits a rate cap, or their BSP deprecates an endpoint, you are rewriting the integration from scratch. That per-client rework does not scale across an agency's book of business.
Pluggable BSP adapter layer — each provider (360dialog, Gupshup, WATI, Interakt, Twilio) is a Python class implementing one shared `send`/`receive`/`status` interface
`WhatsApp Provider` DocType holds per-client BSP configuration; switching or adding a provider is a config change, not a code rewrite
Canonical `WhatsApp Message` DocType records every outbound and inbound message with normalized status states (queued/sent/delivered/read/failed)
Provider-specific webhook payloads mapped to one unified status model, so downstream ERPNext logic is BSP-agnostic
Whitelisted `frappe.whitelist()` send methods exposed on the Frappe REST API for triggering messages from any app or external caller
`hooks.py` doc events let any DocType (Sales Invoice, Lead, Delivery Note, Support Ticket) fire a WhatsApp message on submit/update
This connector solves that at the architecture level. We build a proper Frappe app (whatsapp_bsp_hub) with a pluggable adapter layer: every BSP is a Python adapter class implementing one shared interface (send_template, send_session_message, parse_inbound, handle_status), so ERPNext talks to a single WhatsApp Provider DocType configuration and never to a vendor SDK directly. A WhatsApp Message DocType is the canonical record for every outbound and inbound message, with provider-agnostic status states (queued, sent, delivered, read, failed) normalized from each BSP's own webhook payloads. Sending is triggered through hooks.py doc events and whitelisted methods (frappe.whitelist()) exposed on the Frappe REST API, so any DocType — Sales Invoice, Lead, Delivery Note, Support Ticket — can fire a message from a server script or a client script frm button without knowing which provider is active.
Under the hood we handle the operational realities that off-the-shelf marketplace apps skip. Inbound webhooks land on a whitelisted endpoint per provider, with signature verification and idempotency so retries do not double-post. A scheduler event drains a per-provider outbound queue that respects each BSP's messaging-tier and rate limits, backing off on 429s rather than getting the number flagged. Cost and message-category metadata (marketing, utility, authentication, service) are recorded per message for reconciliation. When a primary provider errors or times out past a threshold, an optional failover policy re-routes the message through a secondary configured provider — the same template, the same recipient, a different rail. An embedded-signup onboarding flow (where the BSP supports it) lets a client connect their own WhatsApp Business Account and phone number without you shuttling API keys by email.
Everything is permission-scoped with Frappe role profiles: an Agent role can send and view conversations, an Administrator role manages provider credentials (stored in encrypted Password fields, never in plain DocType text), and the whole app targets Frappe/ERPNext v15 and v16. Because it is a real app on your bench — not a locked black box — you get the source, the DocTypes, the hooks, and the server scripts, and you can extend the adapter interface to a new BSP yourself later.
This is a build-to-order product, not an instant download. After a short scoping call we confirm which BSPs you need on day one, which ERPNext DocTypes trigger messages, and your failover and templating requirements. ECOSIRE then builds your version, tests it on a staging bench, walks your team through UAT, and installs it on your site — typically 2 to 4 weeks from confirmed scope. You receive the installable app, a git repository handover, documentation, and a post-go-live support window. Request a quotation and we will map your exact BSP mix on the call.
Runs implementations for many clients who each arrived on a different WhatsApp BSP. Needs one connector architecture to reuse across every engagement instead of rebuilding a vendor-specific integration per client.
Wants messaging that fires from Sales Invoices, Leads, and Support Tickets via hooks and server scripts, with a single conversation model regardless of which provider the client pays for.
Has been burned by a provider's price hike or endpoint deprecation and wants failover plus the ability to swap BSPs through configuration, not a code migration.
Needs real source code, the adapter interface, and a git handover so the team can add a new BSP or tune rate-limit behavior without depending on the original vendor.
Buy the license on ecosire.com and download the WhatsApp Business API Provider Connector (BSP Hub) 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 Business API Provider Connector (BSP Hub) 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 |
|---|---|---|---|---|
| Multi-BSP support | One adapter layer covering 360dialog, Gupshup, WATI, Interakt, Twilio | Usually built for one vendor; second BSP means new code | Typically hard-wired to a single provider | |
| Switching providers | Config change on the `WhatsApp Provider` DocType | Code rewrite and re-test | Reinstall or replace the app | |
| Failover between providers | Optional policy re-routes to a secondary BSP on error | Rarely built; extra scope | Almost never offered | |
| Source code and handover | Full app source plus git repository handover | You own it, but tied to one developer | Usually a locked marketplace binary | |
| Rate-limit and cost handling | Per-provider queue, 429 back-off, cost/category metadata | Depends on the developer's diligence | Basic or absent | |
| ERPNext trigger integration | `hooks.py` doc events + whitelisted REST methods on any DocType | Possible but built per project | Limited to the app's own screens | |
| Version support | Built and tested on Frappe/ERPNext v15 and v16 | Whatever the developer targets | Varies; upgrades can lag | |
| Delivery model | Build-to-order, 2-4 weeks, installed and supported | Open-ended timeline and cost | Instant install but generic |
This is build-to-order, so delivery starts after we agree scope on a short call. Typical turnaround is 2 to 4 weeks from confirmed scope — the exact timeline depends on how many BSPs you need on day one, which ERPNext DocTypes trigger messages, and whether you require failover or embedded signup. We confirm the date in writing before work begins.
No. There is no instant download. ECOSIRE builds your version of the connector, tests it on a staging bench, and installs it on your site. You receive the source code and a git repository handover, not a locked binary.
The adapter layer covers 360dialog, Gupshup, WATI, Interakt, and Twilio out of the build. Because every BSP is a Python adapter implementing the same interface, adding another provider is a bounded piece of work — tell us during scoping and we will quote it in. Your team can also add adapters later using the documented interface.
Every build includes a post-go-live support window for defect fixes and configuration questions. Because you get the full source and git history, your own developers can maintain and extend the app. For ongoing enhancements, new BSPs, or an ERPNext version upgrade, we offer a separate support and maintenance arrangement — discussed on the scoping call.
Yes. The app is built and tested against Frappe/ERPNext v15 and v16. We confirm your exact bench version during scoping and pin the delivered app to it so it installs cleanly.
BSP API keys and tokens are stored in encrypted Frappe `Password` fields, never in plaintext DocType columns. Inbound webhooks are signature-verified and idempotent, and access is separated by Frappe role profiles so only an Administrator role can view or change provider credentials.
Yes. Sending is wired through `hooks.py` doc events and whitelisted REST methods, so any DocType — Sales Invoice, Delivery Note, Lead, Support Ticket — can fire a WhatsApp message on submit or status change via a server script, plus manual send buttons added by client scripts.
A build-to-order Frappe app that plugs ERPNext into any WhatsApp Business Solution Provider — 360dialog, Gupshup, WATI, Interakt, or Twilio — behind one unified send/receive layer, so switching providers or supporting clients on different BSPs never means rewriting your integration. ECOSIRE builds, installs, and supports it after we agree scope.