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.
Sem pagamento agora. Isto envia um pedido de orçamento à nossa equipe — responderemos por e-mail com preços e próximos passos.
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.
Compre a licença em ecosire.com e baixe o ZIP do aplicativo Make (Integromat) Connector no painel da sua conta.
Extraia o ZIP na pasta de aplicativos do seu banco ou execute `bench get-app` com o caminho para o aplicativo extraído.
Execute `bench --site SITE_NAME install-app APP_NAME` seguido de `bench Migra` para instalar Make (Integromat) Connector e aplicar seu esquema.
Abra as configurações de licença ECOSIRE em seu site e ative sua chave de licença. Requer os aplicativos gratuitos ecosire_connect e ecosire_license_client.
| Critério | ECOSIRE | Construção personalizada | Concorrente | Odoo nativo |
|---|---|---|---|---|
| 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 2Checkout (Verifone) payment integration for ERPNext, giving global digital-goods sellers card acceptance, 45+ local payment methods, multi-currency checkout, and reconciled invoices. ECOSIRE scopes, builds, installs, and supports it on your ERPNext v15/v16 instance.

A build-to-order 2Checkout / Verifone payment gateway for Magento 2 and Adobe Commerce: localized checkout in 12 languages, iDEAL, Giropay and regional methods, multi-currency global selling, subscription billing and tax/invoicing automation — engineered, installed and supported by ECOSIRE.

A build-to-order ERPNext application for anonymous 360-degree reviews — configurable peer, manager, report and self rater groups, weighted competency scoring, and aggregated gap-analysis and heatmap reports. ECOSIRE scopes, builds, installs and supports it on your Frappe/ERPNext v15/v16 instance.
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.