Skip to main content
Square Payments for ERPNext — A build-to-order Frappe app that connects Square to ERPNext, so online Web Payments checkout an — 1/1Illustrative preview

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.

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

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
Automatic `Payment Entry` creation and allocation against the originating `Sales Invoice` on successful charge, honoring company currency and clearing account
`hooks.py` doc events on `Sales Invoice` and `Payment Request` that trigger charge creation and status write-back
Signature-verified Square webhook endpoint (whitelisted method) consuming `payment.updated` and `refund.created` for real-time settlement and dispute sync
Refunds initiated from ERPNext push to Square via the Refunds API and post the reversing `Payment Entry` automatically
Tokenized card-on-file via Square Customer/Cards API, stored against the ERPNext `Customer` for repeat and subscription billing
Dedicated `Square Payment` log DocType capturing Square `payment_id`/`order_id`, amount, status, and idempotency key for a durable audit trail
Scheduler event (`scheduler_events`) running periodic reconciliation that flags Square settlements with no matching Payment Entry
Idempotency-key handling and retry-safe charge logic so double-submits and webhook replays never double-post
Role-profile and permission-scoped access so only authorized roles can view tokens, issue refunds, or reconcile
`Client Script` adding the Square pay button, live status badges, and error surfacing to the relevant ERPNext forms
Multi-location support mapping Square `location_id` to ERPNext company/branch, with per-location settlement accounts

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

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

CriterionECOSIRECustom BuildCompetitorERPNext Native
Online + in-person in one systemWeb Payments SDK checkout and Terminal API readers settle into the same ERPNext flowPossible but you build and maintain both integrations yourselfMost marketplace apps do online-only, no Terminal reader supportNo Square support at all, online or in-person
Payment Entry write-backAuto-creates and allocates Payment Entry against the originating Sales InvoiceDepends entirely on your developer's accounting knowledgeOften posts a generic payment, weak invoice allocationManual journal entries only
Refund & dispute syncTwo-way via Refunds API plus signature-verified webhooks and a reconciliation sweepRarely built — usually reconciled by handRefund push sometimes; dispute/chargeback sync typically absentNone — reconcile against Square dashboard manually
PCI scopeClient-side tokenization, server never sees raw card dataOnly if the developer implements tokenization correctlyUsually tokenized, but implementation quality variesNot applicable — no card handling
Fit to your ERPNextBuilt to your chart of accounts, POS profiles, currencies, and locationsFully bespoke, at full bespoke cost and timelineGeneric, one-size-fits-all — you adapt to itNo connector to fit
Source & ownershipFull git repo handover, code is yours to extendYou own it but carry all build riskOften closed or license-gated, limited modificationN/A
Version support & upgradesTargets Frappe/ERPNext v15/v16 with a support windowYou maintain compatibility every upgradeUpgrade cadence depends on the vendor's roadmapN/A
Delivery modelBuild-to-order, one working week from confirmed scope, installed and supportedWeeks to months, unpredictable scope creepInstant download but generic and unsupported for your setupImmediate, 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.

Request a quote

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

Request a Quotation

Tell us about your Square Payments 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.