Google Shopping Ads Data: Track Sponsored Product Listings

Every shopping listing you pull through the Google Shopping API carries a sponsored flag. That single boolean is the key to tracking ad placements: filter on it, count the ads, and you have the start of a shopping ad-intelligence feed.

This guide shows how to pull that data with the API, what the sponsored field actually means on a shopping rail, and the honest limits of ad tracking from product listings.

Table of Contents

• Why track sponsored product listings
• Reading the sponsored flag
• Working Python: count and analyze ads
• Honest limits of ad tracking
• What it costs
• FAQ

Why track sponsored product listings

When a shopper searches for a product, the listings they see are largely paid placements — the modern successor to the classic Product Listing Ad unit. Which merchants appear, in what order, and at what price is valuable competitive signal.

Three uses pop up constantly:

• Share of voice. Are you (or a competitor) present in the product rail for a keyword, and at what position?
• Merchant mix. Who is buying the slots in your category — big marketplaces, brands, or resellers?
• Price context. The price on a paid listing is the price a shopper is actually offered. That is the price worth benchmarking.

All three need the same raw material: a clean list of listings with their ad status, price, and merchant. That is exactly what a shopping API returns.

Reading the sponsored flag

Here is a real item from a live sony headphones query through the Google Shopping API engine (August 4, 2026). Note the Google-style field names — link, source, product_rating:

{
  "position": 1,
  "title": "Sony WH-1000XM6",
  "link": "https://www.bestbuy.com/product/sony-wh1000xm6-...",
  "source": "Best Buy",
  "price": "$299.99",
  "currency": "USD",
  "thumbnail": "https://img.example.com/products/wh1000xm6.jpg",
  "product_rating": null,
  "product_reviews": null,
  "sponsored": true,
  "snippet": "These are ideal for users seeking top-tier noise cancellation..."
}

The sponsored field is true here. On Yahoo-sourced shopping rails that is the norm rather than the exception — virtually every listing in the product rail is a paid placement, so don't expect a 50/50 organic mix. Your tracking logic should filter on the flag and report the real split, not assume one.

Working Python: count and analyze ads

Here is a complete, runnable script. It pulls listings for a query, filters the sponsored ones, and prints an ad table plus a merchant breakdown.

Replace sk_live_your_key with your key from the dashboard.

import requests
from collections import Counter

API_KEY = "sk_live_your_key"
BASE_URL = "https://apiserpent.com/api/shopping"

def shopping_listings(query, num=10):
    resp = requests.get(
        BASE_URL,
        params={"q": query, "engine": "google", "num": num},
        headers={"X-API-Key": API_KEY},
        timeout=60,
    )
    resp.raise_for_status()
    return resp.json()["results"]["shopping"]

def money(item):
    return item.get("price") or "n/a"

products = shopping_listings("nike running shoes")
ads = [p for p in products if p.get("sponsored")]
organic = [p for p in products if not p.get("sponsored")]

print(f"listings: {len(products)} | sponsored: {len(ads)} | non-sponsored: {len(organic)}")
print()
print("Sponsored listings")
print("-" * 74)
for p in ads:
    print(f"#{p['position']:>2} {p['title'][:32]:32} {money(p):10} {p['source'][:20]:20}")

print()
print("Merchants in the sponsored rail")
for merchant, count in Counter(p.get("source") for p in ads).most_common():
    print(f"  {merchant or 'unknown':22} {count}")

Run it and you get output like this (trimmed):

listings: 10 | sponsored: 10 | non-sponsored: 0

Sponsored listings
----------------------------------------------------------------------
# 1 Nike Vomero 18                       $155.00    Macy's
# 2 Nike Pegasus 42                      $145.00    Fleet Feet
# 3 Nike Vaporfly 4                      $270.00    Fleet Feet
...

Merchants in the sponsored rail
  Macy's                    3
  Fleet Feet                2
  Foot Locker               1
...

In this real run, all ten listings were sponsored — consistent with a shopping rail made of affiliate placements. Your script now has the exact data you need for a daily share-of-voice report.

Honest limits of ad tracking

Tracking ads from product listings is powerful but has ceilings. Say them out loud before you build on top:

• The rail is mostly or all paid. A shopping query surfaces paid placements. If you need a true organic-vs-paid split, you need the full web SERP, not the shopping rail.
• No bid or spend data. A listing price is not an ad bid. You can observe which merchant won the slot and at what price, but not what they paid for it.
• Short depth. One query returns roughly a dozen listings. Track many keywords to build a representative picture.
• Price can be null. A small share of listings appear without a displayed price at read time; the API returns null rather than inventing a number.

Those limits are why ad tracking from a shopping API works best as a position + price + merchant monitor, not as a replacement for an advertising platform's own reporting.

What it costs

Shopping searches are billed per 1,000 calls, paid from the first call. Current tiers: $0.60 / 1K at Default, $0.06 / 1K at Growth, $0.03 / 1K at Scale. No per-page multiplier, no subscription, credits never expire. Full table on the pricing page.

FAQ