Tech Stack Lookup API: Building Vendor-Triggered Workflows and Automations

Why Trigger Workflows from Tech Stack Data

Most teams treat tech stack data as a one-time enrichment step: look up a company, see their vendors, log it somewhere. But the real leverage comes from automating actions based on what you find.

If a prospect uses Stripe and Salesforce but not HubSpot, that's a specific signal. If they recently added OpenAI (scanned_at timestamp), that's a timing signal. If they use Twilio but you see no SMS vendor evidence, that's a gap signal. Each of these can trigger a different workflow: route to a specific rep, send a targeted email sequence, create a high-priority task, or update a custom field.

This post walks through the technical patterns for building vendor-triggered workflows using VendorStacks' tech stack lookup API. We'll cover Zapier-style no-code flows, Make (Integromat) scenarios, n8n self-hosted automations, and direct API integrations in Python and TypeScript.

The Core Pattern: Lookup → Conditional Logic → Action

Every vendor-triggered workflow follows the same structure:

1. Trigger: a new lead, form submission, CRM record creation, webhook, scheduled scan
2. Lookup: call VendorStacks API with the company domain
3. Conditional logic: check vendor_stack for specific vendors or combinations
4. Action: route, enrich, notify, score, or update downstream systems

The VendorStacks API returns structured data in 24 categories. Here's a minimal response:

{
  "domain": "example.com",
  "vendor_stack": {
    "payments": ["Stripe"],
    "crm_sales": ["Salesforce"],
    "cloud_infra": ["AWS"],
    "ai_ml": ["OpenAI"]
  },
  "scanned_at": "2025-01-15T10:32:11Z",
  "found": true,
  "credits_used": 1,
  "credit_balance": 542
}

You can branch logic on any vendor in any category, or check for absence (no marketing_ads vendors = possible gap to fill).

Pattern 1: Zapier Webhook → Conditional Paths → CRM Update

Zapier doesn't natively support VendorStacks, but you can use Webhooks by Zapier to call the API and Paths to branch on the response.

Setup:

1. Trigger: "New Lead in HubSpot" or "New Row in Google Sheets"
2. Action: Webhooks by Zapier → GET request

• URL: https://api.vendorstacks.com/v1/check?url={{lead_domain}}
• Headers: Authorization: Bearer vr_live_YOUR_KEY

1. Action: Paths (Zapier's built-in conditional branching)

• Path A: payments contains Stripe → set custom field "Payment Processor" = "Stripe", assign to Stripe specialist
• Path B: payments does not exist → add to "No Payment Vendor" segment
• Path C: ai_ml contains OpenAI → trigger "AI Early Adopter" playbook

Each path can then update HubSpot properties, send Slack messages, or create tasks in your project management tool.

Cost note: VendorStacks charges 1 credit per successful lookup. If the domain is already indexed (most of our 1000-company index scans in <1 second), you get instant results. If it's new, we trigger a live scan (15-90 seconds). Either way, you only pay if we find vendor evidence—empty results cost 0 credits.

Pattern 2: Make (Integromat) HTTP Module + Router

Make (formerly Integromat) gives you more flexible conditional logic than Zapier. Use the HTTP module to call VendorStacks, then a Router to branch on vendor combinations.

Scenario structure:

1. Trigger: Webhook (from your app, CRM, or form tool)
2. HTTP Request:

• Method: GET
• URL: https://api.vendorstacks.com/v1/check?url={{domain}}
• Headers: Authorization: Bearer vr_live_YOUR_KEY

1. Router with filters:

• Route 1: vendor_stack.payments[] contains "Stripe" AND vendor_stack.crm_sales[] contains "Salesforce" → high-fit signal, create Salesforce Opportunity
• Route 2: vendor_stack.cloud_infra[] contains "AWS" AND vendor_stack.database_infra[] is empty → potential database vendor gap, send targeted email
• Route 3: scanned_at > (now - 7 days) AND vendor_stack.ai_ml[] length > 0 → recently adopted AI, trigger "AI expansion" playbook

Make's array and date functions let you build sophisticated logic. You can check vendor counts ("uses 3+ analytics vendors = data-heavy company"), check for specific combinations ("Snowflake + Salesforce = likely data team with CRM integration"), or filter by recency.

Pattern 3: n8n Self-Hosted Workflows

If you run your own infrastructure, n8n gives you full control. Use the HTTP Request node to call VendorStacks, then IF or Switch nodes to branch.

Example workflow (lead scoring):

{
  "nodes": [
    {
      "type": "n8n-nodes-base.webhook",
      "name": "New Lead Webhook"
    },
    {
      "type": "n8n-nodes-base.httpRequest",
      "name": "VendorStacks Lookup",
      "parameters": {
        "url": "https://api.vendorstacks.com/v1/check?url={{$json.domain}}",
        "authentication": "headerAuth",
        "headerAuth": {
          "name": "Authorization",
          "value": "Bearer vr_live_YOUR_KEY"
        }
      }
    },
    {
      "type": "n8n-nodes-base.if",
      "name": "Check for Target Stack",
      "parameters": {
        "conditions": {
          "string": [
            {
              "value1": "={{$json.vendor_stack.payments}}",
              "operation": "contains",
              "value2": "Stripe"
            }
          ]
        }
      }
    },
    {
      "type": "n8n-nodes-base.salesforce",
      "name": "Update Lead Score",
      "parameters": {
        "resource": "lead",
        "operation": "update",
        "leadId": "={{$json.lead_id}}",
        "customFields": {
          "Tech_Stack_Score__c": 85,
          "Uses_Stripe__c": true
        }
      }
    }
  ]
}

You can store this in Git, version it, and deploy across environments. n8n also supports Code nodes (JavaScript) for custom logic if you need to score based on vendor combinations our categories don't capture.

Pattern 4: Direct API Integration (Python)

For maximum control, call the VendorStacks API directly and build your own conditional logic. Here's a Python function that triggers different actions based on tech stack:

import requests
import os

def trigger_workflow_from_stack(domain: str, lead_id: str):
    headers = {"Authorization": f"Bearer {os.getenv('VENDORSTACKS_API_KEY')}"}
    response = requests.get(
        f"https://api.vendorstacks.com/v1/check?url={domain}",
        headers=headers
    )
    data = response.json()
    
    if not data.get("found"):
        # No vendor evidence found — could mean small company or privacy-focused
        send_to_manual_research_queue(lead_id)
        return
    
    stack = data.get("vendor_stack", {})
    
    # Workflow 1: High-fit tech stack
    if "Stripe" in stack.get("payments", []) and "Salesforce" in stack.get("crm_sales", []):
        update_crm_field(lead_id, "Tech_Fit_Score", 90)
        assign_to_rep(lead_id, "enterprise_team")
        send_slack_alert(f"High-fit lead: {domain} uses Stripe + Salesforce")
    
    # Workflow 2: AI early adopter
    if "OpenAI" in stack.get("ai_ml", []):
        add_to_segment(lead_id, "ai_early_adopters")
        trigger_email_sequence(lead_id, "ai_expansion_playbook")
    
    # Workflow 3: Cloud infra but no observability vendor
    if stack.get("cloud_infra") and not stack.get("observability"):
        update_crm_field(lead_id, "Vendor_Gap", "observability")
        create_task(lead_id, "Pitch observability vendor — no current solution detected")
    
    # Workflow 4: Recently scanned = fresh data
    from datetime import datetime, timedelta
    scanned_at = datetime.fromisoformat(data["scanned_at"].replace("Z", "+00:00"))
    if datetime.now(scanned_at.tzinfo) - scanned_at < timedelta(days=7):
        update_crm_field(lead_id, "Tech_Stack_Freshness", "recent")

def send_slack_alert(message: str):
    # Your Slack webhook logic
    pass

def update_crm_field(lead_id: str, field: str, value):
    # Your CRM API call
    pass

This pattern gives you full programmatic control. You can:

• Score leads based on vendor combinations ("Snowflake + Salesforce + AWS = data-mature company")
• Detect vendor gaps ("uses Twilio but no observability = monitoring blind spot")
• Route based on stack complexity (vendor count, category coverage)
• Trigger time-sensitive workflows based on scanned_at freshness

Pattern 5: Reverse Lookup Workflows (Vendor Adoption Triggers)

The /v1/prospect?vendor=X endpoint returns companies using a specific vendor (10 per page, 1 credit per result). You can poll this daily to trigger workflows when new companies adopt a vendor.

Use case: You sell to companies using Snowflake. Each morning, run:

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

Compare the results to yesterday's snapshot. Any new domains = companies that recently made Snowflake evidence public. Trigger:

• Add to "Snowflake New Adopters" segment in your CRM
• Send a congratulatory LinkedIn message ("Saw you're using Snowflake—here's how we help Snowflake users...")
• Create a high-priority lead with context ("Uses Snowflake, likely has data team, fresh adoption")

You pay 1 credit per company returned, not per page—so if the query returns 3 results, you pay 3 credits. Empty results cost 0.

Real-World Workflow: Scoring Leads by Stack Maturity

Here's a concrete example: score inbound leads based on tech stack maturity. Companies with more vendors in more categories = more mature, more budget, better fit for enterprise products.

def calculate_stack_maturity_score(domain: str) -> int:
    response = requests.get(
        f"https://api.vendorstacks.com/v1/check?url={domain}",
        headers={"Authorization": f"Bearer {os.getenv('VENDORSTACKS_API_KEY')}"}
    ).json()
    
    if not response.get("found"):
        return 0
    
    stack = response.get("vendor_stack", {})
    
    # Base score: 10 points per category with vendors
    category_score = len([cat for cat in stack.values() if cat]) * 10
    
    # Bonus: 5 points per vendor (capped at 50)
    vendor_count = sum(len(vendors) for vendors in stack.values())
    vendor_score = min(vendor_count * 5, 50)
    
    # Bonus: 20 points if uses enterprise vendors (Salesforce, Snowflake, AWS)
    enterprise_vendors = {"Salesforce", "Snowflake", "AWS"}
    all_vendors = {v for vendors in stack.values() for v in vendors}
    if enterprise_vendors & all_vendors:
        enterprise_bonus = 20
    else:
        enterprise_bonus = 0
    
    return category_score + vendor_score + enterprise_bonus

Plug this into your lead-scoring model. A company with 8 categories, 12 vendors, and Salesforce scores 810 + 50 + 20 = 150. A company with 2 categories and 3 vendors scores 210 + 15 = 35.

Handling Edge Cases

found: false: No public vendor evidence. This doesn't mean the company uses nothing—it means we didn't find public signals (privacy-focused companies, new domains, non-technical businesses). Route these to manual research or a lower-priority queue.

Empty categories: If payments is missing, the company may not sell online, or uses a vendor we haven't categorized. Don't assume "no payment processor" = "opportunity to sell one"—verify the business model first.

Live scans (15-90s): If you call /v1/check on an unindexed domain, we trigger a live scan. This takes 15-90 seconds. For real-time workflows (webhook → instant response), use /v1/company/{domain} first (never scans, returns cached data or null). If null, queue the /v1/check call asynchronously and process the result later.

Credit management: Check credit_balance in the response. If it's low, trigger an alert or pause non-critical workflows. You only pay for successful results—failed scans and empty lookups cost 0 credits.

Next Steps

Start with a single workflow: "When a lead comes in, look up their stack. If they use Stripe, assign to Rep A. If they use Salesforce, add tag 'Enterprise'. Otherwise, do nothing." Get that working in Zapier or n8n, then expand.

Grab an API key at POST https://api.vendorstacks.com/v1/keys (instant, 25 free credits, no card required). Test with:

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

You'll see Stripe's stack (spoiler: they use AWS, Cloudflare, and a bunch of others in our index of 1000 companies and 308 distinct vendors). Build your conditional logic from there.

The leverage isn't in knowing a company's stack—it's in automating what you do with that knowledge.