Tech Stack Lookup API: Building Vendor Moat Analysis and Competitive Positioning Tools

Why Vendor Adoption Patterns Matter for Competitive Intelligence

If you're building a vendor, investing in one, or competing against one, understanding who uses what technology tells you more than marketing claims ever will. A vendor's actual customer base — visible through tech stack data — reveals market penetration, customer profile, and competitive positioning in ways that self-reported metrics cannot.

This guide shows you how to build vendor moat analysis tools using VendorStacks' tech stack lookup API. You'll learn to programmatically measure vendor adoption across markets, identify displacement patterns, and track technology trends using deterministic evidence from public web presence.

What Tech Stack Data Reveals About Competitive Moats

Vendor moat analysis answers questions that traditional competitive intelligence misses:

• Market penetration by segment: Which types of companies actually adopt a vendor versus just evaluate it?
• Technology displacement patterns: What vendors are companies migrating away from, based on evidence of new implementations?
• Stack affinity: Which vendors cluster together, revealing partnership strength or platform effects?
• Category consolidation: Are companies using one tool per category or maintaining multiple overlapping vendors?

These patterns emerge from aggregate tech stack data across hundreds or thousands of companies. VendorStacks indexes 1,000 companies across 315 distinct vendors in 24 categories, with deterministic evidence extracted from public web presence.

Real Vendor Adoption Numbers from Our Index

To illustrate what vendor moat analysis looks like in practice, here are actual adoption counts from the VendorStacks index:

• Google Analytics: 306 companies (30.6% penetration)
• AWS: 288 companies (28.8%)
• Stripe: 189 companies (18.9%)
• HubSpot: 131 companies (13.1%)
• Google Cloud: 127 companies (12.7%)
• OpenAI: 108 companies (10.8%)
• Salesforce: 97 companies (9.7%)
• Cloudflare: 95 companies (9.5%)
• Slack: 94 companies (9.4%)
• Twilio: 91 companies (9.1%)

These numbers reveal real competitive dynamics. Google Analytics has 3x the penetration of HubSpot, but HubSpot still reaches 13% of the indexed market. Stripe dominates payments with nearly 19% adoption. OpenAI has already reached 10.8% adoption despite being the newest vendor on this list.

Building a Vendor Penetration Tracker

Start by measuring how many companies use a specific vendor, then expand to track penetration over time. Here's how to build a basic tracker:

import requests
import time
from collections import defaultdict

API_KEY = "vr_live_your_key_here"
BASE_URL = "https://api.vendorstacks.com/v1"

def get_vendor_users(vendor_name, max_pages=10):
    """
    Find all companies using a specific vendor via reverse lookup.
    Returns list of domains with detection confidence.
    """
    headers = {"Authorization": f"Bearer {API_KEY}"}
    companies = []
    
    for page in range(1, max_pages + 1):
        response = requests.get(
            f"{BASE_URL}/prospect",
            params={"vendor": vendor_name, "page": page},
            headers=headers
        )
        
        if response.status_code != 200:
            break
            
        data = response.json()
        results = data.get("results", [])
        
        if not results:
            break
            
        for result in results:
            companies.append({
                "domain": result["domain"],
                "confidence": result.get("vendor_confidence", {})
                    .get(vendor_name, "unknown"),
                "scanned_at": result.get("scanned_at")
            })
        
        # Reverse lookup costs 1 credit per RESULT
        time.sleep(0.5)  # Rate limiting courtesy
    
    return companies

# Track multiple vendors
vendors_to_track = ["Stripe", "Salesforce", "HubSpot", "OpenAI"]
vendor_adoption = {}

for vendor in vendors_to_track:
    users = get_vendor_users(vendor)
    vendor_adoption[vendor] = {
        "count": len(users),
        "companies": users
    }
    print(f"{vendor}: {len(users)} companies")

This code uses the /v1/prospect?vendor=X endpoint to find companies using each vendor. The endpoint returns 10 results per page and costs 1 credit per result returned (not per page). An empty page costs nothing.

Analyzing Stack Affinity and Co-occurrence

Vendor moat strength often correlates with what other tools customers use. If most Stripe users also use Salesforce, that reveals an enterprise pattern. If they use HubSpot instead, that suggests SMB adoption.

Here's how to detect stack affinity:

def analyze_stack_affinity(target_vendor, comparison_vendors):
    """
    Find what percentage of target_vendor users also use each comparison vendor.
    Reveals stack clustering and partnership strength.
    """
    headers = {"Authorization": f"Bearer {API_KEY}"}
    
    # Get companies using target vendor
    target_users = get_vendor_users(target_vendor)
    target_domains = {c["domain"] for c in target_users}
    
    affinity_scores = {}
    
    for comp_vendor in comparison_vendors:
        comp_users = get_vendor_users(comp_vendor)
        comp_domains = {c["domain"] for c in comp_users}
        
        # Calculate overlap
        overlap = target_domains & comp_domains
        affinity_pct = len(overlap) / len(target_domains) * 100
        
        affinity_scores[comp_vendor] = {
            "overlap_count": len(overlap),
            "affinity_percentage": round(affinity_pct, 1),
            "overlapping_companies": list(overlap)
        }
    
    return affinity_scores

# Example: What do OpenAI users also use?
affinity = analyze_stack_affinity(
    "OpenAI",
    ["AWS", "Google Cloud", "Stripe", "Anthropic"]
)

for vendor, data in affinity.items():
    print(f"{vendor}: {data['affinity_percentage']}% of OpenAI users")

This reveals competitive dynamics that marketing partnerships obscure. If 60% of OpenAI users also run on AWS but only 15% use Google Cloud, that's actionable intelligence about platform preferences.

Detecting Technology Displacement Patterns

The most valuable competitive insight is knowing what vendors are being replaced. VendorStacks includes a scanned_at timestamp on each lookup result. By tracking when vendors appear or disappear from a company's stack, you can detect displacement.

Here's a simple displacement detector:

import json
from datetime import datetime, timedelta

def detect_vendor_changes(domain, historical_data_path):
    """
    Compare current vendor stack to historical snapshot.
    Identifies additions and removals.
    """
    headers = {"Authorization": f"Bearer {API_KEY}"}
    
    # Get current stack
    response = requests.get(
        f"{BASE_URL}/check",
        params={"url": domain},
        headers=headers
    )
    
    current_stack = response.json().get("vendor_stack", {})
    current_vendors = set()
    for category, vendors in current_stack.items():
        current_vendors.update(vendors)
    
    # Load historical snapshot
    with open(historical_data_path, 'r') as f:
        historical = json.load(f)
    
    historical_vendors = set(historical.get("vendors", []))
    
    # Detect changes
    added = current_vendors - historical_vendors
    removed = historical_vendors - current_vendors
    
    return {
        "domain": domain,
        "added_vendors": list(added),
        "removed_vendors": list(removed),
        "current_count": len(current_vendors),
        "historical_count": len(historical_vendors)
    }

Run this weekly across a cohort of companies in your market. If you notice 5 companies removing "Vendor X" and adding "Vendor Y" in the same month, you've detected a displacement trend before it shows up in vendor earnings calls.

Building Market Penetration Reports

For investors or strategic planning teams, market penetration analysis reveals which vendors are winning specific segments. Combine tech stack lookup with firmographic data:

def segment_vendor_penetration(vendor_name, segment_filter):
    """
    Measure vendor penetration within a specific market segment.
    segment_filter is a function that returns True for companies in segment.
    """
    headers = {"Authorization": f"Bearer {API_KEY}"}
    
    # Get all users of this vendor
    all_users = get_vendor_users(vendor_name)
    
    # Filter by segment (you need firmographic data for this)
    segment_users = [u for u in all_users if segment_filter(u["domain"])]
    
    penetration = {
        "vendor": vendor_name,
        "total_users": len(all_users),
        "segment_users": len(segment_users),
        "segment_penetration_pct": round(
            len(segment_users) / len(all_users) * 100, 1
        ) if all_users else 0
    }
    
    return penetration

# Example: What percentage of Stripe users are in ecommerce?
def is_ecommerce(domain):
    # You'd implement this with external firmographic data
    # or by checking for ecommerce_pos vendors in their stack
    pass

This reveals whether a vendor has segment-specific moats or horizontal penetration.

Tracking Category Consolidation Trends

VendorStacks organizes vendors into 24 categories (payments, crm_sales, ai_ml, etc.). By analyzing how many vendors per category companies use, you can detect consolidation trends:

def analyze_category_consolidation(category):
    """
    For companies using tools in this category, how many vendors do they use?
    Reveals whether category is consolidating or fragmenting.
    """
    headers = {"Authorization": f"Bearer {API_KEY}"}
    
    # This requires iterating through your company list
    # and checking vendor_stack for each
    vendor_counts = []
    
    # Example for one company
    response = requests.get(
        f"{BASE_URL}/check",
        params={"url": "example.com"},
        headers=headers
    )
    
    stack = response.json().get("vendor_stack", {})
    category_vendors = stack.get(category, [])
    vendor_count = len(category_vendors)
    
    # Aggregate across many companies
    # vendor_counts.append(vendor_count)
    
    # Then calculate distribution
    avg_vendors = sum(vendor_counts) / len(vendor_counts)
    return avg_vendors

If the average company in your index uses 1.2 CRM vendors, that's consolidation. If they use 3.4 analytics vendors, that's fragmentation.

Implementation Considerations

Cost management: Reverse lookup costs 1 credit per result. If you're analyzing 50 vendors with 100 users each, that's 5,000 credits ($45 at the $50/6,000 tier). The /v1/check endpoint costs 1 credit per lookup only for successful detections.

Data freshness: The scanned_at timestamp tells you when evidence was collected. For displacement analysis, you need historical snapshots. Store results weekly to build a time-series.

Confidence filtering: The API returns vendor confidence levels. Filter to high or medium confidence when precision matters more than recall.

Rate limiting: The API has no hard rate limits, but be courteous with request pacing when running large batch analyses.

What This Enables

With vendor moat analysis infrastructure in place, you can:

1. Identify competitive threats early by detecting when replacement patterns emerge across multiple companies
2. Validate market narratives by comparing claimed adoption to measured penetration
3. Find underserved segments where dominant vendors have weak penetration
4. Track technology trends by measuring adoption velocity for new categories like AI/ML
5. Inform partnership strategy by identifying high-affinity vendor combinations

These capabilities turn tech stack data into a competitive intelligence asset that updates continuously as companies change their technology choices.

Next Steps

Get an API key at VendorStacks (25 free credits, instant provisioning). Start with simple vendor counting, then build toward change detection and segment analysis as you accumulate historical data.

The code examples above use the core endpoints: GET /v1/prospect?vendor=X for reverse lookup and GET /v1/check?url=DOMAIN for individual company stacks. Combine these with your own firmographic data sources for segment-specific moat analysis.

Vendor adoption patterns are ground truth for competitive positioning. Build the infrastructure to measure them programmatically, and you'll see market dynamics that others only guess at.