A build-to-order ERPNext integration that exposes your DocTypes to Make.com as instant triggers, searches and actions, so your team automates ERPNext visually without writing scenario glue code. ECOSIRE builds, installs and supports it after you request a quotation. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $249.00 USD; request a quote for a scoped proposal.

A build-to-order ERPNext integration that exposes your DocTypes to Make.com as instant triggers, searches and actions, so your team automates ERPNext visually without writing scenario glue code. ECOSIRE builds, installs and supports it after you request a quotation.
अभी कोई भुगतान नहीं। यह हमारी टीम को एक कोटेशन अनुरोध भेजता है — हम कीमत और अगले चरणों के साथ ईमेल द्वारा संपर्क करेंगे।
Most teams that live in Make.com hit the same wall with ERPNext: the platform has a solid REST API, but wiring it into scenarios by hand means hand-authoring HTTP modules, managing token headers, hand-parsing pagination, and re-deriving the JSON shape of every DocType each time. There is no first-class Make app for ERPNext, so Sales Order, Customer, Item and custom DocTypes never show up as clean, typed modules. Native ERPNext webhooks fire on doc events but only push generic payloads to a single URL — they cannot search, they cannot fan out, and they give a no-code builder no structured trigger to react to. The result is brittle scenarios that break the moment a fieldname or filter changes.
Make custom app publishing ERPNext DocTypes as typed trigger, search, get, create and update modules — not raw HTTP blocks
Instant webhook triggers registered and torn down through the Make lifecycle, firing on `after_insert`, `on_update`, `on_submit` and `on_cancel`
Companion Frappe app with `hooks.py` doc-event handlers that emit clean, versioned JSON payloads per nominated DocType
Whitelisted server-side methods (`@frappe.whitelist()`) exposing custom actions and computed logic as single Make modules
Search modules mapped onto the Frappe REST API with ERPNext filter syntax (operators, `filters`, `or_filters`, field selection)
Transparent cursor / `limit_start` + `limit_page_length` pagination so large result sets stream in batches without scenario timeouts
ECOSIRE builds a proper Make custom app backed by a dedicated Frappe app installed on your bench. On the ERPNext side we ship a real app/module with hooks.py doc-event handlers and whitelisted server-side methods that emit clean, versioned JSON to Make on after_insert, on_update, on_submit and on_cancel for whichever DocTypes you nominate. Instant webhook triggers are registered and de-registered through the Make lifecycle so scenarios light up the moment a document changes state, with no polling lag. On the Make side, the custom app exposes typed modules — searches (list Sales Invoice by filter), gets (fetch one Customer by name), creates and updates — mapped onto the Frappe REST API and our whitelisted methods, with connection auth handled through API key/secret or token so builders never paste credentials into raw HTTP blocks.
Under the hood the connector respects ERPNext's own guardrails. Every read and write flows through Frappe's permission engine, so a Make connection inherits the role profile and DocType permissions of the API user you assign — a scenario cannot bypass row-level or field-level rules. We handle cursor and page-length pagination transparently so a search over thousands of records streams through in batches instead of timing out, and bulk create/update operations are chunked and idempotent to survive Make retries. Where a workflow needs logic that doesn't belong in a scenario — recomputing totals, validating against another DocType, calling a scheduler event — we implement it as a whitelisted method or server script and expose it as a single Make action. The app targets Frappe/ERPNext v15 and v16.
Because this is build-to-order, nothing ships until we agree on scope. We start with a short scoping call to map the exact DocTypes, trigger events, searches and actions you need, plus your Make organization and auth model. You get installable source for your version, a set of ready-to-import scenario templates seeded with your real DocType shapes, and technical documentation. Typical delivery is 2-4 weeks from confirmed scope, depending on how many DocTypes and custom actions are involved. We validate everything on a staging bench with UAT and a rollback plan before it touches production, then hand over the git repository and stay on through a post-go-live support window.
Lives in Make.com and wants ERPNext to appear as first-class typed modules — instant triggers, searches, create/update actions — so they can build scenarios visually instead of hand-authoring HTTP calls and parsing JSON.
Owns the cross-tool workflows (CRM, forms, billing, messaging) and needs ERPNext orders, invoices and customers to sync reliably in real time, with retries and pagination handled rather than firefighting broken scenarios.
Responsible for data integrity and permissions; wants every Make connection to run under a scoped API user and role profile, with writes going through Frappe's validation, not a back door around it.
Delivers Make automations for clients on ERPNext and needs a maintainable, version-pinned connector plus scenario templates they can hand over, rather than rebuilding fragile HTTP glue on every engagement.
Buy the license on ecosire.com and download the Make (Integromat) Connector 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 Make (Integromat) Connector 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 |
|---|---|---|---|---|
| ERPNext exposure in Make | Typed trigger/search/action modules per DocType | Whatever you hand-build per scenario | Generic REST module, no ERPNext awareness | |
| Real-time triggers | Instant webhooks on doc events via hooks.py | DIY webhook or polling you maintain | Usually polling only | |
| Pagination & bulk | Transparent paging, chunked idempotent writes | You code and test it yourself | Often manual/limited | |
| Permissions | Runs through Frappe role profile of API user | Depends on how you wire it | Broad API token, often unscoped | |
| Custom logic | Whitelisted methods exposed as actions | Buildable but time-consuming | Rarely supported | |
| Version support | Built & tested on v15 and v16 | You own compatibility | Varies, may lag releases | |
| Maintenance & support | Post-go-live window + optional retainer | Your team forever | Vendor tickets, no ERPNext context | |
| Delivery model | Build-to-order, 2-4 weeks, source handover | Open-ended internal project | Instant install but generic |
This is a build-to-order product, so nothing is downloaded off a shelf. After a short scoping call to confirm the DocTypes, triggers, searches and actions you need, typical delivery is 2-4 weeks from confirmed scope. More DocTypes and custom actions push toward the upper end; a focused first phase can land faster.
Every engagement includes a post-go-live support window during which we fix defects and help tune scenarios. Because you receive the git repository and version-pinned source, you own the code. We can also cover ongoing maintenance, ERPNext v15-to-v16 upgrades and new DocType/action additions under a separate support agreement.
No. There is no first-class Make app for ERPNext, and this is not a marketplace one-click install. ECOSIRE builds the companion Frappe app and the Make custom app to your scope, then installs and configures both on your bench and Make organization.
We build and test against Frappe/ERPNext v15 and v16. Any standard or custom DocType can be exposed as triggers and modules — `Sales Order`, `Sales Invoice`, `Customer`, `Item`, leads, projects, and your own custom DocTypes. We confirm the exact list during scoping so the modules match your data model.
No. Every read and write flows through Frappe's permission engine using the API user you assign, so the connection inherits that user's role profile and DocType-level permissions. You control exactly what a Make connection can see and change by scoping the user's roles.
Search modules handle pagination transparently using `limit_start` and `limit_page_length`, streaming large result sets in batches so scenarios don't time out. Bulk create and update operations are chunked and made idempotent, so Make's automatic retries won't create duplicate documents.
Yes. Where a workflow needs logic beyond read/write — recomputing totals, validating against another DocType, or triggering a process — we implement it as a whitelisted method or server script and expose it as a single, clean Make action, rather than making you stitch it together in the scenario.
A build-to-order ERPNext integration that exposes your DocTypes to Make.com as instant triggers, searches and actions, so your team automates ERPNext visually without writing scenario glue code. ECOSIRE builds, installs and supports it after you request a quotation.