Quick facts
- Price
- $299.00 USD
- ERPNext versions
- —
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
One-time Purchase
ERPNext Google Shopping & Merchant Center Connector
A build-to-order Frappe app that pushes your ERPNext product catalog to Google Merchant Center for Shopping ads and free listings, with near-real-time price and stock sync. ECOSIRE scopes, builds, installs, and supports it for your instance.
$299.00USD
No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.
Key Features
`Google Merchant Settings` single DocType holding Merchant Center account ID, service-account OAuth credentials, and default country/language/currency
Product feed generation mapping ERPNext `Item`, `Item Price`, and `Item Group` onto the Content API for Shopping product schema
Near-real-time price and availability sync via `hooks.py` doc events (`on_update` on `Item`/`Item Price` and stock ledger changes) that enqueue background jobs
Hourly/daily full-feed reconciliation through Frappe `scheduler_events` so no SKU silently drifts out of Merchant Center
GTIN, MPN, and brand validation performed in ERPNext before submission to catch invalid identifiers before Google rejects them
Attribute mapping UI for `google_product_category`, `condition`, `custom_label_0..4`, and product-type on a per-item or Item-Group basis
Multi-country / multi-currency feeds — each target market bound to its own ERPNext price list and shipping/tax mapping
Promotions and sale-price feed that reads sale price and effective date range from ERPNext Pricing Rules
Availability resolved from live stock (`get_stock_qty`/Bin) with configurable in-stock / out-of-stock / preorder thresholds
Content API batch submission with exponential backoff, retry, and per-item error capture
Feed-status write-back per product (accepted / warning / disapproved + reason) surfaced in a Frappe report and dashboard
Whitelisted REST methods for manual `push_now` and `validate_feed`, callable from the ERPNext UI and Frappe REST API
Dedicated role profile and permission rules so only authorized users can edit feed settings or trigger a push
Structured logging of every Content API request/response into a Frappe log DocType for audit and troubleshooting
Supports Frappe/ERPNext v15 and v16, packaged as a standard installable Frappe app
About this Product
Selling on Google Shopping means keeping an accurate, attribute-rich product feed in Merchant Center at all times — and ERPNext out of the box has no concept of a Merchant Center feed, GTIN/MPN validation, or Shopping-specific attributes like google_product_category, condition, or shipping. Teams end up hand-maintaining a spreadsheet or a fragile Google Sheets feed that drifts the moment a price changes in Item Price or stock moves in the Bin. The result is disapproved items, "price mismatch" and "availability mismatch" warnings, and ad spend wasted on out-of-stock SKUs.
Why Choose ERPNext Google Shopping & Merchant Center Connector
`Google Merchant Settings` single DocType holding Merchant Center account ID, service-account OAuth credentials, and default country/language/currency
Product feed generation mapping ERPNext `Item`, `Item Price`, and `Item Group` onto the Content API for Shopping product schema
Near-real-time price and availability sync via `hooks.py` doc events (`on_update` on `Item`/`Item Price` and stock ledger changes) that enqueue background jobs
Hourly/daily full-feed reconciliation through Frappe `scheduler_events` so no SKU silently drifts out of Merchant Center
GTIN, MPN, and brand validation performed in ERPNext before submission to catch invalid identifiers before Google rejects them
Attribute mapping UI for `google_product_category`, `condition`, `custom_label_0..4`, and product-type on a per-item or Item-Group basis
ECOSIRE builds a proper Frappe app — its own module, DocTypes, and permissions — that treats Google Merchant Center as a first-class integration inside ERPNext. A Google Merchant Settings single DocType holds your Merchant Center account ID, OAuth service-account credentials, target country/language/currency, and default attribute mappings. A Google Shopping Feed Item DocType (or child mapping on Website Item/Item) captures per-product overrides — GTIN, MPN, brand, google_product_category, custom labels, and sale-price windows. We map ERPNext Item, Item Price, Item Group, UOM, and stock (get_stock_qty/Bin) onto the Content API for Shopping product schema, resolving the availability and price fields Google actually validates against.
The sync runs on two paths. hooks.py doc events (on_update on Item/Item Price, and stock ledger updates) enqueue a background job so a price or availability change propagates to Merchant Center within minutes instead of waiting for the daily crawl — this is what clears "price mismatch" disapprovals. A scheduler_events hourly/daily job performs a full reconciliation and re-submits the batch, so nothing silently drifts. All Google calls go through the Content API with proper batching and exponential backoff; results (accepted, warning, disapproved with reason) are written back to each product record and surfaced in a feed-status report and dashboard, so your team sees exactly which SKUs are live and why others were rejected. Whitelisted methods expose manual "push now" and "validate feed" actions from the ERPNext UI and the Frappe REST API, gated by a dedicated role profile.
Because Google Shopping is multi-market, the app supports multiple target feeds — country/currency/language combinations — each with its own price list and shipping/tax mapping, plus a promotions/sale-price feed that reads a sale price and effective date range from ERPNext pricing rules. GTIN/MPN and brand are validated before submission so invalid identifiers are caught in ERPNext rather than bounced back from Merchant Center days later.
This is build-to-order: ECOSIRE scopes it against your exact ERPNext version (v15 or v16), your catalog structure, your price lists, and your target Google markets, then builds, installs, and supports it. There is no instant download — after a short scoping call we confirm scope in writing, and typical delivery is 2–4 weeks from confirmed scope. You receive the installable source, documentation, a training session, and a post-go-live support window.
What you get
- Installable Frappe app source code, built and version-pinned to your ERPNext release (v15 or v16)
- Installation and configuration on your instance, including Merchant Center OAuth/service-account wiring and initial feed mapping
- Technical documentation — DocType reference, hooks/scheduler behavior, attribute mapping, and whitelisted API methods
- User guide plus a live training session for your catalog and marketing team
- UAT on a staging site with a documented test plan and a rollback plan before production go-live
- Post-go-live support window for bug fixes and configuration adjustments
- Git repository handover with full commit history and release tags
- Feed-status report and dashboard configured against your live catalog
Who this is for
D2C brand running Google Shopping ads on ERPNext
Runs its own online store on ERPNext and spends on Shopping campaigns. Needs prices and stock in Merchant Center to always match ERPNext so ads never point to out-of-stock or mispriced SKUs and items stop getting disapproved.
Multi-market marketplace seller
Sells across several countries and currencies from one ERPNext catalog. Needs separate Merchant Center feeds per market, each tied to the correct price list, shipping, and tax, without maintaining a spreadsheet per country.
Performance-marketing / ecommerce ops lead
Owns feed health and ad ROAS. Wants a single dashboard in ERPNext showing which SKUs are live, which are disapproved and why, plus manual push and re-validate controls instead of logging into Merchant Center to diagnose.
ERPNext implementation partner or in-house admin
Manages the ERPNext instance and wants a clean, upgrade-safe Frappe app with proper DocTypes, permissions, hooks, and scheduler jobs — not a pile of ad-hoc server scripts — that survives v15→v16 upgrades.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the ERPNext Google Shopping & Merchant Center Connector app ZIP from your account dashboard.
Add the app to your bench
Extract the ZIP into your bench's apps folder, or run `bench get-app` with the path to the extracted app.
Install on your site
Run `bench --site SITE_NAME install-app APP_NAME` followed by `bench migrate` to install ERPNext Google Shopping & Merchant Center Connector and apply its schema.
Activate your license
Open the ECOSIRE License settings on your site and activate your license key. Requires the free ecosire_connect and ecosire_license_client apps.
How ERPNext Google Shopping & Merchant Center Connector Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Delivery model | Build-to-order Frappe app, scoped and installed for your instance | Built from scratch by your own developers | Generic marketplace app installed as-is | |
| Price & stock sync | Near-real-time via doc-event background jobs + scheduled reconciliation | Depends entirely on what you build | Usually scheduled batch only; limited event triggers | |
| Multi-country / currency feeds | Per-market feeds bound to their own price list and tax/shipping | Possible but you design and maintain it | Often single-market or extra cost per market | |
| GTIN/MPN & attribute mapping | Validated in ERPNext before submission, per-item and per Item-Group | Whatever you implement | Basic field mapping, minimal pre-validation | |
| Feed error visibility | Disapproval reasons written back per SKU with report + dashboard | You build the reporting yourself | Often only Merchant Center's own dashboard | |
| ERPNext version fit | Pinned and tested to your v15 or v16 instance | You own upgrade compatibility | Generic; may lag ERPNext releases | |
| Ownership & handover | Full source + git repo with history and release tags handed over | You own it, but bear the full build cost and time | Closed source; locked to the vendor | |
| Support | Post-go-live support window + optional retainer from ECOSIRE | Internal team only | Vendor support, variable quality and scope |
Frequently Asked Questions about ERPNext Google Shopping & Merchant Center Connector
+Is this a ready-made app I can download and install today?
No. This is build-to-order. ECOSIRE scopes the connector against your exact ERPNext version, catalog structure, price lists, and target Google markets, then builds, installs, and supports it. There is no instant download or Frappe Cloud Marketplace listing to grab.
+How long does delivery take?
Typical delivery is 2–4 weeks from confirmed scope. After a short scoping call we document the requirements and mappings, you approve them in writing, and the clock starts from that confirmed scope. Larger multi-market catalogs or heavy attribute customization can extend the timeline, which we call out during scoping.
+Which ERPNext versions are supported?
We build for Frappe/ERPNext v15 and v16 as a standard installable Frappe app with its own module, DocTypes, hooks, and scheduler events. We pin the build to your running version and account for v15→v16 API differences so an upgrade doesn't break the integration.
+How fast do price and stock changes reach Google?
Changes propagate on two paths. `hooks.py` doc events on `Item`/`Item Price` and stock ledger updates enqueue a background job that pushes the affected products via the Content API within minutes — this is what clears Google's price and availability mismatch warnings. A scheduled reconciliation job then re-submits the full feed hourly or daily so nothing drifts.
+Can it handle multiple countries and currencies?
Yes. The app supports multiple target feeds — each country/currency/language combination bound to its own ERPNext price list and shipping/tax mapping — plus a promotions/sale-price feed driven by your ERPNext Pricing Rules. The exact set of markets is confirmed during scoping.
+What about support and future updates?
Every build includes a post-go-live support window for bug fixes and configuration adjustments. You also receive the full git repository with commit history and release tags, so your team or any Frappe developer can maintain it. Beyond the included window, we offer ongoing support and enhancement retainers, and we can adapt the app when Google changes its Content API or your ERPNext version changes.
+How does it authenticate with Google Merchant Center?
Authentication is configured in a `Google Merchant Settings` DocType using a Google service account with Content API access to your Merchant Center account. Credentials are stored securely in ERPNext, and access to edit settings or trigger a push is restricted via a dedicated role profile and permission rules.
Related Modules
Request a quote
ERPNext Google Shopping & Merchant Center Connector
A build-to-order Frappe app that pushes your ERPNext product catalog to Google Merchant Center for Shopping ads and free listings, with near-real-time price and stock sync. ECOSIRE scopes, builds, installs, and supports it for your instance.
- `Google Merchant Settings` single DocType holding Merchant Center account ID, service-account OAuth credentials, and default country/language/currency
- Product feed generation mapping ERPNext `Item`, `Item Price`, and `Item Group` onto the Content API for Shopping product schema
- Near-real-time price and availability sync via `hooks.py` doc events (`on_update` on `Item`/`Item Price` and stock ledger changes) that enqueue background jobs
- Hourly/daily full-feed reconciliation through Frappe `scheduler_events` so no SKU silently drifts out of Merchant Center