When Google detects that the price shown in your ad doesn't match the price on your website, it pulls your products offline — instantly, and without warning. For this client, it happened right as they launched their biggest sale of the year. Here's what we built to fix it permanently.
100%
Policy Compliance
10 min
Sync Interval
$0
Lost Ad Revenue Since
The Problem
This client was running a healthy Google Shopping campaign with thousands of products. Their website runs on NetSuite, and they were using GoDataFeed — a feed management platform — to take their product data from NetSuite and send it to Google Merchant Center. For regular, everyday pricing, the setup worked fine.
The problem surfaced when they ran a sale. The website updated prices dynamically using JavaScript — meaning prices changed on-the-fly in the browser rather than being stored as a simple static number. GoDataFeed's standard mapping wasn't built to handle this. It kept pulling the original price and failed to recognise that a sale was in effect. So while the website was showing sale prices to customers, the Google Shopping feed was still advertising the full price.
Google noticed. The price in the ad said one thing. The price on the website said another. That's a policy violation, and Google's response is immediate: every affected product is disapproved and taken offline.
They launched their sale on Friday evening. By Saturday morning, their entire Google Shopping presence had vanished. No ads. No traffic. No sales through that channel — for the entire long weekend.
The root cause was clear but the fix wasn't simple: JavaScript-calculated prices can't be read by standard feed crawlers. GoDataFeed had no way to see them. Something different was needed.
"They launched their sale on Friday evening. By Saturday morning, their entire shopping campaign was offline. By the time they realised what had happened, they'd already lost the busiest part of the weekend."
Our Solution
The goal was a "set and forget" system — one that required absolutely zero involvement from the client, even during sales. We built a three-component closed loop that runs 24/7 and self-corrects when anything goes wrong.
How the system fits together
GoDataFeed manages the product catalogue that gets sent to Google — it holds the product IDs, URLs, names, and base pricing pulled from NetSuite. We start there. Every time our scraper runs, it fetches GoDataFeed's live product list to get the ID and web address for every item in the catalogue. This ensures the scraper always has an up-to-date list and never goes looking for a product that's been discontinued.
This was the key technical challenge. Because prices are calculated on-the-fly by JavaScript in the browser, standard feed crawlers — including GoDataFeed's native scraper — can't see them. They read the page before the JavaScript runs, so they always get the wrong number.
We bypassed the browser entirely. The NetSuite platform exposes a behind-the-scenes data API that returns full product details in a machine-readable format — including the actual current customer price, already calculated. By querying that API directly for each product URL, we get the real live price every time, regardless of what JavaScript might be doing on the frontend.
With 5,000+ products to check, we can't hit the API for all of them at once — Google's script execution environment has a 6-minute time limit per run. So we built a batching system: every 10 minutes, the script processes roughly 150 products, saves the prices to a Google Sheet, then picks up where it left off on the next run.
The full catalogue takes around 5 to 6 hours to cycle through, then it immediately starts again from the top. It never stops. It runs around the clock, every day. If a product fails for any reason, it logs the error to a separate tab in the Sheet and sends a daily summary email to the team. If the scraper ever gets into a stuck state, a reset function starts it over cleanly from the beginning.
The Google Sheet is published as a live CSV file. GoDataFeed is configured to fetch that CSV on a regular schedule and import it as a "Supplemental Import" — a merge file that gets stitched on top of the main NetSuite product data. It uses the product ID as the matching key, so every scraped price lands on exactly the right product record.
This means GoDataFeed always has two prices for each product: the regular price from NetSuite, and the live scraped price from the website. The next step decides what to do with them.
Inside GoDataFeed, we set up one rule: if the scraped live price is lower than the regular price, and the scraped price is greater than zero, mark it as a sale price in the feed.
The moment a sale starts on the website, the scraped price drops below the regular price and the rule kicks in — Google Shopping shows the sale price with the original price crossed out, which typically improves click-through rates during promotions. When the sale ends and prices return to normal, the scraped price matches the regular price again. The rule no longer triggers. The sale price field clears. Google automatically updates the ads to show the full price. Nothing needs to be manually touched at any point.
The Results
100%
Policy Compliance
Google has never flagged a price mismatch since the system went live.
10 min
Sync Cycle
Prices across all 5,000+ products are always within 10 minutes of the live website.
$0
Lost Ad Revenue
Every sale since has run on Google Shopping without a single product going offline.
This solution is a good fit if your store does any of the following:
You run sales, seasonal discounts, or promotional pricing
You have hundreds or thousands of products on Google Shopping
Your website prices update automatically (dynamic pricing)
You've had products disapproved before and don't want it to happen again
You're currently updating your feed manually — and it takes too long
Google Shopping is a meaningful sales channel you can't afford to lose
You use GoDataFeed (or a similar feed management tool) and it's not handling sale prices correctly
We've implemented this kind of solution for e-commerce stores using GoDataFeed, DataFeedWatch, and custom feed setups. If your store exposes live pricing data — and most modern platforms do — we can build the bridge that keeps Google Shopping in sync automatically.
Google's Shopping policies require that the price shown in an ad matches the price a customer actually sees when they land on the product page. If there's a difference — even by a small amount — Google considers it misleading and will disapprove the product. With thousands of products and dynamic pricing, it's very easy for a gap to appear, especially during sales events. The only way to avoid it reliably is to keep your feed in sync automatically.
No. This solution works alongside GoDataFeed, not instead of it. GoDataFeed continues to manage your full product catalogue and handle the connection to Google Merchant Center. We add a supplemental price layer on top — a live price sheet that GoDataFeed merges into its feed using your product IDs. GoDataFeed's existing setup stays intact; we're just giving it better data to work with for sale pricing specifically.
Nothing. The system runs continuously on its own. You run a sale on your website, and within minutes Google Shopping reflects the new price — sale price shown, original crossed out. When the sale ends and prices revert, Google Shopping updates automatically. The only time you'd hear from us is if the daily error report flags something — and in most cases we'd resolve it before it affects any campaigns.
The system is built to be self-healing. Any product that fails to scrape correctly is logged to an error tab in the Google Sheet. A daily summary email is sent to the team with any errors from the previous 24 hours. If the scraper ever gets stuck — for example after a website change or a temporary API timeout — a reset function starts the queue over cleanly from the beginning. This means the team is never left in the dark, and a stuck scraper is a quick fix rather than a silent problem that runs unnoticed for days.
Price mismatch is one of the most common reasons products get disapproved, but it's not the only one. Other frequent issues include missing GTINs (product barcodes), incorrect availability data, and landing page quality problems. We review your entire Merchant Center account as part of our process, so if there are other issues affecting your campaigns we'll flag them at the same time.
Typically 1 to 2 weeks from start to finish, depending on the size of your catalogue and how your website serves pricing data. We handle everything — the build, the testing, the Google Merchant Center rules, and the monitoring setup. We won't go live until we've verified it's working correctly across a representative sample of your products.
We'll review your Google Merchant Center account, identify what's causing disapprovals, and tell you exactly what we'd build to keep your products live — no jargon, no surprises.