Competitive SaaS pricing analysis and dynamic rate card generation

Introduction

Pricing your SaaS product is a constant tightrope walk. Set your rates too high and you lose prospects who can't justify the spend; too low and you leave revenue on the table. The real challenge is that your competitors aren't standing still. They're adjusting their pricing models, bundling features differently, and targeting different customer segments every quarter.

Most teams handle this manually. Someone spends three hours a week scraping competitor websites, copying pricing into a spreadsheet, and then manually adjusting their own rate cards based on what they find. It's tedious, error-prone, and by the time the analysis is complete, half the data is already outdated. You need a system that watches your competitors continuously, analyses their pricing patterns, and generates your own optimised rate cards automatically.

This workflow combines three powerful tools to eliminate that manual work entirely. We'll use Copy.ai to generate multiple pricing variations automatically, Deepnote to run statistical analysis on competitor data, and Parspec.ai to structure and validate the output. Wire them together with an orchestration platform, and you have a system that runs on schedule, delivers fresh insights, and needs zero human intervention between trigger and result.

The Automated Workflow

Which Orchestration Tool to Use

For this workflow, I recommend n8n or Make. Both support scheduled triggers, handle complex branching logic, and provide good error handling. Zapier works but has limitations with data transformation, making it slower for analysis tasks. Claude Code is excellent for one-off runs but less ideal for scheduled automation. I'll show the n8n approach here since it's self-hosted, gives you full audit logs, and costs nothing beyond server time.

The Complete Data Flow

The workflow runs daily at 04:00 UTC. Here's what happens:

1. n8n's Schedule trigger fires, initiating a competitor data collection routine.
2. An HTTP Request node fetches your competitor pricing pages (or uses a pre-built web scraping integration).
3. Parspec.ai structures the raw HTML into clean JSON with standardised fields.
4. The structured data flows into Deepnote via webhook for analysis.
5. Deepnote runs statistical models on pricing trends, calculates elasticity, and identifies gaps.
6. Copy.ai generates three alternative rate card options based on the analysis.
7. The final rate cards are validated, formatted, and stored in your database.
8. A notification is sent to your pricing team with the results.

Setting Up the n8n Workflow

Start by creating a new workflow in n8n. Add a Schedule node set to trigger daily:

Copy
Schedule Node Configuration:
- Trigger type: Every day
- Time: 04:00 UTC
- Timezone: UTC

Next, add an HTTP Request node to collect competitor pricing data. If you're monitoring five competitors, you might set up separate HTTP nodes for each, or use a loop. Here's an example for one competitor:

Copy
HTTP Request Node:
- Method: GET
- URL: https://competitor-domain.com/pricing
- Authentication: None (public pages)
- Response format: String (returns HTML)

Now connect Parspec.ai to structure that HTML. Parspec.ai accepts raw HTML and returns clean JSON. You'll need to set up an account first and grab your API key. Add an HTTP Request node configured for Parspec:

Copy
POST https://api.parspec.ai/v1/parse
Headers:
  Authorization: Bearer YOUR_PARSPEC_API_KEY
  Content-Type: application/json

Body:
{
  "html_content": "{{ $node['HTTP Request'].data.body }}",
  "schema": {
    "pricing_tier": "string",
    "monthly_price": "number",
    "annual_price": "number",
    "included_features": "array",
    "limits": "object"
  }
}

Parspec returns structured data like this:

Copy{
  "competitor": "CompanyA",
  "date_parsed": "2025-01-15T04:22:00Z",
  "pricing_tiers": [
    {
      "name": "Starter",
      "monthly_price": 29,
      "annual_price": 290,
      "included_features": ["Feature1", "Feature2"],
      "limits": {
        "api_calls": 10000,
        "team_members": 2
      }
    },
    {
      "name": "Professional",
      "monthly_price": 99,
      "annual_price": 990,
      "included_features": ["Feature1", "Feature2", "Feature3", "Feature4"],
      "limits": {
        "api_calls": 100000,
        "team_members": 10
      }
    }
  ]
}

Store this structured data in a database node (PostgreSQL, MySQL, or even Google Sheets via API). Use a Function node to transform and store it:

Copy// Function node in n8n
const parsedData = $node['Parspec'].data;
const timestamp = new Date().toISOString();

return {
  competitor: parsedData.competitor,
  data: JSON.stringify(parsedData.pricing_tiers),
  parsed_at: timestamp,
  source_url: $node['HTTP Request'].data.url
};

Triggering Deepnote Analysis

Once you have cleaned pricing data, send it to Deepnote for analysis. Deepnote is a collaborative Python notebook platform with API support. Create a notebook that accepts pricing data via webhook, runs analysis, and returns insights.

Create a Deepnote notebook that includes this Python snippet:

Copyimport pandas as pd
import numpy as np
from scipy import stats

pricing_data = input_data  # This comes via webhook

# Convert to DataFrame
df = pd.DataFrame(pricing_data)

# Calculate price per feature
df['features_count'] = df['included_features'].apply(len)
df['price_per_feature'] = df['monthly_price'] / df['features_count']

# Trend analysis
price_trends = {
    'mean_monthly': df['monthly_price'].mean(),
    'median_monthly': df['monthly_price'].median(),
    'std_dev': df['monthly_price'].std(),
    'price_range': {
        'min': df['monthly_price'].min(),
        'max': df['monthly_price'].max()
    }
}

# Gap analysis
your_price = 79  # Your current Starter tier price
market_position = (your_price - price_trends['mean_monthly']) / price_trends['std_dev']

results = {
    'pricing_trends': price_trends,
    'market_position_zscore': market_position,
    'recommended_adjustment': 'increase' if market_position < -0.5 else 'hold' if market_position < 0.5 else 'decrease',
    'feature_comparison': df.to_dict()
}

In n8n, add an HTTP Request node to trigger this Deepnote notebook:

Copy
HTTP Request Node for Deepnote:
- Method: POST
- URL: https://api.deepnote.com/v1/notebooks/YOUR_NOTEBOOK_ID/run
- Headers:
    Authorization: Bearer YOUR_DEEPNOTE_API_KEY
    Content-Type: application/json
- Body:
{
  "cells": {
    "input_data": {{ JSON.stringify($node['Database'].data) }}
  }
}

Deepnote returns analysis results. You'll poll for completion since it takes a few seconds to run:

Copy
Wait Node:
- Duration: 3 seconds

Then add another HTTP Request:
- Method: GET
- URL: https://api.deepnote.com/v1/notebooks/YOUR_NOTEBOOK_ID/latest_run
- Headers:
    Authorization: Bearer YOUR_DEEPNOTE_API_KEY

Generating Rate Cards with Copy.ai

Now you have market analysis. Feed this into Copy.ai to generate multiple pricing options automatically. Copy.ai is an API-first copywriting tool that can generate variations on demand.

Add an HTTP Request node for Copy.ai:

Copy
POST https://api.copy.ai/api/writing

Headers:
  Authorization: Bearer YOUR_COPY_AI_API_KEY
  Content-Type: application/json

Body:
{
  "prompt": "Based on these competitor pricing insights: {{ JSON.stringify($node['Deepnote'].data.results) }}, generate three alternative rate card options for a SaaS product. For each option, include tier names, prices (monthly and annual), key features, and a brief justification for the pricing strategy. Format as JSON.",
  "model": "gpt-4",
  "temperature": 0.7,
  "max_tokens": 2000
}

Copy.ai generates something like:

Copy{
  "options": [
    {
      "name": "Conservative",
      "justification": "Match competitor average pricing",
      "tiers": [
        {
          "name": "Starter",
          "monthly": 29,
          "annual": 290,
          "features": ["API access", "1000 requests/month", "Email support"]
        },
        {
          "name": "Professional",
          "monthly": 99,
          "annual": 990,
          "features": ["API access", "100000 requests/month", "Priority support", "Advanced analytics"]
        }
      ]
    },
    {
      "name": "Aggressive",
      "justification": "Premium positioning based on superior feature set",
      "tiers": [
        {
          "name": "Starter",
          "monthly": 39,
          "annual": 390,
          "features": ["API access", "2000 requests/month", "Email support", "Basic reporting"]
        },
        {
          "name": "Professional",
          "monthly": 129,
          "annual": 1290,
          "features": ["API access", "200000 requests/month", "Priority support", "Advanced analytics", "Custom integrations"]
        }
      ]
    }
  ]
}

Validation and Storage

Add a Function node to validate the generated rate cards:

Copy// Validation function
const rateCards = $node['Copy.ai'].data.options;

const validated = rateCards.map(card => {
  // Check that annual price is roughly 10x monthly (with tolerance)
  card.tiers.forEach(tier => {
    const ratio = tier.annual / tier.monthly;
    if (ratio < 9 || ratio > 11) {
      tier.validation_warning = 'Annual/monthly ratio unusual';
    }
  });
  
  // Check price progression
  for (let i = 1; i < card.tiers.length; i++) {
    if (card.tiers[i].monthly <= card.tiers[i-1].monthly) {
      card.validation_warning = 'Tier prices do not increase';
    }
  }
  
  return card;
});

return validated;

Store the results in your database:

Copy
Database Insert/Update Node:
- Table: rate_cards
- Fields:
    id: auto-increment
    strategy_name: {{ $node['Validation'].data[0].name }}
    tier_data: {{ JSON.stringify($node['Validation'].data[0].tiers) }}
    analysis_date: {{ new Date().toISOString() }}
    deepnote_analysis: {{ JSON.stringify($node['Deepnote'].data.results) }}
    status: 'pending_review'

Final Notification

End the workflow with a notification to your pricing team:

Copy
Email/Slack Node:
- To: pricing-team@company.com
- Subject: Daily Pricing Analysis Complete: {{ $node['Validation'].data.length }} options generated
- Body: 
  Competitor analysis run completed at {{ new Date() }}.
  Market position: {{ $node['Deepnote'].data.results.market_position_zscore }}
  Recommendation: {{ $node['Deepnote'].data.results.recommended_adjustment }}
  {{ $node['Validation'].data.length }} rate card options ready for review at your dashboard.

The Manual Alternative

If you prefer not to automate this initially, you can run these tools individually. Spend 30 minutes collecting competitor pricing manually into a spreadsheet, then upload it directly to Deepnote for analysis. Run Copy.ai with a custom prompt, pasting the Deepnote results directly into the input. This gives you full control and lets you iterate quickly on analysis parameters, but it means you're doing this weekly or monthly rather than daily, and someone needs to remember to do it.

For occasional pricing reviews, this is fine. For staying competitive in a market where pricing changes weekly, automation is necessary.

Pro Tips

1. Rate Limiting and Backoff Strategy

Parspec.ai and Copy.ai both have rate limits. Build exponential backoff into your n8n workflow. Add a Retry node between Parspec and the database with these settings: retry on HTTP status 429, wait 5 seconds before first retry, double the wait time each subsequent retry, maximum 3 attempts. This prevents your workflow from failing when an API is temporarily overloaded.

2. Validate Competitor Data Quality

Not all competitor pricing pages are structured the same way. Parspec.ai sometimes returns incomplete data when page layouts are unusual. After parsing, check for null values and missing tiers. If a competitor's data looks incomplete, flag it with a low confidence score rather than treating it as fact. Use a Function node to mark suspicious entries:

Copyconst data = $node['Parspec'].data.pricing_tiers;
const flagged = data.map(tier => {
  const missing = !tier.monthly_price || !tier.included_features;
  return {
    ...tier,
    confidence_score: missing ? 0.5 : 1.0
  };
});

3. Historical Tracking for Trend Detection

Store every competitor price change in a time-series table. Over 3 months, you'll see patterns: some competitors always adjust in January, others run promotions in Q4. Deepnote's analysis becomes more powerful with historical context. Add a database query to Deepnote that pulls the last 90 days of pricing history for each competitor, then calculates velocity (how fast prices are changing) and seasonality.

4. Cost Optimisation

This workflow makes three API calls per competitor per day (scrape, parse, analyse). With five competitors, that's 15 calls daily. Copy.ai is the most expensive if you use GPT-4. Switch to GPT-3.5-turbo in production (lower cost, still good quality) and reserve GPT-4 for weekly deep dives. Deepnote's free tier handles this analysis easily; you only pay if you need collaboration features.

5. A/B Testing Integration

Once rate cards are generated and approved, automatically create A/B test variants in your analytics platform. Some customers will see the Conservative option, others the Aggressive option. After 2 weeks, Deepnote can pull conversion data and determine which pricing strategy actually performs better. This closes the loop: analysis informs pricing, pricing is tested, results feed back into next week's analysis.

Cost Breakdown

Running this workflow daily costs less than half the hourly rate of a single analyst, and it never sleeps, never makes transcription errors, and catches pricing changes within 24 hours. The payoff compounds: smarter pricing decisions made weekly rather than quarterly mean you capture more revenue, lose fewer prospects to competitor undercutting, and respond faster to market shifts.