Tech Stack Lookup API: Building Vendor-Based Segmentation for Email Campaigns

Most email segmentation stops at firmographic data: company size, industry, location. But when you're selling to technical buyers or competing against specific vendors, knowing what stack a company runs creates more relevant segments than any demographic filter.

A prospect using Stripe + HubSpot looks completely different from one using Stripe + Salesforce, even if they're the same size and industry. Tech stack data lets you build segments that reflect actual buying contexts, not just surface attributes.

This guide shows how to integrate tech stack lookup into email workflows, build vendor-based segments programmatically, and personalize campaigns with evidence-backed technology data.

Why Tech Stack Segmentation Works

Traditional segments answer "who is this company?" Tech stack segments answer "what does this company use?" That distinction matters when:

• Your product integrates with specific vendors. If you build Salesforce extensions, companies using Salesforce are qualified. Companies using HubSpot aren't—regardless of size or funding.
• You compete with a specific vendor. Migration messaging only works on prospects actually using your competitor. Broad "CRM" filters waste sends on non-users.
• Your ICP clusters around stack patterns. Companies using AWS + Stripe + Segment might convert 5x better than companies with none of those. Stack combos surface that signal.
• Personalization requires specifics. "We integrate with your CRM" is vague. "We sync deal data from Salesforce to your data warehouse" is concrete—but only if you know they use Salesforce.

In our index of 1,000 companies across 314 vendors, the most common stacks are Google Analytics (308 companies), AWS (284), Stripe (189), HubSpot (132), and Salesforce (97). These high-penetration vendors create natural segments, but the real value is in combinations: companies using Stripe without certain fraud tools, or running OpenAI (106 companies) without observability.

How Tech Stack Lookup Returns Vendor Data

The VendorStacks API provides vendor detection through two endpoints: direct lookup and reverse lookup. Both return evidence-backed results across 24 categories.

Direct Lookup: Get One Company's Stack

For a single domain, GET /v1/check?url=DOMAIN returns vendors found in public evidence:

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

Response includes vendor_stack with categories like payments, crm_sales, analytics_data, cloud_infra. Each vendor has vendor_confidence (high/medium/low) and *_evidence fields showing the quoted source row.

If the company is already indexed, results return in <1 second. If not indexed, the endpoint triggers a live scan (15-90 seconds). Either way, you only pay 1 credit on success—failed scans or "not found" results cost 0 credits.

Reverse Lookup: Find Companies Using a Vendor

For building segments, GET /v1/prospect?vendor=VENDOR_NAME returns companies using that vendor:

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

Returns 10 results per page. Each result is 1 credit, so page 1 of a full result set costs 10 credits. Empty pages cost 0.

This powers list builds: "all companies using Intercom" or "all companies using AWS but not using Datadog."

Building Vendor Segments in Your Email Tool

Most email platforms (HubSpot, Customer.io, Iterable, Braze) let you sync custom properties via API. The pattern:

1. Pull your contact list (emails + domains)
2. Look up vendor stacks for each domain
3. Write vendor presence as boolean or array properties
4. Sync properties back to your email tool
5. Build segments using the new fields

Example: Tagging Contacts with CRM Vendor

You want to segment by CRM (Salesforce, HubSpot, Pipedrive, or none detected).

import requests

VENDORSTACKS_API_KEY = "vr_live_YOUR_KEY"
BASE_URL = "https://api.vendorstacks.com"

def get_vendor_stack(domain):
    response = requests.get(
        f"{BASE_URL}/v1/check?url={domain}",
        headers={"Authorization": f"Bearer {VENDORSTACKS_API_KEY}"}
    )
    if response.status_code == 200:
        data = response.json()
        if data.get("found"):
            return data.get("vendor_stack", {})
    return None

def extract_crm_vendor(vendor_stack):
    if not vendor_stack:
        return None
    crm_category = vendor_stack.get("crm_sales", [])
    # Return first CRM found, or None
    for vendor_obj in crm_category:
        return vendor_obj.get("name")
    return None

# Process contact list
contacts = [
    {"email": "alice@acme.com", "domain": "acme.com"},
    {"email": "bob@widgets.io", "domain": "widgets.io"},
]

for contact in contacts:
    stack = get_vendor_stack(contact["domain"])
    crm = extract_crm_vendor(stack)
    contact["crm_vendor"] = crm or "none_detected"
    print(f"{contact['email']}: {contact['crm_vendor']}")

# Now sync contact["crm_vendor"] to your email platform as a custom property

In your email tool, you can now create segments:

• crm_vendor = "Salesforce" → Salesforce users segment
• crm_vendor = "HubSpot" → HubSpot users segment
• crm_vendor = "none_detected" → No CRM detected (or no public evidence)

Remember: "none_detected" means we found no public evidence, not that the company uses nothing. Treat it as "unknown" rather than "confirmed absent."

Multi-Vendor Segments and Stack Patterns

Single-vendor tags are useful, but stack combinations surface better signals.

Example: Companies Using Stripe Without Certain Fraud Tools

If you sell fraud prevention, you want companies processing payments (Stripe) but not yet using specialized fraud detection:

def check_fraud_gap(domain):
    stack = get_vendor_stack(domain)
    if not stack:
        return False
    
    payments = stack.get("payments", [])
    fraud = stack.get("security_fraud", [])
    
    uses_stripe = any(v.get("name") == "Stripe" for v in payments)
    uses_fraud_tool = len(fraud) > 0
    
    return uses_stripe and not uses_fraud_tool

# Tag contacts with boolean: has_fraud_gap = True/False

Segment: has_fraud_gap = True gets messaging like "You're processing payments with Stripe. Here's how [Product] adds fraud detection in 3 lines of code."

Example: AI Companies Without Observability

If you sell LLM observability, target companies using OpenAI/Anthropic without observability vendors:

def check_ai_observability_gap(domain):
    stack = get_vendor_stack(domain)
    if not stack:
        return False
    
    ai_ml = stack.get("ai_ml", [])
    observability = stack.get("observability", [])
    
    uses_ai = len(ai_ml) > 0
    uses_observability = len(observability) > 0
    
    return uses_ai and not uses_observability

With 106 companies in our index using OpenAI, this pattern finds prospects running AI workloads without dedicated monitoring.

Automating Vendor-Triggered Campaigns

Beyond static segments, you can trigger campaigns when stack conditions match.

Pattern: New Sign-Up with Detected Vendor

When a user signs up, look up their domain immediately and branch the onboarding email:

def send_onboarding_email(user_email, user_domain):
    stack = get_vendor_stack(user_domain)
    crm = extract_crm_vendor(stack)
    
    if crm == "Salesforce":
        send_email(user_email, template="onboarding_salesforce")
    elif crm == "HubSpot":
        send_email(user_email, template="onboarding_hubspot")
    else:
        send_email(user_email, template="onboarding_generic")

The Salesforce template includes "Sync deals from Salesforce to [Product] in two clicks." The generic template skips CRM-specific language.

Pattern: Quarterly Re-Scan for Stack Changes

Run a periodic job to re-check domains and detect vendor additions:

import time

def detect_new_vendors(domain, previous_stack):
    current_stack = get_vendor_stack(domain)
    if not current_stack:
        return []
    
    previous_vendors = set()
    for category in previous_stack.values():
        for v in category:
            previous_vendors.add(v.get("name"))
    
    current_vendors = set()
    for category in current_stack.values():
        for v in category:
            current_vendors.add(v.get("name"))
    
    new_vendors = current_vendors - previous_vendors
    return list(new_vendors)

# Run quarterly for your contact list
# If new_vendors includes a trigger vendor (e.g., "Segment"), send campaign

If a company adds Segment (data integration layer), they might now be ready for your data warehouse connector.

Personalization with Evidence Fields

The API returns *_evidence fields with quoted source rows. Use these to add specificity:

{
  "vendor_stack": {
    "payments": [
      {
        "name": "Stripe",
        "vendor_confidence": "high",
        "payments_evidence": "https://js.stripe.com/v3/ loaded in checkout page"
      }
    ]
  }
}

You can surface evidence in internal views (sales reps see "uses Stripe, detected via js.stripe.com on checkout"), but keep emails focused on the vendor name itself. Evidence is proof for your team, not copy for the prospect.

Handling "Not Found" and Confidence Levels

If found: false, no public evidence was located. This doesn't mean the company uses nothing—it means we didn't detect vendors from their public web presence.

Options:

• Exclude from vendor segments. Only target confirmed positives.
• Create a fallback segment. "Stack unknown" gets generic messaging.
• Re-scan later. Companies update websites; evidence appears over time.

If vendor_confidence: "low", the signal is weaker (e.g., indirect reference vs. direct script tag). You can filter segments to "high" confidence only for tighter targeting.

Cost Structure for Email Segmentation

Pricing: 1 credit per successful lookup, 1 credit per reverse-lookup result. Failed lookups and empty results cost 0 credits.

• Checking 1,000 domains (direct lookups): ~1,000 credits if all succeed, less if some return found: false.
• Reverse lookup for "companies using Stripe": 1 credit per company returned. If 189 companies use Stripe (our current index count), pulling the full list costs 189 credits.

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

For a weekly segment refresh of 5,000 contacts, budget ~5,000 credits/week if you're re-checking all domains. For one-time enrichment, it's a one-time cost.

Implementation Checklist

1. Get an API key: POST https://api.vendorstacks.com/v1/keys returns instant key with 25 free credits.
2. Extract domains from your email list. Normalize to root domain (strip www, subdomains).
3. Look up vendor stacks via /v1/check?url=DOMAIN for each domain.
4. Parse vendor_stack response. Extract relevant categories (CRM, payments, analytics, etc.).
5. Write custom properties back to your email platform (HubSpot contact properties, Customer.io attributes, etc.).
6. Build segments using the new properties (e.g., crm_vendor = "Salesforce").
7. Create templated campaigns with vendor-specific messaging.
8. Monitor credit usage via GET /v1/balance and top up as needed.

When Vendor Segmentation Beats Demographic Segmentation

Use tech stack segments when:

• Your product has direct integrations (Salesforce app, Stripe plugin).
• You're running competitive displacement (targeting users of Vendor X).
• Your ICP clusters around specific stack patterns (AWS + Stripe + modern data stack).
• Personalization requires technology context ("we support your observability tool").

Stick with demographic segments when:

• Your product is stack-agnostic and value prop doesn't change by vendor.
• You're targeting job titles or use cases unrelated to technology choices.
• The cost of enrichment exceeds the lift from better targeting.

For technical products sold to technical buyers, vendor data usually outperforms firmographics. A 50-person Series A company using Kubernetes and Datadog is closer to your ICP than a 500-person company using neither—even though traditional scoring might rank the larger company higher.

Next Steps

Start with a small test: pick one high-value vendor (your top integration or competitor) and build a 100-contact segment. Run a personalized campaign against that segment and measure open rates, click rates, and reply rates against your baseline.

If vendor-specific messaging lifts engagement, expand to multi-vendor logic and automate the enrichment pipeline. Tech stack segmentation works because it targets actual buying context, not demographic proxies.

Grab an API key at POST https://api.vendorstacks.com/v1/keys and try vendor lookup on your next 25 contacts (free tier). You'll see whether your ICP clusters around specific vendors—and whether your email segments should reflect that.