Google Shopping feeds are often treated as a purely technical export from an e-commerce website. That approach can keep product data accurate, but it can also make important merchandising fields difficult to inspect, edit and optimise at scale.
For smaller or relatively stable product catalogues, there is another option: use Google Sheets as a controlled product feed management interface while a script keeps the volatile fields synchronised with the ecommerce website.
In this hybrid system, attributes such as price, sale price, availability, product URL and image URL are imported automatically from the website’s XML product feed. More strategic attributes—including product titles, descriptions, product types and custom labels—remain editable in Google Sheets.
The result is a feed that combines automation with direct control. It behaves less like a fixed website export and more like a working Google Shopping management table: one place where every product can be reviewed, categorised and optimised without allowing commercially sensitive data to become stale.
If you are new to the channel, begin with our complete Google Shopping guide. This article focuses specifically on the feed-management architecture.
What a Google Shopping Product Feed Contains
A Google Shopping product feed is a structured catalogue of the products a retailer wants Google to use for Shopping ads and free listings. Each row normally represents one product or product variant, while each column represents an attribute.
Typical attributes include:
-
Product ID
-
Title
-
Description
-
Price and sale price
-
Availability
-
Product landing page URL
-
Main and additional image URLs
-
Brand, GTIN and MPN
-
Google product category
-
Retailer’s product type
-
Colour, size, material, pattern, gender and age group
-
Item group ID for product variants
-
Up to five custom labels for campaign segmentation
Some attributes are always required, some depend on the product category or destination, and others are optional but strategically valuable. Google’s current product data specification should therefore be treated as the authoritative requirements document.
Accurate formatting is only the starting point. Feed quality also affects how Google understands a product, which searches it may match, how the advert appears and how easily the advertiser can organise products within Shopping and Performance Max campaigns.
This makes the feed both a technical data source and a form of targeting.
What Is Google Merchant Center?
Google Merchant Center is the platform that receives, validates and processes a retailer’s product information. It connects the catalogue with Google surfaces such as Shopping ads and free product listings, and it reports product-level data, policy and eligibility issues.
Merchant Center can receive product data through several methods, including:
-
A file or Google Sheet
-
A scheduled file fetch from a URL
-
A supported ecommerce platform or third-party application
-
Website crawling and structured data
-
A direct integration using the Merchant API
Google now refers to these inputs as data sources. The current process for a file-based source is managed from the product data-source area of Merchant Center. Interface labels can change, so the principle matters more than an old sequence of menu clicks.
For large catalogues, marketplaces or inventory that changes continuously, direct platform integrations and the Merchant API are usually more appropriate. Merchant API v1 is Google’s current successor to the older Content API for Shopping.
Why Ordinary Google Sheets Feeds Are Limited
Google Sheets is one of the easiest feed formats to understand and edit. A product can be inspected in a row, attributes can be filtered, and many products can be updated with ordinary spreadsheet tools.
The weakness is freshness.
If a retailer manually enters a price of £49.99 and the website later changes to £44.99, the submitted product data no longer matches the landing page. The same problem occurs when an item goes out of stock, a sale ends, a URL changes or an image is replaced.
Price and availability mismatches can cause incorrect adverts, automatic corrections or product disapprovals. Google offers automatic product information updates, but describes them as a safeguard rather than a replacement for regularly submitting accurate product data.
A completely manual spreadsheet therefore creates an operational burden. Someone must continuously compare the sheet with the website, and the risk rises with every product and every change.
At the opposite extreme, a fully automated website feed can be accurate but rigid. Titles, product types and labels may be inherited directly from an ecommerce database that was designed for website navigation rather than advertising performance. Making a feed-specific change may require a developer, a feed rule or a change to customer-facing website content.
The hybrid model solves this by separating attributes according to how they should be managed.
The Hybrid Google Sheets Feed Model
The central idea is simple:
-
The ecommerce website remains the source of truth for fields that must reflect current commercial reality.
-
Google Sheets becomes the management interface for fields that benefit from advertising judgement and manual optimisation.
-
A script connects the two systems and updates only the columns it owns.
-
Merchant Center reads the completed spreadsheet as a product data source.
The architecture is:
Ecommerce catalogue → XML product feed → script → Google Sheet → Merchant Center → Google Ads
The XML URL is not merely copied into the sheet. The script requests the XML, parses each product, matches it to the correct spreadsheet row using a stable product ID, and writes selected values into protected dynamic columns.
All other columns remain untouched. This is the essential difference between a controlled hybrid feed and a full spreadsheet refresh that overwrites previous optimisation work.
How the XML, Script and Spreadsheet Work Together
The website or ecommerce platform first produces an XML feed containing the current catalogue data. This is normally generated from the same database used by the website, which means price, availability, URLs and image references should change when the underlying product changes.
The script stores the XML feed URL and runs on a schedule. Depending on the implementation, this can be a Google Ads Script that writes to Google Sheets or a Google Apps Script attached to the spreadsheet. Google also makes Merchant API access available to Apps Script, but a direct API integration is a different architecture from the XML-to-Sheets method described here.
On each run, the script should:
-
Fetch the XML source.
-
Check that the response is valid and complete.
-
Read each product and its attributes.
-
Match products to spreadsheet rows by a stable ID—not by row number or title.
-
Update only the designated dynamic columns.
-
Add genuinely new products according to a defined rule.
-
Identify products no longer found in the source.
-
Record the run time, results, warnings and failures.
Merchant Center then processes the finished Google Sheet. This creates a gateway between the ecommerce catalogue and Google’s advertising system while retaining a practical human editing layer in the middle.
Which Fields Should Be Dynamic or Editable?
The correct ownership model depends on the retailer, but every column should have one clearly defined owner. A script should never overwrite a field that the marketing team expects to control manually.
| Attribute group | Recommended owner | Reason |
|---|---|---|
id | Website/source system | Must remain stable and unique; it is the key used to match products safely. |
price, sale_price, sale_price_effective_date | Website/XML | Must match the landing page and active promotion. |
availability, availability_date | Website/XML | Stock and preorder status can change without warning. |
link, mobile_link | Website/XML | URLs may change following product or site updates. |
image_link, additional_image_link | Website/XML or controlled image source | Images may be replaced, although feed-specific image testing can justify separate management. |
title | Google Sheet | Allows search-led, feed-specific title optimisation without changing the website heading. |
description | Google Sheet | Allows clearer product detail and relevant language within Google’s rules. |
product_type | Google Sheet | Creates an advertiser-defined hierarchy for reporting, filtering and campaign structure. |
google_product_category | Google Sheet or reviewed mapping rule | Benefits from deliberate classification and periodic review. |
custom_label_0 to custom_label_4 | Google Sheet or spreadsheet formula | Useful for margin, seasonality, bestseller status, price bands and bidding groups. |
brand, gtin, mpn | Product database wherever possible | These identifiers should be accurate and consistent; manual overrides should be controlled. |
Variant fields such as item_group_id, size and colour | Product database wherever possible | They define genuine product variants and should reflect the catalogue. |
The distinction is not simply “dynamic versus static”. Some apparently stable fields can change, and some strategic fields can be calculated automatically. A better classification is:
-
System-owned: copied from the product database and protected from manual editing.
-
Marketer-owned: intentionally edited for advertising performance.
-
Calculated: generated by formulas or rules from other fields.
-
Governed override: normally automated, but manually replaceable through a separate override column.
An override model is often safer than editing an imported value. For example, the sheet could contain source_title, title_override and final_title. The final field uses the override when present and otherwise falls back to the source title. This preserves both provenance and control.
Why This Gives Advertisers More Control
Search campaigns use keywords as explicit targeting inputs. Shopping campaigns work differently: Google relies heavily on product data to understand what is being sold and when a product may be relevant.
A spreadsheet makes those product inputs visible and editable in bulk. It allows the feed manager to work through the catalogue in a way that feels closer to keyword management, even though Shopping campaigns do not use positive keywords in the same manner as Search campaigns.
This creates several practical advantages.
Product Title Optimisation at Scale
Website product names are often too short, brand-led or internally coded. A title such as “Classic 300” may make sense on the retailer’s website but give Google little information.
The feed title can instead include commercially useful details such as:
Brand + product type + key attribute + size/colour + model
The marketer can filter a category, apply a consistent structure, compare variations and revise every affected product directly in the sheet. The title must remain accurate and should describe the product shown on the landing page; control does not justify keyword stuffing or misleading copy.
Better Product Taxonomy
The product_type attribute uses the retailer’s own classification. It can therefore be designed around how the advertising programme is managed rather than being limited to the website’s menu structure.
For example:
Home & Garden > Garden Furniture > Outdoor Dining Sets
This makes it easier to filter product groups, analyse categories and create coherent campaign structures.
Google product category is different: it uses Google’s taxonomy. Both attributes can be useful, but they serve different purposes and should not be treated as interchangeable.
Custom Labels for Commercial Segmentation
Custom labels are among the strongest reasons to manage a feed deliberately. They do not appear to shoppers; they exist to organise products inside Google Ads.
Useful custom-label frameworks include:
-
Margin band: high, medium or low
-
Price band: under £50, £50–£100, £100–£250 and over £250
-
Sales velocity: bestseller, standard or slow-moving
-
Season: spring, summer, autumn, winter or evergreen
-
Promotional status: sale, clearance, new release or full price
-
Stock depth: high stock, low stock or constrained
-
Commercial priority: hero, growth, maintain or exclude
Some of these labels can be edited manually; others can be calculated with spreadsheet formulas. A margin-band formula, for example, can change automatically when the underlying cost or price changes.
Custom labels can then support cleaner Shopping structures, reporting and value-based decisions. They should reflect a real commercial strategy rather than becoming miscellaneous tags with no agreed meaning.
A Clear Audit Trail
Google Sheets offers filters, comments, permissions and version history. This makes feed changes easier to review than a collection of hidden rules spread across several systems.
A retailer can see:
-
Which value is being submitted
-
Whether it came from the website, a formula or a manual override
-
Who changed an editable field
-
When the automated fields were last refreshed
-
Which products are missing required information
This transparency is especially useful when PPC managers, ecommerce teams and developers share responsibility for the feed.
How to Build the System
The implementation should begin with data governance, not code.
-
Audit the source XML. Confirm that every product and variant has a stable ID and that the source contains accurate price, availability, URL, image and identifier data.
-
Define the final Merchant Center schema. List every required, conditional and useful optional attribute for the relevant categories and countries.
-
Create a column ownership map. Mark each field as system-owned, marketer-owned, calculated or override-controlled.
-
Build the spreadsheet structure. Use a dedicated product tab, consistent headers and separate operational columns for sync status, last update and errors.
-
Write the importer. Match by product ID, update selected columns in batches and preserve all manually managed values.
-
Create new-product logic. Decide whether new products should be appended as drafts, automatically activated or held until required fields are reviewed.
-
Create missing-product logic. Do not immediately delete rows solely because one import did not find them. Mark them for review or exclude them after a defined number of successful source checks.
-
Add validation. Check duplicates, missing IDs, malformed prices, unsupported availability values, invalid URLs and suspicious changes in product count.
-
Schedule the script. Set a frequency that is faster than the normal rate of catalogue change and leaves sufficient time for Merchant Center to process the updated source.
-
Connect the Sheet as a Merchant Center data source. Map the correct country, language, marketing methods and source settings.
-
Review Merchant Center diagnostics. A technically successful script run does not prove that Google accepted every item.
-
Document the process. Record column ownership, schedules, failure contacts, override rules and rollback procedures.
For a broader introduction to automation, see our guide to Google Ads Scripts.
Essential Safeguards
The main risk is not that the script fails visibly. It is that it completes while writing incomplete or incorrect data. A production-quality system should therefore fail safely.
Important controls include:
-
Stable-key matching: use the product ID or variant ID, never the title or row position.
-
Duplicate detection: stop the update if the source contains duplicate IDs.
-
Minimum record threshold: abort when the imported catalogue is unexpectedly small.
-
Change thresholds: warn or stop if price, stock or product counts change beyond reasonable limits.
-
Two-phase updates: validate data in memory or a staging tab before replacing live values.
-
Protected manual columns: prevent the script and unauthorised users from changing marketer-owned data.
-
Batch writes: write ranges in groups rather than one cell at a time to reduce execution time.
-
Logs and alerts: record successes, failures, row counts and warnings, and alert the owner when a run fails.
-
Last successful sync field: show whether the dynamic data is genuinely current.
-
Backup or versioning: retain a recoverable previous state before a large update.
-
Post-import validation: monitor Merchant Center processing and item issues, not just script execution.
Automatic item updates should normally remain enabled as an additional safety mechanism, provided the website’s structured data is accurate. Google can use landing-page data to correct certain price, sale-price, availability and condition discrepancies. However, this does not update every feed attribute and should not be used as the primary synchronisation system.
Managing New, Removed and Changed Products
New and removed products require more thought than ordinary field updates.
When a new ID appears in the XML, the script can append a new row and populate the dynamic columns. However, the product may still need an optimised title, correct category, product type, custom labels and identifiers before it is ready to advertise.
A useful approach is to include a workflow field such as:
-
new_unreviewed -
ready -
hold -
excluded -
source_missing
The final excluded_destination or submission logic can keep unreviewed products out of Shopping ads until the row is complete.
When a product disappears from the XML, avoid deleting it immediately. A temporary website error, incomplete export or timeout could make many valid items appear to have vanished. Mark the row as source-missing, confirm the result across subsequent successful imports, and then archive or exclude it according to policy.
Spreadsheet Formulas Can Add a Second Automation Layer
The script does not need to calculate every output. Google Sheets formulas can transform imported data into management fields that are easier to understand and maintain.
Examples include:
-
Assigning price bands from current price
-
Assigning margin bands from price and product cost
-
Flagging titles that exceed a chosen working length
-
Detecting missing GTINs or images
-
Identifying duplicate titles
-
Building a final title from controlled component columns
-
Setting a promotional label while a sale price is active
-
Flagging products whose last source update is too old
Formula-driven values should be converted or exposed in a way Merchant Center can process reliably. Complex formulas also need documentation: a transparent spreadsheet can become just as rigid as a feed-rule system if nobody understands the logic.
How This Compares with Other Feed Methods
| Method | Control | Freshness | Scalability | Best suited to |
| Manual Google Sheet | Very high | Low unless maintained constantly | Low | Very small, rarely changing catalogues |
| Hybrid XML-to-Sheets system | High | Good when scheduled correctly | Small to medium | Retailers that want hands-on feed optimisation without manually maintaining volatile fields |
| Scheduled XML feed | Moderate | Good | Medium to high | Retailers with a reliable ecommerce export and limited need for manual overrides |
| Platform/app integration | Varies | Good to very good | Medium to high | Standard ecommerce platforms with maintained integrations |
| Feed-management platform | High through rules | Good | High | Larger catalogues, multiple channels, countries or complex transformations |
| Merchant API integration | Very high | Potentially very high | High | High-change inventory, bespoke platforms and engineering-supported retailers |
The hybrid approach is not universally superior. Its advantage is the balance it creates for a particular operational profile.
When This Approach Is Suitable
This model is strongest when:
-
The catalogue is small or medium-sized.
-
Products, URLs and inventory do not change every few minutes.
-
The business wants direct control over titles, taxonomy and labels.
-
The website can produce a reliable XML product export.
-
Feed rules in the existing platform feel too restrictive or opaque.
-
The advertising team is comfortable working in spreadsheets.
-
Someone can maintain and monitor the script.
It is less suitable when:
-
Prices or availability change many times per day.
-
The retailer has tens or hundreds of thousands of variants.
-
Several countries, currencies, languages and marketplaces require different outputs.
-
Local or regional inventory is highly dynamic.
-
The script’s update schedule cannot keep pace with website changes.
-
There is no technical owner for failures and changes to the XML structure.
In these cases, a maintained ecommerce integration, specialist feed-management platform or Merchant API implementation is generally safer.
Feed Optimisation Is an Ongoing Process
Once the system is reliable, the spreadsheet becomes an optimisation workspace rather than a one-off setup file.
A practical routine might include:
-
Reviewing Merchant Center errors and warnings
-
Checking newly added and source-missing products
-
Improving weak or duplicated titles
-
Reviewing category and product-type consistency
-
Updating commercial custom labels
-
Comparing performance by product, category, margin and price band
-
Testing title structures within suitable product groups
-
Excluding products that cannot meet profitability or stock requirements
-
Checking that automation ran successfully and data is fresh
Feed quality should be assessed against commercial outcomes, not only approval rate. A product can be fully approved and still have a weak title, poor image, unhelpful taxonomy or no meaningful segmentation.
Our Google Shopping tips guide covers the wider optimisation process across product data, campaign management and profitability.
Frequently Asked Questions
Can Google Sheets be used as a Google Shopping feed?
Yes. Merchant Center supports product data from files and spreadsheets. The sheet must use Google’s attribute names and valid values, and it must be connected as an appropriate Merchant Center data source.
Can a Google Sheet update automatically from an XML feed?
Yes. A Google Ads Script, Google Apps Script or another integration can fetch an XML URL, parse the product records and write selected attributes into the spreadsheet. This is a custom integration rather than a standard spreadsheet formula.
Should the script overwrite the whole sheet?
No. In this model, the script should update only the system-owned columns. Overwriting the entire row could destroy optimised titles, product types, labels and manual overrides.
What is the most important technical requirement?
A stable, unique product ID. It allows the script to match the same item across the XML source, spreadsheet and Merchant Center even when titles, prices or row positions change.
Should price and stock ever be managed manually in the sheet?
Only when the spreadsheet itself is the authoritative commerce source and there is a process to keep the website consistent. In the architecture described here, price and availability should come from the live product system.
Are Merchant Center automatic updates enough?
No. Google’s automatic updates are useful protection against some mismatches, but Google explicitly advises merchants to continue submitting accurate product data regularly. They should support the feed, not replace its update process.
Is this the same as a supplemental data source?
Not necessarily. This article describes one completed Google Sheet acting as the managed product data source. A different design could leave the XML as the primary source and use an additional source to override selected attributes. The best arrangement depends on the Merchant Center account, source priority and required transformations.
Does Shopping use keywords from the spreadsheet?
Not as positive keyword targeting in the Search-campaign sense. The comparison is operational: titles, descriptions, categories and other product attributes influence Google’s understanding of relevance, while the spreadsheet makes those inputs easy to review and edit in bulk.
Conclusion
A Google Sheet does not have to be a static product feed. When it is connected to a reliable XML source through a carefully designed script, it can become a practical feed-management interface.
The website supplies current commercial facts. The script synchronises the fields that cannot safely become stale. The spreadsheet gives the advertising team direct control over the content and classification fields that shape relevance, reporting and campaign structure. Merchant Center then validates and distributes the finished product data to Google.
For the right catalogue, this creates a useful middle ground between manual feed maintenance and a rigid fully automated export. It preserves accuracy where automation is essential while giving marketers the control needed to optimise the feed as deliberately as any other part of Google Ads.