Skip to main content
ERPNext Salla Connector — A build-to-order Frappe app that keeps your Salla storefront and ERPNext in continuous two-way sync — 1/1Illustrative preview

A build-to-order Frappe app that keeps your Salla storefront and ERPNext in continuous two-way sync

— orders, stock, pricing, catalog and shipping.

ECOSIRE scopes, builds, installs and supports it for your specific setup.

What is ERPNext Salla Connector?

A build-to-order Frappe app that keeps your Salla storefront and ERPNext in continuous two-way sync — orders, stock, pricing, catalog and shipping. ECOSIRE scopes, builds, installs and supports it for your specific setup. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Dedicated Frappe app with its own module, `Salla Settings` single DocType, `Salla Sync Log` and mapping child tables — installed on your bench, not loose scripts
Whitelisted webhook receiver (`@frappe.whitelist(allow_guest=True)`) for `order.created`, `order.updated` and `order.status.updated` with HMAC signature verification
Salla OAuth2 token storage and automatic refresh handled inside `Salla Settings`, encrypted at rest
Inbound order mapping: Salla payload to ERPNext `Sales Order` (or draft `Sales Invoice`) with Customer resolution, Item-code matching, tax and shipping lines
Two-way inventory sync with ERPNext as source of truth, driven by `hooks.py` doc events on `Stock Ledger Entry` and configurable warehouse-to-Salla mapping
Two-way price sync from `Item Price` (per price list) pushed to Salla, with rounding and currency rules you define
Catalog push: create/update Salla products from ERPNext `Item` including SKU, variants, images and descriptions
Shipping & tracking writeback — carrier and tracking number on the `Delivery Note` update the Salla order to shipped and trigger customer notification
ZATCA-compatible invoice field mapping (VAT breakdown, buyer/seller identifiers) aligned to Fatoora Phase 2 so it complements your existing ZATCA setup
Scheduled reconciliation via `scheduler_events` that sweeps for missed webhooks and retries failed rows with exponential backoff
Full `Salla Sync Log` audit trail — every inbound/outbound record, payload, status and error message, with re-queue actions
Client scripts and workspace shortcuts for operator actions (manual re-sync, force-push a product, replay a failed order)
Permissions and role-profile enforcement so only authorized roles can change sync settings or replay records
Idempotent processing keyed on Salla order/product IDs to prevent duplicate Sales Orders on webhook retries
Built and tested against Frappe/ERPNext v15 and v16, upgrade-safe (no core patches — pure app + hooks)

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 a Saudi D2C brand on Salla and your back office on ERPNext, the gap between the two is where the day gets lost. Sales come in on Salla while stock levels, fulfillment status and invoices live in ERPNext, so someone spends the morning re-keying orders, reconciling quantities and chasing why the storefront still shows an item that sold out two hours ago. ERPNext core has no native concept of Salla — there is no built-in integration, no webhook listener for Salla's events, and no field mapping between a Salla order and an ERPNext Sales Order. You can export CSVs, but that is a nightly batch at best and it never touches live inventory. This is exactly where a purpose-built connector earns its place.

We build the ERPNext Salla Connector as a proper Frappe app installed on your bench — its own module, its own DocTypes, and its own settings, not a pile of loose scripts. A Salla Settings single DocType holds your OAuth2 credentials, store ID and sync toggles; child DocTypes and a Salla Sync Log give you a full audit trail of every record that moved and every error that didn't. Inbound, we register a whitelisted endpoint (via @frappe.whitelist()) that receives Salla webhooks for order.created, order.updated and order.status.updated, verifies the signature, and maps the payload to a Sales Order (or draft Sales Invoice) with the right Customer, Item codes, taxes, shipping line and payment reference. Outbound, hooks.py doc events on Stock Ledger Entry, Item Price and Item push inventory and price changes back to Salla through its REST API, so a stock movement in your warehouse updates the storefront without anyone touching a keyboard.

Technically it is built to ERPNext conventions so your team can own it. Two-way inventory and price sync is reconciled against ERPNext as the source of truth, with configurable warehouse-to-Salla mapping and a scheduled scheduler_events job that sweeps for anything a webhook missed and reprocesses failed rows with backoff. Catalog push creates or updates Salla products from ERPNext Item records (name, SKU, price, variants, images). Shipping and tracking numbers written on the Delivery Note flow back to Salla to move the order to shipped and notify the customer. Invoice mapping is structured to be ZATCA-compatible — VAT breakdown, buyer/seller fields and the data points Saudi e-invoicing (Fatoora Phase 2) expects — so it lines up cleanly with your ZATCA setup rather than fighting it. Everything respects ERPNext permissions and role profiles, ships with client scripts for the operator-facing actions, and targets Frappe/ERPNext v15 and v16.

Because every Salla store and ERPNext instance is configured differently, this is build-to-order — not a one-click marketplace download. We start with a short scoping call to map your exact order flow, tax setup, warehouses and edge cases, then build the connector against your real data on a staging bench. Typical delivery is one working week from confirmed scope. You receive the full source code, install it on your bench (or we do), and get a UAT sign-off on staging plus a rollback plan before go-live. After launch you keep a support window and the git repo, so nothing about the integration is a black box.

What you get

  • Installable Frappe app source code for your ERPNext version (v15 or v16), scoped to your store
  • Installation and configuration on your bench (or a documented, repeatable install if your team deploys)
  • Technical documentation: DocType reference, field-mapping tables, webhook/endpoint spec, hooks and scheduler jobs
  • Operator user guide plus a live training session for your fulfillment and finance teams
  • UAT on a staging bench against your real data, with a documented rollback plan before go-live
  • Post-go-live support window for bug fixes and sync issues (duration set in your quotation)
  • Git repository handover with full commit history — you own the code
  • Configuration workbook capturing warehouse/price-list/tax mappings and Salla credentials setup

Who this is for

Saudi D2C merchant on Salla

Runs a growing consumer brand selling through a Salla storefront and manages inventory, purchasing and finance in ERPNext. Needs orders to land in ERPNext automatically and stock to stop overselling, without a person re-keying every sale.

Operations / fulfillment lead

Owns order-to-ship and hates duplicate data entry. Wants Salla orders to become Sales Orders and Delivery Notes cleanly, and tracking numbers to flow back to Salla so customers get notified without manual updates.

Finance / ZATCA compliance owner

Responsible for VAT and Saudi e-invoicing. Needs Salla sales mapped to ERPNext invoices with correct tax breakdown and the fields ZATCA Phase 2 (Fatoora) expects, so compliance reporting is clean rather than reconstructed by hand.

ERPNext administrator / IT

Maintains the bench and worries about upgrade safety and ownership. Wants a proper Frappe app with hooks and DocTypes (no core patches), respecting permissions and role profiles, plus the git repo so the team can maintain it on v15/v16.

How ERPNext Salla Connector Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Salla integrationPurpose-built connector for your exact order and tax flowWhatever your dev writes from scratchGeneric mapping, may not fit Salla's KSA specificsNone — no Salla awareness in ERPNext core
Order syncWebhook-driven Salla to Sales Order, idempotentDepends on build quality and time budgetOften polling/batch, limited field mappingManual re-entry or CSV import
Inventory & price syncTwo-way, ERPNext as source of truth, reconciledPossible but costly to get reliableFrequently one-way or stock-onlyNot available
ZATCA invoice mappingFields aligned to Fatoora Phase 2, scoped to your setupMust be researched and built yourselfRarely KSA/ZATCA-awareGeneric invoice, no Salla link
Upgrade safetyPure Frappe app, hooks/DocTypes, no core patchesRisk of core edits that break on upgradeVaries; may lag ERPNext releasesN/A
Support & fix pathPost-go-live window + direct ECOSIRE supportOnly your own teamVendor tickets, generic priorityCommunity forums
Code ownershipFull source + git repo handover to youYou own it (if it's finished)Usually closed / license-lockedN/A
Time to liveTypically one working week from confirmed scopeUnpredictable; often monthsFast install, slow to fit realityImmediate but does nothing for Salla

Frequently Asked Questions about ERPNext Salla Connector

How long until it's live? Can I download it now?

This is build-to-order, not an instant download. After a scoping call we build the connector against your real Salla store and ERPNext instance on a staging bench. Typical delivery is one working week from confirmed scope, depending on how many order flows, warehouses and tax edge cases you have. You get a firm timeline in your quotation before we start.

How do updates and support work after go-live?

Every build includes a post-go-live support window (duration set in your quotation) covering bug fixes and sync issues. You also receive the full git repository, so your team can maintain or extend the app independently. Beyond the initial window we offer ongoing support and compatibility updates — for example when Salla changes its API or you upgrade ERPNext — on a separate agreement.

Is the invoice mapping actually ZATCA compliant?

The connector maps Salla sales to ERPNext invoices with the VAT breakdown, buyer/seller identifiers and data points that ZATCA Phase 2 (Fatoora) expects, so it lines up cleanly with your ZATCA e-invoicing setup. It complements your ZATCA integration rather than replacing it — during scoping we confirm exactly how your Fatoora submission is handled and map the fields to match.

Which ERPNext and Frappe versions are supported?

We build and test against Frappe/ERPNext v15 and v16. It's a standard Frappe app using DocTypes, `hooks.py` doc events, whitelisted methods and scheduler events — no patches to ERPNext core — so it stays upgrade-safe. Tell us your exact version during scoping and we target that.

How does the two-way sync avoid overselling and duplicate orders?

ERPNext is treated as the source of truth for stock and price. Inventory changes fire on `Stock Ledger Entry` doc events and push to Salla; a scheduled reconciliation job catches anything a webhook missed. Inbound order processing is idempotent, keyed on the Salla order ID, so webhook retries never create duplicate Sales Orders. Every action is recorded in the `Salla Sync Log`.

Do I need to give you access to my production system?

No production access is required to build. We develop and run UAT on a staging bench with representative data. For installation you can either grant scoped access for us to deploy, or your team installs from the delivered source using our documented steps. A rollback plan is agreed before any go-live on production.

What if I sell on Salla and other channels too?

The connector is built for Salla specifically, but it's designed so ERPNext stays the single source of truth, which makes it safe to run alongside other channel integrations. If you need additional marketplaces connected, we scope those as separate connectors that share the same ERPNext-as-truth model so stock and pricing stay consistent across channels.

Request a quote

ERPNext Salla Connector

A build-to-order Frappe app that keeps your Salla storefront and ERPNext in continuous two-way sync — orders, stock, pricing, catalog and shipping. ECOSIRE scopes, builds, installs and supports it for your specific setup.

  • Dedicated Frappe app with its own module, `Salla Settings` single DocType, `Salla Sync Log` and mapping child tables — installed on your bench, not loose scripts
  • Whitelisted webhook receiver (`@frappe.whitelist(allow_guest=True)`) for `order.created`, `order.updated` and `order.status.updated` with HMAC signature verification
  • Salla OAuth2 token storage and automatic refresh handled inside `Salla Settings`, encrypted at rest
  • Inbound order mapping: Salla payload to ERPNext `Sales Order` (or draft `Sales Invoice`) with Customer resolution, Item-code matching, tax and shipping lines

Request a Quotation

Tell us about your ERPNext Salla 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.