Skip to main content
ERPNext Universal Marketplace Connector Framework (SDK) — A reusable ERPNext framework for building marketplace connectors —  — 1/1Illustrative preview

A reusable ERPNext framework for building marketplace connectors

— one pluggable channel adapter interface, a shared order/inventory/price sync engine, a visual field-mapping UI, and a rate-limit-aware retry queue with dead-letter handling.

ECOSIRE builds, installs, and supports the version scoped to your channels.

What is ERPNext Universal Marketplace Connector Framework (SDK)?

A reusable ERPNext framework for building marketplace connectors — one pluggable channel adapter interface, a shared order/inventory/price sync engine, a visual field-mapping UI, and a rate-limit-aware retry queue with dead-letter handling. ECOSIRE builds, installs, and supports the version scoped to your channels. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Pluggable channel adapter base class with a fixed contract (`fetch_orders`, `push_inventory`, `push_price`, `acknowledge_fulfilment`, `normalize_payload`) — new marketplace = one subclass, not a new integration
`Marketplace Channel` DocType storing per-channel credentials, base URL, sync cadence, and enable/disable flags, with secrets held in encrypted password fields
Shared bidirectional sync engine covering orders (inbound → `Sales Order`), inventory (outbound from `Bin`), and price (outbound from `Item Price`)
Visual field-mapping UI via child-table DocTypes plus a client script — map channel fields to ERPNext fields, apply transforms and defaults, and match SKUs to `Item` codes without a redeploy
`hooks.py` doc events on `Stock Ledger Entry` and `Item Price` that auto-enqueue outbound pushes so ERPNext stays the source of truth
Rate-limit-aware request queue with per-channel token-bucket throttling to avoid 429s during bulk catalogue pushes
Automatic retry with exponential backoff, classifying each failure as retryable or fatal
`Connector Error Log` DocType capturing full request/response payloads, HTTP status, and stack context for every failed call
Dead-letter queue viewable in the ERPNext desk — inspect, edit, and replay exhausted jobs from the UI
Scheduler-driven polling through Frappe `scheduler_events` running on the `long`/`default` background job queues, with cadence configurable per channel
Whitelisted methods (`@frappe.whitelist()`) exposing webhook receivers and manual-sync triggers, guarded by permissions
"Marketplace Manager" role profile separating mapping editors from log-only viewers, wired through ERPNext permissions
Idempotent order ingestion keyed on the channel order id to prevent duplicate `Sales Order` creation on webhook replays
Sync dashboard and structured logging giving per-channel status, last-run timestamps, and error counts at a glance
Built and tested for ERPNext/Frappe v15 and v16, packaged as a standard `bench get-app` installable app

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 you run an ERPNext practice or an in-house team, every new marketplace connector tends to start from a blank folder. Amazon, Noon, Shopify, Daraz, eBay, Etsy, TikTok Shop — each vendor ships a different auth model, pagination style, rate limit, and payload shape, and yet the ERPNext side is nearly identical every time: pull orders into Sales Order, push stock from Bin, keep Item Price in sync, and reconcile fulfilment back to the channel. ERPNext core gives you the DocTypes and a solid REST API, but it has no notion of a "channel", no shared sync scheduler, no mapping layer, and no retry/dead-letter machinery. So teams re-implement the same plumbing per connector, copy-paste bugs between them, and end up maintaining five slightly different codebases. That is where ERPNext runs out of road, and it is exactly the gap this framework closes.

ECOSIRE builds you a proper Frappe app — its own module, DocTypes, hooks.py, and fixtures — that factors all the common work into one reusable core. At the center is a pluggable channel adapter interface: a Python base class with a fixed contract (fetch_orders, push_inventory, push_price, acknowledge_fulfilment, normalize_payload) that each channel subclasses. A Marketplace Channel DocType holds per-channel credentials and settings, and a shared sync engine — driven by Frappe scheduler_events and background jobs on the long/default queues — walks every enabled channel on a cadence you set, so adding a new marketplace means writing one adapter, not another integration. Field mapping is data, not code: a visual mapping UI (child-table DocTypes plus a client script) lets your team map channel fields to ERPNext fields, set transforms and defaults, and match SKUs to Item codes without redeploying. hooks.py doc events keep ERPNext the source of truth — a stock movement on Stock Ledger Entry or a price change on Item Price enqueues an outbound push automatically.

Reliability is built into the core rather than bolted on. Every outbound call goes through a rate-limit-aware request queue that respects each channel's throttle (token-bucket per channel key) so you never trip 429s during a big catalogue push. Failures are captured in a Connector Error Log DocType with the full request/response, classified as retryable or fatal, and retried with exponential backoff; anything that exhausts its retries lands in a dead-letter queue an operator can inspect, edit, and replay from the ERPNext desk — no lost orders, no silent drops. Whitelisted methods (@frappe.whitelist()) expose webhook receivers and manual-sync triggers, permissions and role profiles (a "Marketplace Manager" role) gate who can edit mappings versus who can only view logs, and structured logging plus a sync dashboard give you observability across every channel at once. It targets ERPNext/Frappe v15 and v16.

Because this is build-to-order, you are not downloading a finished app — you are commissioning one scoped to the channels and DocTypes you actually use. We start with a short scoping call to confirm your target marketplaces, sync directions, and volume, then build your version of the framework (core plus the specific adapters you need to seed it), validate it on a staging bench through UAT, and hand over installable source and the git repository. Typical delivery is one working week from confirmed scope depending on how many channel adapters ship in the first release. You keep the code, so your team can author further adapters against the same interface long after go-live.

What you get

  • Installable, unobfuscated source for your version of the framework — the reusable core plus the specific channel adapters seeded in the first release
  • Installation and configuration on your bench (site setup, app install, roles, and channel/mapping configuration for your target marketplaces)
  • Technical documentation: adapter-interface reference, DocType schema, hooks and scheduler wiring, and a guide to authoring new channel adapters
  • End-user guide plus a live training session for your team covering mapping, monitoring, and dead-letter replay
  • UAT on a staging bench with sample data, plus a documented rollback plan before production cutover
  • Git repository handover so your team owns the code and can extend it independently
  • Post-go-live support window for defect fixes and configuration questions
  • Compatibility validation against your ERPNext/Frappe version (v15 or v16) with any migration notes

Who this is for

ERPNext implementation partner

A Frappe/ERPNext services firm that keeps rebuilding marketplace connectors per client. They want one framework their consultants can extend with a single adapter per channel, cutting delivery time and standardizing error handling across every engagement.

In-house ERP / integrations team

A retailer or brand running ERPNext across several marketplaces who is tired of maintaining five divergent connector scripts. They need a common sync engine, a mapping UI their operators can edit without a developer, and a dead-letter queue so no order is silently dropped.

Technical product owner scaling channels

Someone responsible for adding new sales channels quickly. They value the pluggable adapter contract and the rate-limit-aware queue so onboarding a new marketplace is a scoped, predictable task rather than a from-scratch project.

Operations manager who owns reconciliation

The person who lives in the ERPNext desk chasing failed syncs. They need the visual mapping tables, the per-channel sync dashboard, and one-click replay of dead-lettered jobs to keep orders, stock, and prices reconciled without engineering escalations.

How ERPNext Universal Marketplace Connector Framework (SDK) Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Adding a new marketplaceSubclass one adapter interface against the shared engineNew integration built from scratch each timeOnly the channels the vendor pre-builtNo channel concept at all
Field mappingVisual mapping UI editable as data, no redeployHard-coded in scripts, needs a developerFixed mapping or limited settings screenManual data entry / imports
Rate-limit handlingPer-channel token-bucket queue avoids 429sWhatever each script author remembered to addBasic or channel-specific throttlingNone
Error recoveryRetry with backoff + dead-letter replay from deskAd-hoc, varies per connectorRetry sometimes, replay rarelyFailed jobs just error out
Source code ownershipFull source + git repo handed to youYou own it but rebuild everythingClosed, licensed per installCore is open but no connector
Multi-channel consistencyOne core, one error log, one dashboardDivergent codebases drift over timePer-app silos, no shared viewNot applicable
Version supportBuilt and tested for Frappe/ERPNext v15 and v16Depends on who wrote itLags core upgradesN/A
Time to valueone working week build-to-order from confirmed scopeMonths per connectorInstant but only for supported channelsImmediate but no marketplace sync

Frequently Asked Questions about ERPNext Universal Marketplace Connector Framework

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

No. This is a build-to-order engagement, not a Frappe Cloud Marketplace download. ECOSIRE builds the framework scoped to your channels and DocTypes, installs it on your bench, and supports it. You receive installable source and the git repo at handover — there is no instant-download.

How long does delivery take?

Typical delivery is one working week from confirmed scope. The exact timeline depends on how many channel adapters ship in the first release and the complexity of your mappings and sync directions. We lock scope on the initial call, then build, run UAT on a staging bench, and cut over to production.

Which ERPNext and Frappe versions are supported?

The framework is built and tested for ERPNext/Frappe v15 and v16, packaged as a standard app you install with `bench get-app`. We validate against your specific version during UAT and provide migration notes if you are mid-upgrade.

How do updates and support work after go-live?

Every engagement includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full source and git repository, your team can author new adapters and apply changes independently; ECOSIRE can also be retained for ongoing maintenance, new-channel builds, and version upgrades separately.

Does adding a new marketplace mean a whole new project?

No — that is the point of the framework. New channels subclass one adapter base class with a fixed contract, and field mappings are configured in the UI as data rather than code. Adding a marketplace is a scoped adapter build against the shared sync engine, retry queue, and error log you already have.

How are failed syncs and rate limits handled?

Outbound calls pass through a per-channel token-bucket queue that respects each marketplace's throttle to avoid 429s. Failures are logged with full request/response detail, classified retryable or fatal, and retried with exponential backoff; exhausted jobs land in a dead-letter queue you can inspect, edit, and replay from the ERPNext desk.

Do we own the code, or are we locked in?

You own it. We hand over the git repository and unobfuscated source for your version, so your team is free to extend the framework and author further channel adapters without depending on ECOSIRE. There is no runtime license lock or per-channel fee baked into the code.

Request a quote

ERPNext Universal Marketplace Connector Framework

A reusable ERPNext framework for building marketplace connectors — one pluggable channel adapter interface, a shared order/inventory/price sync engine, a visual field-mapping UI, and a rate-limit-aware retry queue with dead-letter handling. ECOSIRE builds, installs, and supports the version scoped to your channels.

  • Pluggable channel adapter base class with a fixed contract (`fetch_orders`, `push_inventory`, `push_price`, `acknowledge_fulfilment`, `normalize_payload`) — new marketplace = one subclass, not a new integration
  • `Marketplace Channel` DocType storing per-channel credentials, base URL, sync cadence, and enable/disable flags, with secrets held in encrypted password fields
  • Shared bidirectional sync engine covering orders (inbound → `Sales Order`), inventory (outbound from `Bin`), and price (outbound from `Item Price`)
  • Visual field-mapping UI via child-table DocTypes plus a client script — map channel fields to ERPNext fields, apply transforms and defaults, and match SKUs to `Item` codes without a redeploy

Request a Quotation

Tell us about your ERPNext Universal Marketplace Connector Framework 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.