Ürün ayrıntıları İngilizce olarak görüntülenir. Çeviriler yakında gelecek.
Kısa bilgiler
- Fiyat
- $499.00 USD
- ERPNext versiyonları
- —
- Kurulum süresi
- 30 dk.
- Lisans
- Bir kerelik kalıcı
- Diller
- 11 language
Tek Seferlik Satın Alma
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.
$499.00USD
Şimdi ödeme yok. Bu, ekibimize bir teklif talebi gönderir — fiyat ve sonraki adımlarla e-posta ile dönüş yapacağız.
Temel Özellikler
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)
Bu Ürün Hakkında
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.
Neden ERPNext Salla Connector
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
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 2–4 weeks 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.
Ne elde edeceksin
- 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
Bu kimin için
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.
Kuruluma genel bakış
ECOSIRE'dan indirin
Lisansı ecosire.com adresinden satın alın ve hesap kontrol panelinizden ERPNext Salla Connector uygulamasının ZIP dosyasını indirin.
Uygulamayı bankınıza ekleyin
ZIP dosyasını tezgahınızın uygulamalar klasörüne çıkarın veya çıkarılan uygulamanın yolunu içeren "bench get-app" komutunu çalıştırın.
Sitenize yükleyin
ERPNext Salla Connector yüklemek ve şemasını uygulamak için `bench --site SITE_NAME install-app APP_NAME` komutunu ve ardından `bench move'u çalıştırın.
Lisansınızı etkinleştirin
Sitenizdeki ECOSIRE Lisans ayarlarını açın ve lisans anahtarınızı etkinleştirin. Ücretsiz ecosire_connect ve ecosire_license_client uygulamalarını gerektirir.
ERPNext Salla Connector Nasıl Karşılaştırılır
| Kriter | ECOSIRE | Özel Yapı | Rakip | Odoo Yerlisi |
|---|---|---|---|---|
| Salla integration | Purpose-built connector for your exact order and tax flow | Whatever your dev writes from scratch | Generic mapping, may not fit Salla's KSA specifics | |
| Order sync | Webhook-driven Salla to Sales Order, idempotent | Depends on build quality and time budget | Often polling/batch, limited field mapping | |
| Inventory & price sync | Two-way, ERPNext as source of truth, reconciled | Possible but costly to get reliable | Frequently one-way or stock-only | |
| ZATCA invoice mapping | Fields aligned to Fatoora Phase 2, scoped to your setup | Must be researched and built yourself | Rarely KSA/ZATCA-aware | |
| Upgrade safety | Pure Frappe app, hooks/DocTypes, no core patches | Risk of core edits that break on upgrade | Varies; may lag ERPNext releases | |
| Support & fix path | Post-go-live window + direct ECOSIRE support | Only your own team | Vendor tickets, generic priority | |
| Code ownership | Full source + git repo handover to you | You own it (if it's finished) | Usually closed / license-locked | |
| Time to live | Typically 2–4 weeks from confirmed scope | Unpredictable; often months | Fast install, slow to fit reality |
ERPNext Salla Connector hakkında Sıkça Sorulan Sorular
+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 2–4 weeks 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.
Teklif isteyin
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