Scrape Yahoo Shopping Data (Python + API)

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 you exactly how, with a tested Python example, the real response shape, and the honest limits you'll hit (Yahoo does not return everything a Google Shopping scraper would).

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.

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 rail of listings, and those listings are affiliate placements — Yahoo earns a cut when a shopper clicks through. That means two practical consequences for a scraper:

• You get a short list per query — typically a dozen or so products, not hundreds.
• Every listing is effectively sponsored, so there is no meaningful organic-vs-ads split the way there is on a general web SERP.

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 query returns roughly a dozen products. Requesting num=100 does not conjure more listings — Yahoo only surfaces what it surfaces.
• 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.
• All sponsored. Expect sponsored: true across the rail — these are paid placements.

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 with Serpent are billed per 1,000 calls, paid from the first call (shopping is not in the shared free pool). Current tiers:

Tier	Per 1,000 calls	Per call
Default	$0.60	$0.0006
Growth	$0.06	$0.00006
Scale	$0.03	$0.00003

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