REDPATH

RedPath - Best Price Finder v3.6

One search, every store. RedPath is a Chrome extension that sweeps 27 retailers across the web in parallel, reads prices straight out of their search results, and ranks every offer cheapest-first - with the single lowest price spotlighted at the top.

How it finds prices - the extraction engine

scraper.js runs a tiered extraction waterfall. Every store runs through up to four independent strategies, so a store only fails if all four miss:

1. Site parser: eBay, Amazon, Walmart, Best Buy, and Newegg have parsers tuned to their exact markup (the fast path).
2. Structured data: schema.org Product/ItemList data as JSON-LD and microdata, the machine-readable layer most stores publish for Google.
3. Embedded state mining: modern storefronts are React/Next.js apps that ship their search results as JSON inside the page (__NEXT_DATA__, Redux state…). The engine deep-walks every JSON blob hunting for product-shaped objects by key signature (name/price/url aliases, nested price objects).
4. Automatic record detection: find repeated sibling card structures in the raw DOM, pick the block that best matches a product grid, then pull title/price/link/image from each card (skipping strike-through “was” prices).

If everything misses or the store blocks robots, RedPath still gives you a one-click manual search link. Mercari, Google Shopping, and Bing Shopping are manual links from the start (fully client-rendered).

Official APIs (recommended for eBay)

Scraping public pages is best-effort - retailers can and do block it. The reliable alternative is a store’s official API, and RedPath supports the eBay Browse API out of the box:

• Open RedPath’s options (the “⚙ Connect eBay API” link in the popup footer, or right-click the icon -> Options).
• Follow the steps to get a free eBay developer key (App ID + Cert ID from a Production keyset at developer.ebay.com).
• Paste it in and hit Test connection.

Once connected, eBay searches go through the official API - no scraping, no blocking, cleaner data - and results are ranked by the same Specific/General engine as everything else. Your key is stored only on your device (chrome.storage.local) and is never part of the shipped code or sent anywhere but eBay. Remove it anytime to fall back to public-page reading.

This is the model for adding more official sources later (Best Buy and Walmart both offer free keys); each store adapter is small and self-contained.

Match modes:

• Specific (default) - every word in your search is a hard filter. “silk pillowcase” only returns silk; “nothing ear (a)” only returns the Ear (a), not other Nothing earbuds or other brands. Matching is word-based, so short tokens like “(a)” or “6” must appear as standalone words.
• General: looser: finds the cheapest similar product when you don’t care about exact model or attributes.

Condition filter (Any / New / Refurbished / Used): each listing is classified by Scraper.detectCondition: from eBay’s authoritative API condition field when available, otherwise from title keywords (“Renewed”, “Refurbished”, “Open Box”, “Pre-Owned”, “Used”, …). Anything with no signal defaults to New (most retail listings). Switching the filter re-ranks the current results instantly without re-searching.

Match filtering - the keyword + category engine. After each sweep RedPath decides which listings are genuinely the product using a local relevance engine (scraper.js), with no AI, no API key, and no server: it runs entirely in the popup and works identically on Chrome, Brave, Edge, and Firefox. Beyond plain token matching it:

• catches accessories anywhere in the title (“screen protector”, “case for”, “compatible with”, “for iPhone…”) and penalizes them heavily, so a $12 case never outranks the phone you searched for;
• rejects a different kind of product via a built-in category lexicon - so searching “nothing phone 3” drops “Nothing Ear (3)” (earbuds ≠ phone) even in loose General mode;
• matches model numbers by adjacency (“iPhone 12” only counts when the 12 sits right after “iPhone”, never a stray 12 elsewhere in the title);
• gates on a brand lexicon so “z-bar” pulls Clif Z-Bars, not some other snack with a stray “z”.

It is conservative: a real product with a long, spec-stuffed title is always kept, and Specific mode keeps the accuracy high by requiring every query word to appear.

Ranking defenses (so the “best deal” is actually the product):

• Fuzzy relevance scoring - query token coverage with prefix credit; model numbers count, so a “Charge 5” scores below a “Charge 6” you searched for.
• Accessory penalty - titles that lead with accessory words or pitch compatibility (“Bands for Fitbit…”, “Case for…”) are heavily penalized; legit bundles (“…with extra band”) are not.
• Cross-store outlier rejection - offers priced under 20% of the running median are dropped as accessory noise unless their title is a near-perfect match.
• Fetches retry once with backoff on 403/429/5xx, with realistic headers.

Install (Load Unpacked)

1. Open Chrome and go to chrome://extensions
2. Toggle Developer mode ON (top-right corner)
3. Click Load unpacked and select this folder (Red Path)
   • already installed? Hit the ↻ reload icon on the RedPath card instead
4. Chrome will note the extension can “read data on all websites” - that’s the permission that lets it check prices on any store across the web
5. Pin RedPath from the puzzle-piece menu

Important: live price scanning only works when RedPath runs as an installed extension. Opened as a normal web page, the browser’s security rules block it from reaching other sites - the page will tell you when that’s the case.

How to use

• Search: click the icon, type a product, hit Search. Brand + model works best (“fitbit charge 6” beats “fitbit pro” - if a product name doesn’t exist, stores return unrelated results and RedPath filters them out).
• Detect product on this page: while viewing any product page, one click pulls the product name from the page and price-checks it everywhere else.
• Colored pills show each store live: amber = scanning, green = prices found, red = blocked or no match (with a manual link added below).
• Click any offer to open it in a new tab.

Security & privacy posture (Chrome Web Store readiness)

Hardening applied for publication - this is also the honest list of what the extension does and doesn’t do:

• Least privilege: host permissions name only the retailers actually fetched (no https://*/*); link-only stores get no permission at all. activeTab + scripting are used solely for the user-initiated page scan.
• No XSS surface: every piece of scraped content (titles, URLs, images) is rendered with DOM construction (textContent), never string-built HTML, and all URLs are validated to http(s) at extraction and render time (images https-only).
• Strict CSP: script-src 'self'; object-src 'none'; frame-ancestors 'none' on top of MV3’s baseline; all code and fonts ship in the package, nothing loads from CDNs, no remote code (a CWS requirement).
• Anonymous searches: fetches use credentials: "omit", so the user’s retailer cookies/sessions are never attached to a RedPath search.
• Zero telemetry: no servers, no analytics, no tracking. The only stored datum is the last search term, in local extension storage. See legal/privacy-policy.md.
• Ranking transparency: offers are ranked by price (or price-per-unit in Best value mode) only. No store pays for placement, and rankings are never affected by any affiliate commission. This is stated in the popup itself, as the EU Omnibus/UCPD consumer-transparency rules require of comparison tools.

What no extension can promise: client-side code is always readable by the person who installs it (CWS forbids obfuscation), and searches necessarily reach retailers from the user’s own browser/IP. “Impossible to hack” doesn’t exist in software - the strategy above is minimizing what an attacker could ever get: there are no secrets in the extension, no user data beyond one locally-stored search term, and no privileged surface beyond reading retailer search pages.

Earning money (affiliate links)

RedPath can tag every outbound store link with your affiliate IDs so you earn a commission when someone buys - at no extra cost to them. As the developer, you set the IDs once in the CONFIG block at the top of affiliates.js; the same IDs apply to every user (they are public tracking IDs, not secrets, and never change the price a shopper pays):

CONFIG field	Get it from	Covers
ebayCampaignId	partnernetwork.ebay.com (free)	eBay
skimlinksId	sovrn.com/commerce	~48,000 merchants (Walmart, Target, Best Buy, …) - one ID
amazonTag	affiliate-program.amazon.com	Amazon (see below)
templates (JSON)	Impact / CJ / Rakuten dashboards	any store, per-store {url} template

For each link RedPath uses, in order: your custom template for that store -> a native tag (Amazon tag, eBay EPN params) -> a universal Skimlinks wrap -> otherwise the link is left untouched. Blank fields simply don’t earn; nothing breaks.

You must comply with two things (both handled/flagged):

• Disclosure: Google’s Web Store policy and the US FTC require telling users you earn commissions. RedPath shows a disclosure line automatically whenever any affiliate ID is set. Also state it in your store listing.
• Amazon caveat: Amazon’s Associates terms restrict affiliate links inside browser extensions; using them can get your Associates account terminated. Verify your eligibility before relying on the Amazon field. eBay and network programs (via Skimlinks/Impact) generally allow extension use as long as the click is user-initiated (which RedPath’s are) and not cookie- stuffed.

Realistically, affiliate income needs real user volume - commissions are a few percent per sale - so treat this as “monetize once you have users,” not instant profit.

Performance

• Instant reopen: search results are cached for 10 minutes in session storage (cleared when the browser closes, never synced). Reopening the popup shows your last results immediately; pressing Search always fetches fresh prices.
• Deep sweep: all 23 fetchable stores are queried in parallel with a generous 20-second budget, so slower stores get to answer; results still stream in live as each store responds, so the cheap hits appear within seconds. (Four more stores are one-click manual links.)
• Slim package: fonts ship as Latin-only subsets with just the weights used (vendor payload: ~340 KB, down from ~6 MB), so the popup loads fast and the Web Store package stays small.
• Extraction itself is ~1-2 ms per store page; the network is the only real wait.

Notes & limitations

• Prices come from each store’s public search results at that moment; shipping, tax, and regional pricing can change the true total.
• Results are filtered for relevance (at least half of your search words must appear in the product title) so a $2 accessory doesn’t “win” a phone search.
• Retailer sites change their HTML occasionally; each store’s adapter in retailers.js is small and self-contained, and the universal JSON-LD parser keeps working regardless.

Files

• src/manifest.json: Manifest V3 config; host permissions name only the retailers actually fetched (no https://*/*)
• src/popup/popup.html / popup.css: the UI (light default, dark toggle)
• src/popup/popup.js: search orchestration, ranking, page-scan logic
• src/popup/theme-early.js: applies the stored theme before first paint
• src/lib/scraper.js: the tiered extraction engine (structured data, embedded state mining, DOM record detection, relevance scoring, match filtering)
• src/lib/ebay-api.js: official eBay Browse API adapter (OAuth token + search)
• src/lib/bestbuy-api.js: official Best Buy Products API adapter
• src/lib/affiliates.js: outbound-link affiliate tagging (EPN, Amazon, Skimlinks, custom templates)
• src/lib/retailers.js: the store list + tier-0 site parsers
• src/lib/brands.js: brand lexicon used by the relevance engine
• src/options/options.html / options.js / options.css: API-key settings page
• src/assets/: shipped images and icons/
• src/vendor/: locally bundled npm packages (Chrome extensions can’t use CDNs)
• build/vendor.mjs: copies runtime files from node_modules -> src/vendor/, verbatim and unmodified
• build/build.mjs: assembles dist/ for store upload
• legal/: privacy policy, licence, permission justifications
• store/: Chrome and Firefox listing copy
• docs/: architecture, Firefox notes, submission checklist

UI stack (npm)

Package	Used for
@fontsource/inter	Body text, headings, buttons
@fontsource/jetbrains-mono	Prices and ranks
@fontsource/playfair-display	Display serif accents
animejs	Subtle entrance animations

The REDPATH wordmark is an image (src/assets/wm_title.png), not live text, so no display font is bundled for it.

src/vendor/ is pre-built and checked in, so Load Unpacked works with zero build steps. Only if you update packages: npm install then npm run vendor.

Licence

Apache License 2.0 - see legal/LICENSE.

Author

Karen Contreras Cubas - karenc.cubas@gmail.com

Privacy policy: legal/privacy-policy.md.