- Home
- Apps
- SaaS Tools
- Square Payments for ERPNext
Illustrative previewA build-to-order Frappe app that connects Square to ERPNext,
so online Web Payments checkout and in-person card-reader sales settle against the same Sales Invoices and Payment Entries.
ECOSIRE scopes, builds, installs, and supports it — this is not an off-the-shelf marketplace download.
What is Square Payments for ERPNext?
A build-to-order Frappe app that connects Square to ERPNext, so online Web Payments checkout and in-person card-reader sales settle against the same Sales Invoices and Payment Entries. ECOSIRE scopes, builds, installs, and supports it — this is not an off-the-shelf marketplace download. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.
Key Features
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your ERPNext.
- 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
Omnichannel SMBs in the US, UK, and Australia sell both online and across a counter, but ERPNext core has no native Square connector. Merchants end up reconciling Square's dashboard against ERPNext by hand: online orders captured through a hosted page never write back a Payment Entry, in-person card-reader takings arrive as a lump settlement that nobody can tie to specific invoices, and refunds issued in Square silently drift out of sync with the ledger. The result is manual journal entries, mismatched customer balances, and a monthly close that takes days longer than it should. ERPNext's built-in payment gateway framework covers a handful of redirect-style processors and does not speak Square's Web Payments SDK, Terminal API, or webhook model.
ECOSIRE builds a proper Frappe app — installed on your bench with bench get-app and bench install-app — that treats Square as a first-class ERPNext payment rail. Online, we implement Square's Web Payments SDK to tokenize the card client-side and complete the charge server-side through a whitelisted method (frappe.whitelist()), so raw PAN data never touches your server and PCI scope stays minimal. A Square Settings single DocType holds your application ID, location IDs, and access token (stored as a Password field, encrypted at rest); environment toggles let you point the same install at Square Sandbox for UAT and Production for go-live. In-person sales use Square's Terminal API / device-code pairing so a physical card reader can be driven from an ERPNext POS or a custom checkout screen, with cards, Apple Pay, Google Pay, and Cash App Pay all handled by Square's own SDK.
Under the hood the app maps Square events onto ERPNext documents. A dedicated Square Payment (or Square Transaction) DocType logs every payment, order, and refund with the Square payment_id/order_id for a durable audit trail; hooks.py doc events on Sales Invoice and Payment Request trigger charge creation, and on success we create or allocate a Payment Entry against the correct invoice, respecting company currency and your configured bank/clearing account. A Frappe webhook endpoint (a whitelisted, signature-verified method) receives payment.updated and refund.created callbacks so disputes, chargebacks, and Square-initiated refunds flow back into ERPNext automatically. Tokenized card-on-file is supported via Square's Customer/Cards API and stored against the ERPNext Customer for repeat and subscription billing. A scheduler event (scheduler_events in hooks.py) runs a periodic reconciliation sweep that fetches recent Square settlements and flags any transaction that lacks a matching Payment Entry, so nothing goes un-posted. Access is governed by ERPNext role profiles and permissions, and a Client Script adds the Square payment button and status badges to the relevant forms.
Because every ERPNext install differs — your chart of accounts, POS profiles, currencies, tax treatment, and whether you need Terminal hardware or online-only — this is delivered build-to-order rather than as a generic download. We start with a short scoping call, confirm the exact flows and DocType mappings in a written statement of work, then build against your Square Sandbox and your data model. Typical delivery is one working week from confirmed scope, targeting Frappe/ERPNext v15 and v16. You receive the full app source in a git repository, UAT on a staging bench with a documented rollback plan, and a post-go-live support window — no lock-in, and the code is yours to maintain or extend.
What you get
- Installable Frappe app source code for your ERPNext version (v15 and/or v16), delivered as a proper `bench`-installable app
- Installation and configuration on your bench, including `Square Settings`, location mapping, and account setup
- Technical documentation: DocType reference, hooks/doc-event map, webhook endpoint, and scheduler behavior
- User guide plus a live training session for your finance and counter-sales staff
- UAT on a staging bench against Square Sandbox, with a documented rollback plan before production cutover
- Git repository handover with full commit history — the code is yours to maintain and extend
- Post-go-live support window for defect fixes and configuration adjustments
- Reconciliation runbook covering webhook re-sync, idempotency, and settlement-matching procedures
Who this is for
Omnichannel SMB owner (US/UK/AU)
Runs a shop plus an online store on ERPNext and already uses Square for the counter. Wants online checkout and in-person card-reader sales to land against the same invoices and ledger, so the monthly close stops being a manual reconciliation exercise.
ERPNext finance / accounts manager
Owns the chart of accounts and month-end close. Needs every Square payment and refund to post an accurate `Payment Entry` against the right invoice and clearing account, with a reconciliation sweep that catches anything Square settled but ERPNext never recorded.
Operations / retail manager
Manages POS profiles, store locations, and card readers. Needs Terminal-API pairing that maps each Square location to the correct ERPNext company/branch and supports Apple Pay, Google Pay, and Cash App Pay at the counter without staff retraining.
In-house ERPNext developer / partner
Maintains the bench and custom apps. Wants clean, hook-based source in a git repo — whitelisted methods, signature-verified webhooks, idempotency, and role-scoped permissions — that they can review, extend, and carry forward across v15/v16 upgrades.
How Square Payments for ERPNext Compares
| Criterion | ECOSIRE | Custom Build | Competitor | ERPNext Native |
|---|---|---|---|---|
| Online + in-person in one system | Web Payments SDK checkout and Terminal API readers settle into the same ERPNext flow | Possible but you build and maintain both integrations yourself | Most marketplace apps do online-only, no Terminal reader support | No Square support at all, online or in-person |
| Payment Entry write-back | Auto-creates and allocates Payment Entry against the originating Sales Invoice | Depends entirely on your developer's accounting knowledge | Often posts a generic payment, weak invoice allocation | Manual journal entries only |
| Refund & dispute sync | Two-way via Refunds API plus signature-verified webhooks and a reconciliation sweep | Rarely built — usually reconciled by hand | Refund push sometimes; dispute/chargeback sync typically absent | None — reconcile against Square dashboard manually |
| PCI scope | Client-side tokenization, server never sees raw card data | Only if the developer implements tokenization correctly | Usually tokenized, but implementation quality varies | Not applicable — no card handling |
| Fit to your ERPNext | Built to your chart of accounts, POS profiles, currencies, and locations | Fully bespoke, at full bespoke cost and timeline | Generic, one-size-fits-all — you adapt to it | No connector to fit |
| Source & ownership | Full git repo handover, code is yours to extend | You own it but carry all build risk | Often closed or license-gated, limited modification | N/A |
| Version support & upgrades | Targets Frappe/ERPNext v15/v16 with a support window | You maintain compatibility every upgrade | Upgrade cadence depends on the vendor's roadmap | N/A |
| Delivery model | Build-to-order, one working week from confirmed scope, installed and supported | Weeks to months, unpredictable scope creep | Instant download but generic and unsupported for your setup | Immediate, but nothing is built |
Frequently Asked Questions about Square Payments
Is this an instant download from the Frappe Cloud Marketplace?
No. Square Payments for ERPNext is build-to-order. ECOSIRE scopes the exact flows for your install, builds the app against your data model and Square Sandbox, then installs and supports it. There is no pre-packaged instant download — you receive source tailored to your chart of accounts, POS profiles, and currencies.
How long does delivery take?
Typical delivery is one working week from confirmed scope. The clock starts once we agree the written statement of work — the DocTypes, doc events, online-versus-Terminal flows, and account mappings — after the initial scoping call. Larger multi-location or subscription-billing builds sit at the upper end of that range.
Which Frappe and ERPNext versions are supported?
We target Frappe/ERPNext v15 and v16, delivered as a proper `bench`-installable app. If you are on an older version we will confirm compatibility during scoping and, where feasible, backport — that is part of the SOW rather than an assumption.
How are online card details handled — is my PCI scope affected?
We use Square's Web Payments SDK, which tokenizes the card in the customer's browser. Your ERPNext server only ever receives a single-use token and completes the charge server-side through a whitelisted method, so raw card numbers never touch your bench. This keeps your PCI scope minimal — Square handles the sensitive card data.
Do in-person card readers and online checkout share the same setup?
Yes. That is the point of the omnichannel build. Online payments use the Web Payments SDK and in-person sales use Square's Terminal API with device-code reader pairing, but both settle into the same ERPNext `Sales Invoice` and `Payment Entry` flow and reconcile through one `Square Payment` log. Cards, Apple Pay, Google Pay, and Cash App Pay work across both.
How do refunds and disputes stay in sync with ERPNext?
Refunds initiated in ERPNext call Square's Refunds API and post a reversing `Payment Entry` automatically. Refunds, disputes, and chargebacks initiated in Square flow back through a signature-verified webhook (`payment.updated`, `refund.created`), and a scheduled reconciliation sweep flags any settlement that lacks a matching Payment Entry so nothing drifts out of sync.
What support and updates do I get after go-live?
Every build includes a post-go-live support window for defect fixes and configuration adjustments, plus a reconciliation runbook. You also receive the full git repository, so your own team or partner can maintain and extend the app. Ongoing support beyond the initial window and version upgrades can be arranged as a separate engagement.
Related Modules

South Africa SARS VAT & Compliance
A build-to-order ERPNext localization for South African finance and HR teams — SARS VAT201 returns, PAYE/UIF/SDL payroll, EMP201 statutory reporting and COIDA support, all wired into your ERPNext site. ECOSIRE scopes, builds, installs and supports it for you.

Stripe Billing & Subscriptions Plus
A build-to-order Frappe app that connects ERPNext to Stripe for checkout, recurring subscription sync, card-present Terminal payments, and webhook-driven reconciliation. ECOSIRE scopes, builds, installs and supports it on your bench.

Stripe Connect Marketplace Payouts for ERPNext
A build-to-order ERPNext application that connects your multi-vendor marketplace to Stripe Connect for onboarding, split payments, application fees, and automated seller payouts. ECOSIRE builds it to your exact vendor and settlement model, then installs and supports it.
Square Payments
A build-to-order Frappe app that connects Square to ERPNext, so online Web Payments checkout and in-person card-reader sales settle against the same Sales Invoices and Payment Entries. ECOSIRE scopes, builds, installs, and supports it — this is not an off-the-shelf marketplace download.
- Square Web Payments SDK checkout: card tokenized client-side, charge completed server-side via a `frappe.whitelist()` method — raw card data never reaches your ERPNext server
- In-person Terminal API integration: pair a Square card reader via device code and take counter payments from ERPNext POS or a custom checkout DocType
- Full payment-method coverage through Square's SDK: cards, Apple Pay, Google Pay, and Cash App Pay, online and in-person
- `Square Settings` single DocType holding application ID, location IDs, and access token (encrypted `Password` field) with Sandbox/Production environment toggle
