Tech Stack Lookup API: Building Lead Scoring Models with Vendor Data

Why Tech Stack Data Improves Lead Scoring

Traditional lead scoring relies on demographic firmographics (company size, industry, location) and behavioral signals (website visits, email opens, content downloads). These signals predict engagement reasonably well, but they're weak predictors of fit.

A company that downloaded your whitepaper might be interested, but if they're running a tech stack that makes your product irrelevant or redundant, that lead will never convert. Conversely, a cold prospect running the exact vendor combination that creates pain your product solves is objectively more valuable than a warm lead with the wrong stack.

Tech stack data lets you score leads on actual technology fit rather than proxy signals. A prospect using Stripe, Snowflake, and HubSpot tells you more about their buying context than their industry classification or employee headcount.

Core Implementation Pattern

The basic flow: when a lead enters your system (form submission, trial signup, imported list), make a tech stack lookup, extract scoring signals from the vendor list, and adjust the lead score accordingly.

Here's the fundamental integration:

import requests
import os

API_KEY = os.getenv('VENDORSTACKS_API_KEY')
BASE_URL = 'https://api.vendorstacks.com/v1'

def score_lead_by_stack(domain):
    """Lookup tech stack and return scoring adjustments"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    response = requests.get(
        f'{BASE_URL}/check',
        params={'url': domain},
        headers=headers
    )
    
    if response.status_code != 200:
        return {'stack_score': 0, 'reason': 'lookup_failed'}
    
    data = response.json()
    
    # No public stack found - neutral score
    if not data.get('found'):
        return {'stack_score': 0, 'reason': 'no_public_stack'}
    
    vendor_stack = data.get('vendor_stack', {})
    
    return calculate_stack_score(vendor_stack)

def calculate_stack_score(vendor_stack):
    """Extract scoring signals from vendor categories"""
    score = 0
    signals = []
    
    # Positive signal: uses integration-friendly infrastructure
    if vendor_stack.get('cloud_infra'):
        score += 15
        signals.append('modern_infra')
    
    # Positive signal: uses data warehouse (sophisticated data team)
    if 'Snowflake' in vendor_stack.get('database_infra', []):
        score += 20
        signals.append('data_warehouse')
    
    # Positive signal: uses compatible payment processor
    if 'Stripe' in vendor_stack.get('payments', []):
        score += 10
        signals.append('stripe_user')
    
    # Negative signal: uses competing product
    competitors = ['CompetitorA', 'CompetitorB']
    for category in vendor_stack.values():
        if any(comp in category for comp in competitors):
            score -= 30
            signals.append('uses_competitor')
            break
    
    # Stack breadth signal: counts distinct categories
    category_count = len([cat for cat in vendor_stack.values() if cat])
    if category_count >= 8:
        score += 10
        signals.append('sophisticated_stack')
    
    return {
        'stack_score': score,
        'signals': signals,
        'categories_detected': category_count
    }

This gives you a numeric adjustment (stack_score) and structured reasons (signals) that explain the score. The signals are useful for sales teams reviewing high-scoring leads.

Scoring Pattern 1: Required Vendor Match

The simplest pattern: boost leads that use a specific vendor you integrate with or depend on.

If your product is a Stripe analytics tool, a company using Stripe is objectively more valuable than one that isn't. If your product optimizes Snowflake queries, companies running Snowflake are qualified by definition.

def score_required_vendor(vendor_stack, required_vendor, category):
    """Binary scoring: vendor present or not"""
    vendors_in_category = vendor_stack.get(category, [])
    
    if required_vendor in vendors_in_category:
        return {
            'score': 50,
            'match': True,
            'evidence': f'Uses {required_vendor}'
        }
    else:
        return {
            'score': -50,  # Disqualify if required vendor missing
            'match': False,
            'evidence': f'Does not use {required_vendor}'
        }

This is clean for products with hard technical dependencies. It also works in reverse: if you're selling a HubSpot alternative, automatically downscoring leads already using HubSpot (our index shows 107 companies using it) prevents wasting cycles on low-probability switches.

Scoring Pattern 2: Stack Sophistication

Some products are only relevant to companies with mature technology operations. If you sell database optimization tools, DataOps platforms, or infrastructure observability, you need prospects running sophisticated stacks.

Stack sophistication can be measured by:

• Category breadth: How many of the 24 vendor categories does the company use?
• Cloud infrastructure presence: Are they running AWS, Google Cloud, or Azure?
• Data infrastructure depth: Do they use both a data warehouse (Snowflake, BigQuery) and ETL tools?
• Observability signals: Do they run monitoring/observability vendors?

def score_stack_sophistication(vendor_stack):
    """Score based on technical maturity signals"""
    score = 0
    
    # Count populated categories
    active_categories = sum(1 for v in vendor_stack.values() if v)
    
    if active_categories >= 10:
        score += 25
    elif active_categories >= 6:
        score += 15
    elif active_categories >= 3:
        score += 5
    
    # Cloud infrastructure presence
    cloud_vendors = ['AWS', 'Google Cloud', 'Microsoft Azure']
    if any(v in vendor_stack.get('cloud_infra', []) for v in cloud_vendors):
        score += 20
    
    # Modern data stack
    has_warehouse = bool(vendor_stack.get('database_infra'))
    has_etl = bool(vendor_stack.get('integration_etl'))
    
    if has_warehouse and has_etl:
        score += 20
    elif has_warehouse:
        score += 10
    
    # Observability = operational maturity
    if vendor_stack.get('observability'):
        score += 15
    
    return score

Our index currently tracks 292 distinct vendors across 1,000 companies. The median company uses 4-6 categories; companies using 10+ categories are running meaningfully more complex operations.

Scoring Pattern 3: Vendor Combinations

The most powerful scoring comes from detecting combinations of vendors that indicate specific buying contexts.

Example: a company using Stripe (payments), Snowflake (data warehouse), and Segment (customer data platform) is likely running a subscription business with sophisticated analytics. That combination predicts interest in revenue analytics, churn prediction, or billing optimization tools far better than any single vendor.

def score_vendor_combinations(vendor_stack):
    """Detect high-value vendor combinations"""
    score = 0
    patterns = []
    
    # Subscription SaaS pattern
    has_stripe = 'Stripe' in vendor_stack.get('payments', [])
    has_warehouse = bool(vendor_stack.get('database_infra'))
    has_crm = bool(vendor_stack.get('crm_sales'))
    
    if has_stripe and has_warehouse and has_crm:
        score += 30
        patterns.append('subscription_saas')
    
    # E-commerce pattern
    has_ecommerce = bool(vendor_stack.get('ecommerce_pos'))
    has_ads = bool(vendor_stack.get('marketing_ads'))
    
    if has_ecommerce and has_ads:
        score += 25
        patterns.append('ecommerce_growth')
    
    # AI/ML product pattern
    has_ai = 'OpenAI' in vendor_stack.get('ai_ml', [])
    has_cloud = bool(vendor_stack.get('cloud_infra'))
    
    if has_ai and has_cloud:
        score += 20
        patterns.append('ai_product')
    
    return {'score': score, 'patterns': patterns}

The patterns you define depend entirely on your product. If you sell marketing attribution software, the combination of Google Ads + Meta + Salesforce is a strong signal. If you sell compliance automation, the combination of Stripe + any HR vendor + cloud infrastructure suggests a company handling sensitive data at scale.

Implementing in CRM Workflows

Most CRMs support webhook-triggered scoring updates or API-based enrichment. Here's a pattern for HubSpot (107 companies in our index use it, so this is broadly useful):

def enrich_hubspot_contact(contact_id, domain):
    """Fetch stack, calculate score, update HubSpot contact"""
    
    # Get tech stack
    stack_data = score_lead_by_stack(domain)
    
    if stack_data['stack_score'] == 0:
        return  # Don't update for failed lookups
    
    # Prepare HubSpot properties
    properties = {
        'tech_stack_score': stack_data['stack_score'],
        'stack_signals': ', '.join(stack_data.get('signals', [])),
        'stack_categories': stack_data.get('categories_detected', 0)
    }
    
    # Update contact via HubSpot API
    hubspot_response = requests.patch(
        f'https://api.hubapi.com/crm/v3/objects/contacts/{contact_id}',
        headers={'Authorization': f'Bearer {HUBSPOT_API_KEY}'},
        json={'properties': properties}
    )
    
    return hubspot_response.json()

This pattern works similarly for Salesforce, Pipedrive, or any CRM with custom fields and an API. Create custom fields for tech_stack_score and stack_signals, then update them when leads enter the system.

Handling Lookup Costs

VendorStacks charges 1 credit per successful lookup. You only pay when we return results — failed scans and empty lookups cost nothing.

For lead scoring, you typically want to:

1. Lookup on entry: When a lead first enters your system (form submit, list import)
2. Cache results: Store the vendor stack in your database; don't re-lookup on every scoring pass
3. Refresh periodically: Update stacks for active opportunities monthly or quarterly

Here's a caching pattern:

def get_or_fetch_stack(domain, db_connection):
    """Check cache before making API call"""
    
    # Check if we have a recent lookup
    cached = db_connection.execute(
        'SELECT vendor_stack, scanned_at FROM tech_stacks WHERE domain = ?',
        (domain,)
    ).fetchone()
    
    if cached and (datetime.now() - cached['scanned_at']).days < 30:
        return cached['vendor_stack']
    
    # No cache or stale - fetch fresh
    response = requests.get(
        f'{BASE_URL}/check',
        params={'url': domain},
        headers={'Authorization': f'Bearer {API_KEY}'}
    ).json()
    
    # Cache result
    db_connection.execute(
        'INSERT OR REPLACE INTO tech_stacks (domain, vendor_stack, scanned_at) VALUES (?, ?, ?)',
        (domain, response.get('vendor_stack'), datetime.now())
    )
    
    return response.get('vendor_stack')

With 1,100 credits for $10, you can score 1,100 new leads. That's cost-effective for most lead volumes.

Scoring Logic That Matches Your ICP

The scoring rules above are examples. Your actual scoring logic should derive from analyzing closed deals.

Export a list of your last 50-100 customers, look up their tech stacks, and identify patterns:

• What vendors appear most frequently? (Those are positive signals)
• What categories are most common? (Category breadth might matter)
• Are there vendor combinations that cluster in your customer base?

If 70% of your customers use AWS and Snowflake, that combination deserves a high score. If none of your customers use a specific CRM, that CRM's presence might be a negative signal (wrong buyer persona, wrong company stage, etc.).

The tech stack lookup API gives you the raw vendor data. You define what makes a lead valuable based on your actual win patterns.

Monitoring Scoring Effectiveness

Track two metrics:

1. Conversion rate by score band: Do high stack-scored leads convert at higher rates than low-scored leads?
2. Sales cycle length by score band: Do high stack-scored leads close faster?

If high-scoring leads don't convert better, your scoring logic doesn't match reality. Adjust the weights, add new signals, or remove signals that don't correlate with wins.

Tech stack scoring is most effective when treated as a hypothesis you test and refine, not a static ruleset.

Starting Simple

You don't need complex multi-signal scoring on day one. Start with a single high-value signal:

• If you integrate with Stripe, boost leads using Stripe by 30 points
• If you require cloud infrastructure, boost leads using AWS/GCP/Azure by 20 points
• If you have a competitor, drop leads using that competitor by 50 points

Implement one rule, measure its impact on conversion rates, then add more signals incrementally. Tech stack scoring works best when it's simple, measurable, and tied directly to your product's technical requirements or integrations.