Competitive pricing analysis and dynamic pricing recommendation

Introduction

Pricing strategy is one of the most complicated decisions in business, yet most companies still rely on spreadsheets, annual reviews, or gut feel. The moment a competitor adjusts their prices, you're either playing catch-up or leaving money on the table. What if you could monitor competitor pricing in real time, analyse market conditions, and automatically recommend price adjustments within hours instead of weeks?

The problem is that these three capabilities live in different tools. You need to pull competitor data from the web, normalise it, run statistical analysis, and present recommendations to your team, all without anyone manually stitching the pieces together each morning. Every handoff is a place where data gets stale or human error creeps in.

This is where accio-ai, finster-ai, and terrakotta-ai can work together. Accio gathers competitor pricing data. Finster performs financial modelling and margin analysis. Terrakotta generates the recommendations based on market conditions. Wire them together with an orchestration tool, and you've got a live pricing engine that works while you sleep.

The Automated Workflow

This workflow runs on a schedule, typically once or twice daily, and requires an advanced understanding of APIs, conditional logic, and data transformation. We'll walk through n8n here, though Zapier and Make follow similar patterns.

Why n8n for this workflow?

N8n's native HTTP requests, JavaScript code nodes, and ability to handle complex data transformations make it the best choice for this particular chain. You'll need conditional branching (if margin falls below threshold, flag it) and the ability to pass nested JSON between tools without flattening the structure.

Step 1:

Trigger and Fetch Competitor Data with Accio

The workflow starts on a schedule. Every day at 6 AM, n8n fires a request to accio-ai to pull competitor pricing across your product catalogue.

Copy
POST https://api.accio-ai.com/v1/pricing/scan
Content-Type: application/json
Authorization: Bearer YOUR_ACCIO_API_KEY

{
  "competitors": [
    "competitor-a.com",
    "competitor-b.com",
    "competitor-c.com"
  ],
  "products": [
    "product-sku-001",
    "product-sku-002",
    "product-sku-003"
  ],
  "frequency": "daily",
  "extract_fields": ["price", "discount", "bundle_offer", "stock_status"]
}

Accio returns structured JSON with competitor prices, any active discounts, and bundle information. This response looks something like:

Copy{
  "scan_id": "scan_20250115_001",
  "timestamp": "2025-01-15T06:00:00Z",
  "data": [
    {
      "competitor": "competitor-a.com",
      "product_sku": "product-sku-001",
      "price": 49.99,
      "discount_percent": 10,
      "effective_price": 44.99,
      "bundle_offer": null,
      "stock_status": "in_stock"
    },
    {
      "competitor": "competitor-b.com",
      "product_sku": "product-sku-001",
      "price": 52.00,
      "discount_percent": 0,
      "effective_price": 52.00,
      "bundle_offer": null,
      "stock_status": "low_stock"
    }
  ]
}

In n8n, add an HTTP Request node, paste the endpoint above, and set authentication as Bearer token.

Step 2:

Normalise and Enrich with Your Own Data

Before passing this to finster-ai, you need to combine competitor data with your internal costs, margins, and sales velocity. Use an n8n JavaScript code node to merge accio's output with your product database.

Copyconst accioData = $input.all()[0].json.data;
const yourProducts = {
  "product-sku-001": {
    "cost": 15.00,
    "current_price": 49.99,
    "target_margin_percent": 40,
    "monthly_volume": 2400,
    "elasticity": 1.2
  },
  "product-sku-002": {
    "cost": 22.50,
    "current_price": 79.99,
    "target_margin_percent": 45,
    "monthly_volume": 890,
    "elasticity": 0.95
  }
};

const enriched = accioData.map(item => {
  const sku = item.product_sku;
  const productInfo = yourProducts[sku];
  
  return {
    product_sku: sku,
    competitor: item.competitor,
    competitor_price: item.effective_price,
    your_current_price: productInfo.current_price,
    cost: productInfo.cost,
    current_margin_percent: ((productInfo.current_price - productInfo.cost) / productInfo.current_price * 100).toFixed(2),
    target_margin_percent: productInfo.target_margin_percent,
    monthly_volume: productInfo.monthly_volume,
    price_elasticity: productInfo.elasticity,
    competitor_undercut: (item.effective_price < productInfo.current_price),
    undercut_amount: (productInfo.current_price - item.effective_price).toFixed(2)
  };
});

return enriched;

This produces a list where each row contains competitor prices alongside your cost structure and business constraints. You now have everything finster-ai needs.

Step 3:

Run Financial Analysis with Finster

Pass the enriched data to finster-ai's margin and revenue modelling endpoint. Finster takes your pricing options and simulates what happens to profit if you adjust prices.

Copy
POST https://api.finster-ai.com/v1/margin-analysis
Content-Type: application/json
Authorization: Bearer YOUR_FINSTER_API_KEY

{
  "analysis_type": "dynamic_pricing",
  "products": [
    {
      "sku": "product-sku-001",
      "current_price": 49.99,
      "cost": 15.00,
      "monthly_volume": 2400,
      "price_elasticity": 1.2,
      "competitor_prices": [44.99, 52.00],
      "target_margin_percent": 40,
      "price_scenarios": [
        {"price": 44.99, "label": "match_competitor_a"},
        {"price": 46.99, "label": "undercut_by_3"},
        {"price": 49.99, "label": "hold_current"},
        {"price": 52.00, "label": "premium_position"}
      ]
    }
  ],
  "constraints": {
    "min_margin_percent": 30,
    "avoid_price_drop_above": 5,
    "consider_stockout_cost": true
  }
}

Finster models revenue and profit for each price scenario, accounting for elasticity. If demand is elastic (1.2), a 1% price drop could boost volume by 1.2%. Finster calculates the net profit impact:

Copy{
  "analysis_id": "fin_20250115_001",
  "results": [
    {
      "sku": "product-sku-001",
      "scenarios": [
        {
          "label": "match_competitor_a",
          "price": 44.99,
          "projected_monthly_volume": 2928,
          "projected_revenue": 131795.72,
          "projected_cogs": 43920.00,
          "projected_gross_profit": 87875.72,
          "margin_percent": 66.67,
          "profit_vs_current": 8234.56
        },
        {
          "label": "hold_current",
          "price": 49.99,
          "projected_monthly_volume": 2400,
          "projected_revenue": 119976.00,
          "projected_cogs": 36000.00,
          "projected_gross_profit": 83976.00,
          "margin_percent": 70.00,
          "profit_vs_current": 0.00
        },
        {
          "label": "premium_position",
          "price": 52.00,
          "projected_monthly_volume": 2088,
          "projected_revenue": 108576.00,
          "projected_cogs": 31320.00,
          "projected_gross_profit": 77256.00,
          "margin_percent": 71.16,
          "profit_vs_current": -6720.00
        }
      ],
      "recommendation_rationale": "match_competitor_a increases profit by 8.2k despite lower margin%, due to volume uplift"
    }
  ]
}

In n8n, add another HTTP Request node for finster, and map the enriched data into the request body. Store the results for the next step.

Step 4:

Generate Recommendations with Terrakotta

Terrakotta takes finster's financial analysis and competitor context to produce a ranked set of pricing recommendations with confidence scores and reasoning.

Copy
POST https://api.terrakotta-ai.com/v1/pricing-recommendation
Content-Type: application/json
Authorization: Bearer YOUR_TERRAKOTTA_API_KEY

{
  "request_id": "rec_20250115_001",
  "financial_analysis": finster_results,
  "competitive_context": {
    "market_leader": "competitor-a",
    "price_range_min": 44.99,
    "price_range_max": 52.00,
    "number_of_competitors": 3
  },
  "business_rules": {
    "avoid_frequent_changes": true,
    "days_since_last_change": 45,
    "seasonal_adjustments": false,
    "promotional_period": false
  },
  "output_format": "ranked_recommendations"
}

Terrakotta returns recommendations ranked by expected profit impact, with confidence levels and reasoning:

Copy{
  "recommendations_id": "rec_20250115_001",
  "generated_at": "2025-01-15T06:15:00Z",
  "recommendations": [
    {
      "rank": 1,
      "sku": "product-sku-001",
      "recommended_price": 46.99,
      "confidence": 0.92,
      "rationale": "Undercuts competitor-a by 2% while maintaining 66% gross margin. Elasticity modelling suggests 18% volume uplift, driving 6.8k additional monthly profit.",
      "risk_level": "low",
      "expected_profit_impact": 6800.00
    },
    {
      "rank": 2,
      "sku": "product-sku-001",
      "recommended_price": 44.99,
      "confidence": 0.88,
      "rationale": "Matches competitor-a exactly. Maximises market share capture. Profit uplift 8.2k, but positions you as price-follower rather than leader.",
      "risk_level": "medium",
      "expected_profit_impact": 8234.56
    }
  ]
}

Add a final HTTP node in n8n to call terrakotta.

Step 5:

Store Results and Route to Decision Makers

Add an n8n Database node (or API call to your own database) to log all recommendations. Then, conditionally route outputs:

• High confidence (>0.90) and high profit impact (>5k): Auto-approve and queue for implementation.

• Medium confidence (0.80-0.90): Send to pricing manager for review.

• Low confidence (<0.80) or conflicts with business rules: Log but do not recommend.

Use an n8n Set node to flag each recommendation:

Copyconst terrakottaData = $input.all()[0].json.recommendations;

const flagged = terrakottaData.map(rec => {
  let action = "review";
  if (rec.confidence > 0.90 && rec.expected_profit_impact > 5000) {
    action = "auto_approve";
  } else if (rec.confidence < 0.80) {
    action = "hold";
  }
  return { ...rec, recommended_action: action };
});

return flagged;

For auto-approved recommendations, add an HTTP node that calls your pricing API or e-commerce platform's price update endpoint:

Copy
PATCH https://api.yourplatform.com/v1/products/{sku}/price
Content-Type: application/json
Authorization: Bearer YOUR_PLATFORM_API_KEY

{
  "sku": "product-sku-001",
  "new_price": 46.99,
  "effective_date": "2025-01-15T12:00:00Z",
  "change_reason": "dynamic_pricing_algorithm",
  "log_id": "rec_20250115_001"
}

For flagged recommendations, send an email or Slack notification using n8n's native nodes.

Full n8n Workflow Structure

Your n8n canvas should look like this:

1. Schedule Trigger (Daily, 6 AM)
2. HTTP Request: Accio API (fetch competitor prices)
3. JavaScript Code: Normalise and enrich
4. HTTP Request: Finster API (margin analysis)
5. HTTP Request: Terrakotta API (recommendations)
6. Set Node: Flag and categorise recommendations
7. Conditional Branch:
   • If auto_approve: HTTP Request to price your platform
   • If review: Send email notification
   • If hold: Log to database only

All data flows as JSON through the canvas. No manual exports or imports required.

The Manual Alternative

If you prefer human oversight at each stage, you can run each tool independently and review outputs before moving forward:

1. Run accio-ai manually; export the CSV of competitor prices.
2. Paste into a spreadsheet and manually add your costs and margins.
3. Feed the spreadsheet into finster-ai's UI to generate financial scenarios.
4. Copy finster's output into terrakotta-ai's interface to generate recommendations.
5. Review the recommendations and manually update prices in your system.

This takes 45 minutes to an hour versus 20 minutes automated. More importantly, by the time you've finished, competitor prices have likely changed again. Automation keeps you current.

Pro Tips

Rate limits and throttling. Accio-ai allows 100 scans per day on the standard plan. If you run this workflow multiple times daily, you'll hit the limit quickly. Either upgrade to the professional plan or space your triggers 6-12 hours apart. Check accio's rate limit headers and add conditional waits in n8n if needed.

Copyconst rateLimitRemaining = $input.all()[0].headers['x-ratelimit-remaining'];
if (parseInt(rateLimitRemaining) < 10) {
  throw new Error("Rate limit approaching. Pausing workflow.");
}

Cost sensitivity and rounding. Finster's elasticity models are statistical estimates, not guarantees. A 1.2 elasticity coefficient is directionally correct but carries uncertainty, especially for niche products or during seasonal swings. Always set finster's avoid_price_drop_above parameter to something conservative (5-10%) so you don't aggressively cut prices based on a false signal. Review recommendations manually once a month to catch systematic errors.

Competitor data quality. Accio-ai sometimes scrapes outdated cached prices, especially from websites with JavaScript-heavy pricing. Set up a manual spot check weekly: pick two competitors and verify accio's prices match the live website. If you find systematic lag, contact accio support or reduce scanning frequency to once per week.

Handling tie-ups in finster analysis. If finster takes longer than 30 seconds (it shouldn't, but it might during peak hours), your workflow will timeout. Add a retry logic in n8n:

Copy
HTTP Request node settings:
- Timeout: 60 seconds
- Retry on error: Yes
- Max retries: 3
- Backoff strategy: exponential

Budget bleed. This workflow makes three external API calls per run. At scale with hundreds of products, costs add up. Accio charges per scan; finster per product analysed; terrakotta per recommendation set. Budget roughly £200-400 per month for this workflow if you have under 500 SKUs. Negotiate volume discounts once you commit to three months of data.

Cost Breakdown

If you use Zapier instead of n8n, expect to pay an extra £100-150 per month because you'll hit Zapier's task limits faster (Zapier charges per task, and multi-step workflows use many). Make (Integromat) sits in the middle at roughly £50 more than n8n for this workload.

The return on investment is straightforward: if this workflow helps you capture just one extra percentage point of margin on average across your catalogue, the system pays for itself in the first month for any business doing more than a few million pounds in annual revenue.