DEV Community

DAPDEV
DAPDEV

Posted on

How to Build a Competitive Intelligence Tool That Reveals Any Company's Tech Stack

#python #webdev #startup #api

If you're building a SaaS product, running a sales team, or doing market research, one of the most valuable signals you can get about a company is their technology stack.

What CMS do they use? What analytics? What payment provider? What hosting? These aren't just technical details — they're business intelligence.

  • A company running Shopify is a potential customer for Shopify apps
  • A company using HubSpot has budget for marketing tools
  • A company on AWS with React is likely a modern engineering org
  • A company still on jQuery might be ready for a migration consulting pitch

This post walks through building a competitive intelligence tool in Python that can scan any website and return its full tech stack in under 2 seconds.

The Manual Way (Don't Do This)

You could try to figure out a website's stack manually:

  1. Open DevTools, check the Network tab for server headers
  2. View source, search for framework-specific patterns
  3. Check DNS records with dig
  4. Look at the TLS certificate issuer

This works for one site. It doesn't work for 500 prospects in your CRM.

The Programmatic Way

The Technology Detection API does all four of those detection layers automatically — HTTP headers, HTML/JS patterns, DNS records, and TLS certificates — and returns structured JSON.

import requests

url = "https://technology-detection-api.p.rapidapi.com/detect"
headers = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "technology-detection-api.p.rapidapi.com"
}

response = requests.get(url, headers=headers, params={"url": "https://stripe.com"})
data = response.json()

for tech in data["technologies"]:
    print(f"{tech['name']} ({tech['category']}) - confidence: {tech['confidence']}")
Enter fullscreen mode Exit fullscreen mode

Output:

React (JavaScript Framework) - confidence: 0.95
Next.js (JavaScript Framework) - confidence: 0.90
Cloudflare (CDN) - confidence: 1.0
Google Analytics (Analytics) - confidence: 0.85
Marketo (Marketing Automation) - confidence: 0.80
AWS (Hosting) - confidence: 0.75
Enter fullscreen mode Exit fullscreen mode

One API call. Every technology. Confidence scores on each.

Building the Competitive Intelligence Scanner

Let's build something actually useful: a tool that takes a CSV of competitor URLs, scans each one, and produces a comparison matrix.

Step 1: Install Dependencies 

pip install requests pandas tabulate
Enter fullscreen mode Exit fullscreen mode

Step 2: The Scanner 

import requests
import pandas as pd
import time
import json

API_KEY = "your_rapidapi_key"
API_HOST = "technology-detection-api.p.rapidapi.com"

def detect_tech(url):
    """Detect technologies for a single URL."""
    try:
        response = requests.get(
            f"https://{API_HOST}/detect",
            headers={"x-rapidapi-key": API_KEY, "x-rapidapi-host": API_HOST},
            params={"url": url},
            timeout=10
        )
        response.raise_for_status()
        return response.json()
    except Exception as e:
        return {"error": str(e), "url": url, "technologies": []}


def scan_competitors(urls):
    """Scan a list of URLs and return structured results."""
    results = []
    for url in urls:
        print(f"Scanning {url}...")
        data = detect_tech(url)
        for tech in data.get("technologies", []):
            results.append({
                "company": url.replace("https://", "").replace("www.", "").split("/")[0],
                "technology": tech["name"],
                "category": tech["category"],
                "confidence": tech["confidence"]
            })
        time.sleep(1)  # respect rate limits
    return pd.DataFrame(results)


# Your competitor list
competitors = [
    "https://stripe.com",
    "https://square.com",
    "https://paypal.com",
    "https://braintreepayments.com",
    "https://adyen.com",
]

df = scan_competitors(competitors)
Enter fullscreen mode Exit fullscreen mode

Step 3: Build the Comparison Matrix 

# Pivot: companies as rows, technology categories as columns
matrix = df.pivot_table(
    index="company",
    columns="category",
    values="technology",
    aggfunc=lambda x: ", ".join(sorted(set(x)))
)

print(matrix.to_markdown())
Enter fullscreen mode Exit fullscreen mode

This gives you a table like:

Company Analytics CDN CMS Hosting JS Framework
stripe.com Google Analytics Cloudflare - AWS React, Next.js
square.com Segment Fastly - GCP React
paypal.com Adobe Analytics Akamai - PayPal (self) Angular
adyen.com Google Analytics Cloudflare - AWS Vue.js

Now you can see at a glance: who uses what CDN, who's on which framework, who has which analytics. This is intelligence you can act on.

Practical Use Cases That Generate Revenue

1. Sales Lead Qualification

You sell a Shopify app. Instead of cold-emailing every e-commerce company, scan their sites first:

def is_qualified_lead(url):
    """Check if a prospect uses our target platform."""
    data = detect_tech(url)
    techs = [t["name"].lower() for t in data.get("technologies", [])]
    return "shopify" in techs

# Filter your prospect list
prospects = ["https://allbirds.com", "https://gymshark.com", "https://mvmtwatches.com"]
qualified = [url for url in prospects if is_qualified_lead(url)]
print(f"{len(qualified)}/{len(prospects)} prospects are on Shopify")
Enter fullscreen mode Exit fullscreen mode

Now your sales team only contacts companies that actually use your target platform. Conversion rates go up, wasted time goes down.

2. Market Research at Scale

Want to know what percentage of the top 100 e-commerce sites use Cloudflare vs Akamai? Or how many have adopted React?

from collections import Counter

# After scanning your list
cdn_usage = Counter()
for _, row in df[df["category"] == "CDN"].iterrows():
    cdn_usage[row["technology"]] += 1

print("CDN market share among scanned sites:")
for cdn, count in cdn_usage.most_common():
    print(f"  {cdn}: {count} sites ({count/len(competitors)*100:.0f}%)")
Enter fullscreen mode Exit fullscreen mode

3. Security Auditing

If you run a security consultancy, scanning a prospect's tech stack is the first step in an assessment. Outdated jQuery? No CDN? HTTP instead of HTTPS headers? These are conversation starters.

4. Investment Due Diligence

VCs and analysts scan portfolio company tech stacks to assess technical maturity. A startup claiming "AI-first" that runs on WordPress with no modern framework might raise questions.

What Gets Detected

The API identifies 141+ technologies across these categories:

Category Examples
CMS WordPress, Shopify, Squarespace, Wix, Webflow
JS Frameworks React, Vue.js, Angular, Next.js, Svelte
CDN Cloudflare, Akamai, Fastly, AWS CloudFront
Analytics Google Analytics, Hotjar, Segment, Mixpanel
E-commerce Shopify, WooCommerce, Magento, BigCommerce
Hosting AWS, Google Cloud, Azure, Vercel, Netlify
Email Google Workspace, Microsoft 365, SendGrid
Security Cloudflare WAF, Sucuri, reCAPTCHA

Each detection comes with a confidence score (0.0-1.0) and which detection layer triggered it (HTTP headers, HTML patterns, DNS, or TLS).

Getting Started 

pip install techdetect
Enter fullscreen mode Exit fullscreen mode

The Python client handles authentication, rate limiting, and response parsing:

from techdetect import TechDetectClient

client = TechDetectClient(api_key="your_key")
result = client.detect("https://example.com")

for tech in result.technologies:
    print(f"{tech.name}: {tech.confidence}")
Enter fullscreen mode Exit fullscreen mode

Resources:

If you're building competitive intelligence tooling or have interesting use cases for technology detection data, I'd like to hear about them in the comments. The API is also available as an MCP server for integration with AI assistants.

Top comments (0)