How to Build a Lead Enrichment Pipeline with Tech Detection

Your CRM has thousands of leads. Names, emails, company URLs. But without knowing what technologies those companies use, your sales team is shooting in the dark.

Tech stack data transforms cold outreach into relevant conversations. If you're selling a Shopify app, you only want leads running Shopify. If you offer WordPress security, you need WordPress sites. If you're competing with a specific analytics tool, you need to know who's using it.

In this guide, we'll build a lead enrichment pipeline that takes a list of company domains and enriches each one with technology data using the DetectZeStack API.

The Pipeline

Step 1: Prepare Your Domain List

Export your leads as a CSV or pull them from your CRM's API. The only required field is the company's domain:

domains.csv:
company,domain
Acme Corp,acmecorp.com
Globex Inc,globex.io
Initech,initech.com
Umbrella Corp,umbrella.co

Step 2: Batch Analyze

The /analyze/batch endpoint processes up to 10 URLs concurrently in a single request. Here's a Python script that reads your CSV and enriches each domain:

import csv
import json
import requests
import time

API_URL = "https://detectzestack.com/analyze/batch"
API_KEY = "your-api-key"
BATCH_SIZE = 10

def enrich_domains(csv_path):
    with open(csv_path) as f:
        rows = list(csv.DictReader(f))

    enriched = []

    # Process in batches of 10
    for i in range(0, len(rows), BATCH_SIZE):
        batch = rows[i:i + BATCH_SIZE]
        urls = [row["domain"] for row in batch]

        resp = requests.post(API_URL, json={"urls": urls}, headers={
            "X-Api-Key": API_KEY,
            "Content-Type": "application/json"
        })
        results = resp.json().get("results", [])

        for row, result in zip(batch, results):
            techs = [t["name"] for t in result.get("technologies", [])]
            categories = set()
            for t in result.get("technologies", []):
                categories.update(t.get("categories", []))

            row["technologies"] = ", ".join(techs)
            row["categories"] = ", ".join(categories)
            row["tech_count"] = len(techs)
            enriched.append(row)

        # Respect rate limits
        time.sleep(1)

    return enriched

results = enrich_domains("domains.csv")

# Write enriched CSV
with open("enriched_leads.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=results[0].keys())
    writer.writeheader()
    writer.writerows(results)

This script processes 10 domains per API call. For 1,000 leads, that's 100 API calls — well within the Ultra plan's 10,000 monthly limit, with room to re-enrich as stacks change.

Step 3: Filter and Score

Now that you have technology data, filter leads by relevance. Here's how to find leads using specific technologies:

# Find all Shopify stores
shopify_leads = [r for r in results if "Shopify" in r["technologies"]]

# Find WordPress sites without a CDN
wp_no_cdn = [
    r for r in results
    if "WordPress" in r["technologies"]
    and not any(cdn in r["technologies"]
        for cdn in ["Cloudflare", "Fastly", "CloudFront"])
]

# Score leads by tech stack overlap with your ideal customer
TARGET_TECHS = {"React", "Next.js", "Vercel", "Stripe"}

for lead in results:
    lead_techs = set(lead["technologies"].split(", "))
    lead["score"] = len(lead_techs & TARGET_TECHS)

# Sort by score descending
results.sort(key=lambda r: r["score"], reverse=True)

Step 4: Push to Your CRM

Most CRMs support custom fields. Here's an example pushing enriched data to HubSpot:

import hubspot

client = hubspot.Client.create(access_token="your-hubspot-token")

for lead in results:
    client.crm.contacts.basic_api.update(
        contact_id=lead["hubspot_id"],
        simple_public_object_input={
            "properties": {
                "tech_stack": lead["technologies"],
                "tech_categories": lead["categories"],
                "tech_score": str(lead["score"])
            }
        }
    )

Once technology data is in your CRM, you can:

• Create smart lists filtered by technology (e.g., "All Shopify + Klaviyo leads")
• Trigger automated sequences based on tech stack match
• Personalize email templates with technology references
• Route leads to the right sales rep based on their tech expertise

Real-World Use Cases

Keeping Data Fresh

Tech stacks change. A company might migrate from WordPress to Next.js, switch CDNs, or adopt new analytics. Set up a recurring enrichment job:

# Run weekly via cron
# 0 9 * * 1 python enrich_pipeline.py

# Or use webhooks for real-time monitoring
curl -X POST "https://detectzestack.com/webhooks" \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "important-prospect.com",
    "webhook_url": "https://your-app.com/webhook",
    "secret": "your-hmac-secret"
  }'

Webhook alerts notify you each time a monitored domain is analyzed — perfect for tracking key accounts and keeping enrichment data fresh.

Cost Comparison

Enriching 1,000 leads monthly with technology data:

• BuiltWith: $995/month (Pro plan required for API)
• Wappalyzer: $450/month (Business plan)
• DetectZeStack: $29/month (Ultra plan, 10,000 requests)

At DetectZeStack's pricing, enriching 10,000 leads per month costs $29 on the Ultra plan. That's a fraction of the cheapest alternative. See our full comparison for details.