Les détails du produit sont affichés en anglais. Traductions à venir.
Faits en bref
- Prix
- $349.00 USD
- Versions ERPNext
- —
- Temps d'installation
- 30 minutes
- Licence
- Perpétuel unique
- Langues
- 11 langues
Achat unique
Tabby BNPL for ERPNext
A build-to-order Frappe app that adds Tabby Buy-Now-Pay-Later as a first-class ERPNext payment method — Pay in 4, monthly installments, eligibility pre-scoring, and product/cart promo messaging. ECOSIRE scopes, builds, installs, and supports it on your ERPNext v15/v16 instance.
$349.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
Dedicated Frappe app `erpnext_tabby` with its own module, installed via bench as a versioned, upgrade-safe application rather than loose customizations
`Tabby Settings` single DocType for API keys, merchant code, environment (test/live) toggle, currency and locale config — secret key stored as a `Password` fieldtype, never exposed to the browser
Pre-scoring and eligibility checks invoked through whitelisted server methods so the customer only sees the Tabby option when their cart qualifies
Pay in 4 and monthly installment plans surfaced at checkout with the correct per-installment amounts computed from the live cart total
Product-page and cart-page promo messaging ('or 4 interest-free payments of AED X') rendered via client scripts and Website assets, locale-aware for Arabic and English
`Tabby Session` DocType that logs every checkout session, its Tabby session/payment ID, amount, and status for full traceability
Signature-verified webhook endpoint (whitelisted method) writing to a `Tabby Webhook Log` DocType with an idempotency key so provider retries never double-post
Capture, refund (full and partial), and cancellation lifecycle mapped to the correct ERPNext Payment Entry / Journal Entry so the general ledger always reconciles
`hooks.py` `doc_events` on Sales Order and Sales Invoice (`on_submit`, `on_cancel`) to keep the BNPL settlement state in lockstep with the sale document
Hourly `scheduler_events` reconciliation job that catches authorized sessions whose settlement webhook was delayed or lost
Frappe REST API endpoints for the storefront to fetch eligibility, create sessions, and confirm orders without exposing secret credentials
Dedicated role and role profile restricting key access and manual refunds to finance/store-admin users, with all actions in the Frappe audit trail
Configurable min/max order thresholds and product/category eligibility rules driven by DocType configuration, not hard-coded
Compatible with Frappe/ERPNext v15 and v16, delivered against your actual bench environment and Python/Frappe version
À propos de ce produit
GCC retailers running ERPNext consistently lose cart conversion and average order value at the payment step: shoppers in the UAE and Saudi Arabia now expect a Tabby "Pay in 4" option, and when they don't see it they abandon or downsize the basket. ERPNext core ships card and generic payment-gateway integrations, but it has no native concept of a Buy-Now-Pay-Later provider — no pre-checkout eligibility scoring, no product/cart promotional messaging ("or 4 payments of AED X"), and no way to reconcile a BNPL settlement that is captured, partially refunded, or clawed back on a schedule that differs from the sale document. Bolting this onto ERPNext with ad-hoc client scripts creates silent reconciliation gaps that surface as unbalanced payment entries weeks later.
Pourquoi choisir Tabby BNPL for ERPNext
Dedicated Frappe app `erpnext_tabby` with its own module, installed via bench as a versioned, upgrade-safe application rather than loose customizations
`Tabby Settings` single DocType for API keys, merchant code, environment (test/live) toggle, currency and locale config — secret key stored as a `Password` fieldtype, never exposed to the browser
Pre-scoring and eligibility checks invoked through whitelisted server methods so the customer only sees the Tabby option when their cart qualifies
Pay in 4 and monthly installment plans surfaced at checkout with the correct per-installment amounts computed from the live cart total
Product-page and cart-page promo messaging ('or 4 interest-free payments of AED X') rendered via client scripts and Website assets, locale-aware for Arabic and English
`Tabby Session` DocType that logs every checkout session, its Tabby session/payment ID, amount, and status for full traceability
We build a proper Frappe application — erpnext_tabby — installed on your bench as a versioned app, not a pile of loose customizations. It introduces its own module and DocTypes: a Tabby Settings single DocType (holding public/secret API keys, merchant code, environment toggle, and currency/locale config, with secrets stored as Password fieldtype), a Tabby Session DocType logging every checkout session and its provider ID, and a Tabby Webhook Log DocType for idempotent event capture and replay. The checkout flow calls Tabby's pre-scoring endpoint through whitelisted server methods (@frappe.whitelist()) so the browser never touches your secret key; eligibility results and installment plans are returned to the storefront via the Frappe REST API. On the web storefront we register client scripts and Website-level assets that render Tabby's promo snippet on product and cart pages, honoring the shopper's cart total and locale.
The lifecycle is wired through hooks.py document events and scheduler hooks. When a Sales Order or Sales Invoice is submitted against a Tabby session, on_submit doc events create and reconcile the corresponding Payment Entry; capture, refund, and cancellation each map to the correct accounting document so your general ledger always ties out. Tabby's asynchronous settlement is handled by a whitelisted webhook endpoint that verifies the signature, writes to Tabby Webhook Log with a dedupe key (so retries are idempotent), and updates the linked sale document's status. A scheduler_events hourly job reconciles any sessions that were authorized but whose webhook never arrived, closing the gap between "customer paid Tabby" and "ERPNext knows about it." Access is governed by a dedicated role and role profile so only finance and store-admin users can view keys or trigger manual refunds, and all sensitive actions are captured in the standard Frappe audit trail.
Because this is build-to-order, nothing ships as a blind download. We start with a scoping call to confirm your ERPNext version (v15 or v16), storefront setup, Tabby merchant account, currencies, and reconciliation rules, then build against a staging copy of your instance. You review the working integration in UAT before we touch production. Typical delivery is 2 to 4 weeks from confirmed scope. You receive the full app source in a git repository you own, installed and configured on your bench, with documentation, a training session, and a post-go-live support window — no vendor lock-in and no black box.
Ce que vous obtenez
- Installable source code for your version of the `erpnext_tabby` Frappe app, targeting your ERPNext v15 or v16 instance
- Installation and configuration on your bench — app install, `Tabby Settings` populated, webhook URL registered with Tabby, test-to-live cutover
- Technical documentation: DocType reference, hooks.py events, whitelisted methods, webhook contract, and scheduler job behavior
- End-user guide plus a live training session for finance and store-admin staff (refunds, reconciliation, promo config)
- UAT on a staging copy of your instance with a documented rollback plan before production go-live
- Post-go-live support window for bug fixes and configuration adjustments after launch
- Full git repository handover — you own the source, commit history, and can maintain or extend it independently
- Reconciliation runbook covering capture/refund/settlement edge cases and the hourly recovery job
Pour qui c'est
UAE/KSA ERPNext retail owner
Runs an online store on ERPNext's web storefront and is losing conversions because shoppers expect Tabby. Wants Pay in 4 live at checkout with promo messaging on product pages to lift both conversion and average order value.
Finance / accounts manager
Owns the general ledger and needs every Tabby capture, refund, and settlement to post to the correct Payment Entry so the books reconcile. Cares about the idempotent webhook log, the hourly recovery job, and a clean audit trail.
ERPNext administrator / implementation partner
Manages the bench and other Frappe apps. Wants a properly packaged app with clean hooks.py events, whitelisted methods, and a role profile — not brittle client-script hacks — and full source in git so they can maintain it.
Growth / e-commerce manager
Focused on checkout conversion and AOV. Needs eligibility-aware Tabby messaging on product and cart pages, locale-aware for Arabic and English shoppers across the GCC.
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 Tabby BNPL 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 Tabby BNPL 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 Tabby BNPL for ERPNext se compare
| Critère | ÉCOSIRE | Construction personnalisée | Concurrent | Odoo natif |
|---|---|---|---|---|
| BNPL support in ERPNext | Purpose-built Tabby app with Pay in 4 and installments | Whatever you scope and build yourself | Generic gateway plugin, often not Tabby-specific | |
| Eligibility pre-scoring | Live pre-scoring via whitelisted server methods | Must design and secure the API calls yourself | Rarely included; usually card-only | |
| Promo messaging on product/cart | Locale-aware snippets via client scripts and Website assets | Hand-built client scripts to maintain | Limited or none | |
| Settlement reconciliation | Idempotent webhook log plus hourly recovery job into Payment Entries | DIY reconciliation, easy to leave gaps | Basic status update, often no recovery job | |
| Code ownership | Full source in a git repo you own | You own it but carry the full build cost | Vendor-controlled, often closed or licensed | |
| Delivery and testing | Staging UAT, rollback plan, 2-4 week build-to-order | Depends entirely on your in-house capacity | Install-and-hope, minimal onboarding | |
| Version fit | Built and tested against your v15/v16 bench | Whatever you target | Generic release, may lag your version | |
| Support after launch | Post-go-live support window plus training | Self-supported | Forum or paid tier, variable |
Foire aux questions sur Tabby BNPL for ERPNext
+Is this a ready-made app I can download and install today?
No. Tabby BNPL for ERPNext is build-to-order. ECOSIRE scopes it to your ERPNext version, storefront, and Tabby merchant account, then builds, installs, and supports it. There is no instant download — you receive a working, tested app installed on your bench with the full source in a git repository you own.
+How long does delivery take?
Typical delivery is 2 to 4 weeks from confirmed scope. The timeline starts once we've completed the scoping call and agreed on your ERPNext version, currencies, storefront setup, and reconciliation rules. Complex multi-currency or custom-storefront requirements can extend this, and we confirm the estimate in writing before starting.
+Which ERPNext versions are supported?
We support Frappe/ERPNext v15 and v16. We build and test against your actual bench and Frappe/Python version so the app is upgrade-safe rather than pinned to a generic release.
+How are refunds and settlements kept in sync with my accounts?
Capture, refund (full or partial), and cancellation each map to the correct ERPNext Payment Entry or Journal Entry via `hooks.py` doc events. A signature-verified webhook writes to an idempotent `Tabby Webhook Log`, and an hourly scheduler job reconciles any authorized session whose webhook was delayed, so your general ledger always ties out.
+Do you need my Tabby account, and are my API keys secure?
Yes — you provide your own Tabby merchant credentials. Secret keys are stored in a `Tabby Settings` DocType as a `Password` fieldtype and are only used inside whitelisted server methods, so the browser and storefront never see them. Access is restricted to a dedicated finance/store-admin role.
+What kind of support and updates do I get after launch?
Every build includes a post-go-live support window for bug fixes and configuration adjustments. Because you own the git repository and full source, you or your implementation partner can maintain and extend it freely; ECOSIRE can also provide ongoing support or enhancements under a separate agreement.
+Can I run it on a staging copy before going live?
Yes. We build against a staging copy of your instance and you sign off in UAT before we touch production. We include a documented rollback plan, and the environment toggle in `Tabby Settings` lets you validate in Tabby's test mode before switching to live.
Modules associés
Demander un devis
Tabby BNPL for ERPNext
A build-to-order Frappe app that adds Tabby Buy-Now-Pay-Later as a first-class ERPNext payment method — Pay in 4, monthly installments, eligibility pre-scoring, and product/cart promo messaging. ECOSIRE scopes, builds, installs, and supports it on your ERPNext v15/v16 instance.
- Dedicated Frappe app `erpnext_tabby` with its own module, installed via bench as a versioned, upgrade-safe application rather than loose customizations
- `Tabby Settings` single DocType for API keys, merchant code, environment (test/live) toggle, currency and locale config — secret key stored as a `Password` fieldtype, never exposed to the browser
- Pre-scoring and eligibility checks invoked through whitelisted server methods so the customer only sees the Tabby option when their cart qualifies
- Pay in 4 and monthly installment plans surfaced at checkout with the correct per-installment amounts computed from the live cart total