Quick facts
- Price
- $249.00 USD
- ERPNext versions
- —
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
One-time Purchase
ERPNext Fruugo Connector
A build-to-order Frappe app that connects Fruugo's 40+ country global marketplace to ERPNext, importing orders as Sales Orders, pushing multi-currency listings, and keeping inventory, pricing, shipping, and tax in sync. ECOSIRE scopes, builds, installs, and supports it for you.
$249.00USD
No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.
Key Features
Fruugo order feed pulled on `scheduler_events` and mapped to native ERPNext `Sales Order` with correct `customer`, `currency`, and `conversion_rate`
Dedicated Frappe DocTypes: `Fruugo Settings` (single), `Fruugo Marketplace Account`, `Fruugo Order Log`, and `Fruugo Sync Log`
Two-way inventory sync driven by `hooks.py` doc events on stock ledger `Bin` updates, pushing available quantity to Fruugo listings
Multi-currency listing push with per-market Price List mapping so each Fruugo country shows its localized price
Price sync triggered on `Item Price` insert/update doc events, keeping marketplace prices in step with ERPNext
Shipping and tracking writeback: `Delivery Note` submit event marks the Fruugo order line dispatched with carrier and tracking number
Localized tax handling via configurable Sales Taxes and Charges Template selection per marketplace account
SKU/item mapping layer to reconcile Fruugo product identifiers with ERPNext `Item Code` and variants
Idempotent sync jobs with sha-based dedup so retried webhooks or reruns never create duplicate Sales Orders
Rate-limit-aware API client with exponential backoff and full request/response capture in `Fruugo Sync Log`
Whitelisted server methods and Frappe REST integration, no direct DB writes bypassing the ORM
Role profiles and DocType-level permissions scoping credentials and sync controls to authorized operators
Configurable scheduler cadence (order pull, stock push, price push) tunable per environment
Manual re-sync and replay actions from the Fruugo Sync Log for failed or held records
Supports ERPNext and Frappe v15 and v16 on your own bench (self-hosted or Frappe Cloud)
About this Product
Selling on Fruugo means one catalog reaching buyers across 40+ countries in their own currency and language, but it also means every order, price change, and stock movement has to reconcile against a marketplace you do not control. Teams running ERPNext quickly hit the wall: ERPNext core has no Fruugo integration, so staff re-key orders into Sales Orders by hand, stock counts drift between the warehouse and the Fruugo listing (leading to oversells, cancellations, and damaged seller metrics), and localized pricing across dozens of currencies becomes a spreadsheet nobody trusts. There is no native DocType that speaks Fruugo's order or product feed, and no scheduler job watching for new orders or acknowledging dispatch.
Why Choose ERPNext Fruugo Connector
Fruugo order feed pulled on `scheduler_events` and mapped to native ERPNext `Sales Order` with correct `customer`, `currency`, and `conversion_rate`
Dedicated Frappe DocTypes: `Fruugo Settings` (single), `Fruugo Marketplace Account`, `Fruugo Order Log`, and `Fruugo Sync Log`
Two-way inventory sync driven by `hooks.py` doc events on stock ledger `Bin` updates, pushing available quantity to Fruugo listings
Multi-currency listing push with per-market Price List mapping so each Fruugo country shows its localized price
Price sync triggered on `Item Price` insert/update doc events, keeping marketplace prices in step with ERPNext
Shipping and tracking writeback: `Delivery Note` submit event marks the Fruugo order line dispatched with carrier and tracking number
ECOSIRE builds the ERPNext Fruugo Connector as a proper Frappe app, installed on your bench alongside ERPNext rather than bolted on as a script. It ships dedicated DocTypes: a Fruugo Settings single for credentials and endpoints, Fruugo Marketplace Account for multi-store setups, and Fruugo Order Log plus Fruugo Sync Log for full auditability. Fruugo's order feed is pulled on authenticated scheduler_events and mapped to native Sales Order records with the correct customer, currency, conversion_rate, item mapping, and Sales Taxes and Charges template, so your downstream Delivery Note and Sales Invoice flows work unchanged.
On the outbound side, listing, price, and stock synchronization run as idempotent server-side jobs. hooks.py doc events on Item, Item Price, and Bin (stock ledger updates) queue pushes to Fruugo so a price edit or a goods receipt propagates to the marketplace without manual intervention, with per-currency price list mapping so each of Fruugo's markets shows the localized price you intend. When you fulfil an order, a Delivery Note submit event writes the carrier and tracking number back to Fruugo to mark the line dispatched. All API traffic goes through whitelisted methods and the Frappe REST framework, respects rate limits with exponential backoff, and records every request and response payload in Fruugo Sync Log so failures are visible and replayable rather than silent. Role profiles and DocType permissions keep marketplace credentials and sync controls scoped to the right operators.
Because this is build-to-order, nothing is a generic download. We start with a scoping call to confirm your Fruugo account structure, currencies, tax rules, item/SKU mapping, and warehouse setup, then build against your ERPNext v15 or v16 instance. You get the installable app source, UAT on a staging bench, a rollback plan, and a post-go-live support window. Typical delivery is 2 to 4 weeks from confirmed scope, depending on how many markets and edge cases (returns, partial fulfilment, bundle SKUs) you need covered.
What you get
- Installable Frappe app source code for your commissioned version (v15/v16 compatible)
- Installation and configuration on your ERPNext instance, including Fruugo credentials and scheduler setup
- Technical documentation: DocType reference, hooks/scheduler map, API method list, and configuration guide
- End-user guide plus a live training session for your operations team
- UAT on a staging bench with a documented test plan and a rollback plan before production cutover
- Post-go-live support window for bug fixes and adjustments after launch
- Git repository handover with full commit history and README
- Item/SKU and multi-currency mapping configured to your Fruugo account structure
Who this is for
Cross-border ERPNext seller
A merchant using Fruugo's 40+ country reach who runs operations in ERPNext and needs orders, stock, and localized prices to flow automatically instead of being re-keyed across currencies.
E-commerce operations manager
Owns marketplace fulfilment and hates oversells. Wants two-way inventory sync, dispatch/tracking writeback, and a Sync Log that shows exactly what failed and why, so seller metrics stay healthy.
ERPNext administrator / Frappe developer
Responsible for the bench. Wants a proper installable app with clean DocTypes, `hooks.py` doc events, whitelisted methods, and permissions, not a fragile external script, plus a git handover they can maintain.
Finance / tax lead
Needs each market's currency conversion, price list, and Sales Taxes and Charges template applied correctly on the generated Sales Orders and invoices, so reporting and VAT/GST reconcile cleanly.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the ERPNext Fruugo Connector app ZIP from your account dashboard.
Add the app to your bench
Extract the ZIP into your bench's apps folder, or run `bench get-app` with the path to the extracted app.
Install on your site
Run `bench --site SITE_NAME install-app APP_NAME` followed by `bench migrate` to install ERPNext Fruugo Connector and apply its schema.
Activate your license
Open the ECOSIRE License settings on your site and activate your license key. Requires the free ecosire_connect and ecosire_license_client apps.
How ERPNext Fruugo Connector Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Fruugo integration | Purpose-built Frappe app for Fruugo's order and product feed | Built from scratch in-house, long timeline | Generic marketplace app, Fruugo often unsupported or partial | |
| Order import | Auto-mapped to native Sales Order with currency and tax | Depends entirely on your dev team's build | Basic import, limited field/tax mapping | |
| Inventory sync | Two-way, event-driven on stock ledger updates | Possible but you design and maintain it | Often one-way or scheduled-only | |
| Multi-currency pricing | Per-market Price List mapping across 40+ countries | You build the currency logic yourself | Limited currency handling | |
| Shipping/tracking writeback | Automatic on Delivery Note submit | Custom code required | Sometimes missing or manual | |
| Auditability | Fruugo Sync Log with replay of failed records | Only what you choose to build | Basic logs, limited replay | |
| Fit and ownership | Scoped to your account; git repo handover | Full ownership but full build cost/risk | One-size-fits-all, closed source | |
| Support and updates | Post-go-live window plus optional retainer | Your team maintains it | Vendor SLA varies, API-change risk |
Frequently Asked Questions about ERPNext Fruugo Connector
Is this an existing app I can download and install today?
No. The ERPNext Fruugo Connector is build-to-order. ECOSIRE scopes, builds, installs, and supports it for your specific ERPNext instance, Fruugo account structure, currencies, and tax rules. It is not a generic Frappe Cloud Marketplace download.
How long does delivery take?
Typical delivery is 2 to 4 weeks from confirmed scope. The exact timeline depends on how many Fruugo markets and currencies you sell in and which edge cases (returns, partial fulfilment, bundle SKUs, complex tax rules) need to be covered. We confirm the estimate after the scoping call.
Which ERPNext and Frappe versions are supported?
We build for ERPNext and Frappe v15 and v16, on self-hosted benches or Frappe Cloud. We target the version your production instance runs so the app is validated against your exact environment before go-live.
How does the order and inventory sync actually work?
Orders are pulled from Fruugo's feed on Frappe `scheduler_events` and created as native `Sales Order` records. Stock and price changes are pushed back via `hooks.py` doc events on `Bin` (stock ledger) and `Item Price`, and dispatch details are written back on `Delivery Note` submit. All traffic runs through whitelisted methods with retries and is logged in `Fruugo Sync Log`.
What about support and updates after launch?
Every build includes a post-go-live support window for bug fixes and adjustments. Beyond that, we offer optional ongoing support and maintenance retainers to cover Fruugo API changes, ERPNext version upgrades, and new feature requests. You also receive the git repository so your own team can maintain it.
Will it handle multiple currencies and localized pricing correctly?
Yes. Fruugo listings are pushed per market with per-currency Price List mapping, and incoming orders carry the right `currency` and `conversion_rate` onto the Sales Order, with a configurable Sales Taxes and Charges Template per marketplace account so tax reporting stays correct.
Can we test before it goes live on production?
Yes. We run UAT on a staging bench with a documented test plan covering order import, stock/price push, and dispatch writeback, and we prepare a rollback plan before any production cutover.
Related Modules
Request a quote
ERPNext Fruugo Connector
A build-to-order Frappe app that connects Fruugo's 40+ country global marketplace to ERPNext, importing orders as Sales Orders, pushing multi-currency listings, and keeping inventory, pricing, shipping, and tax in sync. ECOSIRE scopes, builds, installs, and supports it for you.
- Fruugo order feed pulled on `scheduler_events` and mapped to native ERPNext `Sales Order` with correct `customer`, `currency`, and `conversion_rate`
- Dedicated Frappe DocTypes: `Fruugo Settings` (single), `Fruugo Marketplace Account`, `Fruugo Order Log`, and `Fruugo Sync Log`
- Two-way inventory sync driven by `hooks.py` doc events on stock ledger `Bin` updates, pushing available quantity to Fruugo listings
- Multi-currency listing push with per-market Price List mapping so each Fruugo country shows its localized price