Reverse Tech Stack Lookup: How to Build Prospect Lists from Vendor Usage Data

Most tech stack APIs answer the question "what does Company X use?" Reverse lookup flips this: "who uses Vendor Y?" This capability transforms vendor detection from a research tool into a prospect generation engine.

If you sell to companies using Stripe, OpenAI, or Snowflake, reverse lookup gives you a qualified list in seconds. This guide covers the mechanics, implementation patterns, and filtering strategies that make reverse lookup effective for outbound GTM.

How Reverse Tech Stack Lookup Works

Reverse lookup queries an index of company tech stacks by vendor name. Instead of scanning a single domain, you're searching across all indexed companies for those with public evidence of a specific tool.

The VendorStacks /v1/prospect endpoint implements this:

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

Response structure:

{
  "vendor": "Stripe",
  "companies": [
    {
      "domain": "example.com",
      "vendor_stack": {
        "payments": ["Stripe"],
        "cloud_infra": ["AWS"],
        "analytics_data": ["Google Analytics"]
      },
      "stripe_evidence": "https://example.com/checkout uses js.stripe.com/v3",
      "scanned_at": "2025-01-15T10:23:41Z"
    }
  ],
  "page": 1,
  "total_pages": 27,
  "credits_used": 10,
  "credit_balance": 990
}

Each page returns up to 10 results. You're billed 1 credit per company returned—an empty page costs nothing.

Current Index Coverage

As of this writing, the VendorStacks index contains 1,000 companies spanning 324 distinct vendors across 24 categories. Vendor distribution:

• AWS: 338 companies
• Google Analytics: 292 companies
• Stripe: 270 companies
• OpenAI: 210 companies
• Anthropic: 171 companies
• Google Cloud: 168 companies
• Cloudflare: 162 companies
• Microsoft Azure: 141 companies
• HubSpot: 135 companies
• Salesforce: 129 companies
• Slack: 124 companies
• Snowflake: 122 companies

These counts represent companies with public evidence—not the total market. A query for "Stripe" returns companies where we found Stripe checkout scripts, payment forms, or API calls referenced in public source code.

Implementation: Building a Prospect List

Here's a Python script that fetches all companies using a specific vendor and exports to CSV:

import requests
import csv
import time

API_KEY = "vr_live_YOUR_KEY"
BASE_URL = "https://api.vendorstacks.com/v1"
vendor = "OpenAI"

headers = {"Authorization": f"Bearer {API_KEY}"}
all_companies = []
page = 1

while True:
    resp = requests.get(
        f"{BASE_URL}/prospect",
        params={"vendor": vendor, "page": page},
        headers=headers
    )
    data = resp.json()
    
    if not data.get("companies"):
        break
    
    all_companies.extend(data["companies"])
    print(f"Page {page}: {len(data['companies'])} companies, {data['credits_used']} credits")
    
    if page >= data.get("total_pages", 1):
        break
    
    page += 1
    time.sleep(0.5)  # Rate limiting courtesy

# Export to CSV
with open(f"{vendor}_prospects.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["domain", "evidence", "scanned_at"])
    writer.writeheader()
    
    for company in all_companies:
        writer.writerow({
            "domain": company["domain"],
            "evidence": company.get(f"{vendor.lower()}_evidence", ""),
            "scanned_at": company["scanned_at"]
        })

print(f"Exported {len(all_companies)} companies to {vendor}_prospects.csv")

For a vendor like OpenAI (210 indexed companies), this costs 210 credits—about $1.90 at standard pricing. You get every company in the index with public OpenAI evidence.

Filtering Strategies

Raw reverse lookup returns every company using a vendor. Effective prospecting requires filtering:

1. Stack Composition Filters

Target companies using specific vendor combinations:

# Find companies using Anthropic BUT NOT OpenAI
anthropic_exclusive = [
    c for c in all_companies 
    if "OpenAI" not in c["vendor_stack"].get("ai_ml", [])
]

# Find companies using Stripe + Salesforce (payment + CRM)
stripe_salesforce = [
    c for c in stripe_companies
    if "Salesforce" in c["vendor_stack"].get("crm_sales", [])
]

This works because each company record includes their full vendor_stack object, not just the queried vendor.

2. Evidence-Based Filters

The *_evidence field shows where the vendor was detected. Use this to segment by implementation pattern:

# Stripe companies using Checkout (vs. direct API)
checkout_users = [
    c for c in stripe_companies
    if "checkout.stripe.com" in c.get("stripe_evidence", "")
]

# OpenAI companies referencing specific models
gpt4_users = [
    c for c in openai_companies
    if "gpt-4" in c.get("openai_evidence", "").lower()
]

Evidence strings are direct quotes from public source—HTML, JavaScript, DNS records, job postings. They reveal implementation details you can reference in outreach.

3. Multi-Vendor Enrichment

Combine reverse lookup with forward lookup for deeper profiling:

# For each Snowflake user, fetch their full stack
for company in snowflake_companies:
    detail_resp = requests.get(
        f"{BASE_URL}/company/{company['domain']}",
        headers=headers
    )
    company["full_stack"] = detail_resp.json().get("vendor_stack", {})
    
# Now filter by infrastructure patterns
aws_snowflake = [c for c in snowflake_companies 
                 if "AWS" in c["full_stack"].get("cloud_infra", [])]

Note: /v1/company/{domain} never triggers a scan—it only returns already-indexed data, so it costs 0 credits if the company isn't found or 1 credit if data exists.

GTM Workflows

Competitive Displacement

If you compete with Vendor X, reverse lookup gives you their customer list:

curl "https://api.vendorstacks.com/v1/prospect?vendor=Auth0" \
  -H "Authorization: Bearer vr_live_YOUR_KEY"

Filter for companies also using complementary tools (e.g., Auth0 + Stripe might indicate e-commerce businesses). Evidence URLs let you reference their current implementation in cold emails.

Partner Channel Development

Find companies using your integration partners:

# Find Stripe users for a payment optimization tool
stripe_list = fetch_all_pages("Stripe")

# Cross-reference with CRM for net-new prospects
existing_domains = {contact["domain"] for contact in crm_contacts}
net_new = [c for c in stripe_list if c["domain"] not in existing_domains]

You now have a warm list—these companies already use the ecosystem you integrate with.

Market Segmentation Research

Reverse lookup across multiple vendors reveals market patterns:

cloud_providers = {
    "AWS": fetch_all_pages("AWS"),
    "Google Cloud": fetch_all_pages("Google Cloud"),
    "Microsoft Azure": fetch_all_pages("Microsoft Azure")
}

# Companies using multiple clouds (multi-cloud strategies)
multi_cloud = set(cloud_providers["AWS"]) & set(cloud_providers["Google Cloud"])

Current index shows AWS (338 companies) dominates Google Cloud (168) and Azure (141), but 30%+ of companies use multiple cloud providers—a signal for migration or hybrid-cloud tooling.

Pricing and Credit Usage

Reverse lookup costs 1 credit per result returned, not per page. Key pricing facts:

• Empty pages cost 0 credits
• Each company in the results array costs 1 credit
• Pages return up to 10 companies (so max 10 credits per page)
• Failed queries cost 0 credits

Credit packs: $10 for 1,100 credits, $50 for 6,000 credits, $250 for 35,000 credits.

Example: fetching all 210 OpenAI companies (21 pages × ~10 results) costs 210 credits = $1.91. Fetching all 338 AWS companies costs 338 credits = $3.07.

Differences from Forward Lookup

Forward lookup (/v1/check?url=DOMAIN) can trigger a live scan if the domain isn't indexed, taking 15-90 seconds. Reverse lookup only queries pre-indexed data—results are instant but limited to the current index.

If you need data on a domain not in the index, use forward lookup first:

# Trigger indexing for a specific prospect
curl "https://api.vendorstacks.com/v1/check?url=newcompany.com" \
  -H "Authorization: Bearer vr_live_YOUR_KEY"

# Wait for scan to complete, then query their full stack
curl "https://api.vendorstacks.com/v1/company/newcompany.com" \
  -H "Authorization: Bearer vr_live_YOUR_KEY"

Forward lookup costs 1 credit only if vendors are found. Scans that find nothing cost 0 credits.

Limitations and Accuracy

Reverse lookup shows public evidence, not ground truth:

• Absence isn't proof: If a company isn't in results, it doesn't mean they don't use the vendor—it means we found no public evidence.
• Evidence recency: The scanned_at timestamp shows when data was collected. Stacks change; re-scan periodically for updates.
• Vendor name matching: Query "OpenAI" not "Open AI" or "GPT-4". Vendor names must match the taxonomy exactly (check /v1/check responses for canonical names).

The index currently covers 1,000 companies. Coverage expands as more domains are scanned via forward lookup—every /v1/check call adds data to the reverse lookup index.

Getting Started

Generate an API key instantly:

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

You get 25 free credits (25 reverse lookup results or 25 forward lookups). No registration required.

Check your balance anytime:

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

Reverse lookup converts vendor detection from a one-off enrichment task into a repeatable prospecting engine. Query once, get a list. Filter by stack composition or evidence patterns. Export to CSV and load into your outbound sequence.

The companies are already using the vendor—you're just finding them.