PricePulse AI — Cross-Marketplace Product Intelligence

One call, one product_intel_snapshot per product: aligned prices across Amazon + eBay + Walmart (plus any Schema.org storefront via JSON-LD fallback), change flags vs. your baseline, review summaries, opportunity insights, optional webhook alerts on significant price drops, and vs_reference comparison against your product. MCP-ready for AI agents. Pay per snapshot, not per row.

Disclaimer. Output is research material generated by automated extraction from public marketplace pages — NOT authoritative pricing, availability, or rating information. Verify every fact against the cited source URL before pricing decisions or customer-facing use. See Terms of Use at the bottom.

What's new in v0.2 — webhook alerts ($0.005/dispatch), JSON-LD universal fallback (Target, Best Buy, Etsy, Shopify, any storefront with Schema.org Product), reference_label / vs_reference block, dry_run preview mode, Apify Residential proxy support, Amazon 2-retry backoff, Amazon locale support, variants + image-gallery extraction, and keyword_research un-gated with strict caps. See CHANGELOG.md for details.

Keywords this actor ranks for: cross-marketplace price tracker, multi-marketplace product intelligence, Amazon eBay Walmart price compare, competitor price tracker, MAP enforcement, Buy Box monitor, MCP price intelligence, AI agent product compare, change-detection scraper, price-spread analyzer, brand portfolio monitor, restock alerts, opportunity insights actor.

---

Why PricePulse AI

Other product / price scrapers	PricePulse AI
One marketplace per actor — chain three to compare	One run, one snapshot, three marketplaces aligned
One row per marketplace per product (you do the join)	One record per logical product — already grouped
Raw price strings, mixed currencies	Normalized {price, currency, is_on_sale} from every site
No change detection — you store history yourself	Built-in baseline diffing with significant flag
No analysis layer — just data	Opportunity insights: positioning, undercut alerts, spread %
Per-row billing scales with marketplace count	One snapshot = one charge, regardless of marketplaces
Fabricates fields when scrape fails	Never guesses — surfaces risk_flags, returns candidates_only
LLM-locked or LLM-required	Rule-based by default, optional Claude Haiku enrichment
Awkward for MCP / AI agents	MCP-first schema: short enums, fixed output, stamped event name

---

When to use

• Cross-marketplace tracking. You sell on Amazon and Walmart and want one record per SKU per day showing where you stand on each.
• Competitor benchmarking. You name 3–5 competitor ASINs and want a daily who-is-undercutting-whom report.
• MAP enforcement. You set a price floor; you want flagged any site that drops below it.
• Brand portfolio health. You ship 25 SKUs; you want a single dataset row per SKU per day across all marketplaces.
• Sale event monitoring. Black Friday, Prime Day, Cyber Monday — hourly cadence with change_detection_baseline_key for live deltas.
• MCP / AI agent workflows. Claude or GPT calls this every N minutes; gets back a structured product_intel_snapshot ready to reason over.

When NOT to use

• Full review-text extraction (per-review author + body + helpful votes) → not in v1. We compute themes + rating distribution; full reviews need a dedicated reviews scraper.
• JavaScript-rendered storefronts only (e.g., some niche Shopify themes) → v1 is HTTP-only. Pages exposing data via JSON-LD or server-rendered HTML work; pure SPAs do not.
• Locale-specific Amazon parsing (UK, DE, JP) → v1 targets amazon.com selectors. Other locales may parse partially.
• Single-marketplace, max-volume scraping at $0.005/row → use a commodity Amazon-only scraper. We're priced for the joined, enriched, change-detected use case.

---

Quick start — 6 recipes that cover 90% of real use

1. Track your main product on Amazon (cheapest, fastest)

{
  "mode": "product_list",
  "products": [{"label": "my_main_chair", "asin": "B08N5WRWNW"}],
  "marketplaces": ["amazon"]
}

→ 1 snapshot, $0.04.

2. Cross-marketplace snapshot — your product on all 3 sites

{
  "mode": "product_list",
  "products": [{"label": "my_main_chair", "asin": "B08N5WRWNW"}],
  "marketplaces": ["amazon", "ebay", "walmart"],
  "include_reviews_summary": true
}

→ Still 1 snapshot, $0.04. (Marketplaces are bundled, not billed separately.)

3. Daily competitor digest with change detection

{
  "mode": "product_list",
  "products": [
    {"label": "my_chair",       "asin": "B08N5WRWNW"},
    {"label": "competitor_A",   "asin": "B09ZZZ9999"},
    {"label": "competitor_B",   "asin": "B07YYY0000"}
  ],
  "marketplaces": ["amazon", "walmart"],
  "change_detection_baseline_key": "daily_chairs"
}

→ 3 snapshots = $0.12/day. Each snapshot carries changes.price_change_flags vs. yesterday's run.

4. Brand portfolio (full SKU sweep)

See examples/example6_brand_monitoring.json — 5 SKUs × 3 marketplaces = 5 snapshots = $0.20/run.

5. MAP enforcement (price-floor watch)

See examples/example7_map_enforcement.json — every sites[].price below your floor is a violation. Pair with Apify's webhook integration to alert legal.

6. AI agent quick comparison via MCP

{
  "mode": "product_list",
  "products": [{"label": "user_question_target", "asin": "B08N5WRWNW"}],
  "marketplaces": ["amazon", "ebay", "walmart"],
  "include_reviews_summary": true
}

→ The agent uses markdown_report directly as a reply or pulls opportunity_insights.notes for a TL;DR.

More: see the 10 ready-to-run input JSONs in examples/.

---

Built for

Role	What you do with it
Amazon / FBA seller	Daily check on your top 5 SKUs across Amazon + Walmart. priceDelta against competitors, plus opportunity notes you can paste into a Slack channel.
Brand manager	MAP enforcement: detect resellers selling below your minimum price. Cross-marketplace coverage means you catch eBay-only violators that Amazon-only tools miss.
E-commerce ops lead	Brand portfolio health — 25-SKU sweep once a day. Single dataset row per SKU per day for direct BI ingestion.
Pricing analyst	Price-spread analysis: which marketplace is the cheapest right now, by how much, and is the spread widening or closing?
Dropshipper / arbitrage	Identify cross-marketplace pricing arbitrage. Buy on the marketplace with the lowest sites[].price, list on the one with the highest.
Agency	Run on behalf of a client portfolio. One snapshot per client SKU; reports auto-derive from markdown_report.
AI agent / MCP tool builder	Plug into Claude Desktop / Cursor / any MCP client. The fixed output shape + stamped event name mean agents discover and call it without prompting acrobatics.
BI / data team	Pipe snapshots into Snowflake/BigQuery. Each record has stable group_key, request_context.finished_at, and JSON-friendly nested shape.

---

Typical costs (worked examples)

Scenario	Snapshots	Cost per run	Cadence	Monthly cost
1 product, 1 marketplace	1	$0.04	Daily	~$1.20/mo
5 products, 3 marketplaces (brand portfolio)	5	$0.20	Daily	~$6/mo
25 products (max), 3 marketplaces	25	$1.00	Daily	~$30/mo
10 competitor ASINs hourly during Black Friday week	10	$0.40	Hourly × 7 days	~$67/week
Failed validation / Amazon block (candidates_only)	0	$0.00	—	$0.00

Compare: dedicated price-tracking SaaS (Keepa, Prisync, etc.) typically charge $19–$99/month per tracked product. At 25 products that's $475–$2,475/month. PricePulse AI gives you a raw cross-marketplace data feed for $30/month at the same volume — you keep your data, you control the cadence, you own the analysis layer.

---

How it works

flowchart LR
    A[products and/or URLs<br/>+ marketplaces] --> B[Pydantic input validation<br/>bound lists, dedupe, mode rules]
    B --> C[Per-host robots.txt + rate limit<br/>identifying User-Agent]
    C --> D[Parallel marketplace fetch<br/>httpx + BeautifulSoup]
    D --> E[Normalize each site<br/>5-anchor extraction confidence]
    E --> F[Aggregate metrics<br/>min/avg/max, spread, blended rating]
    F --> G{baseline key?}
    G -->|yes| H[Diff vs. stored baseline<br/>price/availability/rank flags]
    G -->|no| I[skip]
    H --> J[Opportunity insights<br/>rule-based notes]
    I --> J
    J --> K{LLM enrichment?}
    K -->|anthropic + key| L[Claude Haiku<br/>review summary]
    K -->|none| M[Rule-based summary]
    L --> N[Stamp billing fields<br/>chargeable_event_count, paid_event_name]
    M --> N
    N --> O[Push chargeable records to dataset<br/>Always set OUTPUT key]
    O --> P[(JSON + markdown + one-pager)]

Five-step short version:

1. Validate input against a strict Pydantic schema — bail out cleanly on bad input, never charge for invalid runs.
2. Fetch the relevant marketplace pages concurrently. httpx + BeautifulSoup, polite per-host rate limit (0.6s minimum interval), robots.txt honoured.
3. Normalize each page into the canonical SiteMetrics shape. Per-site extraction_confidence = (anchors parsed) / 5.
4. Aggregate + analyze: compute cross-site stats, diff against your stored baseline (if any), derive reviews summary + opportunity insights.
5. Stamp + push: chargeable records (output_status.code in {ok, partial}) land in the dataset; the full payload always lands in OUTPUT for observability — even when nothing was chargeable.

---

Sample output (truncated for readability)

{
  "label": "my_main_chair",
  "group_key": "my_main_chair",
  "core_profile": {
    "canonical_title": "ErgoPlus Ergonomic Office Chair",
    "canonical_brand": "ErgoPlus",
    "category": "Office Products > Chairs",
    "image_url": "https://m.media-amazon.com/images/I/example.jpg"
  },
  "sites": [
    {
      "marketplace": "amazon",
      "url": "https://www.amazon.com/dp/B08N5WRWNW",
      "currency": "USD", "price": 199.99, "list_price": 249.99, "is_on_sale": true,
      "availability": "in_stock", "buy_box_seller_type": "amazon",
      "rating": 4.5, "review_count": 1243, "bestseller_rank": 12,
      "extraction_confidence": 0.92
    },
    {
      "marketplace": "walmart",
      "url": "https://www.walmart.com/ip/123456789",
      "currency": "USD", "price": 189.00, "list_price": 219.00, "is_on_sale": true,
      "availability": "in_stock",
      "rating": 4.3, "review_count": 578, "extraction_confidence": 0.85
    }
  ],
  "aggregated_metrics": {
    "min_price": 189.0, "max_price": 199.99, "avg_price": 194.5,
    "price_spread_pct": 5.8, "avg_rating": 4.4, "total_review_count": 1821,
    "marketplace_count": 2
  },
  "changes": {
    "price_change_flags": [
      {"marketplace": "amazon", "direction": "decrease",
       "absolute": -20.0, "relative_pct": -9.1, "significant": true}
    ],
    "baseline_age_days": 2
  },
  "reviews_summary": {
    "summary_text": "Average rating across 2 marketplaces is 4.4 over 1,821 reviews. Recurring positives: comfort, support. Recurring concerns: armrests.",
    "top_positive_themes": ["comfort", "support"],
    "top_negative_themes": ["armrests"],
    "enrichment_source": "rule_based"
  },
  "opportunity_insights": {
    "positioning": "mid_price_premium_quality",
    "notes": [
      "Walmart currently has the lowest listed price (USD 189.00).",
      "On sale on amazon, walmart — check timing.",
      "Cross-marketplace price spread is 5.8% — possible arbitrage signal."
    ]
  },
  "output_status": {"code": "ok"},
  "confidence": {"overall": 0.88, "discovery": 1.0, "extraction": 0.88, "reviews": 0.7, "insights": 0.85},
  "chargeable_event_count": 1,
  "paid_event_name": "product_intel_snapshot",
  "markdown_report": "> **Disclaimer.** ...\n\n# ErgoPlus Ergonomic Office Chair\n...",
  "one_pager_text": "PRODUCT INTEL — ErgoPlus Ergonomic Office Chair\n..."
}

The markdown_report and one_pager_text are derived from the JSON; embed them straight into Slack, Notion, or an LLM prompt.

---

How to call it

From the Apify console (no code)

1. Open the actor page → Try for free.
2. Paste ASINs / URLs into products in the input form.
3. Pick marketplaces (defaults to ["amazon"]).
4. Save & Start. Each input product becomes one dataset record.

From an MCP-enabled LLM (Claude Desktop, Cursor, etc.)

The actor's input schema, output shape, and tool description are written for MCP auto-discovery. Sample agent prompt:

"Use PricePulse AI to compare my product B08N5WRWNW against competitors B09ZZZ9999 and B07YYY0000 on Amazon and Walmart. Tell me where I'm being undercut and by how much."

Programmatically — Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("entranced_gelato/price-pulse-ai").call(run_input={
    "mode": "product_list",
    "products": [
        {"label": "my_chair",     "asin": "B08N5WRWNW"},
        {"label": "competitor_A", "asin": "B09ZZZ9999"},
    ],
    "marketplaces": ["amazon", "walmart"],
    "include_reviews_summary": True,
})

for snap in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{snap['label']}: min ${snap['aggregated_metrics']['min_price']:.2f} "
          f"across {snap['aggregated_metrics']['marketplace_count']} sites")
    for note in snap["opportunity_insights"]["notes"]:
        print(f"  - {note}")

Programmatically — Node.js / TypeScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('entranced_gelato/price-pulse-ai').call({
    mode: 'product_list',
    products: [
        { label: 'my_chair',     asin: 'B08N5WRWNW' },
        { label: 'competitor_A', asin: 'B09ZZZ9999' },
    ],
    marketplaces: ['amazon', 'walmart'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const undercut = items.filter(s =>
    s.changes?.price_change_flags?.some(f => f.direction === 'decrease' && f.significant)
);
console.log(`${undercut.length} product(s) saw a significant price decrease since baseline.`);

Programmatically — curl

curl -X POST -H "Content-Type: application/json" \
  -d '{"mode":"product_list","products":[{"label":"my_chair","asin":"B08N5WRWNW"}],"marketplaces":["amazon","walmart"]}' \
  "https://api.apify.com/v2/acts/entranced_gelato~price-pulse-ai/run-sync-get-dataset-items?token=$APIFY_TOKEN"

Scheduling for time-series

Pair with Apify Scheduler to run hourly or daily. Each snapshot stamps request_context.finished_at, so the dataset becomes a price-history database queryable via the Apify dataset API:

# Pull last 24h of my-chair snapshots
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?clean=true&desc=true&limit=24"

---

Input reference

Field	Type	Default	What it does
mode	enum	"product_list"	Pick product_list (v1) for explicit ASIN/URL lists; keyword_research is scaffolded for v1.1 and gated in v1.0.
products	array of {label, asin, urls}	[]	One entry per group to track. asin OR at least one urls[] required per entry. label is a stable key for baseline diffing.
marketplaces	array	["amazon"]	Subset of ["amazon", "ebay", "walmart"]. Bundled into the same snapshot — adding sites does NOT add cost.
include_reviews_summary	bool	true	Attach a reviews_summary block (themes + rating distribution).
include_history	bool	false	Attach a recent 30-day history block if prior runs stored in KV.
change_detection_baseline_key	string	null	KV key for diffing — first run writes the baseline; later runs diff against it and overwrite.
user_notes	string	null	Free-form context, echoed back in request_context. Useful for tagging runs.
enrichment_model	enum	"none"	"none" (rule-based) or "anthropic" (Claude Haiku). anthropic falls back to rule-based on any LLM failure.
anthropic_api_key	string (secret)	—	Required when enrichment_model = "anthropic". Stored as Apify secret input, never echoed.
max_products_per_marketplace	int	20	Cap for keyword_research mode only (1–100). Ignored in product_list.
keyword	string	—	Used by keyword_research mode (gated in v1.0).

---

Output reference

Field	Description
request_context	Echo of input + started_at / finished_at.
label, group_key	Human label + stable key for baseline lookups.
query_inputs	{asin, input_urls, keyword, resolved_marketplaces}.
core_profile	{canonical_title, canonical_brand, category, image_url} — unified across sites.
sites[]	Per-marketplace normalized metrics + per-site extraction_confidence.
aggregated_metrics	{min_price, max_price, avg_price, price_spread_pct, avg_rating, total_review_count, marketplace_count}.
changes	{price_change_flags[], availability_changes[], rank_changes[], baseline_age_days} vs. baseline.
reviews_summary	{summary_text, top_positive_themes, top_negative_themes, rating_distribution, enrichment_source}.
opportunity_insights	{positioning, notes[]} — rule-based, 1–5 short notes.
confidence	{overall, discovery, extraction, reviews, insights} in [0, 1].
sources[]	Every URL fetched + status. Citation trail.
risk_flags[]	Data-quality warnings (info / warn / error).
output_status	{code, reason} — drives billing (ok/partial charged; candidates_only/failed not).
disclaimer	Legal disclaimer; rendered atop every derived format.
chargeable_event_count, paid_event_name	Billing transparency.
markdown_report, one_pager_text	Embed-ready derived formats.

Trust contract — what this actor will / won't do

• Never fabricates prices, ratings, review counts, or stock state. If a field can't be parsed, it is null.
• Always cites every URL it fetched in sources[].
• Distinguishes rule-based vs. LLM-derived enrichment via reviews_summary.enrichment_source.
• Honors robots.txt for every host; surfaces blocks as risk_flag entries.
• Identifies itself with a clear User-Agent; no spoofing; per-host minimum interval of 0.6s.
• Returns candidates_only (non-chargeable) rather than guessing when nothing resolves.

---

Pricing

$0.04 per product_intel_snapshot. One snapshot = one fully processed product group, regardless of how many marketplaces you queried.

• Non-chargeable runs (candidates_only, failed, validation errors) push nothing to the dataset.
• 50-result free trial for new users.
• Plus standard Apify platform compute & proxy (typically a fraction of a cent per run; paid by you to Apify).

---

FAQ

Q: I asked for 3 marketplaces — why is it only 1 snapshot? A: A snapshot is one record per logical product group, not per marketplace. We bundle all marketplaces for a given product into one snapshot. Charge is $0.04 regardless of marketplace count.

Q: My run returned candidates_only for an Amazon ASIN. Am I billed? A: No. Amazon serves bot-detection pages to non-residential traffic and that fraction of runs can't be parsed. We mark them candidates_only and don't push to the dataset, so you're not charged.

Q: How do I track changes over time? A: Pass any string as change_detection_baseline_key. First run writes the baseline; subsequent runs read it, compute price/availability/rank deltas, then overwrite with the new state.

Q: Can I use Claude Haiku for richer review summaries? A: Yes — set enrichment_model = "anthropic" and supply anthropic_api_key (it's stored as an Apify secret, never echoed in output). Falls back to rule-based on any LLM failure.

Q: Does this work for Amazon UK / .de / .co.jp? A: v1 targets amazon.com selectors. Other locales accept URLs as inputs but may have partial extraction. Full locale support is on the v1.2 roadmap.

Q: Does this scrape full customer reviews? A: Not in v1. We compute themes from rating distributions and (with LLM enrichment) a small sample of public review snippets. No reviewer names or PII retained. For full review-text extraction, use a dedicated reviews scraper.

Q: Is keyword research available? A: It's in the input schema but gated in v1.0 to avoid surprise bills while per-marketplace SERP scrapers are battle-tested. Runs in this mode return failed with a clear message. Planned for v1.1.

Q: Can I run 1,000 products in one run? A: No — capped at 25 product groups per run for reliability and to keep your bill predictable. For larger universes, run multiple actor calls (each $0.04 × N).

Q: How accurate is the price field? A: Prices come from server-rendered HTML selectors and JSON-LD blocks (eBay, Walmart) or Amazon-specific selectors. Currency derives from the listing or symbol. Sale price → price, list price → list_price when both present. Per-site extraction_confidence shows how many of the 5 anchor fields parsed; below 0.5 you should treat the row as unreliable.

Q: Does it support webhook alerts? A: Not natively in v1, but pair with Apify's generic webhook integration — fire on every run, your endpoint reads changes.price_change_flags[].significant to decide whether to alert.

Q: Is this legal? A: This actor reads HTML that any anonymous web visitor can see; it honours robots.txt and uses an identifying User-Agent. You are responsible for ensuring your use complies with each marketplace's Terms of Service and applicable law. Don't redistribute the marketplaces' product images, descriptions, or reviews beyond what your usage rights allow. See TERMS.md for the full Terms of Use.

---

Limitations

• JavaScript-rendered pages (rare on Amazon/eBay/Walmart product pages; common on niche storefronts) → not supported in v1.
• Amazon's anti-bot serves CAPTCHAs to a portion of anonymous requests → mitigated by risk_flags + non-chargeable candidates_only, but the failure rate is non-zero.
• keyword_research mode is gated in v1.0 (see FAQ).
• 25 product groups max per run.

---

Changelog

• 0.2.0 (2026-05-22) — Webhook alerts, JSON-LD universal fallback, vs_reference, dry_run, Apify Residential proxy, Amazon retry/locale, variants + images, keyword_research un-gated. 165 tests.
• 0.1.0 (2026-05-22) — Initial release with cross-marketplace bundle, change detection, opportunity insights. 94 tests.

Related work

Looking for something more specific? These other actors in the same broader space may be a better fit:

• Single-marketplace, max-volume scraping at $0.005/row — search "Amazon product scraper" / "Walmart product scraper" on the Apify Store.
• Full review-text extraction with author + helpful votes — search "Amazon reviews scraper".
• Shopify / WooCommerce / Etsy / niche storefront scraping — search "Shopify scraper".
• Generic JSON-LD scraping of any storefront — search "ecommerce JSON-LD scraper".

PricePulse AI complements these — it's the opinionated aggregation + intelligence layer on top of single-source row dumps.

---

For developers

Architecture

.actor/                     # Apify metadata + input schema
src/                        # Production code
  marketplaces/             # One module per marketplace (amazon, ebay, walmart)
  models.py                 # Input + output Pydantic models — the spec
  utils.py                  # HTTP, parsing, rate limit helpers
  robots.py                 # robots.txt cache
  normalizer.py             # cross-marketplace aggregates + profile merge
  reviews.py                # rule-based summary + optional LLM enrichment
  insights.py               # rule-based opportunity insights
  changes.py                # baseline diff computation
  llm.py                    # Anthropic enrichment helper
  assembler.py              # canonical FinalOutput builder
main.py                     # Actor entrypoint with top-level exception handler

Confidence math

overall = 0.3·discovery + 0.4·extraction + 0.1·reviews + 0.2·insights

• discovery = resolved_marketplaces / requested_marketplaces
• extraction = mean of per-site extraction_confidence (anchors_parsed / 5)
• reviews = 0 / 0.7 (rule-based) / 0.9 (Anthropic)
• insights = 0 / 0.5 (1 site) / 0.85 (≥2 sites)

Run locally

pip install -r requirements-dev.txt
APIFY_LOCAL_STORAGE_DIR=./storage python main.py < sample_input.json

Tests

$pytest -q   # 94 tests, ~0.3s

Extending — add a marketplace

Implement src/marketplaces/<name>.py with the same fetch_<name>(...) -> MarketplaceResult signature, register it in FETCHERS (in src/extraction.py), add a tests/test_<name>.py. The assembler picks up new marketplaces automatically.

---

Terms of Use (summary)

By using this actor you agree to (a) verify all output against the cited source URLs, (b) comply with the Terms of Service of each marketplace you query, and (c) accept that output is provided AS IS, with the Operator's aggregate liability capped at the greater of 12 months of fees paid or USD 100. Marketplace and brand names are used nominatively; no affiliation is implied. The actor does not retain your inputs or outputs outside the run. See TERMS.md for the complete text.