Skip to main content
Google Sheets Two-Way Sync for ERPNext — A no-code, scheduled bridge between Google Sheets and any ERPNext DocType, with inse — 1/1Illustrative preview

A no-code, scheduled bridge between Google Sheets and any ERPNext DocType,

with insert and upsert modes, incremental sync, and an optional two-way write-back.

ECOSIRE builds, installs, and supports it for your v15/v16 site after a scoping call.

What is Google Sheets Two-Way Sync for ERPNext?

A no-code, scheduled bridge between Google Sheets and any ERPNext DocType, with insert and upsert modes, incremental sync, and an optional two-way write-back. ECOSIRE builds, installs, and supports it for your v15/v16 site after a scoping call. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

A dedicated Frappe app (own module, DocTypes, hooks.py) installed on your ERPNext site — not a fragile server-script hack
Sheet Sync Profile DocType: one record per connection defining spreadsheet ID, worksheet, target DocType, mapping, mode, and schedule
Child-table column-to-field mapping configured entirely in the UI — remap or add fields with no code changes
Insert mode appends new rows; upsert mode matches on a nominated key column to update-or-create ERPNext documents
Incremental sync via a per-profile watermark (last row or timestamp column) so runs process only changed rows, not the whole sheet
Scheduler-driven execution registered in scheduler_events — hourly, daily, or a custom cron expression
Jobs run in Frappe's background worker (frappe.enqueue), so large sheets never hit web-request timeouts
Google service-account authentication with the JSON key stored server-side; sheet shared to the service account email, no per-user OAuth
Per-field transforms: date parsing, number coercion, and Link-field resolution by name so raw sheet values land as valid ERPNext data
Optional two-way write-back via on_update / after_insert doc_events, pushing changed ERPNext documents back to the worksheet
Loop-prevention guard so a sync-in never re-triggers a sync-out (and vice versa)
Sheet Sync Log DocType recording inserted / updated / skipped / errored counts with per-row error detail and re-run
Permission-aware writes — inserts and upserts respect ERPNext role permissions and validation, not raw SQL
Whitelisted 'Sync now' method exposed in the UI and callable via the Frappe REST API for on-demand runs

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

Every ERPNext rollout has a corner of the business still run out of Google Sheets — a sales pipeline the reps actually update, a supplier price list finance maintains, a field-ops tracker, a marketing lead sheet. The data has to reach ERPNext, so someone exports CSVs and babysits the Data Import Tool a few times a week, or copies rows by hand. ERPNext core gives you a one-shot Data Import and a manual "Export" button, but no scheduled, incremental, bidirectional link to a live spreadsheet. There is no native cron that says "every hour, pull new rows from this worksheet into Lead, updating anything that already exists." That gap is exactly where this app lives.

We build a proper Frappe app — its own module, DocTypes, and hooks.py wiring — installed on your ERPNext site. A Sheet Sync Profile DocType defines each connection: the Google spreadsheet ID and worksheet, the target ERPNext DocType, the field-to-column mapping, the sync mode, and the schedule. Authentication is a Google service account whose JSON key is stored server-side (never in the browser), so the sheet is shared to the service account email and no per-user OAuth dance is required. Column-to-field mapping is configured through a child table in the UI — no code editing to add or remap a field — and each mapping can carry a light transform (date parsing, number coercion, Link-field resolution by name) so a messy spreadsheet lands as clean ERPNext data.

Technically, the engine runs on Frappe's scheduler. You choose hourly, daily, or a specific cron expression, registered under scheduler_events in hooks.py, and the job runs in the background worker — not the web request — so large sheets never time out. Insert mode appends new rows; upsert mode uses a key column you nominate (e.g. an email, an item code, an external ID) to update the matching ERPNext document or create it if absent, via frappe.get_doc / db lookups with permission checks intact. Incremental sync tracks a per-profile watermark (last-synced row or a timestamp column) so each run only processes what changed instead of re-importing the whole sheet. Every run writes a Sheet Sync Log row — counts of inserted, updated, skipped, and errored records, with per-row error detail — so you can see exactly what happened and re-run a failed batch. The optional two-way write-back is driven by ERPNext doc_events (on_update, after_insert) hooks that push the changed document back to the mapped worksheet through the Google Sheets API, with loop-prevention so a sync-in doesn't trigger a sync-out ping-pong. Whitelisted methods expose a manual "Sync now" button and can be called from the Frappe REST API for on-demand runs.

Because this is build-to-order, nothing is a mystery download. We start with a short scoping call to confirm your DocTypes, the worksheets, the key columns for upsert, and whether you need write-back. We build against Frappe/ERPNext v15 or v16, validate on a staging copy of your site with your real sheets during UAT, then install on production with a rollback plan. You receive the full app source in a git repository you own, along with install and configuration docs, a user guide, a training session, and a post-go-live support window. Typical delivery is one working week from confirmed scope, depending on how many DocTypes and transforms are in play.

What you get

  • Installable source code for your version of the app, delivered as a Frappe app installable via bench
  • Installation and configuration on your ERPNext site (or a guided install), including service-account setup and worksheet sharing
  • Technical documentation: DocType schema, hooks.py events, scheduler configuration, and mapping/transform reference
  • End-user guide plus a live training session for the team that owns the sync profiles
  • Post-go-live support window for defect fixes and configuration help
  • UAT on a staging copy of your site with your real sheets, plus a documented rollback plan for production install
  • Handover of the full git repository so you own the source and can extend or re-deploy it

Who this is for

Sales ops running the pipeline in Sheets

The revenue team lives in a shared Google Sheet for leads and deal stages but reporting has to come from ERPNext CRM. They need new and updated rows flowing into Lead / Opportunity on an hourly upsert without anyone touching the Data Import Tool.

Finance keeping supplier and price data current

A maintained pricing or supplier sheet needs to reach Item Price, Supplier, or a custom DocType on a schedule, with upsert on item code so corrections update the right record instead of creating duplicates.

Field and operations teams capturing data offline

Crews and agents log activity in spreadsheets from the field. Operations wants that data landing in ERPNext daily, cleaned and validated, and — with write-back — the ERPNext status flowing back so the sheet stays authoritative for the people who use it.

ERPNext admin who wants a supported, source-owned solution

The system owner is wary of brittle one-off scripts. They want a proper versioned Frappe app compatible with v15/v16, permission-aware, logged, and handed over as a git repo they can audit and maintain.

How Google Sheets Two-Way Sync for ERPNext Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Sync directionTwo-way: scheduled sheet-to-ERPNext plus optional doc-event write-backWhatever you build; two-way is significant extra effortOften one-direction import only, or a fixed set of DocTypesOne-shot manual import and manual export only
SchedulingHourly, daily, or custom cron via scheduler_events in a background workerYou wire up scheduler jobs and enqueue yourselfFixed intervals, sometimes only manual triggerNone — Data Import is manual each time
Insert vs upsertBoth, with a nominated key column for update-or-createBuildable but you own the dedupe and key logicUsually insert-only or basic dedupeInsert or overwrite via Data Import; no keyed upsert on a schedule
Incremental processingPer-profile watermark processes only changed rowsYou design and maintain the change-trackingOften re-imports the full sheet each runFull re-import each time
Field mappingUI child-table mapping with per-field transforms, no code editsHardcoded or a mapping layer you buildBasic column mapping, limited transformsManual column matching per import
Logging and error handlingSheet Sync Log with inserted/updated/skipped/errored counts and re-runWhatever logging you addVaries; often minimal per-row detailImport log per manual run only
Ownership and supportFull git repo handover, docs, training, post-go-live support windowYou own it and all its maintenanceVendor-controlled; support tied to a subscriptionCovered by ERPNext support but no such feature exists
Version fitBuilt and UAT-tested against your v15/v16 siteDepends on your team's version disciplineMay lag ERPNext releases or target other versionsShips with core, no config for this use case

Frequently Asked Questions about Google Sheets Two-Way Sync

How long does delivery take?

This is a build-to-order app, not an instant download. After a short scoping call to confirm your DocTypes, worksheets, upsert keys, and whether you need write-back, typical delivery is one working week from confirmed scope. Simple single-DocType, one-direction syncs land toward the shorter end; multiple DocTypes, heavy transforms, or two-way write-back push toward the longer end.

Is this a Frappe Cloud Marketplace app I can just install?

No. ECOSIRE builds it for your specific ERPNext site and DocTypes, validates it on your staging environment, installs it, and hands you the full git repository. It is a proper Frappe app installed via bench, tailored to your worksheets and field mappings rather than a generic one-size download.

Which Frappe/ERPNext versions do you support?

We build and test against Frappe/ERPNext v15 and v16. Tell us your exact version and hosting (Frappe Cloud, self-hosted, or ECOSIRE managed) on the scoping call and we target that during development and UAT.

How does authentication to Google Sheets work — is it secure?

The app uses a Google service account. The JSON key is stored server-side on your ERPNext site and never exposed in the browser or to end users. You share each spreadsheet with the service account's email address, which scopes access to only the sheets you grant. There is no per-user OAuth login for the sync to run.

What does the two-way write-back actually do, and can it cause loops?

Write-back is optional. When enabled, ERPNext doc_events (on_update, after_insert) push the changed document back to the mapped worksheet via the Google Sheets API, so ERPNext status flows back to the people working in the sheet. A loop-prevention guard ensures a sync-in from the sheet does not immediately trigger a sync-out back to it, and vice versa. If you only need data flowing into ERPNext, we ship insert/upsert one-direction and leave write-back off.

What happens after go-live — do I get support and updates?

Every engagement includes a post-go-live support window for defect fixes and configuration help. Because you receive the full source in a git repository you own, your team can extend it directly, or you can engage ECOSIRE for further changes, new DocType mappings, or a version upgrade when you move ERPNext versions.

Will syncing bypass ERPNext validation or permissions?

No. Inserts and upserts go through Frappe's document layer with permission and validation checks intact — not raw SQL — so mandatory fields, Link validation, and role permissions all apply. Rows that fail validation are recorded in the Sheet Sync Log with per-row error detail so you can fix the source and re-run.

Request a quote

Google Sheets Two-Way Sync

A no-code, scheduled bridge between Google Sheets and any ERPNext DocType, with insert and upsert modes, incremental sync, and an optional two-way write-back. ECOSIRE builds, installs, and supports it for your v15/v16 site after a scoping call.

  • A dedicated Frappe app (own module, DocTypes, hooks.py) installed on your ERPNext site — not a fragile server-script hack
  • Sheet Sync Profile DocType: one record per connection defining spreadsheet ID, worksheet, target DocType, mapping, mode, and schedule
  • Child-table column-to-field mapping configured entirely in the UI — remap or add fields with no code changes
  • Insert mode appends new rows; upsert mode matches on a nominated key column to update-or-create ERPNext documents

Request a Quotation

Tell us about your Google Sheets Two-Way Sync 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.