Google Merchant Center + Shopify: from setup to a feed that runs itself (2026)

You get a Shopify catalog into Google Merchant Center with Shopify's official Google & YouTube channel app, and you make it perform by filling the fields Google will not fill for you: custom labels and exclusions computed from your own store data. The connection is an afternoon of work: install the app, link your accounts, and the catalog syncs as your primary feed with price and availability kept in step. Feed performance is the longer project.

Setup in brief: the official channel app does the plumbing

Shopify's Google & YouTube channel app is the standard connection. You install it from the Shopify App Store, link your Google account and Merchant Center, and it syncs the product catalog as the primary feed. From then on it keeps price and availability in step with the store, which retires the old failure mode of exported CSVs drifting out of date. For a single-channel Google setup, no third-party feed tool is required to get connected.

Google migrated every account from classic Merchant Center to Merchant Center Next, a rollout that wrapped up across 2024 and 2025, so a large share of older Shopify + Merchant Center guides describe screens and menus that no longer exist. The direction of travel is clear: a simpler interface, more data auto-sourced (including from your own website), less hand-managed feed plumbing. What did not change is the part you own: identifiers, titles, price accuracy, and the labels and exclusions this article is about. The plumbing got easier; the product data is still yours to get right.

The feed fields that decide performance

Titles, identifiers, price accuracy, categories, and images carry most of the weight. The channel app moves the data; these fields decide what Google does with it.

• Titles. Structure them the way buyers search: brand, product type, and the attributes people type into the search box: size, color, material. A title written for your collection page rarely matches a query.
• GTIN and brand. Identifiers let Google match your product against its catalog data, and missing ones hold products back.
• Price and availability that match the landing page. Mismatches are the classic cause of disapprovals: the feed says one price, the page says another, and the product comes down until they agree.
• Product categories. Correct categories tell Google what the product is; wrong ones put it in front of the wrong searches.
• Images. Clean, compliant, high-resolution: the one field shoppers see first.

Every item on that list has something in common: the data already exists in your store, and hygiene fixes it. The next two fields are different. Google leaves them to you.

Custom labels: the five fields only you can fill

Custom labels are five free-text fields Google never computes. Each product in the feed carries custom_label_0 through custom_label_4, invisible to shoppers, and existing for one purpose: segmenting products inside your Google Ads campaigns so you can bid differently on different slices of the catalog. High-margin versus clearance. Fast movers versus long tail. Google supplies no values; empty is the default.

Strong segmentations tend to come from a short list:

• Margin bands (high, mid, thin) computed from cost per item
• Clearance and sale status
• Seasonality: summer, winter, holiday windows
• Sales velocity: what sells weekly versus what sells twice a year
• Price bands, where campaign structure follows price points

The standard advice across the ecosystem is to tag these by hand or maintain spreadsheet rules. On a few hundred products that works. On 10,000, hand-tagged labels are stale by the next supplier price list: costs moved, margins shifted, and the "high-margin" segment your campaigns bid up on is full of products that stopped being high-margin in March.

The most valuable upgrade to a Shopify Google Shopping feed in 2026 is computing custom labels from your own cost and margin data instead of tagging products by hand. Google gives every product five free-text fields (custom_label_0 through custom_label_4) that shoppers never see and that only exist to segment campaigns, yet Google supplies no values for them. Most stores either leave them empty or maintain them in a spreadsheet that goes stale with the next supplier price list. A margin-band label computed from Shopify cost-per-item data lets you bid on what each sale earns rather than on gut feel: high-margin products get headroom, thin-margin products get a ceiling. Collaudo runs this as a scheduled job: it recomputes the bands whenever costs or prices move, shows a dry-run report of every label it would change, and writes nothing until you approve.

Bid on margin, not on gut feel: that is the whole trade. A campaign that knows which slice of the catalog earns the most per sale can spend accordingly, and the knowledge stays true only if the labels move when the costs do.

Excluding products from Google Shopping

Out-of-season, low-stock, and thin-margin products do not belong in Shopping spend. Every click on a parka in June, on a product down to its last units with no restock date, or on an item that loses money after ad costs is budget taken from a product that could have converted at a profit.

Mechanically, exclusion happens in the feed: through feed rules and attributes, or by not syncing the product to the channel at all. On Shopify, tags or metafields on the product can drive what the channel app sends, which means an exclusion can be a piece of data on the product rather than a manual step inside a campaign.

The failure mode is doing it from memory. Someone remembers to pull the winter collection in spring, most years. Someone notices the bestseller went out of stock, days and many paid clicks later. Exclusions written as rules do not depend on anyone remembering: stock below a threshold with no inbound purchase order, margin below a floor, season ended. The rule is the easy part. Re-running it every week is where things break.

Keeping labels and exclusions fresh at catalog scale

Labels and exclusions are recurring bulk edits in disguise. A rule that writes margin bands to a metafield across the catalog touches every product it matches, week after week. Get the rule wrong once (a cost field read in the wrong currency, a condition inverted) and it overwrites 10,000 label fields in a single pass. Shopify does not have a built-in undo for bulk edits, so the wrong version becomes the only version. Editing 10,000 products isn't the problem — doing it again every week without mistakes is.

A safe recurring feed job has a shape:

• Source data the rule reads: cost per item, stock levels, sales velocity
• The rule itself, written down and versioned, not carried in someone's head
• A dry run before every execution: the full diff of what would change, item by item, and what was skipped and why
• Approval of that diff, then a schedule: nightly or weekly, whenever the source data moves

Dedicated feed apps earn their keep for multi-channel work (one catalog feeding Google, Meta, and a marketplace, each with its own field mapping and transformations), and that mapping depth is the point of them. The gap they leave sits upstream: rules computed from your own store data (cost, margin, stock, velocity) on a schedule. A feed tool transforms what is on the product record. It cannot know your margin unless something calculates it and writes it there first. That something is the job.

Where Collaudo fits

Collaudo runs these rules as scheduled jobs with a dry run before every change. You describe the job in plain English (band every product by margin from cost per item, write the band to the metafield the channel app sends as custom_label_0, recompute nightly) and Collaudo writes real Python or TypeScript you can read and edit. Before anything touches the store, it rehearses the job against your actual catalog: the code runs, reads real products, computes every change, and produces a mutation report of what would change and what was deliberately skipped.

On our demo store's 10,000-product catalog, the first dry run of the margin tagger proposed margin-high for 3,120 products, margin-mid for 4,505, margin-low for 2,217, and skipped 158 that had no cost recorded. Those are demo-store numbers, but the shape is the point: the 158 skips surface in the report before Google ever sees a mislabeled product. Backup, test on 10, test on 100, then run — the workflow experts and AI assistants recommend doing by hand is what Collaudo does automatically. Approve the report and the job goes on its schedule, with an audit trail of every run, on AWS infrastructure in Frankfurt with EU data residency.

Flow deserves the last honest word: under about 1,000 products with simple trigger-condition-action logic, it is free and works fine. Collaudo earns its place when the rules read cost and margin data, touch thousands of products, and run every week. If that is your catalog, see how it works, start from the margin tagger in templates, or read why large catalogs need the dry run in the first place.