Les détails du produit sont affichés en anglais. Traductions à venir.
Faits en bref
- Prix
- $399.00 USD
- Versions ERPNext
- —
- Temps d'installation
- 30 minutes
- Licence
- Perpétuel unique
- Langues
- 11 langues
Achat unique
Multi-Carrier Rate Shopping Engine for ERPNext
A build-to-order Frappe app that fans out a single rate request to every carrier account you have connected in ERPNext, then applies your business rules to auto-select the cheapest, fastest, or best-value option at checkout and on the Delivery Note. Scoped, built, installed, and supported by ECOSIRE.
$399.00USD
Aucun paiement maintenant. Ceci envoie une demande de devis à notre équipe — nous vous recontacterons par e-mail avec les tarifs et les prochaines étapes.
Fonctionnalités clés
`Carrier Rate Request` orchestration DocType that fans out one request concurrently to every enabled carrier connector and aggregates the responses
Normalized `Carrier Rate Quote` child rows so DHL, Aramex, FedEx and local couriers are compared on a common schema (service level, transit days, base, surcharges, landed total)
`Rate Shopping Rule` DocType with cheapest / fastest / best-value policies and a configurable transit-vs-cost weighting factor
Dimensional-weight calculation from per-carrier volumetric divisors, compared against actual weight to match real carrier billing
Zone and weight-band resolution driven by carrier-specific tables, refreshed on a scheduler event
Hard-constraint rules (service exclusions, hazmat/perishable restrictions, max transit days, markup caps) evaluated before selection
Customer-facing shipping markup layer that applies handling margin while retaining raw carrier cost on the quote for reconciliation
Client script adding a 'Shop Rates' action with ranked inline quotes on Quotation, Sales Order and Delivery Note
`Delivery Note` `validate` / `before_submit` doc-event hook that auto-assigns the winning carrier, service level, tracking-carrier field and chosen rate
Whitelisted REST methods (`@frappe.whitelist()`) `get_rates()` and `select_rate()` for storefront, POS and headless-checkout integration
Per-company / per-warehouse / per-customer-group / per-item-group rule scoping so different channels shop rates differently
Rate caching with configurable TTL and stale-quote expiry via a Frappe scheduler event to control carrier-API call volume
Role-profile and permission-rule gating so carrier credentials and pricing logic are restricted from general users
Error and fallback handling when a carrier connector times out, returns no service, or fails auth — logged and surfaced without blocking the sale
Audit trail linking every shipment back to the quote set it was chosen from, for margin analysis and carrier SLA review
À propos de ce produit
If you run more than one carrier account, ERPNext gives you a Shipping Rule engine that resolves to a flat or slab-based charge from a table you maintain by hand — it does not call your carriers, does not know today's fuel surcharge, and cannot compare DHL against Aramex against your local courier for a specific parcel. The result is either overpaying because you default everything to one carrier, or a person tabbing between four carrier portals copying quotes into a Sales Order. Neither scales past a few dozen shipments a day, and neither reflects dimensional weight, zone bands, or the negotiated discounts sitting in your carrier contracts.
Pourquoi choisir Multi-Carrier Rate Shopping Engine for ERPNext
`Carrier Rate Request` orchestration DocType that fans out one request concurrently to every enabled carrier connector and aggregates the responses
Normalized `Carrier Rate Quote` child rows so DHL, Aramex, FedEx and local couriers are compared on a common schema (service level, transit days, base, surcharges, landed total)
`Rate Shopping Rule` DocType with cheapest / fastest / best-value policies and a configurable transit-vs-cost weighting factor
Dimensional-weight calculation from per-carrier volumetric divisors, compared against actual weight to match real carrier billing
Zone and weight-band resolution driven by carrier-specific tables, refreshed on a scheduler event
Hard-constraint rules (service exclusions, hazmat/perishable restrictions, max transit days, markup caps) evaluated before selection
ECOSIRE builds the Multi-Carrier Rate Shopping Engine as a proper Frappe app (its own module, DocTypes, and hooks.py wiring) installed on your ERPNext v15 or v16 bench. At its core is a Carrier Rate Request orchestration layer: given an origin, destination, weight, and package dimensions, it fans out concurrently to every carrier connector you have enabled and normalizes each response into comparable Carrier Rate Quote rows (service level, transit days, base cost, surcharges, landed total). A Rate Shopping Rule DocType lets you define selection policy per company, warehouse, customer group, or item group — cheapest, fastest, or best-value with a configurable transit-vs-cost weighting — plus hard constraints like "never ship perishables on ground" or "cap markup at 15%". Dimensional weight is computed from your carrier divisors and compared against actual weight so quotes match what the carrier will actually bill.
The engine hooks into the documents where the decision actually happens. A client script surfaces a "Shop Rates" action on Quotation, Sales Order, and Delivery Note so an agent sees ranked live quotes inline; a Delivery Note validate/before_submit doc event can auto-assign the winning carrier, write the service level, and stamp the chosen rate and margin. Customer-facing markup is applied through a rules layer so the rate you show at checkout already includes your handling margin, while the raw carrier cost is retained on the quote for reconciliation. Everything is exposed over the Frappe REST API through whitelisted methods (@frappe.whitelist()), so your storefront, POS, or a headless checkout can request get_rates() and post back the selection without touching the carrier APIs directly. A scheduler event refreshes cached zone/fuel tables and expires stale quotes, and all access is gated by Frappe role profiles and permission rules so pricing logic and carrier credentials stay locked down.
Because this is build-to-order, we start from your actual carrier mix and contracts rather than a generic template. After a short scoping call we confirm which carriers, service levels, and selection rules you need, then build against your ERPNext version, run it through UAT on a staging bench, and hand over installable source and a Git repository. Typical delivery is 2–4 weeks from confirmed scope depending on how many carrier connectors and edge-case rules are in play. You get the code, the docs, a training session, and a post-go-live support window — not a black box.
Ce que vous obtenez
- Installable source code for your ERPNext v15 or v16 version, built as a proper Frappe app
- Installation and configuration on your bench (staging first, then production) including carrier connector wiring
- Technical documentation: DocType reference, hooks, whitelisted API methods, and rule configuration
- End-user guide plus a live training session for shipping and sales staff
- UAT on a staging bench with agreed acceptance criteria and a documented rollback plan
- Post-go-live support window for bug fixes and configuration adjustments
- Git repository handover with full commit history so your team owns and can extend the code
- Rule and rate-table seed configuration matched to your carriers, zones and contracts
Pour qui c'est
Multi-carrier ERPNext merchant
Runs three or more live carrier accounts and wants ERPNext to pick the cheapest or fastest option automatically instead of defaulting everything to one courier or hand-copying quotes from carrier portals.
Fulfillment / warehouse operations lead
Owns the Delivery Note process and needs carrier auto-assignment, service-level rules and dimensional-weight accuracy so packers stop guessing and shipments go out on the right service every time.
Ecommerce / omnichannel manager
Needs live, marked-up shipping rates surfaced at checkout via the Frappe REST API so the customer sees an accurate landed price and the business protects its handling margin.
Finance / margin owner
Wants raw carrier cost retained alongside the customer-facing rate and an audit trail from shipment back to quote, to reconcile carrier invoices and review which carriers actually hit their SLAs.
Aperçu de l'installation
Télécharger depuis ECOSIRE
Achetez la licence sur ecosire.com et téléchargez le ZIP de l'application Multi-Carrier Rate Shopping Engine for ERPNext depuis le tableau de bord de votre compte.
Ajoutez l'application à votre banc
Extrayez le ZIP dans le dossier d'applications de votre banc ou exécutez « bench get-app » avec le chemin d'accès à l'application extraite.
Installer sur votre site
Exécutez `bench --site SITE_NAME install-app APP_NAME` suivi de `bench migrate` pour installer Multi-Carrier Rate Shopping Engine for ERPNext et appliquer son schéma.
Activez votre licence
Ouvrez les paramètres de licence ECOSIRE sur votre site et activez votre clé de licence. Nécessite les applications gratuites ecosire_connect et ecosire_license_client.
Comment Multi-Carrier Rate Shopping Engine for ERPNext se compare
| Critère | ÉCOSIRE | Construction personnalisée | Concurrent | Odoo natif |
|---|---|---|---|---|
| Live carrier rate comparison | One request fans out to all connected carriers and ranks them | Possible but you build the orchestration yourself | Often single-carrier or a fixed shortlist | |
| Auto-selection logic | Cheapest/fastest/best-value rules per company, warehouse, customer | Whatever you code and maintain | Basic or cheapest-only, limited scoping | |
| Dimensional weight | Per-carrier divisors, billed on greater of actual vs volumetric | Must be implemented and tested per carrier | Sometimes supported, often generic | |
| Delivery Note auto-assignment | `before_submit` hook stamps winning carrier, service, rate | Custom doc events you write and own | Rarely wired into Delivery Note | |
| Customer-facing markup | Margin layer with raw cost retained for reconciliation | Build your own markup and audit fields | Limited or no margin handling | |
| API / headless access | Whitelisted REST methods for storefront, POS, headless | You expose and secure the endpoints | Varies; may be UI-only | |
| Fit and ownership | Scoped to your carriers + ERPNext version, source + Git handed over | Fully yours but you carry all the build risk | Generic; you adapt to its assumptions | |
| Support model | Install, UAT, training, post-go-live support window | Your team supports it | Vendor support, upgrade risk on your version |
Foire aux questions sur Multi-Carrier Rate Shopping Engine for ERPNext
+How long until it is live?
This is build-to-order, so it is built for your carrier mix and ERPNext version rather than downloaded ready-made. Typical delivery is 2–4 weeks from confirmed scope, depending on how many carrier connectors and edge-case selection rules are involved. We confirm the exact timeline in writing after the scoping call.
+Which carriers does it support?
The engine is carrier-agnostic — it fans out to whatever carrier connectors you have installed and enabled in ERPNext. During scoping we confirm your carriers (for example DHL, FedEx, Aramex, UPS, or a regional/local courier). If a carrier you use has no existing connector, we quote building that connector as part of the same engagement.
+Is this an existing Frappe Marketplace app I can just install?
No. ECOSIRE designs, builds, installs and supports this specifically for your ERPNext v15/v16 bench, your carrier contracts, and your selection rules. There is no instant download — you are buying a scoped build plus installation, documentation, training and support, and you receive the full source and Git repository.
+How does it handle support and future ERPNext updates?
Every build includes a post-go-live support window for bug fixes and configuration tweaks. Because you receive installable source and the Git repository, your own team can maintain and extend it. For version upgrades (for example a v15-to-v16 migration) or new carriers and rules after the support window, we offer a maintenance arrangement or scoped follow-on work.
+Will it interfere with ERPNext's native Shipping Rules?
It runs alongside ERPNext core rather than replacing it. Native Shipping Rules stay available; the rate shopping engine adds live multi-carrier comparison and auto-selection on Quotation, Sales Order and Delivery Note through client scripts and doc-event hooks, so nothing in standard ERPNext is patched destructively.
+Can our storefront or POS call it directly?
Yes. Rate shopping is exposed over the Frappe REST API through whitelisted methods such as `get_rates()` and `select_rate()`, so a web storefront, a headless checkout, or ERPNext POS can request live marked-up rates and post back the customer's selection without ever handling carrier credentials themselves.
+How do you make sure the quoted rate matches what the carrier actually bills?
The engine computes dimensional (volumetric) weight from each carrier's divisor and bills against the greater of actual and dimensional weight, resolves the correct zone and weight band, and includes surcharges in the landed total. We validate the numbers against your real carrier invoices during UAT on staging before go-live.
Demander un devis
Multi-Carrier Rate Shopping Engine for ERPNext
A build-to-order Frappe app that fans out a single rate request to every carrier account you have connected in ERPNext, then applies your business rules to auto-select the cheapest, fastest, or best-value option at checkout and on the Delivery Note. Scoped, built, installed, and supported by ECOSIRE.
- `Carrier Rate Request` orchestration DocType that fans out one request concurrently to every enabled carrier connector and aggregates the responses
- Normalized `Carrier Rate Quote` child rows so DHL, Aramex, FedEx and local couriers are compared on a common schema (service level, transit days, base, surcharges, landed total)
- `Rate Shopping Rule` DocType with cheapest / fastest / best-value policies and a configurable transit-vs-cost weighting factor
- Dimensional-weight calculation from per-carrier volumetric divisors, compared against actual weight to match real carrier billing