- Home
- Apps
- SaaS Tools
- Make (Integromat) Connector
Illustrative previewA 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.
What is Make (Integromat) Connector?
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 $999.00 USD; request a quote for a scoped proposal.
Key Features
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your ERPNext.
- 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
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.
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 one working week 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.
What you get
- Installable source code for the companion Frappe/ERPNext app, pinned to your v15 or v16 bench
- Make custom app definition (modules, connection, webhooks) configured against your Make organization
- Installation and configuration on your staging bench, including API user, role profile and auth setup
- Technical documentation: architecture, DocType/event mapping, whitelisted methods and payload contracts
- End-user guide plus a live training session for your Make automation builders
- Ready-to-import scenario templates seeded with your real DocType shapes
- UAT on a staging bench with a documented rollback plan before production cutover
- Git repository handover and a post-go-live support window
Who this is for
No-code automation builder
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.
Operations / RevOps lead
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.
ERPNext administrator
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.
Systems integrator / agency
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.
How Make (Integromat) Connector Compares
| Criterion | ECOSIRE | Custom Build | Competitor | ERPNext Native |
|---|---|---|---|---|
| ERPNext exposure in Make | Typed trigger/search/action modules per DocType | Whatever you hand-build per scenario | Generic REST module, no ERPNext awareness | None — only outbound webhooks |
| Real-time triggers | Instant webhooks on doc events via hooks.py | DIY webhook or polling you maintain | Usually polling only | Fires payload to one URL, no structure |
| Pagination & bulk | Transparent paging, chunked idempotent writes | You code and test it yourself | Often manual/limited | Not applicable |
| Permissions | Runs through Frappe role profile of API user | Depends on how you wire it | Broad API token, often unscoped | Full API access, no Make layer |
| Custom logic | Whitelisted methods exposed as actions | Buildable but time-consuming | Rarely supported | Not available |
| Version support | Built & tested on v15 and v16 | You own compatibility | Varies, may lag releases | Ships with ERPNext |
| Maintenance & support | Post-go-live window + optional retainer | Your team forever | Vendor tickets, no ERPNext context | Community/self-managed |
| Delivery model | Build-to-order, one working week, source handover | Open-ended internal project | Instant install but generic | Already installed |
Frequently Asked Questions about Make (Integromat) Connector
How long does delivery take?
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 one working week from confirmed scope. More DocTypes and custom actions push toward the upper end; a focused first phase can land faster.
How do updates and support work after go-live?
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.
Is this an existing Frappe Cloud Marketplace app I can install myself?
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.
Which ERPNext versions and DocTypes are supported?
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.
Will Make scenarios be able to bypass ERPNext permissions?
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.
How are large data sets and retries handled?
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.
Can it run custom logic, not just plain CRUD?
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.
Related Modules

LinkedIn Lead Gen Forms Connector for ERPNext
A build-to-order ERPNext app that captures LinkedIn Lead Gen Form submissions in real time, enriches them with company and title data, and routes them into your ERPNext CRM as attributed, auto-assigned Leads. Designed, built, and supported by ECOSIRE after a scoping call.

Live Chat & Web Chat Widget for ERPNext
An embeddable website live-chat widget that turns visitor conversations into ERPNext Leads and HD Tickets, routes chats to the right agents, and hands them page context and canned responses. Built, installed, and supported by ECOSIRE on request.

Marketing Automation Workflow Builder for ERPNext
A visual, drag-and-drop marketing automation engine built natively into ERPNext that orchestrates email, SMS and WhatsApp journeys from CRM behavior and time-based triggers. ECOSIRE builds, installs and supports it as a proper Frappe app on your own instance.

Mautic Marketing Automation Connector for ERPNext
A build-to-order Frappe app that keeps ERPNext CRM and Mautic in lock-step — two-way contact and lead sync, segment and tag mapping, event-triggered campaigns, and engagement data flowing back to your ERPNext records. ECOSIRE scopes, builds, installs and supports it on your Frappe/ERPNext v15/v16 site.
Make (Integromat) Connector
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.
- 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