# 🔧 Website Tech Stack Detector - 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 bulk list of domains, 90+ tools. A pay-per-result BuiltWith & Wappalyzer alternative for technographic B2B targeting. No API key, no per-lookup subscription.

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

## Pricing

from $18.60 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## 🔧 Tech Stack Detector — What Any Website Is Built With

Feed it a list of domains and get back each site's full technology fingerprint: CMS, frameworks, analytics, ad pixels, payments, chat, marketing automation and CDN/hosting across 90+ tools — plus derived sales signals (`hasEcommerce`, `hasPaidAds`, `sophisticationTier`). For B2B sales teams doing technographic targeting, agencies, and integration partners.
**Pricing: $0.02 per domain enriched.** No API key, no subscription — a keyless BuiltWith / Wappalyzer alternative.

### 🎥 Video walkthrough

https://youtu.be/0aO9d9rHw3Q

### BuiltWith alternative: how this compares

| | **This Actor** | **BuiltWith** | **Wappalyzer** |
|---|---|---|---|
| Access | Keyless, run on Apify | Account + paid plans for lists | Account/extension; API for bulk |
| Bulk from your own list | Paste domains, one dataset out | List exports on higher tiers | Via paid API |
| Pricing | $0.02 per domain, pay-per-result | Monthly seat | Credits |
| Data depth | Live scan, 90+ tools, precision-first | Massive historical index | Large index |
| Derived sales flags | `hasEcommerce`, `hasPaidAds`, `sophisticationTier` built in | DIY from raw data | DIY |

Honest read: BuiltWith's historical index (when a site *adopted or dropped* a tool) is something a live scan can't replicate — if you need adoption timelines, use BuiltWith. If you need "what does this list of 5,000 domains run **today**, cheaply, in one CSV", that's exactly this Actor.

### How detection works (and why you can trust a flag)

Each site's homepage — plus one relevant internal page (`/pricing`, `/checkout`, `/contact`…) when `fetchExtraPage` is on — is fetched through a US residential proxy. Technologies are fingerprinted from HTML, script and link URLs, meta generators, cookies and response headers. Detection is **evidence-based and conservative**: a tool is only reported on a clear signal, so you get a low-false-positive stack instead of a wall of guesses. Precision over recall — consent-gated, server-side-only or first-party-proxied tools may stay invisible, same as with every client-side technographics scanner.

#### Categories covered

- **CMS / builders:** WordPress, Shopify, Wix, Webflow, Squarespace, Drupal, Ghost, HubSpot CMS, Contentful, Sanity…
- **Frameworks:** React, Vue, Angular, Next.js, Nuxt, Svelte, Gatsby…
- **Analytics:** GA4/UA, GTM, Segment, Mixpanel, Amplitude, Hotjar, Plausible, PostHog…
- **Ad pixels:** Google Ads, Meta, LinkedIn, TikTok, X, Pinterest, Snap, Bing UET, Reddit…
- **Payments:** Stripe, PayPal, Braintree, Square, Adyen, Klarna, Razorpay…
- **Chat:** Intercom, Drift, Zendesk, Crisp, Tawk.to, Gorgias…
- **Marketing:** Klaviyo, Mailchimp, HubSpot, Marketo, ActiveCampaign, Braze…
- **Ecommerce:** WooCommerce, Magento, BigCommerce, PrestaShop, Salesforce Commerce…
- **CDN / hosting:** Cloudflare, Fastly, CloudFront, Akamai, Vercel, Netlify, WP Engine…

### Input and output

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

`domains` (required) accepts bare domains or URLs. `maxConcurrency` up to 20. `fetchExtraPage: true` (default) meaningfully improves recall for payments and chat, which often load only off-homepage.

```json
{
  "domain": "shopify.com",
  "technologies": [
    { "name": "Cloudflare", "category": "cdnHosting" },
    { "name": "Google Analytics (GA4)", "category": "analytics" },
    { "name": "React", "category": "frameworks" },
    { "name": "Shopify", "category": "cms" }
  ],
  "categoriesSummary": {
    "cms": "Shopify",
    "frameworks": ["React"],
    "analytics": ["Google Analytics (GA4)", "Google Tag Manager"],
    "cdnHosting": ["Cloudflare"]
  },
  "techCount": 5,
  "hasEcommerce": true,
  "hasPaidAds": false,
  "sophisticationTier": "growing"
}
```

Ships with a ready table view (domain, tier, tech count, ecommerce, paid ads, CMS) and exports to CSV, Excel, JSON or API — schema-stable and easy for an LLM agent to consume.

### Technographic plays that actually close deals

- **Platform-specific selling** — filter `cms = "Shopify"` to find every Shopify store in your list; pitch your app/agency service only to them.
- **Displacement** — filter `technologies` for Intercom, Mailchimp or Marketo and pitch your alternative to accounts already paying for the category.
- **Spend qualification** — `hasPaidAds: true` means a live ad pixel: the company already buys acquisition. Warm signal for ads/analytics/landing-page tools.
- **Routing by maturity** — `sophisticationTier` (`basic` / `growing` / `advanced`) sends enterprise-y stacks to sales, thin stacks to self-serve.
- **Buying-signal monitoring** — schedule a weekly re-scan of a watchlist and diff: a prospect adding Stripe or a Meta Pixel is a timing trigger.

Downstream, spend contact credits only on accounts that pass the tech filter: [Company Enrichment](https://apify.com/renzomacar/company-enrichment) for firmographics and decision-makers, [Website Contact Finder](https://apify.com/renzomacar/website-contact-finder) for emails and phones.

### FAQ

**How do I check what technology a website uses in bulk?**
Paste your domain list into this Actor and run — each domain returns a structured technology profile in one dataset. No extension, no per-site manual lookups.

**Do I need a BuiltWith or Wappalyzer API key?**
No. Detection is fully self-contained; you only need an Apify account.

**Why does a big site show only a few technologies?**
Sophisticated sites proxy scripts through first-party domains, gate tags behind consent, or keep tools server-side — invisible to any client-side scanner. We flag only what's confidently visible; `fetchExtraPage` usually surfaces more.

**Can I find all sites using a specific tool, like Klaviyo?**
Yes — run your list, then filter the dataset where `technologies` contains Klaviyo (or Stripe, Intercom, Shopify…). The filtered set is your target list.

**How accurate is it?**
Precision-first: a technology is reported only on clear evidence (script URLs, cookies, headers, markup). Expect very few false positives; the trade-off is that hidden tools can be missed — true of BuiltWith and Wappalyzer as well.

**What does a 1,000-domain scan cost?**
$20 ($0.02 each), billed only for successfully enriched domains. No monthly fee.

**Does it get blocked?**
Requests route through Apify residential proxies with rotation and retry on transient failures, which clears most datacenter blocks. Keep concurrency modest on very large lists.

**Can I automate it end to end?**
Yes — schedule re-scans in Apify Console and push the dataset to Sheets, Slack, a webhook or your CRM; chain it between a domain source and the enrichment/contact Actors for a hands-off technographic pipeline.

***

*Detection is signal-based and best-effort. Not affiliated with BuiltWith, Wappalyzer, or any detected technology.*

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,renzomacar/tech-stack-enricher"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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