Skip to main content
WATI Connector for ERPNext — A build-to-order Frappe app that links WATI and ERPNext with two-way contact and chat sync, orde — 1/1Illustrative preview

A build-to-order Frappe app that links WATI and ERPNext with two-way contact and chat sync,

order and invoice notifications, template triggers from DocType events, and inbound-message capture into Leads or Tickets.

ECOSIRE builds, installs, and supports it for your bench.

What is WATI Connector for ERPNext?

A build-to-order Frappe app that links WATI and ERPNext with two-way contact and chat sync, order and invoice notifications, template triggers from DocType events, and inbound-message capture into Leads or Tickets. ECOSIRE builds, installs, and supports it for your bench. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Two-way `Contact` sync: WATI contacts upsert into ERPNext `Contact`/`Customer`, and ERPNext contact edits push back to WATI with configurable field mapping
Order and invoice status notifications fired from `Sales Order`/`Sales Invoice` `on_submit`/`on_update` doc events via approved WATI templates
Template trigger engine bound in `hooks.py`: map any DocType + doc event to a specific WATI template with per-field parameter substitution
Inbound WATI webhook landed on a whitelisted method (`@frappe.whitelist(allow_guest=True)`) with payload signature verification
Inbound-message routing rules that create a `Lead` or `HD Ticket` (Helpdesk) and assign it per your team's ownership logic
Broadcast list sync: ERPNext filters/segments map to WATI broadcast lists, reconciled on a schedule so membership stays current
`WATI Settings` (Single) DocType for endpoint, access token, and defaults — no credentials hardcoded in source
All outbound API calls run through `frappe.enqueue` background jobs so document saves are never blocked by WATI latency
`WATI Message Log` DocType records every inbound/outbound call with status, payload, idempotency key, and one-click retry
Dedicated `WATI Integration` role profile controlling who can edit settings, view logs, and trigger manual sends
Scheduler events (`scheduler_events`) for daily contact/broadcast reconciliation and stuck-message retry sweeps
Configurable send cooldowns and de-duplication so a rapid sequence of doc updates doesn't spam the customer
Client scripts adding a 'Send WATI message' action and live delivery status onto `Contact`/`Customer`/`Sales Order` forms
Full compatibility with Frappe/ERPNext v15 and v16, packaged as an installable app with pinned dependencies

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

If your team runs sales and support on WATI but everything of record lives in ERPNext, you spend the day copying between two tabs. A customer messages on WhatsApp through WATI, but their Contact and Customer history sits in ERPNext; an order ships, but nobody fires the "your order is on the way" template; a prospect replies to a broadcast, and that intent never becomes a Lead. ERPNext core has notifications and the odd webhook, but it has no native concept of a WATI session, template, or broadcast list — so the two systems stay stitched together by humans, and the seams show as missed messages and stale records.

The WATI Connector is a proper Frappe app (its own module, DocTypes, and hooks.py) that ECOSIRE builds and installs onto your bench, running natively on ERPNext v15/v16. On the ERPNext side we add configuration DocTypes — a single WATI Settings (Single) DocType holding the API endpoint and access token, plus mapping DocTypes for template-to-DocType-event bindings and broadcast-list membership. Outbound flows hang off hooks.py doc events (on_submit, on_update, after_insert): when a Sales Order or Sales Invoice reaches the right state, a background job (enqueued via frappe.enqueue, never blocking the user's save) calls the WATI API to send the mapped approved template with field-level parameter mapping from the source document. Inbound flows arrive on a whitelisted method (@frappe.whitelist(allow_guest=True)) registered as your WATI webhook; we verify the payload, upsert the Contact, thread the message onto the linked record, and — per your rules — create a Lead or a HD Ticket and route it. A daily scheduler_events job reconciles contacts and broadcast-list membership so the two directories don't drift.

Everything is driven by your data and your permission model. Template-to-event mappings, cooldowns, and routing live in DocTypes so your admins tune behavior without a code change; server scripts and client scripts we author cover the org-specific logic; and a dedicated WATI Integration role profile scopes who can edit settings, view message logs, and trigger manual sends. Sync state and every API call are logged to a WATI Message Log DocType with retry and idempotency keys, so a failed WATI call is visible and replayable rather than silently lost. Where you already have custom fields on Customer or Sales Order, we map to them rather than duplicating.

Because this is build-to-order, nothing ships until we agree on scope. We start with a short scoping call, confirm which DocTypes and events drive messages, which templates are already approved in your WATI account, and how inbound replies should route. You get your own versioned build of the app installed on a staging bench first, UAT against real documents, then a scheduled production go-live with a rollback plan and the git repository handed to you. Typical delivery is one working week from confirmed scope, depending on how many event triggers and routing rules are in play.

What you get

  • Installable source code for your versioned build of the WATI Connector Frappe app, pinned to your Frappe/ERPNext v15 or v16 bench
  • Installation and configuration on your staging and production benches, including `WATI Settings`, webhook registration, and role-profile setup
  • Technical documentation: DocType reference, hooks/doc-event map, whitelisted endpoints, scheduler jobs, and environment/API-key setup
  • End-user guide plus a live training session for your admins and support team
  • UAT on a staging bench against real documents, with a documented rollback plan before production go-live
  • Post-go-live support window for defect fixes and configuration adjustments
  • Handover of the private git repository with commit history, README, and upgrade notes

Who this is for

E-commerce seller on WATI + ERPNext

Runs WhatsApp sales and support through WATI while fulfilling from ERPNext. Needs order/shipping/invoice notifications fired automatically from `Sales Order` and `Sales Invoice` events, and replies captured back as records instead of lost chats.

SMB support/CS lead

Manages a shared WATI inbox and wants every inbound message to become a routed `Lead` or `HD Ticket` in ERPNext, with contact history unified so agents see the full customer picture in one system.

ERPNext administrator / implementation partner

Owns the bench and the permission model. Wants a clean Frappe app with its own module, DocTypes, and role profile — configurable via UI without code changes — plus the git repo and docs to maintain it after handover.

Sales/marketing manager

Runs WATI broadcasts and needs ERPNext customer segments to sync into broadcast lists automatically, so campaign audiences stay accurate as the customer base changes.

How WATI Connector for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Delivery modelBuild-to-order app installed on your bench, source handed overYou hire/allocate a Frappe developer to build from scratchGeneric marketplace app, install yourselfNo WATI concept exists in core
Two-way contact & chat syncBi-directional upsert with your field mappingPossible but you design and test it allOften one-way or fixed field mappingManual copy between WATI and ERPNext
Order/invoice notificationsFired from `Sales Order`/`Sales Invoice` doc events via approved templatesBuild the doc-event and template logic yourselfLimited to the events the vendor choseEmail/print only; no WhatsApp templates
Inbound → Lead/TicketRouted to `Lead` or `HD Ticket` per your rulesCustom webhook + routing you own end to endUsually logs a message, not routed recordsNot available
Fit to your DocTypes/permissionsMaps to your custom fields + dedicated role profileFully yours, but full build cost and riskFixed schema, adapt your process to itN/A
Reliability & retries`frappe.enqueue` jobs + `WATI Message Log` with idempotent retryYou must design logging and retry yourselfVaries; often minimal visibilityN/A
Support & upgradesPost-go-live window + optional v15/v16 upgrade supportWhoever built it, if still availableVendor SLA, often generic queueCommunity/self-support
Cost profileFixed scoped quote, no core changesHighest and least predictableLow licence fee, hidden fit/customization costFree, but the integration doesn't exist

Frequently Asked Questions about WATI Connector

Is this an app I can download and install myself right now?

No. The WATI Connector is build-to-order: ECOSIRE builds a version scoped to your ERPNext setup, then installs and configures it on your bench. There is no instant self-download. You receive installable source and the git repository as part of handover.

How long does delivery take?

Typical delivery is one working week from confirmed scope. The exact timeline depends on how many DocType/event triggers, routing rules, and broadcast segments you need. We lock scope on the initial call, build and demo on a staging bench, then schedule production go-live.

How does ongoing support and updates work?

Every build includes a post-go-live support window for defect fixes and configuration tweaks. Beyond that we offer a support/maintenance arrangement covering ERPNext version upgrades (v15/v16 and forward), WATI API changes, and new template or routing requirements. Because you hold the git repo, you or your own team can also maintain it.

Do I need an existing WATI account and approved templates?

Yes. WATI is a paid WhatsApp Business platform; you provide the account and access token, and WhatsApp-approved message templates must exist in WATI before we can bind them to ERPNext events. We map your existing approved templates to the relevant DocTypes during the build.

Will this modify ERPNext core or break upgrades?

No. It ships as a separate Frappe app with its own module, DocTypes, `hooks.py`, and role profile. It uses doc events, whitelisted methods, server/client scripts, and scheduler events — the supported extension points — so ERPNext core stays untouched and standard `bench update` upgrades remain safe.

What happens if a WATI API call fails?

Outbound calls run as `frappe.enqueue` background jobs and every call is written to a `WATI Message Log` DocType with status and an idempotency key. Failed sends are visible and replayable with one click, and a scheduled sweep retries stuck messages — nothing is silently dropped.

Can inbound messages route to different teams or as tickets vs leads?

Yes. Routing is configurable: an inbound WATI message can upsert the `Contact`, create a `Lead` for sales or an `HD Ticket` for support, and assign to the right owner based on rules we define with you during scoping. The logic lives in server scripts and mapping DocTypes so admins can adjust it later.

Request a quote

WATI Connector

A build-to-order Frappe app that links WATI and ERPNext with two-way contact and chat sync, order and invoice notifications, template triggers from DocType events, and inbound-message capture into Leads or Tickets. ECOSIRE builds, installs, and supports it for your bench.

  • Two-way `Contact` sync: WATI contacts upsert into ERPNext `Contact`/`Customer`, and ERPNext contact edits push back to WATI with configurable field mapping
  • Order and invoice status notifications fired from `Sales Order`/`Sales Invoice` `on_submit`/`on_update` doc events via approved WATI templates
  • Template trigger engine bound in `hooks.py`: map any DocType + doc event to a specific WATI template with per-field parameter substitution
  • Inbound WATI webhook landed on a whitelisted method (`@frappe.whitelist(allow_guest=True)`) with payload signature verification

Request a Quotation

Tell us about your WATI Connector 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.