Want the extension now? You can download it here
Amazon’s fake review problem has gotten completely out of hand. You know it, I know it, and apparently Amazon knows it too. Which is apparently why they’ve been systematically shutting down review analysis tools. First Fakespot announced they’re shutting down, then Amazon started tightening access to product reviews to “fight fakes”. According to Amazon, the best way to fight fake reviews is to make it harder for people to analyze them.
That’s where Null Fake comes in! We created an open-source alternative that’s free, MIT-licensed, and available on GitHub. But here’s the thing: building a web app is one thing. No matter what the Fakespot-adjascent services promise you, extracting Amazon reviews on a massive automated scale is virtually impossible. They consistently threshold, block and tighten controls of who sees what and how many reviews you actually see.
After launching Null Fake, it became immediately clear that building a Chrome extension that can actually extract review data was the natural next step from Amazon’s ever-increasing control of information. Developing this extension presented a series of new challenges. We thought it might be useful to document some of these challenges for those interested in a technical breakdown of how this was accomplished!
The Chrome Extension Challenge
When we started building the Null Fake Chrome extension, I thought it would be straightforward. Extract some reviews, send them to our API, display results. How hard could it be? Turns out, pretty hard.
Amazon doesn’t exactly make it easy for data extraction. Their DOM structure changes regularly, they use dynamic loading for reviews, and they’ve got 21+ different country domains with slightly different layouts. Oh, and Chrome’s Manifest V3 requirements mean you can’t just throw some jQuery at the problem and call it a day.
Chrome Extension Architecture: Manifest V3 and Service Workers
The extension is built on Chrome’s Manifest V3, which means service workers instead of background pages. Here’s the basic structure:
{
"manifest_version": 3,
"permissions": ["storage", "activeTab", "scripting"],
"host_permissions": [
"https://*.amazon.com/*",
"https://*.amazon.co.uk/*",
// ... 19 more Amazon domains
"https://nullfake.com/*"
],
"background": {
"service_worker": "background/service-worker.js"
}
}The service worker handles API communication and message passing between the popup and content scripts. Content scripts do the heavy lifting with DOM manipulation, review extraction, and UI injection.
The DOM Extraction Nightmare
Amazon’s review structure is “creative” for lack of a better word. Reviews can appear in multiple formats depending on the page type, and selectors break regularly. The solution? Multiple fallback selectors for everything:
// Primary selectors with fallbacks
const reviewSelectors = {
container: [
'[data-hook="review"]',
'.review',
'[data-testid="reviews-section"] > div'
],
rating: [
'[data-hook="review-star-rating"] .a-icon-alt',
'.review-rating .a-icon-alt',
'.cr-original-review-rating'
],
content: [
'[data-hook="review-body"] span',
'.review-text',
'.cr-original-review-body'
]
};The extractor tries each selector in order until it finds elements. If the primary selector fails (which happens more often than you’d think), it falls back to alternatives. This approach has kept the extension working through multiple Amazon layout changes.
URL-First Detection Strategy
Here’s something that took way too long to figure out: URL patterns are way more reliable than DOM detection for identifying Amazon pages. Amazon rarely changes their URL structure, but they change DOM layouts constantly.
function isAmazonProductPage() {
const url = window.location.href;
return /\/dp\/[A-Z0-9]{10}/.test(url) ||
/\/gp\/product\/[A-Z0-9]{10}/.test(url);
}
function isAmazonReviewsPage() {
return /\/product-reviews\/[A-Z0-9]{10}/.test(window.location.href);
}URL detection is about 10x faster than DOM parsing and infinitely more reliable. Lesson learned: always check the URL first.
AJAX Pagination Detection
Amazon’s review pages use AJAX for pagination, which means traditional page load events don’t fire when users click “next page.” We needed to detect these transitions and automatically extract new reviews.The solution? A multi-layered detection system:
// Layer 1: MutationObserver for DOM changes
const observer = new MutationObserver((mutations) => {
mutations.forEach((mutation) => {
if (mutation.type === 'childList' &&
mutation.target.matches('[data-hook="reviews-medley-footer"]')) {
// New reviews loaded
setTimeout(() => checkAutoExtraction(), 500);
}
});
});
// Layer 2: XMLHttpRequest interception
const originalXHR = window.XMLHttpRequest;
window.XMLHttpRequest = function() {
const xhr = new originalXHR();
xhr.addEventListener('load', function() {
if (this.responseURL.includes('/reviews-render/ajax/')) {
setTimeout(() => checkAutoExtraction(), 1000);
}
});
return xhr;
};This catches both DOM updates and AJAX requests, ensuring we don’t miss review page transitions.
Real-Time Counter Synchronization
One of the trickier problems was keeping the floating “Extract Reviews” button counter in sync with the popup. Chrome’s storage API helps, but you need to actively listen for changes:
// Setup storage listener for real-time updates
function setupStorageListener() {
chrome.storage.local.onChanged.addListener((changes) => {
if (changes.extractedReviews) {
const newCount = changes.extractedReviews.newValue?.length || 0;
updateCounter(newCount);
}
});
}Plus a periodic refresh interval as backup, because sometimes storage events don’t fire reliably.
API Communication and Security
The extension communicates with the Null Fake API through the service worker, which handles all the security headers Amazon requires:
const headers = {
'X-Extension-ID': chrome.runtime.id,
'X-Extension-Version': manifest.version,
'User-Agent': navigator.userAgent,
'X-API-Key': apiKey
};The API expects specific headers for validation, and missing any of them results in a 403. The extension also implements client-side validation before sending data to avoid API errors.
Chrome Web Store Compliance
Getting approved by the Chrome Web Store relatively straightforward. In fact it was much easier than anticipated! The key requirements to meet approval in the web store for our extension are the following :
- User-initiated actions only : no background scraping or automated data collection
- Minimal permissions : we only request
storage,activeTab, andscripting - Transparent consent : users see exactly what data will be extracted before agreeing
- Single purpose : the extension does one thing: analyze Amazon reviews
The description had to be exactly 132 characters or less and every permission needs justification.
Performance Optimizations
The extension caches extracted reviews locally to avoid re-extraction, batches DOM queries to minimize reflows, and processes reviews in chunks to avoid blocking the UI. The floating button uses CSS transforms for smooth animations, and we debounce rapid clicks to prevent duplicate extractions.
What’s Next?
The current version works, but there’s room for improvement. We have a list of items on the roadmap for future updates of the extension :
- Faster processing : the API currently takes 30-60 seconds per analysis
- Better error handling : more graceful degradation when selectors fail
- Expanded coverage : support for Walmart, Best Buy and eBay reviews (open to suggestions!)
- Smarter extraction : context-aware AI to better identify review quality
- Notification and Queuing : Extract and submit your reviews for analysis, then be notified when they are ready
The Real Challenge
The hardest part about this entire process wasn’t the code, it was building something that works reliably despite Amazon’s best efforts to make it as difficult as possible. Every DOM change, every layout update, every new anti-bot measure is a potential breaking point. It became clear that these challenges are what Amazon wants as a deterrent and to protect their sales conversion numbers.
The true challenge is longevity. Many talented developers can push out a tool that works today but supporting and updating that tool over time is where the real grind happens. Especially when the tool is free!
That’s exactly why tools like this need to exist. When platforms make it harder to analyze the authenticity of user-generated content, that’s usually a sign you need to analyze it more, not less.
The extension is live on the Chrome Web Store now.