How do I set up a competitor pricing tracker in Structify using web sources and schedule refreshes?

Quick Answer: You set up a competitor pricing tracker in Structify by connecting web sources with built-in scrapers, mapping the extracted data into a clean pricing schema, and then scheduling refreshes so pricing updates flow into dashboards automatically. Once it’s live, you can monitor competitor price changes in one place and ask follow-up questions in plain English—without writing code or maintaining custom scripts.

Why This Matters

If you’re still checking competitor pricing manually, you’re burning operator time on copy-paste work and reacting to the market days or weeks late. A structured, always-on competitor pricing tracker means you can catch undercutting early, justify increases with confidence, and stop relying on ad-hoc spreadsheets that go stale the second they’re shared. Structify turns messy web pages, PDFs, and public records into a single, queryable view of competitor prices so your team can move from “we think we’re competitive” to “we know where we win and where we’re exposed.”

Key Benefits:

See pricing shifts in near real time: Track competitor increases, discounts, and promos without refreshing 20 browser tabs.
Make pricing decisions with context: Combine web pricing data with your CRM, win/loss notes, and support tickets to see how price actually impacts deals.
Stop manual research loops: Replace recurring “who checked competitor X this week?” with scheduled, automated refreshes that feed dashboards and Slack.

Core Concepts & Key Points

Concept	Definition	Why it's important
Web source connector	Structify’s no-code web scraping that pulls live data from competitor websites, industry databases, and public records.	Lets you track competitor pricing without hiring developers or maintaining brittle scripts.
Pricing schema	The structured table for prices (product, plan, currency, list price, discount, effective date, source URL, etc.).	Keeps messy web inputs consistent so you can compare competitors, trend over time, and join with CRM data.
Scheduled refreshes	Automated runs that re-scrape web sources and update your pricing tables and dashboards on a defined cadence.	Gives you “dashboards that don’t need updating” and keeps pricing analysis current without manual effort.

How It Works (Step-by-Step)

Structify’s flow is the same whether you’re tracking SaaS plans, SKUs, or marketplace fees: bring in web sources, clean and structure the data, then visualize and share.

1. Bring In Any Web Source

List your competitors and key URLs
- Pricing pages (e.g., /pricing, /plans, region-specific pages).
- Product catalog pages or category listings.
- Promo/offer pages (discounts, bundles, seasonal pricing).
- Industry databases or marketplaces where competitors list their prices.
Create a simple table before you start:

Competitor URL Type Notes
Competitor A https://competitor-a.com/pricing SaaS pricing page Main B2B plans
Competitor B https://marketplace.com/competitor-b Marketplace listing Volume-based fees
Configure Structify web scrapers
- In Structify, add a new web source for each URL or pattern (e.g., /pricing).
- Point Structify to the exact page(s) you care about. You can:
  - Target specific pages (e.g., three different regional pricing URLs).
  - Define patterns (e.g., a product category path on a marketplace).
- Structify’s web scrapers will:
  - Pull live HTML content.
  - Extract tables, price blocks, and relevant text.
  - Make that content available for structuring—no scripts, no dev work.
Include non-HTML sources if relevant
- If competitors publish price sheets as PDFs, decks, or downloadable docs:
  - Upload or point Structify at those files.
  - Structify will extract tables, numbers, and text and blend them with your web-scraped data.

Competitor	URL	Type	Notes
Competitor A	https://competitor-a.com/pricing	SaaS pricing page	Main B2B plans
Competitor B	https://marketplace.com/competitor-b	Marketplace listing	Volume-based fees

2. Clean, Merge, and Analyze

Now you turn scraped content into a clean competitor pricing dataset you can actually use.

Define your pricing schema Decide the fields you want Structify to maintain as your “pricing truth,” for example:
- competitor_name
- product_or_plan
- tier (Basic, Pro, Enterprise)
- billing_term (monthly, annual, usage-based)
- currency
- list_price
- discounted_price or promo_price
- unit (per user, per seat, per 1,000 units)
- feature_highlights (short text)
- region / market
- effective_date (when Structify saw this price)
- source_url
- scrape_timestamp
This schema becomes the backbone of your competitor pricing tracker.
Map web content into your schema Using Structify’s AI-driven extraction and normalization, you:
- Point Structify to:
  - Pricing tables on pages.
  - Labels near price elements (“per seat”, “billed annually”).
  - Any footnotes that impact interpretation (e.g., “min 10 seats,” “discount applies to year one only”).
- In Structify, define mappings:
  - “This table column → product_or_plan”
  - “This price cell → list_price”
  - “This frequency label → billing_term”
- Let Structify normalize inconsistent formats:
  - $99 / month vs 99 USD/mo vs From 99.
  - Different date formats for promos and expirations.
Over time, this becomes your evolving business wiki for competitor pricing: fields and definitions stay consistent even as sites change.
Deduplicate and align entities Competitor naming gets messy fast across sources.
- Use Structify to:
  - Normalize names like “ACME,” “Acme Corp,” and “ACME Corporation” into a single competitor_name.
  - Associate multiple URLs and marketplaces with one entity.
- This alignment matters when you join pricing with:
  - Win/loss notes in your CRM.
  - Support tickets referencing competitor offers.
  - Call transcripts where reps talk through competitive pricing.
Join pricing with your internal data (optional but powerful) To understand impact on revenue—not just price lists—connect:
- CRM (Salesforce, HubSpot) for:
  - Deals mentioning competitors.
  - Closed-lost reasons citing “price”.
- Call logs/transcripts for:
  - Objections around being “too expensive.”
- Support tickets for:
  - Churn citing cheaper alternatives.
Then you can ask questions like:
- “Did our Q1 price increase cause more losses to Competitor A?”
- “Where are we underpriced vs Competitor B on Enterprise plans?”

3. Visualize and Share Insights

Once the web sources and schema are in place, you move from raw data to operational views.

Create competitor pricing dashboards In Structify, build charts and tables that answer operator questions directly:
- Competitive price positioning
  - Compare your plans vs each competitor by tier and billing term.
- Pricing change history
  - Line chart of list_price over time by competitor and product.
- Promo / discount monitor
  - Table of active promos with discounted_price, % discount, and end date.
- Region-specific pricing
  - Heatmap of prices by region/currency to spot where you’re misaligned.
These dashboards update automatically when your scrapers run—no exports, no rebuilds.
Work where your team already lives
- Use Structify’s Slack integration so sales, RevOps, and pricing teams can:
  - Ask: “What’s Competitor A’s current annual price for their Pro plan in the US?”
  - Follow up: “When did they last change that price?”
  - Share a chart or table directly into a Slack channel before a pricing review.
- Treat it like a conversation, not a query builder: plain-English questions instead of SQL.
Share with leadership without the weekly scramble
- Turn dashboards into:
  - Quarterly pricing review packs.
  - Board-ready views of competitive positioning.
- Because the definitions and schema are maintained, you’re not rebuilding or re-explaining the same metrics every quarter.

Setting Up Scheduled Refreshes

The difference between a one-time scrape and a real competitor pricing tracker is scheduling. Here’s how to keep it fresh.

Choose your refresh cadence Match frequency to how often your market changes:
- Fast-moving SaaS / promo-heavy markets:
  - Daily or multiple times per week.
- Industrial/B2B with rare changes:
  - Weekly or bi-weekly may be enough.
- Marketplaces with dynamic pricing:
  - Daily at minimum; consider multiple checks around high-activity times.
Configure schedules in Structify For each web source (or group of sources):
- Set a refresh schedule (e.g., every day at 2 AM UTC).
- Stagger runs if you’re tracking many competitors to avoid hitting rate limits.
- Ensure each run:
  - Re-scrapes the target URLs.
  - Re-applies your mapping and normalization into the pricing schema.
  - Writes new rows with updated scrape_timestamp and effective_date.
Handle changes and anomalies Use Structify to flag and control unexpected behavior:
- Price spike/drop alerts
  - Configure rules like: “Alert if list_price changes by >15% since last run” or “if a new promo appears with >20% discount.”
- Schema drift
  - If a competitor redesigns their pricing page, Structify can surface extraction errors so you fix mappings once instead of silently ingesting bad data.
- Versioning
  - Keep historical records rather than overwriting:
    - Allows you to analyze “before vs after” for competitor changes.
    - Helps explain quarter-to-quarter win/loss shifts to leadership.
Refresh downstream dashboards automatically Because Structify maintains a semantic layer and definitions:
- Dashboards and charts update as new data lands—no manual refresh.
- Your “competitive pricing” views stay intact even when:
  - You add new competitors.
  - You expand to new regions.
  - Source websites shift layout (after you update mappings once).

Common Mistakes to Avoid

Treating it like a one-off research project
- If you scrape once into a spreadsheet and never schedule refreshes, you’re back to stale data in two weeks. Use Structify’s scheduling so your trackers live on without manual hustle.
Skipping a clear pricing schema
- Capturing raw HTML or screenshots (“we’ll parse it later”) leads to messy, unjoinable data. Define fields up front—product, plan, term, list price, discount, effective date—and map everything into that structure from day one.
Ignoring external + internal context
- Knowing competitors’ prices is useful; knowing how those prices hit your pipeline is revenue-critical. Connect CRM, call logs, and win/loss notes so you can see when a competitor price move actually changes win rates.

Real-World Example

A mid-market SaaS company selling into manufacturing was constantly hearing “Competitor X is cheaper,” but no one had a clean, consolidated view of what “cheaper” actually meant across regions and tiers. Pricing and RevOps were manually checking three competitor sites every few weeks, copy-pasting into a shared spreadsheet, and arguing about what counted as a “comparable” plan.

They set up Structify to:

Scrape each competitor’s pricing page and relevant PDF price sheets automatically.
Normalize everything into a single pricing schema with product_or_plan, billing_term, and list_price by region.
Schedule daily refreshes and alert if any plan changed more than 10% or a new discount promo appeared.
Join that data with Salesforce closed-lost reasons and Gong call transcripts where competitors were mentioned.

Within a month, they uncovered that:

In Europe, they were 25–30% above the closest competitor on mid-tier plans while win rates had dropped sharply.
In the US, they were actually underpriced at the top tier, leaving margin on the table with no competitive pressure at that level.

They used Structify’s dashboards in their pricing committee to justify a targeted price adjustment: lowering mid-tier EU prices to close the gap and raising US enterprise prices where they held clear feature and support advantages. Both moves were backed by live competitor pricing and connected directly to pipeline behavior—no guesswork.

Pro Tip: When you first configure your competitor pricing tracker, add a simple “sanity check” dashboard that compares each competitor’s prices against the previous run. Scan that view once after the first few scheduled refreshes; it’ll help you catch mapping issues early and build trust in the data before you roll it out broadly.

Summary

A competitor pricing tracker that actually influences revenue decisions needs more than screenshots and spreadsheets. With Structify, you can pull live data from competitor websites and external databases, structure it into a consistent pricing schema, join it with your CRM and call data, and keep everything refreshed on a schedule. That means your team can stop arguing about whose spreadsheet is current and start answering questions like “Where are we overpriced, underpriced, or perfectly positioned?” in seconds—right from Slack.

Next Step

Get Started