Find Companies Using a Vendor: Building Prospect Lists from Tech Stack Data

The Reverse Lookup Problem

Most tech stack APIs answer the question "what does Company X use?" But sales and partnership teams need the inverse: "who uses Vendor Y?" This reverse lookup—finding companies by their technology choices—is harder than it looks. You can't scrape vendor customer pages (incomplete, stale, biased toward enterprise logos), and you can't infer usage from job postings or LinkedIn mentions (noisy, indirect).

The reliable approach is deterministic detection: scan public web artifacts (JavaScript tags, DNS records, HTTP headers, subprocessor disclosures) and index the results. VendorStacks provides this as an API endpoint that returns companies using a specified vendor, with the exact source evidence.

How Reverse Tech Stack Lookup Works

The /v1/prospect endpoint takes a vendor name and returns up to 10 companies per page that use it, along with the URL and text snippet where we detected it:

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

Response structure:

{
  "vendor": "Stripe",
  "prospects": [
    {
      "domain": "example.com",
      "company_name": "Example Corp",
      "evidence_url": "https://example.com/privacy",
      "evidence_text": "We use Stripe to process payments...",
      "detected_at": "2024-01-15T10:30:00Z"
    }
  ],
  "total_results": 217,
  "page": 1,
  "per_page": 10,
  "credits_used": 10,
  "credit_balance": 990
}

Pricing note: You pay 1 credit per result returned, not per query. If a vendor has zero users in the index, prospects is empty and credits_used is 0. A full page of 10 results costs 10 credits.

Real Index Statistics

Our current index covers 1,000 companies and 306 distinct vendors. Here are the vendors with the most detected users (safe to cite—these are measured counts):

• Google Analytics: 337 companies
• AWS: 295 companies
• Stripe: 217 companies
• Google Cloud: 145 companies
• HubSpot: 127 companies
• OpenAI: 122 companies
• Meta: 121 companies (usually Meta Pixel or Facebook Login)
• Microsoft Azure: 109 companies
• Salesforce: 102 companies
• Slack: 100 companies

These counts reflect public evidence only. A company not in the list may still use the vendor—we just haven't scanned them yet or they don't disclose it publicly.

Building a Prospecting Workflow

Here's a Python script that fetches all Stripe users, filters by a second criterion, and exports to CSV:

import requests
import csv
import time

API_KEY = "vr_live_your_key_here"
BASE_URL = "https://api.vendorstacks.com/v1"
headers = {"Authorization": f"Bearer {API_KEY}"}

def get_vendor_users(vendor, max_pages=10):
    """Fetch all companies using a vendor, paginated."""
    companies = []
    for page in range(1, max_pages + 1):
        resp = requests.get(
            f"{BASE_URL}/prospect",
            headers=headers,
            params={"vendor": vendor, "page": page}
        )
        data = resp.json()
        companies.extend(data.get("prospects", []))
        
        if len(data.get("prospects", [])) < 10:
            break  # Last page
        time.sleep(0.5)  # Rate limit courtesy
    
    return companies

def check_company_stack(domain):
    """Get full vendor stack for a domain."""
    resp = requests.get(
        f"{BASE_URL}/check",
        headers=headers,
        params={"url": domain}
    )
    return resp.json()

# Step 1: Find all Stripe users
stripe_users = get_vendor_users("Stripe", max_pages=22)
print(f"Found {len(stripe_users)} Stripe users")

# Step 2: Filter for companies also using Salesforce
qualified = []
for company in stripe_users:
    stack = check_company_stack(company["domain"])
    vendors = []
    for category, items in stack.get("vendor_stack", {}).items():
        vendors.extend([v["name"] for v in items])
    
    if "Salesforce" in vendors:
        qualified.append({
            "domain": company["domain"],
            "company_name": company["company_name"],
            "stripe_evidence": company["evidence_url"],
            "all_vendors": ", ".join(vendors)
        })

print(f"Qualified: {len(qualified)} companies")

# Step 3: Export
with open("stripe_salesforce_prospects.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=qualified[0].keys())
    writer.writeheader()
    writer.writerows(qualified)

Cost calculation: If Stripe has 217 users in the index, fetching all pages costs 217 credits. Checking each company's full stack costs 217 more credits (1 per successful lookup). Total: 434 credits (~$4 at the 1,100-credit pack rate).

Filtering Strategies

By Category Combination

Look for companies with specific category overlap—e.g., both ai_ml and payments vendors, signaling AI products with monetization:

ai_vendors = get_vendor_users("OpenAI", max_pages=13)
for company in ai_vendors:
    stack = check_company_stack(company["domain"])
    categories = stack.get("vendor_stack", {}).keys()
    if "payments" in categories:
        print(f"{company['domain']}: AI product with payment processing")

By Vendor Absence

Find companies using Vendor A but NOT Vendor B (competitive displacement opportunities):

hubspot_users = get_vendor_users("HubSpot", max_pages=13)
for company in hubspot_users:
    stack = check_company_stack(company["domain"])
    all_vendors = []
    for items in stack.get("vendor_stack", {}).values():
        all_vendors.extend([v["name"] for v in items])
    
    if "Salesforce" not in all_vendors:
        print(f"{company['domain']}: HubSpot user, no Salesforce")

By Evidence Freshness

The detected_at timestamp tells you when we last saw the evidence. For outreach timing, prioritize recently detected stacks (signals active engineering):

from datetime import datetime, timedelta

recent_cutoff = datetime.now() - timedelta(days=30)
for company in stripe_users:
    detected = datetime.fromisoformat(company["detected_at"].replace("Z", "+00:00"))
    if detected > recent_cutoff:
        print(f"{company['domain']}: detected in last 30 days")

When Companies Don't Appear

If a vendor returns fewer results than expected:

1. Not indexed yet: We have 1,000 companies; if your target isn't in the index, use /v1/check?url=their-domain.com to trigger a scan (15-90 seconds for new domains).
2. No public evidence: Some vendors (especially B2B SaaS with no client-side footprint) don't appear in JavaScript, DNS, or privacy pages. We can't detect what isn't disclosed.
3. Name variations: Try aliases—"Twilio SendGrid" vs "SendGrid", "Google Analytics" vs "GA4".

Combining with Enrichment APIs

Tech stack data is one signal. Combine it with firmographic data for scoring:

import requests

def enrich_prospect(domain):
    # Example using Clearbit (not affiliated)
    resp = requests.get(
        f"https://company.clearbit.com/v2/companies/find",
        params={"domain": domain},
        headers={"Authorization": f"Bearer {CLEARBIT_KEY}"}
    )
    return resp.json()

for company in qualified:
    enrichment = enrich_prospect(company["domain"])
    if enrichment.get("metrics", {}).get("employees", 0) > 50:
        print(f"{company['domain']}: mid-market, Stripe+Salesforce")

This creates a "uses our competitor, has budget, right size" list.

Reverse Lookup for Partnerships

If you build a product that integrates with Vendor X, finding X's users is a warm outreach list:

# You built a Slack app that enhances Salesforce
slack_users = get_vendor_users("Slack", max_pages=10)
salesforce_users = get_vendor_users("Salesforce", max_pages=11)

# Intersection
slack_domains = {c["domain"] for c in slack_users}
salesforce_domains = {c["domain"] for c in salesforce_users}
both = slack_domains & salesforce_domains

print(f"{len(both)} companies use both Slack and Salesforce")

Real numbers from our index: 100 Slack users, 102 Salesforce users. The overlap is your ICP.

API Mechanics

Authentication

Get a key instantly:

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

Returns a vr_live_* key with 25 free credits. No card required.

Rate Limits

No documented rate limit, but paginating through 200+ results? Add time.sleep(0.5) between requests.

Error Handling

If credits_used: 0 and prospects: [], either the vendor has no users or the name didn't match. Try variations:

variants = ["Stripe", "Stripe Payments", "Stripe, Inc."]
for variant in variants:
    resp = requests.get(f"{BASE_URL}/prospect", headers=headers, params={"vendor": variant})
    if resp.json().get("total_results", 0) > 0:
        print(f"Found results for: {variant}")
        break

What You Can't Do (Yet)

This is deterministic detection from public evidence, not:

• Real-time monitoring (data is refreshed on scan, not streamed)
• Private vendor relationships (if it's not public, we don't see it)
• Historical stack changes (no "Company X used Vendor Y in 2022")
• Spend estimation (we detect presence, not contract value)

For those use cases, you'd need vendor partnership data or payment-flow analysis, which we don't provide.

Practical Use Cases

1. Competitive intelligence: Find companies using a competitor, filter by size/category, export for outreach.
2. Integration marketing: You built a Stripe plugin—here are 217 potential customers.
3. Market research: Which vendors cluster together? ("92% of Anthropic users also use AWS"—hypothetical, but calculable from the data.)
4. Lead scoring: Enrich inbound leads with stack data, prioritize those using complementary tools.

Getting Started

Minimal working example:

# Get a key (25 free credits)
curl -X POST https://api.vendorstacks.com/v1/keys \
  -H 'Content-Type: application/json' \
  -d '{"email": "test@example.com"}'

# Find Stripe users
curl 'https://api.vendorstacks.com/v1/prospect?vendor=Stripe&page=1' \
  -H 'Authorization: Bearer vr_live_your_key_here'

# Check a specific company
curl 'https://api.vendorstacks.com/v1/check?url=shopify.com' \
  -H 'Authorization: Bearer vr_live_your_key_here'

You'll get back JSON with domains, evidence URLs, and the exact text where we detected each vendor. From there, it's standard data pipeline work—filter, enrich, score, export.

The index grows as more domains are scanned. If your target vendor or company isn't in the results, trigger a scan with /v1/check and check back in 60 seconds.