Enrich HubSpot companies with technographic data from BuiltWith using Make

Prerequisites

Why Make?

Make's visual builder makes it easy to see the flow from HubSpot search through BuiltWith lookup to the HubSpot update. The Iterator handles per-company processing naturally, and the Code module (Core plan) simplifies the technology categorization. If you're already running Make scenarios for other workflows, this keeps technographic enrichment alongside your existing automations.

The trade-off is credit consumption and execution time. Each company passes through 4-5 modules, and the 2-second Sleep between BuiltWith calls means 50 companies take 100+ seconds just in delays. On the Free plan's 5-minute execution limit, you're capped at about 15-20 companies per run.

Step 1: Create the scenario and schedule

Create a new scenario. Set the schedule for weekly execution:

• Schedule type: At regular intervals
• Run scenario: Every week
• Day: Sunday
• Time: 22:00
• Timezone: Your team's timezone

Step 2: Search for companies without tech data

Add an HTTP module (Make an API Call):

• URL: https://api.hubapi.com/crm/v3/objects/companies/search
• Method: POST
• Headers: Authorization handled by HubSpot connection
• Body:

{
  "filterGroups": [{
    "filters": [{
      "propertyName": "tech_stack_crm",
      "operator": "NOT_HAS_PROPERTY"
    }]
  }],
  "properties": ["domain", "name"],
  "limit": 50
}

Step 3: Iterate over companies

Add an Iterator module:

• Array: {{1.results}}

This emits one bundle per company for the downstream modules.

Step 4: Call BuiltWith API

Add an HTTP module:

• URL: https://api.builtwith.com/v21/api.json?KEY=YOUR_BUILTWITH_KEY&LOOKUP={{2.properties.domain}}
• Method: GET

Step 5: Parse technologies with a Text Parser

Use Make's built-in JSON module → Parse JSON to extract the Technologies array.

Then add a Set Multiple Variables module (under Tools) to categorize the results. Map expressions using Make's map() and join() functions:

For complex categorization, use a Code module (available on Core plan) instead:

const techs = input.Results?.[0]?.Result?.Paths?.[0]?.Technologies || [];
const crm = techs.filter(t => /crm/i.test(t.Tag)).map(t => t.Name);
const marketing = techs.filter(t => /marketing|email/i.test(t.Tag)).map(t => t.Name);
const analytics = techs.filter(t => /analytics/i.test(t.Tag)).map(t => t.Name);
 
return {
  tech_stack_crm: crm.join(", ") || "None detected",
  tech_stack_marketing: marketing.join(", ") || "None detected",
  tech_stack_analytics: analytics.join(", ") || "None detected",
  tech_stack_all: techs.map(t => t.Name).join(", "),
};

Step 6: Update the HubSpot company

Add an HTTP module:

• Method: PATCH
• URL: https://api.hubapi.com/crm/v3/objects/companies/{{2.id}}
• Headers: Authorization via HubSpot connection
• Body:

{
  "properties": {
    "tech_stack_crm": "{{4.tech_stack_crm}}",
    "tech_stack_marketing": "{{4.tech_stack_marketing}}",
    "tech_stack_analytics": "{{4.tech_stack_analytics}}",
    "tech_stack_all": "{{4.tech_stack_all}}",
    "tech_enrichment_date": "{{formatDate(now; 'YYYY-MM-DD')}}"
  }
}

Step 7: Add rate limiting and error handling

1. Add a Sleep module (2 seconds) between the Iterator and the BuiltWith HTTP call — BuiltWith rate limits vary by plan
2. Add a Resume error handler on the BuiltWith module for 429 responses
3. Add a Filter after the BuiltWith module to skip domains that returned no technologies
4. Click Run once to test with a few companies
5. Toggle the scenario to Active

Cost and credits

• Make Free plan: 1,000 credits/month. Each company uses ~4-5 credits. Handles ~200-250 lookups/month.
• Make Core plan: $29/mo for 10,000 credits. Handles ~2,000-2,500 lookups/month.
• BuiltWith Pro: $295/mo for 500 API calls ($0.59 per lookup). Enterprise: $495/mo for 2,000 calls ($0.25 per lookup).
• Weekly batch of 50 companies: ~50 BuiltWith calls + ~250 Make credits.

Common questions

How many companies can I enrich per run on Make's Free plan?

About 15-20 companies, limited by the 5-minute execution timeout. Each company needs a 2-second BuiltWith delay plus processing time. On the Core plan (40-minute limit), you can process up to ~200 companies per run.

Do I need the Code module, or can I use Set Multiple Variables?

The Code module (Core plan, $29/mo) is strongly recommended for this recipe. BuiltWith's response is deeply nested, and categorizing technologies by tag requires loop logic that's awkward to express with Make's built-in functions. On the Free plan, you can use JSON Parse + Set Variables, but it requires more modules and is harder to maintain.

What happens when BuiltWith doesn't recognize a domain?

BuiltWith returns an empty Results array (not an error). Without the Filter after the BuiltWith module, the Code module would try to parse empty data and fail. The Filter silently skips these companies, and the tech_enrichment_date isn't set — so they'll appear in the next run for retry.

Next steps

• Add a Data Store — track which domains have been looked up to avoid duplicate BuiltWith calls on subsequent runs
• Detect competitor tools — add specific variable-setting for whether the company uses a competitor product (uses_competitor = true/false)
• Add to lead scoring — create a HubSpot workflow that adjusts company score based on tech_stack_crm values