If you want to advertise e-commerce products through Google Shopping or a retail Performance Max campaign, you need to provide Google with structured product information.
This information is commonly called a product feed, shopping feed or data feed.
The feed tells Google:
What the product is
What it costs
Whether it is available
Which variant is being advertised
Where the product can be purchased
Which image should appear
Who manufactured it
How the product should be categorised
How much delivery costs
Unlike a conventional Google Search campaign, Google Shopping does not ordinarily use advertiser-selected positive keywords to decide which products should appear for a search.
Instead, Google analyses your product feed, landing pages and other contextual signals. Product titles, descriptions, identifiers and categories therefore perform much of the targeting work normally handled by keywords.
This makes the data feed one of the most important components of a Google Shopping campaign.
Is the Feed Built in Google Ads?
Despite commonly being called a Google Ads data feed, a Shopping product feed is normally submitted to Google Merchant Center.
The basic relationship is:
Your ecommerce website stores the product information.
A product feed sends that information to Merchant Center.
Merchant Center processes and reviews the products.
Merchant Center is linked to Google Ads.
Approved products become available to Shopping and Performance Max campaigns.
Google Ads uses purchase tracking to measure resulting orders and revenue.
Google increasingly uses the term “data source” within Merchant Center. However, advertisers, developers and ecommerce platforms still commonly use the term “product feed”.

What Does a Product Feed Contain?
A feed is a structured collection of product records.
Each row or item represents a product or variant. Each column or attribute describes part of that product.
A simple feed might contain:
| ID | Title | Price | Availability | Link |
|---|---|---|---|---|
| SHOE-BLK-9 | Men’s Running Trainers – Black – UK Size 9 | 79.99 GBP | in_stock | Product URL |
A more comprehensive feed can include:
ID
Title
Description
Product link
Main image
Additional images
Price
Sale price
Availability
Condition
Brand
GTIN
Manufacturer part number
Google Product Category
Product Type
Colour
Size
Material
Pattern
Gender
Age group
Item group ID
Delivery weight
Delivery dimensions
Custom labels
Google uses this data to understand the product and match it with relevant searches. Missing or incorrectly formatted attributes can cause limited visibility or disapproval. Google Merchant Center product-data specification

The Main Ways to Build a Google Shopping Feed
There is no single feed-building method that is right for every retailer.
The most suitable approach depends on:
Ecommerce platform
Number of products
Number of variants
Frequency of stock changes
Frequency of price changes
Number of advertising channels
Number of target countries
Need for title optimisation
Available technical resources
Budget for third-party software
The main options are:
Ecommerce platform integration
Platform plugin or extension
Third-party feed-management platform
Merchant Center Product Editor
Merchant Center attribute rules
Google Sheets
Google Sheets combined with a script
CSV, TSV or XML file
Merchant API
Automatic website product discovery
Using an Ecommerce Platform’s Own Feed Tools
Most established ecommerce platforms have tools, applications or extensions for sending product data to Google Merchant Center.
Platforms and ecosystems that support product-feed integrations include:
Shopify
WooCommerce
BigCommerce
Magento or Adobe Commerce
Wix
Squarespace
PrestaShop
OpenCart
These tools usually take information already stored in the ecommerce platform and map it to Merchant Center attributes.
They can potentially synchronise:
Product IDs
Titles
Descriptions
Images
Prices
Sale prices
Availability
Variants
Brand
GTIN
Delivery information
This is often the simplest starting point because price and stock updates can be automated.
Shopify Product Feeds
Shopify merchants can use the Google sales-channel integration or compatible Shopify applications to connect the catalogue with Merchant Center.
The integration can reduce the amount of manual feed development required by synchronising product information directly from Shopify.
However, the Shopify product title used on the website may not be the ideal title for Google Shopping.
A website title such as:
Air Max 90
may work when the customer is already browsing a Nike category. It provides less context when shown independently in Google Shopping.
The Shopping title might be improved to:
Nike Air Max 90 Men’s Trainers – Black – UK Size 9
Before relying on the default Shopify connection, check:
Which product title is submitted
Which description is submitted
Whether variants have unique IDs
Whether GTINs are stored correctly
How Google Product Categories are assigned
Whether custom labels can be created
How delivery settings are transferred
How frequently prices and availability update
Whether product exclusions are supported

WooCommerce and WordPress Product Feeds
WooCommerce merchants can use official or third-party extensions to create or synchronise a Merchant Center feed.
Google for WooCommerce, for example, supports server-to-server product synchronisation between WooCommerce and Merchant Center. WooCommerce also provides a separate Google Product Feed extension, while other WordPress developers offer alternative feed plugins. Google for WooCommerce
A WooCommerce feed plugin may generate:
XML feeds
CSV feeds
Scheduled product updates
Variant records
Category mappings
Custom attributes
Merchant Center synchronisation
The quality of plugins varies considerably. Before choosing one, check:
Update frequency
Product and variant limits
Support for variable products
GTIN and MPN support
Compatibility with custom fields
Delivery support
Sale-price handling
Custom-label support
Error reporting
Plugin maintenance
Compatibility with the current WordPress and WooCommerce versions
Do not select a plugin merely because it creates an XML URL. Confirm that the resulting file contains complete, correctly formatted and current product data.
Advantages of Platform Integrations
A platform integration can provide:
Faster initial setup
Automatic product creation
Automatic stock updates
Automatic price updates
Variant synchronisation
Less manual maintenance
Reduced development requirements
Limitations of Platform Integrations
The default output may still have:
Weak product titles
Short descriptions
Missing GTINs
Poor Product Type structures
Incomplete variant information
No commercial custom labels
Limited exclusion controls
Incorrect category mapping
Insufficient control for multiple countries
A platform connection is a data-delivery method. It is not necessarily a complete feed-optimisation strategy.
Using a Third-Party Feed-Management Tool
Third-party feed-management platforms sit between the ecommerce platform and Merchant Center.
The typical flow is:
Import product data from the ecommerce platform.
Map source fields to Google attributes.
Apply rules and transformations.
Exclude unsuitable products.
Validate the resulting data.
Send the transformed feed to Merchant Center.
Repeat the process automatically.
Examples include:
DataFeedWatch
Channable
Feedonomics
Productsup
GoDataFeed
Other specialist feed-management services
These examples should not be interpreted as a universal recommendation. The right platform depends on catalogue size, required channels, internal resources and budget.
Google also maintains information about recognised feed-tool partners that can assist with building and managing feeds. Google Merchant Center feed-tool partners
What Third-Party Tools Can Do
A feed-management platform may allow you to:
Rewrite titles without changing website titles
Combine multiple source attributes
Standardise colour values
Map internal categories to Google categories
Exclude low-margin products
Exclude out-of-stock products
Add custom labels
Create different feeds for different countries
Convert currencies
Apply channel-specific rules
Identify missing attributes
Manage multiple marketplaces
Schedule frequent updates
For example, a rule could create a Google Shopping title by combining:
Brand
Source title
Colour
Size
Another rule could assign a commercial label:
Gross margin above 40% →
high_marginGross margin from 20% to 40% →
medium_marginGross margin below 20% →
low_margin
When a Third-Party Tool Makes Sense
A dedicated platform becomes more useful when:
The catalogue contains hundreds or thousands of products
Products are advertised across several channels
The source data requires extensive transformation
The retailer operates in multiple countries
Different teams manage source data and advertising
The website cannot be changed easily
Product titles need channel-specific optimisation
Commercial segmentation is important
The feed requires frequent error monitoring
Potential Disadvantages
Third-party feed platforms can introduce:
Additional monthly costs
Another system to maintain
Complex transformation rules
Dependency on the provider
Greater difficulty identifying the original source of an error
Duplicate or conflicting data sources
A learning requirement for internal teams
The tool should simplify product-data management rather than create an undocumented second product database.
Using the Product Editor in Google Merchant Center
Merchant Center has its own Product Editor.
This allows merchants to add or edit product information directly inside Merchant Center without building an external file for every change.
Depending on the account and product source, the editor can be used to change information such as:
Product title
Description
Price
Images
Availability
Brand
Identifiers
Other product attributes
Individual products can be selected from the Products area and edited. Bulk editing may also be available to some merchants. Google’s Product Editor guidance
When the Product Editor Is Useful
The Product Editor is useful when:
Only a few products need to be added
A small number of corrections are required
The catalogue is very small
A merchant needs to test a product
Missing information must be added quickly
The business does not have another feed system
Why It Is Not Ideal for Large Catalogues
Editing products individually becomes impractical when:
Hundreds of products are involved
Prices change frequently
Stock levels change throughout the day
Variants are numerous
The same correction applies to an entire category
Several people manage the catalogue
Direct Merchant Center edits also need to be considered alongside the primary source. If an ecommerce integration or product file remains authoritative, later synchronisation may replace, conflict with or complicate manual changes.
For long-term management, correct important information in the primary source or use a controlled transformation rule.
Using Merchant Center Attribute Rules
Merchant Center attribute rules provide an intermediate option between accepting the source data exactly as submitted and purchasing a third-party feed-management platform.
Attribute rules can transform product data inside Merchant Center.
They can be used to:
Replace a value
Add a missing value
Combine source attributes
Standardise formatting
Map categories
Construct titles
Create custom labels
Apply conditions
Google currently makes attribute rules available through the Data Sources area for applicable product sources. Google Merchant Center attribute rules
Example Title Rule
Suppose the original product data contains:
Brand: Nike
Title: Air Max 90
Gender: Men
Colour: Black
Size: UK 9
A rule could combine these into:
Nike Air Max 90 Men’s Trainers – Black – UK 9
The exact rule structure depends on the source attributes and Merchant Center configuration.
Example Custom-Label Rule
A rule could assign:
Products above £250 →
high_valueProducts between £100 and £250 →
medium_valueProducts below £100 →
low_value
This can help organise Google Ads product groups.
Advantages of Merchant Center Rules
Rules provide:
No additional feed-management subscription
Transformations without changing the website
Conditional attribute creation
Useful corrections for small or medium feeds
Direct integration with the existing product source
Limitations of Merchant Center Rules
Rules can become difficult to manage when:
Many transformations are required
Several source feeds are involved
Multiple countries require different logic
Rules depend on commercial data not present in the feed
The same products are sent to several advertising platforms
Documentation is poor
The logic becomes deeply nested
If dozens of rules are needed to repair basic product information, the source data or feed architecture probably needs to be improved.
Using Google Sheets as the Product Feed
Google Sheets is one of the most accessible ways to create a Merchant Center feed.
Google provides a compatible spreadsheet template. Changes made to the connected spreadsheet are reflected in Merchant Center, with Google stating that the sheet is synchronised approximately every 24 hours. Adding products with Google Sheets
A basic sheet might contain:
| id | title | description | link | image_link | availability | price |
| RUN-BLK-9 | Men’s Running Trainers – Black – UK 9 | Lightweight road-running trainers | Product URL | Image URL | in_stock | 79.99 GBP |
Advantages of Google Sheets
Google Sheets provides:
Simple initial setup
Direct control over product attributes
Familiar spreadsheet editing
Easy collaboration
Flexible title optimisation
Custom-label creation
No specialist feed-management subscription
Disadvantages of a Fully Manual Sheet
A completely manual feed creates risks when:
Prices change
Products sell out
Sale periods begin or end
Images change
URLs change
New products are introduced
Products are discontinued
The more dynamic the catalogue, the greater the chance that Merchant Center and the website will become inconsistent.
This is where a hybrid Google Sheets and script-based system can become useful.
Building a Hybrid Google Sheets Feed With an XML Source and Script
A useful custom approach is to combine:
A Google Sheet
A product XML file from the website
A Google Ads Script or Google Apps Script
Merchant Center’s Google Sheets data source
The objective is to separate relatively static marketing information from dynamic ecommerce information.
Static and Dynamic Feed Attributes
Some feed attributes benefit from manual optimisation and do not change frequently.
These include:
Product title
Description
Product Type
Google Product Category
Custom labels
Marketing classifications
Campaign groupings
Other values can change regularly and should normally come from the ecommerce system.
These include:
Price
Sale price
Sale effective date
Availability
Product URL
Main image URL
Stock-dependent status
The sheet can therefore act as a controlled marketing layer while the script keeps transactional information synchronised.
Example Sheet Structure
| id | title | description | product_type | custom_label_0 | price | availability | link | image_link |
| RUN-BLK-9 | Optimised title | Optimised description | Footwear > Running | high_margin | Updated by script | Updated by script | Updated by script | Updated by script |
In this example:
The marketing team controls the title and description.
The ecommerce system remains responsible for price and stock.
The script joins the two datasets using the product ID.
Merchant Center reads the completed Google Sheet.
Important Clarification: Product XML Is Not Necessarily a Sitemap
The website XML file must contain the product information required by the script.
A conventional XML sitemap may contain only:
Page URL
Last-modified date
Change frequency
Priority
It will not necessarily contain:
Product ID
Price
Sale price
Availability
Image URL
GTIN
For the hybrid approach, you normally need a product-feed XML file, an ecommerce export or another endpoint containing structured product data.
If the website’s XML source does not contain price and availability, the script cannot reliably extract those values from it without crawling individual product pages or using another API.
How the Google Sheets Script Workflow Operates
The automated workflow can operate as follows:
The ecommerce platform publishes an XML product feed.
The script retrieves the XML URL.
The script parses the product records.
Each XML product is matched with a Google Sheets row using the product ID.
The script updates only the approved dynamic columns.
Manually optimised static columns remain untouched.
The script records errors and unmatched IDs.
Merchant Center synchronises the completed sheet.
Merchant Center processes the updated products.
Google Ads uses the approved product data.
The product ID should be the joining key. Do not match products by row number because products can be added, removed or reordered.
Google Ads Script or Google Apps Script?
Both terms are sometimes used interchangeably in casual discussion, but they are not exactly the same environment.
Google Ads Scripts
A Google Ads Script runs from the Google Ads account. It can access Google Sheets through SpreadsheetApp, and Google’s documentation provides examples of opening and modifying spreadsheets. SpreadsheetApp in Google Ads Scripts
A Google Ads Script can therefore be scheduled from Google Ads to:
Fetch an external product source
Read or modify a Google Sheet
Update dynamic product fields
Produce logs or alerts
This may be convenient when the PPC team already manages scripts within Google Ads.
Google Apps Script
A Google Apps Script can be attached directly to the Google Sheet.
It can:
Fetch HTTP or HTTPS resources with
UrlFetchAppParse XML with
XmlServiceRead and update spreadsheet cells
Run on time-based triggers
Send alerts
Record processing logs
Google documents both URL fetching and XML parsing as supported Apps Script services. UrlFetchApp documentation, XmlService documentation
For a process whose only purpose is updating a Google Sheet, a spreadsheet-bound Google Apps Script is often the cleaner choice because it does not need to be associated with a specific Google Ads account.
However, a Google Ads Script remains technically possible and may suit an agency workflow where feed operations and alerts are managed centrally from Google Ads.
Designing the Script Safely
The script should not simply erase and rebuild the entire spreadsheet without safeguards.
A robust design should:
Match products using a stable ID
Update only specified dynamic columns
Preserve manually edited static columns
Validate prices and currencies
Validate allowed availability values
Reject blank or malformed source values
Identify products missing from the XML
Identify new XML products missing from the sheet
Record the update time
Produce an error log
Avoid changing the header row
Avoid changing manually assigned labels
Keep a backup before major structural changes
Recommended Column Ownership
A clear ownership model prevents accidental overwrites.
| Attribute | Suggested owner |
| ID | Ecommerce platform; locked after creation |
| Title | Marketing team or controlled title rule |
| Description | Marketing team or source product content |
| Product Type | Marketing or merchandising team |
| Google Product Category | Marketing or feed manager |
| Custom labels | PPC or commercial team |
| Price | Ecommerce platform |
| Sale price | Ecommerce platform |
| Availability | Ecommerce platform |
| Product link | Ecommerce platform |
| Image link | Ecommerce platform |
| Brand | Ecommerce product database |
| GTIN | Ecommerce product database |
| MPN | Ecommerce product database |
Not every business needs the same ownership structure, but each attribute should have one clear source of truth.
Script Update Logic
A safe update process might follow this logic:
Fetch the XML file.
Confirm that the server returned a successful response.
Parse the XML.
Build a product lookup table keyed by product ID.
Read the existing sheet into memory.
Locate the dynamic-column indexes by header name.
Match each sheet ID to an XML ID.
Validate the proposed values.
Update price, availability, link and image fields.
Leave title, description and labels unchanged.
Mark unmatched products for review.
Write the changes in batches.
Record the completion time and number of updates.
Send an alert if the process fails.
Batch spreadsheet writes are preferable to updating one cell at a time because they are generally faster and more reliable for larger datasets.
What Happens When a Product Disappears From the XML?
The script needs a defined policy for missing products.
Possible approaches include:
Set availability to
out_of_stockExclude the product from Shopping
Leave the previous value but flag the product for review
Remove the product after a defined grace period
Move the row to an archive sheet
Immediately deleting a product because it is absent from one XML request can be risky. The source feed might be temporarily incomplete or unavailable.
A safer process can require the product to be missing for several consecutive updates before taking irreversible action.
What Happens When the XML Contains a New Product?
A new source product might not yet have manually optimised static fields.
The system could:
Add it to a separate “New Products” sheet
Add a draft row without activating it
Populate the source title and description temporarily
Notify the feed manager
Require manual approval before Merchant Center submission
Automatically adding every new product directly to the live feed may result in weak titles, missing classifications or unsuitable products entering campaigns.
Scheduling the Script
Schedule the update according to how frequently the source data changes.
Possible schedules include:
Daily for stable catalogues
Several times per day for active stock
Hourly for faster-moving catalogues
The script should ideally run before Merchant Center’s next sheet synchronisation.
If more frequent or near-real-time updates are essential, a Google Sheet may no longer be the best architecture. A platform integration or Merchant API connection may be more appropriate.
Limitations of the Google Sheets and Script Approach
The hybrid approach provides flexibility, but it is still a custom system.
Potential limitations include:
Script execution limits
Google service quotas
Large spreadsheet performance
XML namespace complexity
Feed URL timeouts
Unexpected XML structure changes
Missing source identifiers
Multiple people editing the sheet
Merchant Center’s sheet synchronisation interval
Requirement for monitoring and maintenance
The approach is most suitable when:
The catalogue is small or medium-sized
The business needs manual title control
Price and availability change regularly
The XML structure is dependable
A technically capable person can maintain the script
Near-real-time stock updates are not essential
For a very large catalogue or rapidly changing stock, use a platform integration, third-party feed tool or Merchant API.
Building a CSV or TSV Feed
A CSV or tab-separated feed uses the same row-and-column structure as Google Sheets.
A simplified CSV record could look like:
id,title,description,link,image_link,availability,price
RUN-BLK-9,"Men’s Running Trainers – Black – UK 9","Lightweight road-running trainers","https://example.com/product","https://example.com/image.jpg",in_stock,"79.99 GBP"
Use quotation marks correctly when values contain commas.
Check:
Character encoding
Delimiter
Column headers
Quotation marks
Escaped characters
Line breaks
Currency formatting
URL formatting
After submission, inspect several products in Merchant Center to confirm that the values entered the intended attributes.
Building an XML Feed
An XML feed wraps the attributes in structured tags.
A simplified product could resemble:
<item>
<g:id>RUN-BLK-9</g:id>
<g:title>Men’s Running Trainers – Black – UK 9</g:title>
<g:description>Lightweight road-running trainers</g:description>
<g:link>https://example.com/product</g:link>
<g:image_link>https://example.com/image.jpg</g:image_link>
<g:availability>in_stock</g:availability>
<g:price>79.99 GBP</g:price>
<g:brand>Example Brand</g:brand>
<g:gtin>5012345678900</g:gtin>
</item>
This is a simplified individual record rather than a complete XML document.
A production XML feed needs:
Valid document structure
Correct namespace declarations
Proper character escaping
Accessible hosting
Dependable regeneration
A scheduled Merchant Center retrieval
Valid product attributes
Validate the complete XML file before submitting it.
Using the Merchant API
The Merchant API is designed for programmatic product management.
It is most suitable where:
The catalogue is large
Product information changes frequently
Price and stock need rapid updates
Several countries are involved
A custom commerce platform is used
Merchant Center configuration also needs automation
The API can manage product data much more directly than a daily spreadsheet synchronisation.
However, it requires:
Development expertise
Authentication
Error handling
Monitoring
API quota management
Maintenance as systems change
A successful API response means Merchant Center accepted the product data for processing. It does not automatically mean the product has been approved for advertising.
Creating the Core Product Attributes
Regardless of the technical method, the same underlying product data principles apply.
Product ID
Every product or variant needs a unique and stable ID.
A retailer’s SKU can be suitable when it is:
Unique
Permanent
Not recycled
Specific to the variant
Do not change IDs whenever the feed is regenerated.
Product Title
The title is one of the most important feed attributes for matching and click-through rate.
A useful structure is:
Brand + Product Type + Model + Important Attributes + Colour + Size
For example:
Nike Air Max 90 Men’s Trainers – Black – UK Size 9
Put important information near the beginning because the entire 150-character title will not appear in every placement. Google’s product-title specification
Product Description
Include:
Product type
Features
Materials
Dimensions
Intended use
Compatibility
Technical details
Included components
Avoid promotional language, competitor terms and unrelated search phrases.
Product Link
The link should lead directly to the specific purchasable product or variant.
Do not send customers to:
Homepage
Search results
Broad category
Unrelated product
Quotation form
Image Link
The image should:
Show the correct product
Match the variant
Be high resolution
Be accessible to Google
Contain no promotional overlays
Contain no watermark
Contain no artificial border
Google has announced a minimum image size of 500 × 500 pixels for all products from 31 January 2027 and recommends images of 1500 × 1500 pixels or above. Google’s product-image requirements
Price
Use the amount and currency:
79.99 GBP
For UK consumer Shopping activity, the submitted price should include VAT where applicable.
The same price should appear in:
Feed
Landing page
Basket
Checkout
Availability
Use supported values such as:
in_stockout_of_stockpreorderbackorder
Do not keep unavailable products marked as in stock merely to preserve advertising visibility.
Brand and Product Identifiers
Submit:
Manufacturer brand
GTIN when assigned
MPN where applicable
Do not invent identifiers or use an internal SKU as a GTIN.
Product Category
Google Product Category uses Google’s own taxonomy. Product Type uses the retailer’s category hierarchy.
For example:
Google Product Category:Apparel & Accessories > Shoes > Athletic Shoes
Product Type:Footwear > Men’s Footwear > Running Trainers
Product Variants
Every variant should have:
Unique ID
Shared item-group ID
Correct colour
Correct size
Correct image
Correct price
Correct availability
Suitable landing-page selection
Add Custom Labels for Google Ads
Custom labels provide commercial information that does not ordinarily appear in the advert.
Google provides five custom-label fields:
custom_label_0custom_label_1custom_label_2custom_label_3custom_label_4
They can contain values such as:
high_marginlow_marginbestsellerclearancenew_productwinterlow_stockprice_100_250
These labels can be used to organise products inside Google Ads according to commercial value rather than product category alone.
Keep the Feed Updated
The feed should update frequently enough to reflect changes to:
Price
Sale price
Availability
Images
Landing-page URLs
New products
Discontinued products
A stable catalogue may need only daily updates. Fast-moving stock may require several updates per day or an API-based solution.
Automatic item updates can use website structured data to correct some temporary price and availability inconsistencies. They should not replace a properly maintained primary data source.
Submit the Feed to Merchant Center
Once the data source is ready:
Create or access Merchant Center.
Add the business information.
Verify and claim the website.
Configure delivery.
Configure returns.
Select the relevant countries and languages.
Add the product data source.
Allow Google to process the products.
Review product diagnostics.
Correct errors and warnings.
Link Merchant Center with Google Ads.
Google supports primary data sources from files, Google Sheets and APIs. The primary source is the only source type that can add or remove products. Creating a Merchant Center product data source
Review Merchant Center Diagnostics
Products may appear as:
Approved
Pending
Limited
Disapproved
Common feed issues include:
Missing attributes
Invalid GTINs
Incorrect categories
Price mismatches
Availability mismatches
Image problems
Landing-page errors
Delivery problems
Variant issues
Policy violations
Correct the underlying source problem where possible rather than repeatedly patching individual products.
Which Feed-Building Method Should You Use?
The following provides a practical starting point.
| Situation | Suitable approach |
| Very small, stable catalogue | Product Editor or Google Sheets |
| Small catalogue requiring manual title control | Google Sheets |
| Small or medium catalogue with dynamic price and stock | Google Sheets plus script |
| Shopify store requiring straightforward synchronisation | Shopify integration |
| WooCommerce store requiring straightforward synchronisation | WooCommerce feed plugin or integration |
| Medium or large catalogue needing transformation rules | Third-party feed-management platform |
| Multiple advertising and marketplace channels | Third-party feed-management platform |
| Large, rapidly changing catalogue | Merchant API or robust platform integration |
| A few simple corrections | Merchant Center Product Editor |
| Conditional transformations to one Merchant Center source | Merchant Center attribute rules |
| Custom ecommerce platform with development resources | XML feed or Merchant API |
The cheapest method is not necessarily the most cost-effective. Account for maintenance time, feed errors, stock accuracy and the commercial cost of product disapprovals.
Google Shopping Data Feed Checklist
Before activating Google Ads, confirm that the feed is ready.
Data Source
The correct feed method has been selected
The primary source of truth is documented
Dynamic and static attributes have clear owners
The feed updates frequently enough
Backup and error-handling processes exist
Duplicate product sources have been avoided
Product Identification
Every product has a unique ID
IDs remain stable
Every variant has a unique ID
Variants use an appropriate item-group ID
Brand information is accurate
GTINs are supplied where assigned
MPNs are supplied where applicable
Product Content
Titles accurately describe the products
Important title information appears first
Descriptions contain useful product information
Product Types are consistent
Google Product Categories are accurate
Apparel attributes are complete
Colours and sizes are standardised
Price and Availability
Prices match the landing pages
UK consumer prices include VAT where applicable
Currencies are correct
Sale prices are genuine
Sale dates are accurate
Availability is current
Bulk pricing reflects the minimum purchasable quantity
Links and Images
Links lead directly to the correct products
Landing pages show the submitted variants
Image URLs are accessible
Images match the product variants
Images meet current size requirements
Images contain no promotional overlays
Additional images are supplied where available
Automation
Script matching uses product ID—not row position
Dynamic columns are updated automatically
Manually optimised columns are protected
Blank source values do not overwrite valid data
Missing products are flagged
New products require an appropriate review process
Script failures generate alerts
Update times are logged
Merchant Center synchronisation timing is understood
Merchant Center and Google Ads
Merchant Center has processed the feed
Product diagnostics have been reviewed
Critical errors have been corrected
Products are approved or appropriately pending
Merchant Center is linked to Google Ads
Purchase-conversion tracking has been tested
Revenue values and currencies are accurate
Unique transaction IDs are recorded
Final Thoughts
There are many ways to build a Google Ads product feed.
A small retailer might begin with the Merchant Center Product Editor or Google Sheets. A Shopify or WooCommerce store may use its platform integration. A larger retailer may require a third-party feed-management platform or the Merchant API.
The hybrid Google Sheets approach can be particularly useful when a business wants direct control over static marketing attributes while automatically synchronising dynamic ecommerce information.
In that structure:
The ecommerce platform controls price and stock.
The marketing team controls titles and descriptions.
The script joins the two datasets using the product ID.
Merchant Center processes the completed Google Sheet.
Google Ads uses the approved products.
Whichever method is selected, the core principles remain the same.
The feed should be:
Comprehensive
Accurate
Search-relevant
Variant-specific
Consistent with the website
Updated regularly
Easy to monitor
Clear about which system owns each attribute
A product feed is not merely a technical requirement. It is the targeting and data foundation of a Google Shopping campaign. The better the information supplied to Google, the stronger the foundation for relevant visibility, automated bidding and profitable ecommerce growth.
To learn more, explore our Google Ads Guide to Google Shopping and practical Google Shopping Tips for improving feed quality, campaign structure and advertising performance.