Scrape Yahoo Shopping Data in Python: Real Code (2026)

Yahoo Shopping product data — title, merchant, price, currency, URL, thumbnail, and a sponsored flag — comes back as clean JSON through a shopping API. There is no official Yahoo Shopping search API, so the practical path for a Python script is a shopping API that returns the product rail as structured data.

This guide shows the documented Python request and the practical limits observed in saved August 2026 examples: nullable prices and a short result set. Verify current output before building a production alert.

Table of Contents

• Why scrape Yahoo Shopping at all
• What Yahoo actually exposes
• The fields the API returns
• Working Python: one call to a product table
• Honest limits: what Yahoo won't give you
• What it costs
• FAQ

Why scrape Yahoo Shopping at all

Google Shopping gets nearly all the attention. Every SERP provider, scraper library, and tutorial covers Google Shopping prices. Yahoo Shopping is the quieter sibling — and that is exactly why it is worth a look. Inspect the Yahoo Search interface for the actual query and region; classify an ad from its label or returned indicator, not from its position.

Fewer people track it means less competition for the data you collect. If you run a price-monitoring or price intelligence workflow, adding a second product source gives you a cross-market check on what a shopper actually sees on another engine. That cross-engine view is the whole idea behind our Google vs Yahoo price comparison workflow.

Yahoo Shopping also surfaces real merchants — Macy's, Best Buy, Fleet Feet, Foot Locker, Walmart — with real prices, which makes it a genuine complement to a Google Shopping feed rather than a low-quality mirror.

What Yahoo actually exposes

First, the honest picture. Yahoo does not have a public API for reading Shopping search results. Its product search returns a compact set of listings. A card’s position alone does not establish whether it is an ad or how a click is monetized.

• You get a short list per query — up to 20 listings (about 17 on average in our October 2026 measurement); there is no pagination.
• Classify an ad only when its label or returned indicator supports that status; leave other cards unclassified.

Those aren't bugs in an API — they are properties of the source. Any tool that scrapes Yahoo Shopping runs into the same ceiling, because the page itself only shows that much.

The fields the API returns

The Yahoo Shopping API returns each product with the fields below. Here is one real item from a live sony headphones query (August 4, 2026):

{
  "position": 2,
  "title": "Sony WF-1000XM6",
  "price": "$299.99",
  "extractedPrice": 299.99,
  "currency": "USD",
  "merchant": "Best Buy",
  "store": "Best Buy",
  "url": "https://www.bestbuy.com/product/sony-wf1000xm6-...",
  "thumbnail": "https://img.example.com/products/wf1000xm6.jpg",
  "rating": null,
  "reviews": null,
  "sponsored": true,
  "snippet": "These earbuds are ideal for users seeking a premium audio experience..."
}

Field	What it is
position	1-based slot in the Yahoo rail.
title	Product name.
price	Displayed price as text, e.g. $299.99. May be null — see limits below.
extractedPrice	The same price as a number, ready for math. Present only when a price is.
currency	ISO currency code, e.g. USD. Our API keeps this as a separate field.
merchant / store	Seller name, e.g. Best Buy.
url	Direct product URL on the merchant's site.
thumbnail	Product image.
rating / reviews	Review score and count when Yahoo shows them (often null).
sponsored	true when the listing is a paid placement.
snippet	A short product description.

Working Python: one call to a product table

Here is a complete, runnable script. It queries Yahoo Shopping, prints a table, and handles the two things that trip people up: missing prices and the short result list.

Replace sk_live_your_key with your key from the dashboard. Authentication is the X-API-Key header.

import requests

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

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

def money(item):
    price = item.get("price")
    if not price:
        return "n/a"          # Yahoo sometimes shows the card without a price
    return price

products = yahoo_shopping("nike running shoes")

print(f"{'#':>2} {'title':38} {'price':10} {'merchant':22}")
print("-" * 76)
for p in products:
    print(f"{p['position']:>2} {p['title'][:38]:38} {money(p):10} {p['merchant'][:22]:22}")

priced = sum(1 for p in products if p.get("price"))
print(f"\n{len(products)} products, {priced} with a price, "
      f"{len(products) - priced} without.")

Run it and you get a table like this (trimmed):

 # title                                       price      merchant
 1 Nike Vomero 18                              $155.00    Macy's
 2 Nike Pegasus 41                             n/a        Macy's
 3 Nike Pegasus 42                             $145.00    Fleet Feet
 4 Nike Vaporfly 4                             $270.00    Fleet Feet

10 products, 8 with a price, 2 without.

Notice two things. First, the result list is short — that is Yahoo's rail, not a missing feature. Second, one product came back without a price. The script treats that honestly instead of pretending a number exists.

Honest limits: what Yahoo won't give you

Scraping Yahoo Shopping has hard ceilings, and a good scraper plans around them:

• Depth. One call returns up to 20 products. Requesting a larger num does not conjure more listings — Yahoo only surfaces what it surfaces.
• Use the documented API route. Build against /api/shopping; historical search-page URLs are outside this contract.
• No delivery or condition fields. Yahoo's product rail does not expose shipping speed, product condition, or an internal product ID in its card markup. We do not fabricate them.
• No old-price / discount data. There is no original-price field in the rail, so a true "was / now" discount split is not available from this source.
• Price can be missing. Yahoo hydrates the price footer asynchronously, so a small share of listings can appear without a price at read time.
• Ad status. Use a supported sponsored value when present; do not force every card into the paid category.

If you need deep catalogs, delivery data, or discount history, a dedicated product feed or a marketplace's own API is the right tool. For a fast, clean read of what Yahoo Shopping shows for a query — which is the realistic use case — a shopping API is the sweet spot.

What it costs

Yahoo Shopping searches are billed per 1,000 calls, pay-as-you-go. Tiers:

Tier	Per 1,000 calls	Per call
Default	$0.35	$0.00035
Growth	$0.32	$0.00032
Scale	$0.25	$0.00025
Enterprise	$0.21	$0.00021
Enterprise Plus	$0.18	$0.00018

There is no per-page multiplier on shopping and no subscription — credits never expire. See the pricing page for the full table. If you want the Google-shaped view of the same product data instead, the Google Shopping API engine returns link/source/product_rating fields.

FAQ