# 🔧 Website Tech Stack Checker - BuiltWith Alternative (`renzomacar/tech-stack-enricher`) Actor

Detect the technologies behind any website — CMS, frameworks, analytics, ad pixels, payments, chat, marketing, and CDN/hosting — from a list of domains. A pay-per-result BuiltWith & Wappalyzer alternative for technographic B2B targeting.

- **URL**: https://apify.com/renzomacar/tech-stack-enricher.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 domain enricheds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Website Tech Stack Enricher — Technographics for B2B Targeting

### 🎥 Video walkthrough

https://youtu.be/0aO9d9rHw3Q

Give this Actor a list of domains and it tells you **what each website is built with**: its CMS, JavaScript framework, analytics, advertising pixels, payment processors, chat/support widget, marketing-automation platform, and CDN/hosting — plus derived signals like whether the site runs ecommerce, buys paid ads, and how sophisticated its stack is. It's a keyless, pay-per-result alternative to **BuiltWith** and **Wappalyzer** that runs in bulk and drops clean JSON/CSV/Excel straight into your workflow.

Under the hood it fetches each site's homepage (and one relevant internal page) through a US residential proxy, then fingerprints technologies from the HTML, inline and external `<script>` sources, `<link>` tags, `<meta>` generators, cookies, and response headers. Detection is **evidence-based and conservative** — a technology is only reported when there's a clear signal, so you get a low-false-positive stack rather than a wall of guesses.

### Why tech-stack targeting matters for B2B sales

Technographics let you build a lead list around the exact question a good sales or partnerships team actually asks: *"who uses the tools we integrate with, compete with, or complement?"* A few concrete plays:

- **Sell an app or agency service to a specific platform.** Filter for `cms = "Shopify"` to find every Shopify store in a list, or `hasEcommerce = true` to find online retailers worth pitching a CRO/ads/fulfilment service to.
- **Displacement selling.** Looking for companies on a competitor's tool? Filter `technologies` for `Intercom`, `Zendesk`, `Mailchimp`, `Marketo`, etc. and pitch your alternative to accounts that already pay for that category.
- **Qualify by spend & maturity.** `hasPaidAds = true` (a Google/Meta/TikTok/LinkedIn pixel is present) means the company already spends on acquisition — a warm signal for ad, analytics, and landing-page tools. `sophisticationTier` ("basic" / "growing" / "advanced") lets you route enterprise-y stacks to sales and thin stacks to self-serve.
- **Integration & partnership discovery.** Find accounts running Stripe, HubSpot, Segment, or Klaviyo when your product plugs into those.
- **Enrich an existing CRM.** Push a column of account domains through this and append a technographic profile to every row.

### Categories detected

| Category | Example technologies |
|----------|----------------------|
| **CMS / site builders** | WordPress, Shopify, Wix, Webflow, Squarespace, Drupal, Joomla, Ghost, HubSpot CMS, Contentful, Sanity |
| **Frameworks / frontend** | React, Vue, Angular, Next.js, Nuxt, Svelte, Gatsby, Ember |
| **Analytics** | Google Analytics (GA4 & UA), Google Tag Manager, Segment, Mixpanel, Amplitude, Hotjar, Plausible, Fathom, Matomo, Heap, PostHog |
| **Advertising / pixels** | Google Ads, Meta Pixel, LinkedIn Insight, TikTok Pixel, Twitter/X Pixel, Pinterest, Snap, Bing/UET, Reddit, DoubleClick |
| **Payments** | Stripe, PayPal, Braintree, Square, Shopify Payments, Adyen, Klarna, Razorpay |
| **Chat / support** | Intercom, Drift, Zendesk, Crisp, Tawk.to, LiveChat, Freshchat, Olark, Gorgias |
| **Email / marketing** | Klaviyo, Mailchimp, HubSpot, Marketo, ActiveCampaign, ConvertKit, Pardot, Drip, Braze, Omnisend |
| **Ecommerce platforms** | WooCommerce, Magento, BigCommerce, PrestaShop, Salesforce Commerce |
| **CDN / hosting / infra** | Cloudflare, Fastly, CloudFront, Akamai, Vercel, Netlify, AWS, Nginx, Apache, IIS, LiteSpeed, WP Engine, Kinsta |

### Input

```json
{
  "domains": ["stripe.com", "shopify.com", "notion.so"],
  "maxConcurrency": 5,
  "fetchExtraPage": true
}
```

- **domains** *(required)* — list of domains or URLs. Scheme, `www.`, and paths are normalized away.
- **maxConcurrency** — how many domains to analyse in parallel (default `5`, max `20`).
- **fetchExtraPage** — also fetch one internal page (`/pricing`, `/products`, `/checkout`, `/contact`…) to catch payment/chat/marketing scripts that only load off the homepage. Default `true`; set `false` for a faster homepage-only pass.

### Output

One record per domain:

```json
{
  "domain": "shopify.com",
  "url": "https://www.shopify.com/",
  "technologies": [
    { "name": "Cloudflare", "category": "cdnHosting" },
    { "name": "Google Analytics (GA4)", "category": "analytics" },
    { "name": "Google Tag Manager", "category": "analytics" },
    { "name": "React", "category": "frameworks" },
    { "name": "Shopify", "category": "cms" }
  ],
  "categoriesSummary": {
    "cms": "Shopify",
    "frameworks": ["React"],
    "analytics": ["Google Analytics (GA4)", "Google Tag Manager"],
    "advertising": [],
    "payments": [],
    "chat": [],
    "marketing": [],
    "cdnHosting": ["Cloudflare"]
  },
  "techCount": 5,
  "hasEcommerce": true,
  "hasPaidAds": false,
  "sophisticationTier": "growing",
  "scrapedAt": "2026-07-03T00:00:00.000Z"
}
```

#### Field reference

| Field | Meaning |
|-------|---------|
| `domain` | Normalized domain analysed. |
| `url` | The final URL fetched (after redirects). |
| `technologies` | Flat, deduped list of `{ name, category }` for every detected technology. |
| `categoriesSummary` | The stack grouped for easy filtering: single best `cms`, plus arrays for the other categories. |
| `techCount` | Number of distinct technologies detected. |
| `hasEcommerce` | `true` when a store platform (Shopify/WooCommerce/Magento/BigCommerce/…) is present. |
| `hasPaidAds` | `true` when at least one advertising pixel/tag is present — the site runs paid acquisition. |
| `sophisticationTier` | `basic` / `growing` / `advanced`, from tech breadth plus presence of paid-ads and marketing-automation tooling. |
| `scrapedAt` | ISO timestamp of the scan. |

A ready-made **table view** ships with the Actor (domain, tier, tech count, ecommerce, paid-ads, CMS, technologies) so the dataset is readable at a glance and trivially consumable by an LLM agent.

### The find → enrich workflow

This Actor is the **technographic** layer of a lead pipeline. Combine it with its siblings to go from "a domain" to "a qualified, contactable account":

1. **Find domains** — start from any list of company domains (a scrape, a CRM export, an ICP list).
2. **Profile the stack** *(this Actor)* — attach the technologies, ecommerce/paid-ads flags, and sophistication tier so you can *segment and prioritise*.
3. **Enrich the company** — run [**Company Enrichment**](https://apify.com/renzomacar/company-enrichment) to add industry, size signals, description, and decision-maker names for the accounts that pass your tech filter.
4. **Find the contact** — run [**Website Contact Finder**](https://apify.com/renzomacar/website-contact-finder) to pull emails, phones, and social profiles for outreach.

Filter at step 2, then only spend enrichment/contact credits on the accounts that match your technographic ICP.

### Honest note on detection

Detection is **signal-based and best-effort**, exactly like every client-side technographics tool (BuiltWith and Wappalyzer included). It reads what a website exposes to a browser: markup, script/link URLs, meta tags, cookies, and headers.

- Some technologies are deliberately invisible from the outside (server-side-only tools, tag-managed scripts that fire after consent, self-hosted/proxied assets, first-party-domained bundles) and won't be detected.
- We favour **precision over recall** — when in doubt we *don't* flag a tech, to keep false positives low. That means the stack we return is trustworthy but not necessarily exhaustive.
- Enabling `fetchExtraPage` meaningfully improves recall for payments and chat, which frequently only load on inner pages.

Treat the output as a strong, structured *signal* for segmentation — not a legal audit of a company's infrastructure.

### FAQ

**Do I need a BuiltWith or Wappalyzer API key?**
No. This is fully self-contained and keyless — it inspects each site directly. You only need an Apify account to run it.

**How is this different from BuiltWith?**
Same idea (technographics), different economics and ergonomics: you pay per enriched domain instead of a monthly seat, it runs in bulk on your own domain lists, routes through residential proxies, and returns schema-stable JSON/CSV/Excel with derived flags (`hasEcommerce`, `hasPaidAds`, `sophisticationTier`) built for lead segmentation.

**Why do some big sites return only a few technologies?**
Sophisticated sites often serve first-party-domained, tag-managed, or consent-gated scripts that hide third-party fingerprints, and route everything through their own CDN. We report only what we can see with confidence. Turning on `fetchExtraPage` usually surfaces more.

**Can it detect a specific tool, like "all sites using Klaviyo"?**
Yes — run your domain list, then filter the dataset where `technologies` contains the tool (Klaviyo, Intercom, Stripe, Shopify, etc.). That filtered set *is* your target list.

**What about rate limits and blocking?**
Requests go through Apify's residential proxy with a User-Agent and a proxy-rotation retry on transient failures, which handles most datacenter blocks. Keep `maxConcurrency` modest on very large lists.

**Is it agent / automation friendly?**
Yes. No auth, no browser step, deterministic structured output with a table view — ideal to call as a tool from an LLM/agent or wire into a pay-per-call workflow.

### Automate it

Set a **schedule** in Apify to re-profile a watchlist of accounts (catch when a prospect adds Stripe, switches to Shopify, or turns on a Meta Pixel — all buying signals), and connect the dataset to a **webhook**, Google Sheet, Slack, or your CRM. Chain it after a domain-finder and before [Company Enrichment](https://apify.com/renzomacar/company-enrichment) + [Website Contact Finder](https://apify.com/renzomacar/website-contact-finder) to run a full, hands-off technographic lead pipeline with zero infrastructure to maintain.

***

*Detection is signal-based and best-effort. This Actor is not affiliated with BuiltWith, Wappalyzer, or any of the technologies it detects.*

# Actor input Schema

## `domains` (type: `array`):

Website domains or full URLs to detect the tech stack for (e.g. stripe.com, https://www.shopify.com). Each domain is fetched and analysed independently and produces one dataset record.

## `maxConcurrency` (type: `integer`):

How many domains to fetch and analyse in parallel. Higher = faster on large lists, but more load; keep it modest to stay polite to target sites and proxies.

## `fetchExtraPage` (type: `boolean`):

Besides the homepage, also fetch one relevant internal page (e.g. /pricing, /products, /checkout, /contact) to catch payment, chat, and marketing scripts that don't load on the homepage. Turn off for a faster, homepage-only scan.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "shopify.com",
    "notion.so"
  ],
  "maxConcurrency": 5,
  "fetchExtraPage": true
}
```

# Actor output Schema

## `results` (type: `string`):

One row per domain with the technologies detected.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "stripe.com",
        "shopify.com",
        "notion.so"
    ],
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/tech-stack-enricher").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domains": [
        "stripe.com",
        "shopify.com",
        "notion.so",
    ],
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/tech-stack-enricher").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "stripe.com",
    "shopify.com",
    "notion.so"
  ],
  "maxConcurrency": 5
}' |
apify call renzomacar/tech-stack-enricher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=renzomacar/tech-stack-enricher",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/AbD99TteCpboEGpQD/builds/xnbPYHqHYm2k6mpI1/openapi.json