Tech Stack Lookup API: How to Programmatically Detect What Technologies Companies Use

If you're building lead scoring systems, competitive intelligence tools, or integration marketplaces, you need to know what technologies companies use. Manual research doesn't scale past a few dozen targets. Browser extensions require human clicking. This guide covers how tech stack lookup APIs work and how to integrate them into your workflows.

What Tech Stack Lookup APIs Actually Do

A tech stack lookup API returns the vendors a company uses by analyzing their public web presence. The API scans HTML source, JavaScript includes, HTTP headers, DNS records, and linked policy documents to identify technology signatures.

For example, querying a domain returns results across 24 categories: cloud infrastructure (AWS, Google Cloud, Azure), payments (Stripe, PayPal), CRM (Salesforce, HubSpot), AI/ML (OpenAI, Anthropic), analytics, databases, and more. Each detection includes the source evidence—the actual HTML snippet or URL where the vendor was identified.

This is deterministic detection from public data, not guesswork. If a company loads js.stripe.com/v3/ in their checkout page, that's evidence of Stripe. If their privacy policy lists "Snowflake Inc." as a data processor, that's evidence of Snowflake.

How to Query a Company's Tech Stack

The VendorStacks API provides instant lookups for indexed companies and on-demand scans for new domains. Here's the basic request:

curl -X GET "https://api.vendorstacks.com/v1/check?url=example.com" \
  -H "Authorization: Bearer vr_live_YOUR_KEY"

The response includes the vendor stack organized by category, confidence scores, and quoted evidence:

{
  "found": true,
  "vendor_stack": {
    "payments": ["Stripe"],
    "cloud_infra": ["AWS"],
    "ai_ml": ["OpenAI"],
    "analytics_data": ["Google Analytics"]
  },
  "payments_evidence": [
    "<script src='https://js.stripe.com/v3/'></script>"
  ],
  "cloud_infra_evidence": [
    "DNS: example.com CNAME -> aws.cloudfront.net"
  ],
  "vendor_confidence": {
    "Stripe": 0.95,
    "AWS": 0.92,
    "OpenAI": 0.88
  },
  "scanned_at": "2025-01-15T10:30:00Z",
  "credits_used": 1
}

If the domain is already indexed (currently 1,000 companies covering 325 distinct vendors), the response is instant. If not, the API triggers a live scan that completes in 15-90 seconds. You can check indexing status first using the /v1/company/{domain} endpoint, which never triggers a scan:

import requests

BASE_URL = "https://api.vendorstacks.com"
HEADERS = {"Authorization": "Bearer vr_live_YOUR_KEY"}

# Check if indexed without triggering a scan
response = requests.get(
    f"{BASE_URL}/v1/company/example.com",
    headers=HEADERS
)

if response.json().get("found"):
    print("Already indexed")
else:
    # Trigger scan if needed
    scan_response = requests.get(
        f"{BASE_URL}/v1/check?url=example.com",
        headers=HEADERS
    )

Use Case: Enriching Inbound Leads

When a prospect fills out a demo form, you can instantly enrich their company profile with tech stack data. This enables intelligent lead routing: prospects using Salesforce go to the enterprise sales team, while those using HubSpot go to SMB reps.

// Webhook handler for form submissions
app.post('/webhook/demo-request', async (req, res) => {
  const { email, company_domain } = req.body;
  
  const stackResponse = await fetch(
    `https://api.vendorstacks.com/v1/check?url=${company_domain}`,
    { headers: { 'Authorization': `Bearer ${process.env.VENDORSTACKS_KEY}` } }
  );
  
  const stack = await stackResponse.json();
  
  // Route based on actual tech usage
  const isEnterprise = stack.vendor_stack.crm_sales?.includes('Salesforce') ||
                       stack.vendor_stack.cloud_infra?.includes('AWS');
  
  const assignedRep = isEnterprise ? 'enterprise-team' : 'smb-team';
  
  await createLead({
    email,
    company_domain,
    tech_stack: stack.vendor_stack,
    assigned_to: assignedRep,
    enriched_at: new Date()
  });
  
  res.status(200).send();
});

Use Case: Finding Integration Opportunities

If you're building a product that integrates with specific platforms, you need to identify companies already using those platforms. The reverse lookup endpoint returns companies using a specified vendor:

curl -X GET "https://api.vendorstacks.com/v1/prospect?vendor=Stripe&page=1" \
  -H "Authorization: Bearer vr_live_YOUR_KEY"

Response:

{
  "results": [
    {
      "domain": "acme-corp.com",
      "vendor_stack": {"payments": ["Stripe"], "cloud_infra": ["AWS"]},
      "confidence": 0.94
    },
    // ... up to 10 results per page
  ],
  "total_found": 249,
  "credits_used": 10,
  "page": 1
}

Based on real index data, here's what you'd find for common platforms:

• Stripe: 249 companies
• Salesforce: 224 companies
• OpenAI: 216 companies
• Snowflake: 214 companies
• Google Cloud: 203 companies
• Slack: 182 companies
• Twilio: 170 companies
• HubSpot: 166 companies
• Anthropic: 160 companies

Pricing for reverse lookups: 1 credit per result returned (10 credits for a full page of 10 results). Empty results cost nothing.

Use Case: Competitive Intelligence Automation

Track when prospects adopt or drop specific technologies. Run daily checks on your target account list and diff the results:

import requests
from datetime import datetime
import json

def track_tech_changes(domains, previous_state):
    changes = []
    
    for domain in domains:
        current = requests.get(
            f"https://api.vendorstacks.com/v1/check?url={domain}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        ).json()
        
        if domain in previous_state:
            prev_vendors = set(flatten_vendors(previous_state[domain]))
            curr_vendors = set(flatten_vendors(current['vendor_stack']))
            
            added = curr_vendors - prev_vendors
            removed = prev_vendors - curr_vendors
            
            if added or removed:
                changes.append({
                    'domain': domain,
                    'added': list(added),
                    'removed': list(removed),
                    'timestamp': datetime.now().isoformat()
                })
        
        previous_state[domain] = current['vendor_stack']
    
    return changes, previous_state

def flatten_vendors(vendor_stack):
    vendors = []
    for category, vendor_list in vendor_stack.items():
        vendors.extend(vendor_list)
    return vendors

Understanding the Response Fields

Key fields in the API response:

• vendor_stack: Dictionary with 24 category keys (ai_ml, payments, cloud_infra, crm_sales, etc.). Each contains an array of vendor names.
• {category}_evidence: Arrays containing the actual source text where each vendor was detected—HTML snippets, DNS records, or policy document excerpts.
• vendor_confidence: Scores from 0-1 for each detected vendor. Higher confidence means more sources or stronger signals.
• scanned_at: Timestamp of when the data was collected. Indexed companies show their last scan time; new scans show the current time.
• found: Boolean. false means no public evidence was located—not that the company uses zero vendors, just that none were publicly detectable.
• credits_used: Always 1 for a lookup that finds results, 0 for scans that find nothing or fail.
• subprocessor_urls: Array of privacy policy or data processing URLs where vendors were mentioned.

Pricing and Credit Usage

Credits are consumed only for successful results:

• Tech stack lookup: 1 credit if vendors are found, 0 credits if nothing is detected
• Reverse lookup: 1 credit per company returned (a page of 10 results = 10 credits; an empty page = 0 credits)
• Failed scans or "found: false" responses: 0 credits

Credit packs: $10 for 1,100 credits, $50 for 6,000 credits, $250 for 35,000 credits. You can check your balance:

curl -X GET "https://api.vendorstacks.com/v1/balance" \
  -H "Authorization: Bearer vr_live_YOUR_KEY"

Getting Started

Generate an API key instantly:

curl -X POST "https://api.vendorstacks.com/v1/keys"

You'll receive a key with 25 free credits—enough to test lookups and reverse searches. No signup form, no credit card required for the trial.

What This Approach Can't Do

Tech stack lookup APIs work from public web data. They cannot:

• Detect vendors with zero public footprint (internal tools, completely white-labeled services)
• Analyze payment flows or transaction data
• Access private infrastructure, databases, or network traffic
• Monitor changes in real-time (data reflects point-in-time scans)
• Map phone numbers or personal identifiers to vendors

If a company uses a vendor entirely through backend APIs with no client-side JavaScript, no DNS records pointing to the vendor, and no mention in public policies, it won't appear in results. The found: false response means "no public evidence located," not "definitely uses nothing."

Integrating with Your Stack

Common integration patterns:

1. CRM enrichment: Add a webhook to your form handler that enriches leads before they hit Salesforce/HubSpot
2. Reverse ETL: Export prospect lists from your warehouse, enrich with tech stack data, push back to your GTM tools
3. Product-led growth: Show personalized onboarding flows based on detected integrations
4. Competitive tracking: Daily cron job that checks target accounts and alerts on tech stack changes

The API returns standard JSON over HTTPS. Any language with an HTTP client works—no special SDKs required.

Accuracy and Coverage

The current index covers 1,000 companies and 325 distinct vendors. AWS appears in 435 company stacks, Google Analytics in 272, Stripe in 249. These are real counts from actual detections, not projections.

Confidence scores reflect signal strength. A score above 0.9 typically means multiple sources (e.g., both JavaScript includes and privacy policy mentions). Scores in the 0.7-0.9 range usually indicate a single strong source. Below 0.7 might warrant manual verification for high-stakes decisions.

For use cases requiring absolute certainty (legal compliance, audit trails), treat the evidence fields as leads requiring human confirmation. For statistical GTM work (lead scoring, market segmentation), the confidence scores provide sufficient signal.

Tech stack detection from public data gives you a scalable alternative to manual research, browser extensions, and surveys. Whether you're scoring leads, finding integration prospects, or tracking competitive moves, an API call beats hours of clicking through websites.