Walmart & eBay Scraping Templates: Fields, Inputs & Exports (2026)

Walmart and eBay are where ecommerce pricing battles play out in public. Walmart is the catalog to watch for big-box retail pricing, and eBay — with its auctions and sold listings — shows what buyers actually pay rather than what sellers ask. Scraping both gives you the two halves of any pricing decision: the competitor’s shelf price and the market’s clearing price.

This tutorial gives you copy-paste starting templates for both sites as they work in 2026: exactly which fields you get from each product page, ready JSON inputs for the eBay Scraper and the E-Commerce Scraping Tool, how to schedule runs and move the data into Google Sheets, and how to stay under the radar while you do it.

Walmart Field Map: What Each Product Page Yields

Walmart has no dedicated single-site actor in this stack, so you scrape it with the general-purpose E-Commerce Scraping Tool, which accepts any Walmart product or category URL. Conceptually, each Walmart product page breaks down into the same blocks on every listing: the title and brand header, the price block with currency, the rating summary, the fulfillment and availability line, the seller attribution (“Sold and shipped by”), the image gallery, and the longer description and specifications further down. The actor maps those blocks to the following structured fields:

Start every Walmart project by deciding which of these fields drive your decision. Price trackers need price, availability, seller, and url. Assortment researchers need title, brand, identifiers, and rating plus reviewsCount. Pulling the full record is fine, but knowing your key fields in advance keeps the downstream spreadsheet clean.

eBay Field Map: Listings, Auctions, and Sold Prices

eBay pages carry two kinds of pricing that no fixed-price catalog has: live auction state (current bid, bid count, time left) and historical truth (what sold listings actually closed for). The eBay Scraper extracts both, along with the seller reputation data that explains why identical items sell at different prices:

The single most valuable eBay dataset is sold listings: completed sales with the sold-and-completed filters applied. Listed prices are aspirations; sold prices are transactions. Every arbitrage, repricing, or sourcing model should be calibrated on sold data first and use live listings only for availability context.

eBay Input Template: Copy-Paste JSON for ebay-scraper

The eBay Scraper’s input form centers on two fields — Start URLs (the eBay pages to extract) and Max Items (how many results to return). Open the eBay Scraper, switch to JSON input, and paste a template like this one:

{
  "Start URLs": [
    { "url": "https://www.ebay.com/sch/i.html?_nkw=sony+wh-1000xm5" },
    { "url": "https://www.ebay.com/sch/i.html?_nkw=sony+wh-1000xm5&LH_Sold=1&LH_Complete=1" }
  ],
  "Max Items": 200
}

How to adapt it to your own research:

1. Replace the keyword. Swap sony+wh-1000xm5 for your product, keeping eBay’s +-separated query format. One precise query beats three vague ones — eBay search rewards specificity.
2. Keep both URL flavors. The first URL captures live listings (current prices, bid states, seller mix). The second, with LH_Sold=1&LH_Complete=1, captures sold and completed listings — your ground truth for market value.
3. Set Max Items deliberately. 200 covers a typical category scan. Raise it for broad sweeps across whole categories; lower it to a few dozen when you are testing a new query and just want to validate the output shape before spending usage.
4. Add category URLs for breadth. You can mix search URLs and eBay category pages in the same Start URLs array to cover both targeted products and their neighboring listings in one run.

At the time of writing, the actor page lists flat-rate rental from $50/month or roughly $0.63 per 1,000 items in pay-per-use, so size Max Items to the question you are actually answering rather than defaulting to the maximum.

Walmart Input Template: Copy-Paste JSON for e-commerce-scraping-tool

The E-Commerce Scraping Tool takes product or category URLs in startUrls, caps the run with maxItems, and accepts an optional proxyConfiguration for its built-in rotation. Paste this into the JSON input tab:

{
  "startUrls": [
    { "url": "https://www.walmart.com/search?q=sony+wh-1000xm5" },
    { "url": "https://www.walmart.com/ip/sony-wh-1000xm5-wireless-headphones-black/123456789" }
  ],
  "maxItems": 200,
  "proxyConfiguration": { "useApifyProxy": true }
}

Adapting it:

1. Mix search and product URLs. Category and search URLs give you breadth (the competitive set, current shelf prices, ratings distribution). Individual product URLs give you depth (full descriptions, image sets, seller attribution). One run can contain both.
2. Prefer searchTerms for discovery. If you do not have URLs yet, the actor also accepts a searchTerms array of plain keywords that finds products across retailers — useful when you are scoping a new category before committing to a URL list.
3. Keep maxItems honest. Like the eBay template, 200 is a sane default for a category snapshot. Walmart catalog sweeps get large fast, so start narrow, check the output shape, then widen.
4. Leave proxy rotation on. The actor ships with built-in proxy rotation for anti-bot handling. Keep proxyConfiguration enabled, especially for recurring scheduled runs that hit the same pages on a rhythm.

If you also track Amazon for the same products, run the same discipline through the Amazon Product Scraper and join the three datasets on brand plus identifiers — Walmart shelf price, Amazon shelf price, and eBay clearing price together make a complete market picture. Our ecommerce scraping walkthrough covers the multi-site pattern in more depth.

Scheduling Runs and Exporting to Google Sheets

A one-off scrape is a snapshot; pricing intelligence needs a time series. Both actors support scheduled runs — daily for fast-moving categories like electronics, weekly for stable catalogs — and the actor’s own FAQ recommends exactly that cadence split. The workflow that scales:

1. Schedule the run. In the actor’s Schedules tab, attach your saved input and pick a frequency. Daily suits volatile prices and auction-heavy eBay queries; weekly suits assortment tracking and review-count trends.
2. Export from the Storage tab. When a run finishes, preview the dataset and download it as CSV for spreadsheets or JSON for pipelines. Excel export works too when the file goes straight to a stakeholder — see our Excel export tips for formatting large datasets.
3. Import into Google Sheets. In Sheets, use File > Import to load each CSV export. Keep one tab per run date, or append every run into a master table with an added run_date column — the latter is what makes price-history charts possible.
4. Normalize with a short script. Field names differ slightly between the two actors, so standardize columns before analysis. This snippet merges any exported JSON files into one flat CSV:

import csv
import glob
import json

rows = []
for path in sorted(glob.glob("apify_runs_*.json")):
    run_date = path.split("_")[-1].replace(".json", "")
    with open(path, encoding="utf-8") as f:
        for item in json.load(f):
            price = item.get("price", {})
            rows.append({
                "run_date": run_date,
                "source": item.get("seller") or item.get("url", ""),
                "title": item.get("title", ""),
                "price": price.get("value") if isinstance(price, dict) else item.get("price", ""),
                "currency": price.get("currency", "") if isinstance(price, dict) else "",
                "rating": item.get("rating", ""),
                "reviews": item.get("reviewsCount", ""),
                "availability": item.get("availability", ""),
                "url": item.get("url", ""),
            })

with open("price_history.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
    writer.writeheader()
    writer.writerows(rows)

print(f"Wrote {len(rows)} rows to price_history.csv")

Three habits keep the dataset trustworthy: append, never overwrite, so history accumulates; dedupe on (url, run_date), since the same listing can appear in both search-driven and category-driven inputs; and record the input alongside the output — which URLs, which Max Items, which date — so a strange spike three months from now is explainable.

Anti-Block Notes: Staying Undetected

Marketplace sites invest heavily in bot detection, and hammering them with naive requests gets IP ranges throttled or blocked. Read our full anti-blocking guide before scaling up; the essentials for these two templates:

1. Use the managed actors’ built-in rotation. Both actors run on managed infrastructure with proxy rotation rather than your own IP. That is the single biggest protection — never reimplement these templates as raw scripts from a single machine and expect the same stability.
2. Respect rate limits and run size. Keep maxItems proportionate to the question, space scheduled runs sensibly, and treat a sudden wave of blocks or CAPTCHAs as a signal to slow down, not to add circumvention.
3. Scrape public pages only. These templates target publicly visible listings and search results. Do not aim them at anything behind a login or account wall — the E-Commerce Scraping Tool documents that limitation explicitly — and always review each site’s terms of service for your use case.
4. Monitor run health. Watch dataset item counts run over run. A sudden drop usually means a changed page layout or a throttle, and catching it in the schedule logs beats discovering it in a stakeholder’s quarterly chart.

These notes are practical guidance, not legal advice. For anything commercial or large-scale, review our legality guide and have qualified counsel check the plan.

Related Resources

• Web scraping without getting blocked
• How to scrape ecommerce sites with Apify
• Amazon price monitoring guide
• Excel export tips for scraped data
• Browse ready-made scrapers