Technographic Data API: Building Market Maps and Tracking Vendor Adoption Programmatically

Why Market Maps Need Technographic Data

If you're analyzing a market—whether as an investor, product strategist, or competitive intelligence analyst—you need to understand which vendors companies actually use. Press releases and self-reported surveys create lag and selection bias. A technographic data API gives you a programmatic way to build market maps from observed vendor usage across hundreds or thousands of companies.

This post walks through how to use the VendorStacks API to build market maps, track vendor adoption over time, and analyze competitive dynamics using real tech stack data extracted from public web presence.

What You Can (and Can't) Build

Before writing code, understand what technographic data actually tells you. VendorStacks extracts vendor usage from public evidence: JavaScript tags, DNS records, HTML comments, HTTP headers, cookie names, and other deterministic signals. The API returns which vendors a company uses, organized into 24 categories, with the source evidence quoted.

You can build:

• Market share estimates across vendor categories (cloud infrastructure, AI/ML platforms, payment processors)
• Adoption velocity tracking (how many companies added a vendor in the last 30 days)
• Technology pairing analysis (what companies using Stripe also use for analytics)
• Competitive displacement patterns (companies switching from Vendor A to Vendor B)

You cannot:

• Measure private infrastructure not visible in public web presence
• Detect vendors used only in internal tools with no public footprint
• Calculate exact spend or usage volume
• Access real-time changes (scans take 15-90 seconds for unindexed domains)

Building a Basic Market Map

Start by mapping vendor adoption across a category. Here's how to find all companies in the index using specific AI vendors:

import requests
import time

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

def get_companies_using_vendor(vendor_name):
    """Fetch all companies using a specific vendor via reverse lookup."""
    companies = []
    page = 1
    
    while True:
        response = requests.get(
            f"{BASE_URL}/prospect",
            headers={"Authorization": f"Bearer {API_KEY}"},
            params={"vendor": vendor_name, "page": page}
        )
        data = response.json()
        
        if not data.get("results"):
            break
            
        companies.extend(data["results"])
        
        # Reverse lookup charges 1 credit per RESULT
        # Empty pages cost nothing
        if len(data["results"]) < 10:  # Last page
            break
            
        page += 1
        time.sleep(0.5)  # Rate limiting courtesy
    
    return companies

# Map the AI/ML vendor landscape
ai_vendors = ["OpenAI", "Anthropic", "Google Cloud", "AWS"]
market_map = {}

for vendor in ai_vendors:
    companies = get_companies_using_vendor(vendor)
    market_map[vendor] = {
        "count": len(companies),
        "domains": [c["domain"] for c in companies]
    }
    print(f"{vendor}: {len(companies)} companies")

This gives you a baseline map. In the VendorStacks index of 1,000 companies, you'd see:

• AWS: 334 companies
• OpenAI: 204 companies
• Anthropic: 171 companies
• Google Cloud: 167 companies

These are real counts from our index. They show market presence, not market share (companies often use multiple cloud providers).

Tracking Adoption Velocity

Market maps are snapshots. To track trends, you need to monitor when vendors appear in tech stacks. The API returns scanned_at timestamps for each lookup:

import json
from datetime import datetime, timedelta

def track_new_adoptions(vendor_name, lookback_days=30):
    """Find companies that added a vendor recently."""
    companies = get_companies_using_vendor(vendor_name)
    cutoff = datetime.now() - timedelta(days=lookback_days)
    
    recent_adoptions = []
    for company in companies:
        # Check when this company was last scanned
        response = requests.get(
            f"{BASE_URL}/company/{company['domain']}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        )
        data = response.json()
        
        if data.get("scanned_at"):
            scan_time = datetime.fromisoformat(data["scanned_at"].replace("Z", "+00:00"))
            if scan_time > cutoff:
                recent_adoptions.append({
                    "domain": company["domain"],
                    "scanned_at": data["scanned_at"],
                    "vendor_stack": data.get("vendor_stack", {})
                })
    
    return recent_adoptions

# Track Anthropic adoption in the last 30 days
new_adopters = track_new_adoptions("Anthropic", lookback_days=30)
print(f"New Anthropic adopters: {len(new_adopters)}")

Note that scanned_at tells you when we scanned, not when the company adopted. For indexed companies (1,000 in our current index), you're seeing cached data. For trend analysis, trigger fresh scans periodically:

def refresh_company_data(domain):
    """Trigger a fresh scan for unindexed or stale data."""
    response = requests.get(
        f"{BASE_URL}/check",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params={"url": domain}
    )
    return response.json()

# Scan takes 15-90 seconds for unindexed domains
fresh_data = refresh_company_data("newstartup.com")

Analyzing Technology Pairing

Which vendors do companies use together? This reveals ecosystem patterns:

from collections import Counter

def analyze_vendor_pairs(anchor_vendor, category):
    """Find what vendors companies pair with an anchor vendor."""
    companies = get_companies_using_vendor(anchor_vendor)
    paired_vendors = Counter()
    
    for company in companies:
        response = requests.get(
            f"{BASE_URL}/company/{company['domain']}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        )
        data = response.json()
        
        # Extract vendors from a specific category
        if category in data.get("vendor_stack", {}):
            for vendor in data["vendor_stack"][category]:
                if vendor != anchor_vendor:
                    paired_vendors[vendor] += 1
    
    return paired_vendors.most_common(10)

# What analytics tools do Stripe users prefer?
analytics_pairs = analyze_vendor_pairs("Stripe", "analytics_data")
print("Top analytics tools among Stripe users:")
for vendor, count in analytics_pairs:
    print(f"  {vendor}: {count} companies")

In our index, Stripe appears in 270 company tech stacks. Google Analytics appears in 290. You'd see significant overlap—companies using Stripe for payments and Google Analytics for tracking.

Building Competitive Displacement Maps

To track vendor switching, you need historical data. The API doesn't provide history directly, but you can build it:

import sqlite3
from datetime import datetime

def store_snapshot(db_path="market_data.db"):
    """Store current vendor usage for trend analysis."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS snapshots (
            domain TEXT,
            vendor TEXT,
            category TEXT,
            scanned_at TEXT,
            snapshot_date TEXT,
            evidence TEXT
        )
    """)
    
    # Store data for tracked vendors
    vendors = ["OpenAI", "Anthropic", "AWS", "Google Cloud"]
    snapshot_date = datetime.now().isoformat()
    
    for vendor in vendors:
        companies = get_companies_using_vendor(vendor)
        for company in companies:
            data = requests.get(
                f"{BASE_URL}/company/{company['domain']}",
                headers={"Authorization": f"Bearer {API_KEY}"}
            ).json()
            
            # Store each vendor in their tech stack
            for category, vendor_list in data.get("vendor_stack", {}).items():
                for v in vendor_list:
                    cursor.execute("""
                        INSERT INTO snapshots VALUES (?, ?, ?, ?, ?, ?)
                    """, (
                        company["domain"],
                        v,
                        category,
                        data.get("scanned_at"),
                        snapshot_date,
                        json.dumps(data.get(f"{category}_evidence", {}))
                    ))
    
    conn.commit()
    conn.close()

# Run weekly to build historical dataset
store_snapshot()

After collecting snapshots over weeks or months, query for displacement patterns:

def find_switchers(db_path, old_vendor, new_vendor, category):
    """Find companies that switched vendors."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    
    # Companies using old vendor in earlier snapshots
    cursor.execute("""
        SELECT DISTINCT domain FROM snapshots
        WHERE vendor = ? AND category = ?
        AND snapshot_date < date('now', '-30 days')
    """, (old_vendor, category))
    old_users = {row[0] for row in cursor.fetchall()}
    
    # Companies using new vendor in recent snapshots
    cursor.execute("""
        SELECT DISTINCT domain FROM snapshots
        WHERE vendor = ? AND category = ?
        AND snapshot_date > date('now', '-7 days')
    """, (new_vendor, category))
    new_users = {row[0] for row in cursor.fetchall()}
    
    # Intersection: switched from old to new
    switchers = old_users & new_users
    
    conn.close()
    return list(switchers)

Category-Level Market Analysis

The API organizes vendors into 24 categories. To analyze an entire category:

def map_category_landscape(category, min_companies=5):
    """Build a market map for an entire category."""
    # We don't have a category endpoint, so we need to
    # collect vendors from company lookups
    vendor_counts = Counter()
    
    # Sample approach: check known companies
    # In production, you'd maintain a list of target companies
    sample_domains = [
        "stripe.com", "shopify.com", "openai.com",
        # ... your target company list
    ]
    
    for domain in sample_domains:
        data = requests.get(
            f"{BASE_URL}/company/{domain}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        ).json()
        
        if category in data.get("vendor_stack", {}):
            for vendor in data["vendor_stack"][category]:
                vendor_counts[vendor] += 1
    
    # Filter to significant vendors
    return {v: c for v, c in vendor_counts.items() if c >= min_companies}

# Map the payments landscape
payments_map = map_category_landscape("payments")
print("Payment processor adoption:")
for vendor, count in sorted(payments_map.items(), key=lambda x: x[1], reverse=True):
    print(f"  {vendor}: {count} companies")

In our index, Stripe appears in 270 company tech stacks, making it the most visible payment processor.

Cost Management

Pricing is 1 credit per lookup, 1 credit per reverse-lookup result. You're charged only for successful results—failed scans and empty reverse lookups cost nothing.

For market map projects:

• Reverse lookups to find companies using a vendor: 1 credit per company returned
• Individual company lookups to get full tech stack: 1 credit if data exists, 0 if not found
• Fresh scans (unindexed domains): 1 credit if vendors are found, 0 if scan finds nothing

def check_balance():
    response = requests.get(
        f"{BASE_URL}/balance",
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
    return response.json()["credit_balance"]

print(f"Credits remaining: {check_balance()}")

A market map covering 10 vendors with an average of 150 companies each costs ~1,500 credits ($13.64 at the 1,100-credit pack rate). The indexed 1,000 companies return instantly; unindexed domains trigger 15-90 second scans.

Limitations and Methodology Notes

Technographic data reflects public web presence, not complete infrastructure:

• Private tools are invisible: Internal admin panels, staging environments, and tools without public tags won't appear
• Sampling bias: Companies with minimal web presence (pure API businesses, internal tools) provide less data
• Detection confidence: The API returns vendor_confidence scores. High-confidence detections have multiple evidence sources
• Timing lag: scanned_at timestamps tell you when we observed, not when adoption occurred

The API provides found: false when no public evidence exists. This means "we found nothing," not "the company uses nothing."

What to Build Next

With this foundation, you can build:

1. Investor intelligence: Track which portfolio companies adopt new vendors, signaling product-market fit
2. Competitive positioning: Map your vendor category to identify white space and crowded segments
3. Partnership targeting: Find companies using complementary vendors for integration partnerships
4. Market timing: Detect early adoption curves before vendors appear in industry reports

The VendorStacks index currently covers 1,000 companies across 324 distinct vendors in 24 categories. For unindexed companies, the /v1/check endpoint triggers live scans in 15-90 seconds.

Get started with instant API access at https://api.vendorstacks.com. New keys include 25 free credits.