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

Most teams trying to track competitor pricing end up with a messy spreadsheet, a dozen bookmarked URLs, and a monthly “price check” ritual that always slips. With Structify, you can turn that manual grind into an automated competitor pricing tracker powered by live web sources, with refresh schedules that keep your data and dashboards up to date without another reminder on your calendar.

Quick Answer: You set up a competitor pricing tracker in Structify by defining the competitor sites you want to monitor, configuring web scrapers to pull pricing data into a structured table, then building a dashboard that updates on a schedule. Once it’s live, Structify keeps refreshing the data automatically and you can query it in plain English or from Slack.

Why This Matters

Pricing is where strategy meets reality. If your competitors move first—discounting, changing packaging tiers, or quietly tweaking enterprise pricing—you feel it in win rates and deal cycles long before anyone updates your battlecards.

When you automate a competitor pricing tracker in Structify, you stop reacting late to anecdotal intel and start making revenue decisions (discounts, packaging, promos) based on current, structured data pulled directly from competitor websites and other live web sources.

Key Benefits:

• Always-fresh competitor pricing: Structify’s web scraping keeps your pricing tracker synced to live sites so you can see changes days or weeks before they filter in via sales chatter.
• One source of truth for price intelligence: Combine competitor web pricing with your CRM, win/loss notes, and call transcripts to understand not just what they charge, but how it impacts deals.
• Zero manual checking: No more weekly “price check” screenshots—Structify schedules refreshes, normalizes the data, and updates dashboards automatically.

Core Concepts & Key Points

Concept	Definition	Why it's important
Competitor Pricing Tracker	A structured dataset and dashboard that continuously pull and organize pricing information from competitor websites and other web sources.	Turns ad-hoc “what do they charge?” questions into a repeatable, always-on system for pricing and discount decisions.
Structify Web Scraping	Structify’s no-code capability to pull live data from competitor websites, industry databases, news sites, and public records into structured tables.	Lets you monitor competitor pricing, promos, and packaging changes automatically—without engineering support or custom scripts.
Scheduled Refreshes	Automated update cycles where Structify re-scrapes defined sources, normalizes changes, and updates dashboards and alerts.	Ensures your pricing intel is current, so RevOps, Sales, and Product aren’t making calls based on month-old screenshots or spreadsheets.

How It Works (Step-by-Step)

At a high level, setting up a competitor pricing tracker in Structify follows the same three-step flow Structify uses for all revenue workflows:

1. Bring in web sources (competitor sites, industry pages, marketplaces).
2. Clean, normalize, and enrich pricing data into a consistent, queryable table.
3. Visualize, schedule refreshes, and share via dashboards, alerts, and Slack.

Here’s how to do it end-to-end.

1. Define the pricing questions you actually need to answer

Before you touch a scraper, get explicit about what you want your tracker to tell you. For example:

• “Which competitors changed list pricing in the last 30 days?”
• “How do our mid-market and enterprise plans compare by feature and price per seat?”
• “Who is running discounts or promotions by region or segment?”
• “Which competitors have usage-based vs seat-based pricing, and at what thresholds?”

Turn these questions into a simple schema:

• Competitor metadata: competitor_name, url, segment (SMB/MM/ENT), region
• Plan info: plan_name, billing_type (monthly/annual), price_per_unit, unit_type (seat, usage, tier), currency
• Promo info: discount_type, discount_amount, promo_start, promo_end, qualifying_conditions
• Change tracking: first_seen_at, last_seen_at, scrape_run_id, changed_fields

Structify will help with a lot of this normalization, but knowing what fields you care about up front keeps the whole setup aligned to revenue decisions—not just a wall of scraped HTML.

2. Identify and catalog your web sources

Next, make a list of the web locations where pricing actually lives:

• Official pricing pages: /pricing, /plans, /subscriptions
• Add-ons & extras: pages for implementation fees, support tiers, overage pricing
• Regional or currency-specific pages: localized pricing for EU, UK, APAC
• Marketplace listings: pricing on marketplaces or partner listings (where applicable)
• Public docs: PDFs or pages that encode pricing (rate cards, RFP templates, public contracts)

Put these into a simple table or doc:

• competitor_name
• primary_pricing_url
• additional_pricing_urls
• notes (e.g., “enterprise is ‘contact sales’ only”, “discounts only shown in checkout”)

You’ll use this to configure Structify’s web scrapers and keep your tracker maintainable as competitors add new products or plans.

3. Configure Structify web scrapers to extract pricing

Now, you’ll tell Structify what to scrape and what to extract.

At a conceptual level inside Structify:

1. Create a new web data pipeline

   • Choose Web Scraping as your source type.
   • Add your list of competitor pricing URLs (you can paste or upload a list).

2. Define extraction patterns

   • Use Structify’s configuration to specify the elements you care about:
     • Plan names
     • Prices
     • Billing cycles (monthly vs annual)
     • Feature lists per plan
     • Any visible discounts or “save X%” banners
   • Structify’s AI helps by:
     • Parsing the page
     • Identifying tables, price blocks, and plan sections
     • Extracting the relevant text, numbers, and structures into columns like plan_name, price_value, price_period, currency.

3. Normalize by competitor and plan

   • Map raw fields into your schema:
     • raw_price_string → price_value (numeric) + currency
     • raw_billing_string → billing_type (monthly/annual)
     • plan_section → plan_name
   • Add a competitor_name field (Structify can auto-fill based on URL rules you define).

4. Handle messy pages and edge cases

   • For pages with “contact sales” instead of public pricing:
     • Still capture plan_name and note price_visibility = "hidden" or pricing_type = "custom only".
   • For usage-based pricing:
     • Extract thresholds into usage_unit, tier_min, tier_max, tier_price.
   • For promo callouts:
     • Extract phrases like “20% off annual” into structured discount_type and discount_amount.

Under the hood, Structify is doing the heavy lifting—finding the relevant content on each page, extracting tables, text, and numbers from the HTML (and PDFs where needed), and turning that into rows and columns you can analyze.

4. Clean, deduplicate, and align definitions

Once the first scrape runs, you’ll have raw structured data. Now you turn it into something usable by the wider team.

1. Deduplicate plans and normalize naming

   • Use Structify’s AI to merge variations like:
     • “Pro”, “Professional”, “Pro Plan” → Professional
     • “Enterprise”, “Enterprise (Custom)” → Enterprise
   • Create a canonical plan_name_normalized field across all competitors.

2. Standardize units and currencies

   • Convert all prices to a standard currency where needed.
   • Normalize units:
     • per user, per seat, per license → per_seat
     • Usage-based units into standard labels (per_gb, per_api_call, etc.).

3. Define and document your pricing ontology

   • Use Structify’s semantic layer / business wiki to:
     • Define what a “plan” is vs an “add-on”.
     • Explain how you define “effective price per seat”.
     • Document how you handle “starting at” or custom-only pricing.
   • This prevents debates later when someone sees two slightly different price numbers for the same competitor.

4. Enrich with internal data (optional but powerful)

   • Connect CRM data (e.g., Salesforce, HubSpot) to tie competitor pricing to:
     • Win/loss outcomes
     • Discount levels granted
     • Deal size and segment
   • Connect call transcripts, notes, or support tickets to capture:
     • Mentioned competitor pricing concessions
     • Requests triggered by competitor promos.

Now your pricing tracker isn’t just a list of numbers; it’s a revenue context engine: “When Competitor X moves their Pro tier from $99 to $79, what happens to our win rate in mid-market?”

5. Build a competitor pricing dashboard

With your structured table ready, create a dashboard that surfaces answers without making people wade through raw data.

Key views to include:

• Current pricing snapshot

  • Table: competitor_name × plan_name_normalized with:
    • price_value, billing_type, currency
    • price_per_seat_normalized (if applicable)
    • price_visibility (public/custom-only)

• Pricing changes over time

  • Line chart by competitor:
    • plan_name_normalized on color
    • price_value over time (last_seen_at)
  • Highlight up/down movements with thresholds (e.g., changes >10%).

• Promo and discount tracker

  • List of active promos:
    • competitor_name, plan_name, discount_amount, promo_end
  • Filter by region or segment.

• Comparison to your pricing

  • Join to your internal pricing table and show:
    • Relative premium/discount vs each competitor
    • Gaps by segment or plan.

Because Structify is built for revenue teams, you can also ask:

• “Show me competitors who are cheaper than us on mid-market plans by more than 15%.”
• “List all pricing changes for Competitor Y in the last quarter.”

You get answers as charts, tables, or text without writing SQL.

6. Set up scheduled refreshes

This is where you move from a one-time research project to an always-on pricing system.

1. Choose refresh cadence by source

   • Pricing pages don’t all change at the same rate. Typical patterns:
     • High-velocity SaaS competitors: daily or every few days
     • Slower-moving or enterprise-heavy: weekly
     • Static rate cards or PDFs: monthly or quarterly
   • In Structify, configure refresh schedules per web source or pipeline:
     • e.g., “Competitor A, B, C pricing pages: daily at 2am”
     • “Industry benchmark PDFs: first Monday of the month.”

2. Automate change detection

   • Have Structify compare each new scrape to the previous one and flag:
     • price_value changes
     • New or removed plans
     • New promos or discount callouts
   • Create a “Pricing Change Log” table with:
     • competitor_name, plan_name, field_changed, old_value, new_value, changed_at.

3. Trigger alerts and updates

   • Configure alerts for key events:
     • Any price drop above N%
     • New entry-level or freemium plan added
     • New promo that undercuts your price in a target segment
   • Deliver alerts where your team already works:
     • Slack channel for competitive intel (e.g., #market-pricing)
     • Email summary for leadership (weekly digest).

4. Keep dashboards synced

   • Tie dashboards directly to the refreshed tables:
     • When the pipeline runs, dashboards update automatically.
   • Because Structify maintains a semantic layer, changing or adding a field in the scrape pipeline won’t silently break your dashboards—you can adjust definitions and mappings once and keep everything aligned.

7. Enable plain-English questions and Slack workflows

Once your competitor pricing tracker is up and refreshing, make it accessible beyond the analyst team.

• Enable Slack integration so sellers and PMs can ask:
  • “How does Competitor Z’s enterprise pricing compare to ours by seat for 500 users?”
  • “Which competitors raised prices in the last 60 days?”
• Use Structify’s conversation-style analysis instead of a query builder:
  • Ask a question.
  • Get a table or chart.
  • Follow up: “Filter to North America only,” “Show only plans with usage-based pricing,” etc.

This turns your pricing tracker into a real-time assistant instead of one more dashboard link nobody clicks.

Common Mistakes to Avoid

• Scraping too much and defining too little: Pulling every pricing-related element from every page without a clear schema leads to a swamp of columns nobody trusts. Start with the questions you need to answer, then design the fields to match.
• Ignoring context beyond list price: List pricing alone doesn’t tell the full story. Use Structify to capture promos, “starting at” ranges, and custom-only signals—and join to your CRM and win/loss data to understand what actually happens in deals.

Real-World Example

A mid-market SaaS company selling into the same accounts as three well-funded rivals kept hearing from reps, “Competitor X came in way lower,” but they had no reliable way to verify how often pricing was shifting or where.

They used Structify to:

1. Scrape competitor pricing pages and marketplace listings daily—no code, no separate scraping stack.
2. Normalize plans, currencies, and unit types into a single competitor pricing table.
3. Join that table to Salesforce opportunities to see:
   • Win rates by competitor and segment.
   • How often deals with Competitor Y involved aggressive discounting.
4. Build a pricing change log and Slack alerts so RevOps and product marketing saw:
   • “Competitor Z dropped enterprise list pricing by 12% yesterday.”
   • “Competitor X introduced a new usage-based tier for SMB.”

Within a quarter, they used this tracker to justify sharpening discount guardrails, re-position their mid-market plan, and arm reps with up-to-date talk tracks instead of stale battlecards. The manual “pricing checks” that used to eat hours every month disappeared; Structify handled the monitoring.

Pro Tip: When you first set up your competitor pricing tracker, run the scraper more frequently than you think you need for the first few weeks. Use that period to observe how often each competitor actually changes pricing, then dial your refresh cadence to match reality—it keeps costs and noise down while staying responsive.

Summary

Setting up a competitor pricing tracker in Structify using web sources isn’t a research project; it’s a repeatable revenue workflow:

• Bring in competitor pricing pages, marketplace listings, and public docs with Structify’s web scraping.
• Clean, normalize, and merge that data into a consistent pricing schema, enriched with CRM and win/loss context.
• Visualize and schedule refreshes so dashboards, alerts, and Slack answers reflect live competitor moves—not last quarter’s screenshots.

Once it’s in place, you stop guessing what competitors charge and start reacting in hours instead of weeks when they shift pricing, add promos, or launch new plans.

Next Step

Get Started