Skip to main content
Make (Integromat) Connector — A build-to-order ERPNext integration that exposes your DocTypes to Make — 1/1Illustrative preview

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.

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

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
Chunked, idempotent bulk create/update handling that survives Make's automatic retries without duplicating documents
Connection auth via API key/secret or token — credentials configured once on the Make connection, never pasted into modules
Reads and writes flow through Frappe's permission engine, inheriting the assigned API user's role profile and DocType permissions
Ready-to-import scenario templates seeded with your actual DocType field shapes for common flows (lead-to-quote, invoice sync, stock updates)
Field-level data pills and dynamic mapping so builders see real ERPNext fieldnames and link fields, including child tables
Optional scheduler-event and server-script hooks for logic that shouldn't live in a scenario (revalidation, cross-DocType checks)
Structured error surfacing — ERPNext validation and permission errors returned to Make as typed, catchable module errors
Built and tested against Frappe/ERPNext v15 and v16 with a version-pinned source drop per your environment

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

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

CriterionECOSIRECustom BuildCompetitorERPNext Native
ERPNext exposure in MakeTyped trigger/search/action modules per DocTypeWhatever you hand-build per scenarioGeneric REST module, no ERPNext awarenessNone — only outbound webhooks
Real-time triggersInstant webhooks on doc events via hooks.pyDIY webhook or polling you maintainUsually polling onlyFires payload to one URL, no structure
Pagination & bulkTransparent paging, chunked idempotent writesYou code and test it yourselfOften manual/limitedNot applicable
PermissionsRuns through Frappe role profile of API userDepends on how you wire itBroad API token, often unscopedFull API access, no Make layer
Custom logicWhitelisted methods exposed as actionsBuildable but time-consumingRarely supportedNot available
Version supportBuilt & tested on v15 and v16You own compatibilityVaries, may lag releasesShips with ERPNext
Maintenance & supportPost-go-live window + optional retainerYour team foreverVendor tickets, no ERPNext contextCommunity/self-managed
Delivery modelBuild-to-order, one working week, source handoverOpen-ended internal projectInstant install but genericAlready 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.

Request a quote

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

Request a Quotation

Tell us about your Make (Integromat) 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.