Amazon Scraper: How to Collect Product Data, ASINs, and Reviews

Your Amazon product export looks ready for analysis until you check a few rows. Two prices belong to different sizes, delivery estimates reflect different ZIP codes, and the collected reviews cover only part of the feedback you expected. Those gaps can distort a price comparison or send product research in the wrong direction.

An Amazon scraper helps you collect data, but useful results depend on how you configure the job and verify its output. This guide walks you through choosing between Python, web scraping APIs, and no-code tools, then collecting product details, ASINs, and reviews with consistent settings. You’ll also learn how to check location accuracy, handle missing fields, and build a repeatable workflow before scaling up.

TL;DR

• Choose your method: Build an Amazon scraper with Python when you need custom logic and can maintain the code. Choose a managed API to reduce extraction work, or a no-code tool for quick exports with minimal setup.

• Use proxies where the workflow needs them: Proxies provide network routing and IP control for custom scripts. Match rotation or sticky sessions to the task, then verify Amazon’s delivery settings and the extracted data.

• Keep comparisons consistent: Save the ASIN, selected variant, seller, price, currency, marketplace, delivery ZIP code, source URL, and collection timestamp.

• Check review coverage separately: Filters, pagination, and access limits can restrict your sample. Record what you collected rather than assuming the export contains every review.

What is an Amazon scraper, and what data can it collect?

An Amazon scraper is a tool that extracts information from Amazon pages and organizes it into structured records, such as a CSV file, spreadsheet, or JSON output. Instead of manually copying product details, you provide URLs, search terms, or ASINs, depending on the tool, and specify the information you need.

Common fields include product titles, ASINs, brands, prices, currencies, selected variants, seller names, availability, ratings, and review counts. Some tools also collect search listings and individual customer reviews, although coverage depends on the tool and what it can access.

Businesses use this data to monitor prices, compare competing products, track assortment changes, and analyze customer feedback. For scraping Amazon product data to support reliable comparisons, each record needs context: which variant and seller it represents, the delivery location applied, and when the information was collected.

Product details, prices, sellers, and availability

Choose fields that let you identify the exact product and understand the offer attached to it. A price alone tells you little if you cannot confirm the size, seller, or currency.

Search results, ratings, and customer reviews

An Amazon scraper can collect several types of data, but each answers a different question. Search results show which listings appear for a query, while product pages describe a selected product and its displayed offer. Aggregate ratings summarize customer scores; individual review records provide the written feedback behind some of those scores.

When scraping Amazon product data, keep these datasets connected through identifiers such as ASINs while preserving their separate meanings.

Configure proxy access for your Amazon scraper with CyberYozh App

CyberYozh App provides proxy infrastructure for controlling the network connection your Amazon scraper uses. Match the proxy type and session behavior to your collection process, then evaluate performance using correctly extracted records rather than connection success alone.

Choose rotating residential or sticky sessions for the task

Rotating residential connections suit independent collection jobs that do not need to retain the same network address between tasks. For related requests, such as setting a delivery location and opening several product pages, use a sticky session to maintain the IP while your application preserves its cookies and browser state.

Evaluate mobile, static ISP, and datacenter options

Compare these options using the same product sample, location requirements, and acceptance criteria.

Connect, verify, and monitor the workflow

Connect the proxy through your Python HTTP client or the proxy settings supported by automations like Scrapy, Playwright, Puppeteer, Selenium, or another compatible framework. CyberYozh provides full API access and integration support, while the exact configuration depends on the tool and selected proxy protocol.

Follow this setup sequence:

1. Retrieve the connection details. Copy the host, port, protocol, and authentication details from your proxy configuration. Keep credentials in environment variables or a secret manager.

2. Configure session behavior. Choose rotation for independent jobs or a sticky session for related requests. Preserve cookies separately in your application.

3. Verify the exit connection. Confirm that requests use the proxy and that its observed region matches your selection.

4. Verify Amazon’s delivery context. Apply and check the destination on the product page independently of the proxy’s location.

5. Run a small collection job. Monitor usable records, response times, missing fields, traffic consumption, and repeated failures before increasing volume.

Choose your Amazon scraper: Python, API, or no-code tool

Choose your Amazon scraper based on how often you need data, how much control the job requires, and who will maintain it. A one-time product comparison has different demands from a daily collection job feeding an internal dashboard.

Python fits workflows that need custom extraction rules, validation, or storage. You control the code, but your team also handles parsing errors, page changes, and ongoing maintenance.

A managed API suits recurring collection when you want the provider to handle more of the extraction work. Before committing, check whether it returns your required fields, supports your target locations, and charges for requests or usable results.

A no-code web scraper works well for quick research and straightforward exports. Check its batch limits, scheduling options, and customization controls if you expect the workload to grow.

Python for custom collection and validation

Python gives you control over what your Amazon scraper collects and what happens to each record afterward. You can select the fields your research needs, schedule collection around reporting deadlines, and save results directly to CSV files, databases, or internal systems. Custom validation rules can flag a missing currency, an unexpected ASIN, or a changed variant before the record reaches your analysis.

You also control how the scraper handles failures. For example, you can retry a temporary connection error within a defined limit, log an unavailable product separately, and pause a job when repeated responses contain unexpected content.

An Amazon scraper API for managed extraction

An Amazon scraper API lets your application request data without maintaining every part of the collection process yourself. Depending on the service, the provider handles page retrieval, proxy infrastructure, retries, rendering, and parsing, then returns structured results. Check what is included: some endpoints return raw page content that still needs extraction.

Your responsibility is to confirm that the output matches the job. Test the required product fields, verify that delivery-location settings are applied, and check review coverage separately from product-page support. Ask whether results are collected on request or served from a cache, particularly when tracking prices or availability.

No-code tools for smaller exports and quick research

Browser extensions and ready-made scrapers are practical for collecting a shortlist of competing products, checking displayed prices, or exporting listings for a research report. You typically provide product URLs or open a supported page, choose the available fields, and export the results without writing collection code.

Check how the tool runs before relying on it for repeat work. A browser extension may require your browser to remain open, while a hosted scraper may support scheduled jobs. Verify batch limits, export formats, scheduling, and whether delivery-location settings persist between runs.

Is there an official Amazon API for web scraping?

Amazon provides official APIs for defined business uses, but these differ from third-party services that extract website content. If you’re looking for an Amazon API for web scraping, first check whether an official API supplies the information your project needs.

The Selling Partner API (SP-API) supports authorized seller and vendor workflows. Access depends on the application, required roles, and relevant authorization process; having an Amazon shopping account alone does not grant access. Public applications generally require selling-partner authorization, while private applications use self-authorization.

Amazon also offers a Customer Feedback API, which provides review insights at the ASIN and product-category level, plus return insights at the category level. It covers topics and trends rather than providing a complete export of every individual review. Access requires an eligible role, such as Brand Analytics or Selling Partner Insights.

A third-party Amazon scraper API is a separate provider’s extraction service. Its credentials, supported fields, and billing belong to that provider, and subscribing does not grant Amazon authorization.

How to scrape Amazon product data with Python

A useful Python walkthrough should take you from a product URL to a structured record you can inspect. We’ll build that workflow in stages: define the required fields, set up the project, fetch a page, extract the product details, and export the results to CSV or JSON.

Start with a small set of product URLs so you can compare the output against the source pages. Each record should preserve the ASIN, selected variant, price, currency, and collection timestamp, with missing values clearly marked.

Define your fields, marketplace, and collection scope

Before writing the scraper, decide what one complete record should contain and which conditions must stay consistent between runs. For this walkthrough, start with a small list of product URLs from one Amazon marketplace.

Define which missing fields make a record unusable. A missing price, for example, prevents a price comparison but may still leave useful availability information. Preserve that distinction so your Amazon scraper can flag incomplete records without discarding valid observations.

Set up your Amazon scraper Python project

Start with a virtual environment to keep the project’s dependencies separate from other Python applications. This setup was checked with Python 3.12.14, Requests 2.34.2, and Beautiful Soup 4.15.0. Installation, imports, and sample HTML parsing passed; live Amazon extraction has not been tested at this stage.

Requests handles HTTP requests, while Beautiful Soup extracts fields from the returned HTML. Neither executes JavaScript.

Create the project folder and virtual environment:

mkdir amazon-scraper

cd amazon-scraper

python -m venv .venv

Activate the environment using the command for your operating system.

macOS or Linux 

source .venv/bin/activate

Windows 

.\.venv\Scripts\Activate.ps1 

Install the checked dependency versions:

python -m pip install requests==2.34.2 beautifulsoup4==4.15.0

Create a file named amazon_scraper.py and add the initial configuration below. Insert your target product URLs into PRODUCT_URLS, keeping each URL in quotation marks and separating entries with commas. 

</> python

import os

from urllib.parse import urlparse

import requests

from bs4 import BeautifulSoup

MARKETPLACE = "www.amazon.com"

REQUEST_TIMEOUT = 30

OUTPUT_FILE = "amazon_products.csv"

PRODUCT_URLS = [

    # Add your target Amazon product URLs here.
]

for url in PRODUCT_URLS:

    parsed = urlparse(url)

    if parsed.scheme != "https" or parsed.hostname != MARKETPLACE:

        raise ValueError("Each URL must use the selected marketplace.")

session = requests.Session()

# Optional: supply the full proxy URL through your environment.

proxy_url = os.environ.get("AMAZON_PROXY_URL")

if proxy_url:

    session.proxies.update({

        "http": proxy_url,

        "https": proxy_url,
    })

Keep proxy passwords and API keys in environment variables supplied through your development environment or deployment secret manager. Avoid embedding credentials in the script, committing them to Git, or printing them in logs.

Fetch a product page and check what came back

A successful HTTP response does not guarantee that your Amazon scraper received the product page. A server can return HTTP 200 OK with a challenge, sign-in screen, or another unexpected page, so check both the response status and the content before extracting product fields.

Add the function below after your session configuration. It checks for request failures, unexpected redirects, non-HTML responses, common challenge indicators, and a product-title element.

def fetch_product_page(url):

    try:

        response = session.get(url, timeout=REQUEST_TIMEOUT)

        response.raise_for_status()

    except requests.RequestException:

        # Avoid logging exception details that could expose proxy credentials.

        raise RuntimeError(

            "Request failed. Check connectivity and the HTTP response."

        ) from None



    if urlparse(response.url).hostname != MARKETPLACE:

        raise RuntimeError("The request redirected to another domain.")



    content_type = response.headers.get("Content-Type", "").lower()

    if "text/html" not in content_type:

        raise RuntimeError("Expected HTML but received another content type.")


    soup = BeautifulSoup(response.text, "html.parser")

    page_text = soup.get_text(" ", strip=True).lower()


    challenge_markers = (

        "enter the characters you see below",

        "sorry, we just need to make sure you're not a robot",

        "validatecaptcha",
    )



    if (

        soup.select_one('form[action*="validateCaptcha"]')

        or any(marker in page_text for marker in challenge_markers)

    ):

        raise RuntimeError(

            "A challenge page was returned. Pause and review the request."

        )



    title = soup.select_one("#productTitle")

    if title is None or not title.get_text(strip=True):

        raise RuntimeError(

            "Product title not found. The page may be unexpected "

            "or its structure may have changed."

        )


    return soup, response.url

Call the function for one URL before processing the full list: 

if not PRODUCT_URLS:
    raise SystemExit("Add a product URL to PRODUCT_URLS first.")

try:
    soup, final_url = fetch_product_page(PRODUCT_URLS[0])
    print("Page passed the initial checks.")
    print("Title:", soup.select_one("#productTitle").get_text(strip=True))
except RuntimeError as error:
    print("Collection stopped:", error)

Beautiful Soup parses the HTML here to inspect its structure; extracting the product record comes next. These checks are preliminary: challenge wording and page layouts can change, and finding a title does not confirm the requested ASIN, selected variant, or delivery location. Verify those separately before accepting the record. 

Extract product fields and handle missing values

Once the page passes the initial checks, extract a small set of fields: ASIN, title, displayed price, and availability. Keep the source URL and collection timestamp with each record so you can trace it later.

Use None when a field is missing. A missing price could mean the offer is unavailable, the page requires another selection, or the selector no longer matches. Converting it to zero would introduce a false price into your analysis.

Add the following below your existing functions.

from datetime import datetime, timezone


def text_or_none(soup, selector):
    element = soup.select_one(selector)
    if element is None:
        return None
 return element.get_text(" ", strip=True) or None


def extract_product_fields(soup, source_url):
    asin_element = soup.select_one("input#ASIN")
    asin = (
        asin_element.get("value", "").strip() or None
        if asin_element is not None
        else None
    )

    # Limit extraction to the main price area to reduce the chance
    # of collecting a price from recommendations or another offer.
    price_text = text_or_none(
        soup,
        "#corePriceDisplay_desktop_feature_div "
        ".priceToPay .a-offscreen",
    )

    return {
        "asin": asin,
        "title": text_or_none(soup, "#productTitle"),
        "price_text": price_text,
        "availability_text": text_or_none(soup, "#availability"),
        "source_url": source_url,
        "collected_at": datetime.now(timezone.utc).isoformat(),
    }

Keep the price as displayed text at this stage. Separating its numeric value and currency requires validation against the marketplace’s formatting; a currency symbol alone may be ambiguous.

After a successful fetch, call the extraction function:

record = extract_product_fields(soup, final_url)

missing_fields = [
    field
    for field in ("asin", "title", "price_text", "availability_text")
    if record[field] is None
]

print(record)
print("Missing fields:", missing_fields)

Place this call inside the successful try block from the previous step, immediately after fetch_product_page(), so extraction does not run after a failed request. 

A missing value should trigger inspection rather than a broader search for any price on the page. Before using the record for comparisons, also verify the requested ASIN, selected variant, seller, and delivery context. 

Export to CSV or JSON and validate a sample

Export each product record with its source URL, collection timestamp, marketplace, and delivery context. Keep the requested ZIP code separate from the location actually observed on the page: entering a target in your configuration does not prove Amazon applied it.

JSON preserves missing values as null, while this CSV export leaves them blank. Neither format should replace a missing price with zero.

Add this function below your existing functions.

import csv
import json


def export_records(records, csv_path, json_path):
    if not records:
        raise ValueError("No records to export.")

    fields = list(records[0])

    with open(csv_path, "w", encoding="utf-8", newline="") as file:
        writer = csv.DictWriter(file, fieldnames=fields)
        writer.writeheader()
        writer.writerows(records)

    with open(json_path, "w", encoding="utf-8") as file:
        json.dump(
            records,
            file,
            ensure_ascii=False,
            indent=2,
            allow_nan=False,
        )

Replace the earlier single-URL test block with the following. It connects fetching, extraction, and export using the functions already defined. 

if not PRODUCT_URLS:
    raise SystemExit("Add a product URL to PRODUCT_URLS first.")

# Leave unknown until you implement delivery-location controls.
REQUESTED_DELIVERY_ZIP = None

try:
    soup, final_url = fetch_product_page(PRODUCT_URLS[0])
    record = extract_product_fields(soup, final_url)

    record.update({
        "marketplace": urlparse(final_url).hostname,
        "requested_delivery_zip": REQUESTED_DELIVERY_ZIP,
        "observed_delivery_zip": None,
        "delivery_location_verified": False,
    })

    export_records(
        [record],
        OUTPUT_FILE,
        "amazon_products.json",
    )
    print("Exported one record. Validate it before using it.")

except (RuntimeError, ValueError, OSError) as error:
    print("Job stopped:", type(error).__name__)

The following is an example showing how missing fields appear. 

{
  "asin": null,
  "title": "Sample product, blue",
  "price_text": null,
  "availability_text": null,
  "source_url": "https://www.amazon.com/dp/EXAMPLE123",
  "collected_at": "2026-10-14T14:00:00+00:00",
  "marketplace": "www.amazon.com",
  "requested_delivery_zip": null,
  "observed_delivery_zip": null,
  "delivery_location_verified": false
}

Validation check: The export function was tested on Python 3.12.14 with a sample record. JSON preserved missing values and the Boolean location flag, CSV preserved a title containing a comma and left missing values blank, and empty input was rejected. This verifies export behavior; it does not verify live Amazon retrieval or selectors.

Before scheduling your Amazon scraper Python project, inspect a few records against their source pages:

• Confirm the ASIN, selected variant, and seller match the intended product and offer.

• Compare the displayed price and currency under the same delivery settings.

• Check timestamps and source URLs, and investigate missing required fields.

• Keep location-dependent records out of comparisons until their delivery context is verified.

Expected failures include blocked requests, changed page layouts, missing offer details, and file-write errors. A partial record may still contain useful information, but it should not pass as a complete price observation.

How to use an Amazon ASIN scraper without mixing up products

An Amazon ASIN scraper helps you build a list of product identifiers and retrieve their associated details. For reliable comparisons, keep those identifiers connected to the correct marketplace, selected variant, and seller offer. Otherwise, a switch between products or offers can look like a price change.

What is an Amazon Standard Identification Number?

An Amazon Standard Identification Number (ASIN) is a 10-character alphanumeric identifier used to identify an item in Amazon’s catalog. It gives your collection workflow a more precise reference than a product title, which may change or resemble other listings.

Store the marketplace alongside each ASIN and distinguish the identifier from the seller’s SKU. The ASIN identifies the catalog item, while a seller SKU identifies a listing within that seller’s own inventory system. Amazon’s APIs use these identifiers for different operations.

Extract ASINs from product URLs and search results

Treat ASIN discovery as a separate step from collecting prices, availability, and other product details. A list of identifiers tells your scraper which items to investigate; it does not confirm what those items currently cost.

Use this sequence when you scrape Amazon ASIN data:

1. Discover candidate identifiers. Extract them from product links or listing attributes in the returned search-page HTML. Preserve the source URL and, for search results, the query and position.

2. Validate the format. Check for exactly 10 letters or digits. Passing this check only confirms the expected shape, not that the ASIN exists or represents your intended variant.

3. Deduplicate the collection queue. Use the marketplace and ASIN together to avoid fetching the same catalog item repeatedly.

4. Fetch and verify product details. Compare the discovered identifier with the item actually returned, then check the selected variant before accepting its offer data.

Keep search observations separately from the deduplicated queue. An ASIN appearing under two queries may require only one product fetch, but both appearances can matter for visibility analysis.

Keep parent products, child variants, and seller offers separate

A parent ASIN groups related variations and is not itself a purchasable offer. A child ASIN identifies a particular variation, such as one size-and-color combination. Seller offers sit beneath that product identity and describe who is selling it, in what condition, and at what price.

Consider this illustrative example:

Suppose the next run captures a blue T-shirt in size large for $24. That is a different variant, so reporting a $6 increase would be misleading. If the medium shirt instead appears at $20 from Seller B, the observed offer has changed, but that does not establish that Seller A raised its price.

For price monitoring, compare the same marketplace, child ASIN, seller, condition, and delivery context across collection times. If your goal is to track whichever offer Amazon displays, record seller changes explicitly so you can explain what moved.

How to scrape Amazon reviews and measure coverage

To understand how to scrape Amazon reviews reliably, start by defining the feedback you need and checking how much your chosen method can retrieve. An Amazon review scraper may return useful records without covering every review associated with a product. Measure that coverage before drawing conclusions about customer sentiment.

Choose the review fields your research needs

Collect enough information to analyze the feedback, identify duplicates, and trace each record back to its source.

How to scrape Amazon by ZIP code

Learning how to scrape Amazon by ZIP code starts with setting the delivery destination and confirming that it remains applied when you collect the product data. A US proxy connection alone does not establish the ZIP code Amazon uses for delivery estimates.

The Python example above does not yet implement delivery-location controls. Its location fields remain unverified until you add a browser workflow or use a scraping service with documented support for Amazon delivery settings.

Set and verify the delivery location

For a browser-based workflow, use the following sequence:

1. Open the target marketplace

2. Open Amazon’s delivery-location selector

3. Wait for the page to update

4. Open the target product and select its variant

5. Capture the observed location alongside the product fields

Keep delivery settings and session context consistent

Several settings contribute to the collection context, but they serve different purposes.

For a custom browser workflow, a sticky proxy session can help preserve network continuity. It does not replace the location-selection step or prove that Amazon retained your chosen destination.

Compare the same product under controlled conditions

Start with one child ASIN and two ZIP codes, collecting both observations within a short window. Keep the selected variant, product condition, quantity, and account state consistent. Hold the seller constant where possible; if the displayed seller changes, record that change before interpreting a price difference.

Save these details with each observation:

• Requested ZIP code, observed delivery location, and verification status.

• Marketplace, child ASIN, selected variant, seller, and condition.

• Displayed item price, currency, shipping charge, availability, and delivery estimate.

• Source URL and collection timestamp.

For a small comparison, use the following recording template. It is a test worksheet, not observed Amazon results.

How to choose the best e-commerce scraping API for Amazon product data

The best e-commerce scraping API for Amazon product data is the one that returns the fields your workflow needs, under the right collection conditions, at a sustainable cost. Evaluate providers against the same inputs and acceptance criteria so a fast but incomplete response does not outperform a slower, usable record on paper.

Check field coverage, location controls, and review support

Turn your dataset requirements into a checklist before testing. Separate essential fields from optional ones: a price-monitoring job may require the child ASIN, seller, price, currency, and delivery context, while product discovery may prioritize titles, brands, categories, and identifiers.

Check the documentation for each required capability, then verify it in the output. Support for “Amazon data” does not establish that every endpoint handles variants, seller offers, delivery ZIP codes, and reviews equally well.

Measure usable results, response time, and total cost

Define a usable result before calculating success. For a price comparison, it might mean a record with the correct child ASIN, required offer fields, verified delivery context, and an acceptable collection timestamp. For availability monitoring, a correctly identified unavailable product may be useful even without a price.

Use the same definition across providers:

Usable-result rate = requested observations that meet your acceptance criteria ÷ total requested observations × 100

An observation is one planned product-and-location check at a particular collection time. Retries and duplicate responses should not increase the number of successful observations.

Track failures by cause: missing required fields, wrong product or location, duplicate output, retrieval failure, and parsing failure. This makes it easier to see whether a provider’s weakness affects your actual workload.

Measure elapsed time until usable data is available, including retries and asynchronous polling. For larger tests, compare typical response times with slower requests rather than relying only on an average.

Calculate cost using the same principle:

Cost per usable observation = total test charges ÷ usable observations

Include billable retries, rendering charges, location features, and other required extras. For recurring jobs, also account for subscription minimums and the work needed to clean or repair the output.

Test a representative sample before scaling

Start with approximately 20 product URLs across three or four categories, covering different variants and a few products observed as unavailable. Run each against two delivery ZIP codes for a manageable first test of around 40 observations.

Keep inputs and settings consistent across providers, collect within a short window, and record any source-page changes that could affect the comparison. Inspect every record in this initial sample before introducing a recurring schedule.

Use this table to document the results:

Choose based on the requirements that matter most to your Amazon product data scraping workflow. A provider that performs well on this small test earns a larger trial; it has not yet demonstrated the same performance across your entire catalog.

Using GitHub code for your Amazon scraper

Searching for “how to scrape amazon product data github” can lead you to runnable scrapers, API integrations, and tutorials with very different requirements. Before installing a repository, establish what it does locally, which services it depends on, and whether its output matches your project.

Check what the repository actually provides

Read the README alongside the code that sends requests. The repository name alone does not tell you how collection works.

Why your Amazon scraper returns blocked, empty, or incorrect results

When an Amazon scraper produces unexpected output, inspect the response before changing the connection settings. A blocked request, a missing offer, and a broken selector require different fixes. Rotating the IP will not repair a parser or restore a delivery location that was never applied.

Keep a short error log with the source URL, timestamp, response status, failure category, and relevant collection settings. Exclude credentials and sensitive session values. This gives you enough evidence to distinguish retrieval problems from extraction errors and genuine changes on the page.

Amazon product data scraping: best practices and ethical guidelines

Ethical web scraping starts with a defined purpose: what information you need, how you will obtain it, and what you plan to do with it afterward. If you are searching for “amazon product data scraping best practices ethical guidelines,” use the following checks to turn those questions into concrete decisions.

Review Amazon’s terms and your intended data use

Publicly visible content does not automatically come with unrestricted permission to collect, store, or republish it. Amazon’s Conditions of Use address data mining, robots, and similar extraction tools. Review the terms applicable to your marketplace and any API or data service you use before starting collection.

Consider collection and reuse separately. Internal price analysis, publishing review excerpts, and redistributing a product dataset involve different uses of the material. Confirm the permissions relevant to your project, including any restrictions on retention, display, or redistribution. A scraping subscription or proxy connection does not itself grant rights to Amazon’s content.

Preserve provenance and document limitations

Another person should be able to understand where a record came from and what it represents without reconstructing your scraper. Preserve the source URL, marketplace, ASIN, collection timestamp, selected variant, seller, and requested and observed delivery context where relevant.

Add a short collection note documenting:

• The tool or code version and collection settings.

• Filters, sorting, pagination, and stopping conditions.

• Missing fields, failed requests, and deduplication rules.

• Whether location settings were verified and results were cached.

• Known coverage gaps, particularly for customer reviews.

Keep observed values separate from assumptions or calculated fields. If coverage is unknown, say so; if a price is missing, leave it missing. Those distinctions make the dataset easier to audit and help prevent misleading comparisons.