Find Companies Using a Vendor: Implementation Guide for Reverse Tech Stack Lookup

Reverse tech stack lookup—finding companies that use a specific vendor—is one of the highest-signal prospecting methods available. If you sell a Stripe alternative, companies using Stripe are definitionally in-market. If you're building integrations, knowing which companies use your integration partner creates immediate partnership opportunities.

This guide covers how to implement reverse vendor lookup programmatically, with actual code patterns and integration approaches that work.

Why Reverse Lookup Works for GTM

Traditional lead generation starts with firmographics (company size, industry, funding) and hopes the company has a relevant pain point. Reverse vendor lookup starts with verified technology usage—a concrete signal that the company has already chosen to solve a problem in a specific way.

The use cases are direct:

• Competitive displacement: Find companies using the vendor you're replacing
• Integration partnerships: Identify companies using your integration partners
• Market segmentation: Build lists by technology category (find all companies using observability tools, all companies using CRMs)
• Vendor migration tracking: Monitor companies moving from one vendor to another
• Partnership pipeline: Feed vendor usage into partner portal workflows

The key difference from contact databases: you're filtering by actual infrastructure choices, not predicted fit.

API Mechanics: How Reverse Lookup Actually Works

The VendorStacks reverse lookup endpoint returns companies that have public evidence of using a specific vendor. Each result costs 1 credit—you only pay for companies returned, not for the query itself.

Here's the basic request:

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

Response structure:

{
  "vendor": "Stripe",
  "total_found": 185,
  "page": 1,
  "per_page": 10,
  "results": [
    {
      "domain": "example.com",
      "vendor_stack": [
        {"vendor": "Stripe", "category": "payments", "confidence": "high"},
        {"vendor": "AWS", "category": "cloud_infra", "confidence": "high"},
        {"vendor": "Google Analytics", "category": "analytics_data", "confidence": "high"}
      ],
      "stripe_evidence": "https://example.com/checkout confirmed via <script src='https://js.stripe.com/v3/'></script>",
      "scanned_at": "2024-01-15T10:23:45Z"
    }
  ],
  "credits_used": 10,
  "credit_balance": 990
}

Key points:

• Results are paginated at 10 per page
• Each result includes the full vendor stack, not just the queried vendor
• Evidence fields show the exact source of detection
• You're charged 1 credit per company returned (10 results = 10 credits)

Implementation Pattern 1: Building Prospect Lists

The simplest implementation: generate a CSV of companies using a specific vendor for manual outreach or CRM upload.

import requests
import csv
import time

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

def fetch_all_companies_using_vendor(vendor_name, max_pages=10):
    """Fetch all companies using a vendor, respecting pagination."""
    companies = []
    
    for page in range(1, max_pages + 1):
        response = requests.get(
            f"{BASE_URL}/prospect",
            headers={"Authorization": f"Bearer {API_KEY}"},
            params={"vendor": vendor_name, "page": page}
        )
        
        if response.status_code != 200:
            print(f"Error on page {page}: {response.status_code}")
            break
            
        data = response.json()
        companies.extend(data["results"])
        
        # Check if we've hit the last page
        if len(data["results"]) < data["per_page"]:
            break
            
        time.sleep(0.5)  # Rate limiting courtesy
    
    return companies

def export_to_csv(companies, filename):
    """Export company list to CSV with key fields."""
    with open(filename, 'w', newline='') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow(['Domain', 'Target Vendor', 'Other Vendors', 'Evidence', 'Scanned Date'])
        
        for company in companies:
            other_vendors = [v['vendor'] for v in company['vendor_stack'] if v['vendor'] != vendor_name]
            evidence_key = f"{vendor_name.lower().replace(' ', '_')}_evidence"
            
            writer.writerow([
                company['domain'],
                vendor_name,
                ', '.join(other_vendors[:5]),  # First 5 other vendors
                company.get(evidence_key, '')[:100],  # Truncated evidence
                company['scanned_at']
            ])

# Usage
vendor_name = "Stripe"
companies = fetch_all_companies_using_vendor(vendor_name, max_pages=20)
print(f"Found {len(companies)} companies using {vendor_name}")
export_to_csv(companies, f"companies_using_{vendor_name.lower()}.csv")

This pattern works for one-off list building. For recurring workflows, you'll want to track which companies you've already processed.

Implementation Pattern 2: Automated Lead Scoring

Integrate reverse lookup into your lead scoring system to automatically flag high-value prospects based on their tech stack.

// Node.js example: Express webhook that scores inbound leads
const express = require('express');
const axios = require('axios');

const app = express();
app.use(express.json());

const VENDORSTACKS_API_KEY = 'vr_live_YOUR_API_KEY';
const TARGET_VENDORS = ['Stripe', 'Salesforce', 'HubSpot'];

app.post('/webhook/new-lead', async (req, res) => {
  const { domain, email, company_name } = req.body;
  
  try {
    // Check the company's tech stack
    const stackResponse = await axios.get(
      `https://api.vendorstacks.com/v1/check?url=${domain}`,
      { headers: { 'Authorization': `Bearer ${VENDORSTACKS_API_KEY}` }}
    );
    
    const vendorStack = stackResponse.data.vendor_stack || [];
    const usesTargetVendor = vendorStack.some(v => 
      TARGET_VENDORS.includes(v.vendor)
    );
    
    // Score the lead
    let score = 50; // Base score
    if (usesTargetVendor) {
      score += 30; // Boost for target vendor usage
    }
    
    // Count total vendors as proxy for tech sophistication
    score += Math.min(vendorStack.length * 2, 20);
    
    // Send to CRM with enriched data
    await axios.post('https://your-crm.com/api/leads', {
      email,
      company: company_name,
      domain,
      score,
      tech_stack: vendorStack.map(v => v.vendor).join(', '),
      uses_target_vendor: usesTargetVendor,
      stack_categories: [...new Set(vendorStack.map(v => v.category))]
    });
    
    res.json({ success: true, score });
    
  } catch (error) {
    console.error('Error enriching lead:', error.message);
    res.status(500).json({ error: 'Enrichment failed' });
  }
});

app.listen(3000);

This pattern triggers on new lead creation (form fill, demo request) and automatically enriches the record with tech stack data before routing.

Implementation Pattern 3: Multi-Vendor Filtering

For more sophisticated targeting, combine multiple vendor queries to find companies using specific technology combinations.

import requests
from collections import defaultdict

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

def find_companies_using_all_vendors(required_vendors):
    """
    Find companies that use ALL vendors in the required list.
    More expensive (N queries) but highly targeted.
    """
    # Fetch results for each vendor
    vendor_companies = {}
    for vendor in required_vendors:
        response = requests.get(
            f"{BASE_URL}/prospect",
            headers={"Authorization": f"Bearer {API_KEY}"},
            params={"vendor": vendor, "page": 1}
        )
        data = response.json()
        vendor_companies[vendor] = set(r['domain'] for r in data['results'])
    
    # Find intersection: companies using ALL required vendors
    if not vendor_companies:
        return []
    
    common_companies = set.intersection(*vendor_companies.values())
    
    # Fetch full details for companies in intersection
    results = []
    for domain in common_companies:
        response = requests.get(
            f"{BASE_URL}/company/{domain}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        )
        if response.status_code == 200:
            results.append(response.json())
    
    return results

# Find companies using both Stripe AND Salesforce
target_combo = ["Stripe", "Salesforce"]
matches = find_companies_using_all_vendors(target_combo)
print(f"Found {len(matches)} companies using all of: {', '.join(target_combo)}")

This pattern is useful for partnership plays ("companies using both our product and Partner X") or highly specific ICP targeting.

Real-World Vendor Coverage

The VendorStacks index currently tracks 1,000 companies across 313 distinct vendors. Here's the distribution of the most commonly detected vendors:

• Google Analytics: 306 companies
• AWS: 282 companies
• Stripe: 185 companies
• HubSpot: 130 companies
• Google Cloud: 124 companies
• Meta: 103 companies
• OpenAI: 102 companies
• Salesforce: 95 companies
• Slack: 92 companies
• Google Ads: 90 companies
• Twilio: 88 companies
• Cloudflare: 87 companies

These counts are real index statistics—not estimates. They represent companies with verified public evidence of vendor usage.

Category-Based Reverse Lookup

Vendors are classified into 24 categories: ai_ml, crm_sales, media_cdn, support_cx, cloud_infra, ecommerce_pos, analytics_data, security_fraud, productivity, observability, email, payments, database_infra, integration_etl, privacy_compliance, marketing_ads, sms_messaging, finance_accounting, data_enrichment, auth_identity, hr_payroll, esignature_contracts, realtime_infra, search_discovery.

While the API doesn't support direct category filtering, you can query for major vendors in a category and aggregate:

# Find companies using any major payment processor
payment_vendors = ["Stripe", "PayPal", "Square", "Adyen"]
all_payment_companies = set()

for vendor in payment_vendors:
    response = requests.get(
        f"{BASE_URL}/prospect",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params={"vendor": vendor}
    )
    companies = response.json().get('results', [])
    all_payment_companies.update(c['domain'] for c in companies)

print(f"Total companies using payment processors: {len(all_payment_companies)}")

Cost Management

Reverse lookup costs 1 credit per company returned. If a vendor has 185 companies in the index and you fetch all of them across 19 pages (10 per page), you'll use 185 credits.

Strategies to control costs:

1. Pagination limits: Only fetch the first N pages if you don't need the full list
2. Caching: Store results and refresh weekly rather than querying real-time
3. Sampling: For market research, a sample of 50-100 companies may be sufficient
4. Combination queries: Use /v1/company/{domain} (no scan cost) if you already have a domain list and just need stack verification

Empty results cost nothing—if you query for a vendor with zero companies in the index, you use 0 credits.

Integration Checklist

Before you deploy reverse lookup into production:

• [ ] Decide on pagination strategy (full export vs. limited pages)
• [ ] Implement credential rotation if exposing via public-facing tools
• [ ] Cache results to avoid redundant queries for the same vendor
• [ ] Handle empty result sets (vendor not in index, or no companies found)
• [ ] Log credits_used per request for budget tracking
• [ ] Consider rate limiting on your end if proxying to end users
• [ ] Test with a small vendor list before scaling to hundreds of vendors

When Reverse Lookup Doesn't Work

Reverse lookup relies on public evidence. It will not find:

• Companies using a vendor with no public footprint (fully internal tools, no embedded scripts, no DNS records, no external references)
• Companies that have removed or hidden vendor integrations since the last scan
• Companies using vendors via resellers or white-labeled solutions that don't expose the underlying vendor name

If you query for a niche vendor with 0 companies in the index, you'll get an empty result set at zero cost. This is expected—it means no public evidence was detected, not that no companies use the vendor.

Starting Point: Get an API Key

You can generate an API key instantly at the VendorStacks dashboard. New keys come with 25 free credits—enough to test reverse lookup queries and see real results before committing to a credit pack.

curl -X POST "https://api.vendorstacks.com/v1/keys" \
  -H "Content-Type: application/json" \
  -d '{"email": "your@email.com"}'

Response includes your live API key and initial credit balance. From there, run a reverse lookup for a vendor relevant to your market and see what comes back.

Reverse tech stack lookup is not a replacement for contact data or intent signals—it's a filtering layer that ensures you're targeting companies with verified technology choices. Build it into your stack, and your outbound lists get immediately more relevant.