Product & E-Commerce

Updated Feb 2026

Monitor pricing, track inventory, extract product catalogs, and migrate between e-commerce platforms. Firecrawl transforms product pages into structured data that powers pricing intelligence, catalog management, and competitive analysis.

Why Firecrawl for E-Commerce

E-commerce teams need reliable product data from across the web -- competitor pricing, marketplace listings, product specifications, and reviews. Firecrawl handles the hard parts: JavaScript rendering for dynamic pricing, pagination for large catalogs, variant extraction, and structured output that feeds directly into your systems.

What You Can Extract

Data Type	Examples
Product Details	Title, SKU, descriptions, specifications, categories
Pricing	Current price, sale price, MAP, shipping costs, tax
Inventory	Stock levels, availability, lead times, variants
Reviews	Ratings, review text, review count, Q&A content
Media	Product images, videos, size guides, documentation
Variants	Size, color, material, configuration options with pricing

How It Works

Firecrawl Features Used

Feature	Role in E-Commerce
Scrape	Extract structured product data from individual pages
Crawl	Ingest entire product catalogs with all categories
Map	Discover all product URLs across a store
Browser	Handle JavaScript-rendered pricing, infinite scroll, and lazy-loaded content
Change Tracking	Detect pricing and inventory changes between checks

Price Monitoring

Track Competitor Pricing

from firecrawl import Firecrawl

app = Firecrawl(api_key="fc-YOUR_API_KEY")

# Extract structured pricing data
result = app.scrape(
    url="https://competitor-store.com/product/widget-pro",
    params={
        "formats": ["json"],
        "jsonOptions": {
            "schema": {
                "type": "object",
                "properties": {
                    "product_name": {"type": "string"},
                    "sku": {"type": "string"},
                    "current_price": {"type": "string"},
                    "original_price": {"type": "string"},
                    "discount_percentage": {"type": "string"},
                    "in_stock": {"type": "boolean"},
                    "shipping_cost": {"type": "string"},
                    "free_shipping_threshold": {"type": "string"}
                }
            }
        }
    }
)

product = result["json"]
print(f"Product: {product['product_name']}")
print(f"Price: {product['current_price']} (was {product['original_price']})")
print(f"In stock: {product['in_stock']}")

Detect Price Changes

# Monitor for pricing changes with change tracking
result = app.scrape(
    url="https://competitor-store.com/product/widget-pro",
    params={
        "formats": ["json", "changeTracking"],
        "jsonOptions": {
            "schema": {
                "type": "object",
                "properties": {
                    "product_name": {"type": "string"},
                    "current_price": {"type": "string"},
                    "in_stock": {"type": "boolean"}
                }
            }
        }
    }
)

if result.get("changeTracking", {}).get("changeStatus") == "changed":
    print("PRICE CHANGE DETECTED")
    print(result["changeTracking"]["diff"])

Batch Price Comparison

# Compare pricing across multiple competitors
competitors = [
    "https://store-a.com/product/widget-pro",
    "https://store-b.com/product/widget-pro",
    "https://store-c.com/product/widget-pro",
]

pricing_schema = {
    "type": "object",
    "properties": {
        "store_name": {"type": "string"},
        "product_name": {"type": "string"},
        "price": {"type": "string"},
        "shipping": {"type": "string"},
        "in_stock": {"type": "boolean"}
    }
}

batch_result = app.batch_scrape(
    urls=competitors,
    params={
        "formats": ["json"],
        "jsonOptions": {"schema": pricing_schema}
    }
)

# Compare prices
for page in batch_result["data"]:
    data = page["json"]
    print(f"{data['store_name']}: {data['price']} | "
          f"Shipping: {data['shipping']} | "
          f"Stock: {data['in_stock']}")

Product Catalog Extraction

Extract Full Product Details

# Extract comprehensive product data
result = app.scrape(
    url="https://store.com/products/premium-headphones",
    params={
        "formats": ["json"],
        "jsonOptions": {
            "schema": {
                "type": "object",
                "properties": {
                    "product_name": {"type": "string"},
                    "brand": {"type": "string"},
                    "sku": {"type": "string"},
                    "price": {"type": "string"},
                    "description": {"type": "string"},
                    "specifications": {
                        "type": "object",
                        "additionalProperties": {"type": "string"}
                    },
                    "variants": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "price": {"type": "string"},
                                "sku": {"type": "string"},
                                "in_stock": {"type": "boolean"}
                            }
                        }
                    },
                    "images": {
                        "type": "array",
                        "items": {"type": "string"}
                    },
                    "categories": {
                        "type": "array",
                        "items": {"type": "string"}
                    },
                    "rating": {"type": "string"},
                    "review_count": {"type": "number"}
                }
            }
        }
    }
)

Crawl an Entire Store Catalog

# Discover all product pages
site_map = app.map(url="https://store.com")
product_urls = [u for u in site_map["links"] if "/products/" in u or "/product/" in u]

print(f"Found {len(product_urls)} product pages")

# Batch extract product data
batch_result = app.batch_scrape(
    urls=product_urls,
    params={
        "formats": ["json"],
        "jsonOptions": {
            "schema": {
                "type": "object",
                "properties": {
                    "product_name": {"type": "string"},
                    "sku": {"type": "string"},
                    "price": {"type": "string"},
                    "category": {"type": "string"},
                    "in_stock": {"type": "boolean"}
                }
            }
        }
    }
)

# Build catalog
catalog = []
for page in batch_result["data"]:
    catalog.append(page["json"])

print(f"Extracted {len(catalog)} products")

E-Commerce Platform Migration

Move product catalogs between platforms (Magento to Shopify, WooCommerce to BigCommerce, etc.):

# Step 1: Discover all product pages on source store
source_map = app.map(url="https://old-store.com")
product_pages = [u for u in source_map["links"] if "/product" in u]

# Step 2: Extract full product data
migration_schema = {
    "type": "object",
    "properties": {
        "title": {"type": "string"},
        "handle": {"type": "string"},
        "body_html": {"type": "string"},
        "vendor": {"type": "string"},
        "product_type": {"type": "string"},
        "tags": {"type": "array", "items": {"type": "string"}},
        "variants": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "price": {"type": "string"},
                    "sku": {"type": "string"},
                    "weight": {"type": "string"},
                    "inventory_quantity": {"type": "number"}
                }
            }
        },
        "images": {"type": "array", "items": {"type": "string"}},
        "seo_title": {"type": "string"},
        "seo_description": {"type": "string"}
    }
}

batch_result = app.batch_scrape(
    urls=product_pages,
    params={
        "formats": ["json"],
        "jsonOptions": {"schema": migration_schema}
    }
)

# Step 3: Transform for target platform (e.g., Shopify CSV import)
import csv

with open("shopify_import.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Title", "Body (HTML)", "Vendor", "Type", "Tags",
                      "Variant Price", "Variant SKU", "Image Src"])
    for page in batch_result["data"]:
        p = page["json"]
        for variant in p.get("variants", [{}]):
            writer.writerow([
                p["title"], p.get("body_html", ""), p.get("vendor", ""),
                p.get("product_type", ""), "; ".join(p.get("tags", [])),
                variant.get("price", ""), variant.get("sku", ""),
                p.get("images", [""])[0]
            ])

Review and Sentiment Extraction

# Extract customer reviews for sentiment analysis
reviews_result = app.scrape(
    url="https://store.com/products/widget-pro/reviews",
    params={
        "formats": ["json"],
        "jsonOptions": {
            "schema": {
                "type": "object",
                "properties": {
                    "average_rating": {"type": "string"},
                    "total_reviews": {"type": "number"},
                    "reviews": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "rating": {"type": "number"},
                                "title": {"type": "string"},
                                "text": {"type": "string"},
                                "author": {"type": "string"},
                                "date": {"type": "string"},
                                "verified_purchase": {"type": "boolean"}
                            }
                        }
                    }
                }
            }
        }
    }
)

Supported Platforms

Firecrawl handles extraction from all major e-commerce platforms:

Platform	JavaScript Rendering	Pagination	Variants
Shopify	Handled automatically	Supported	Full support
WooCommerce	Handled automatically	Supported	Full support
Magento	Handled automatically	Supported	Full support
BigCommerce	Handled automatically	Supported	Full support
Custom stores	Handled automatically	Supported	Schema-dependent

Quick Start: Firecrawl Migrator Template

The Firecrawl Migrator template on GitHub provides a ready-made pipeline for e-commerce data extraction and migration. Supports multi-platform product catalog transfers.

Best Practices

1. Use JSON schemas for consistency -- Define schemas that match your target platform's import format
2. Handle variants carefully -- Products with multiple variants need schema definitions that capture all options
3. Extract images separately -- Catalog product images with their alt text for SEO preservation during migration
4. Monitor at appropriate intervals -- Pricing checks every few hours; catalog structure checks daily
5. Validate after migration -- Use Change Tracking to compare source and destination content
6. Respect rate limits -- Large catalog extractions should use batch endpoints with appropriate pacing

Related Use Cases

• Data Migration -- General platform migration workflows
• Competitive Intelligence -- Monitor competitor product strategies
• Observability & Monitoring -- Monitor your own product pages for issues