# Tech Stack Detector - Wappalyzer & BuiltWith Alternative (`kantolabs/website-tech-stack-detector`) Actor

Find what any website is built with: CMS, ecommerce platform, analytics, tag managers, JS frameworks, CDN, hosting and payments. 7,600+ technologies with versions and confidence. Bulk domains in, clean JSON/CSV out. $3 per 1,000 sites, failed URLs are free.

- **URL**: https://apify.com/kantolabs/website-tech-stack-detector.md
- **Developed by:** [Kanto Labs](https://apify.com/kantolabs) (community)
- **Categories:** Developer tools, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 url analyzeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Tech Stack Detector - find what any website is built with

**Paste a list of domains, get each site's technology stack back as clean JSON, CSV or Excel:** CMS,
ecommerce platform, analytics, tag managers, JavaScript frameworks, UI libraries, CDN, hosting, web
server, payment and marketing tools - with versions and a confidence score for each detection.

- **7,600+ technologies** recognized, using the open Wappalyzer-format fingerprint database
- **$3 per 1,000 websites** ($0.003 each) - no subscription, no API key, no monthly minimum
- **Unreachable websites are free** - you are only charged for sites that were actually analyzed
- **Bulk-friendly**: thousands of domains per run, 10 in parallel by default, one row per site

A Wappalyzer and BuiltWith alternative for people who need the data in bulk, in a spreadsheet or
behind an API, without a browser extension or a per-seat plan.

### What does Tech Stack Detector do?

For each domain or URL you give it, the actor loads the page once (like a browser visiting it),
checks the response against 7,600+ technology fingerprints, and returns:

- the **list of technologies** found, grouped by **category** (CMS, Ecommerce, Analytics, CDN, ...)
- the **version** of each technology when the site exposes it (for example `WordPress 7.2`)
- a **confidence score** (0-100) and **which signals** matched (headers, cookies, meta, script URLs, DOM)
- the site's HTTP status, final URL after redirects, page title, web server and response time
- the technology's **CPE identifier** when one exists, for matching against vulnerability databases

### Use cases

- **Lead generation** - find every Shopify, WooCommerce, Magento or HubSpot site in a list of prospects.
- **Sales intelligence** - see which analytics, chat, CRM or payment tool a prospect already uses before the call.
- **Lead scoring and CRM enrichment** - add a `technologies` column to company domains in HubSpot, Salesforce, Clay or a spreadsheet.
- **Competitor research** - compare the stacks of the top sites in your niche.
- **Market research** - count how many sites in a sample use a given CMS, framework or tool.
- **Security and IT audits** - spot outdated CMS or JavaScript library versions across a portfolio of sites.
- **Agency prospecting** - find sites on an old platform that are candidates for a migration project.

### How to use it

1. Click **Try for free**.
2. Paste your domains or URLs into **Websites**, one per line (`example.com` works, so does a full URL).
3. Click **Start**. Each site takes about as long as its page takes to load (2.1 s for shopify.com in the example below), with 10 sites fetched in parallel.
4. Download the results as **JSON, CSV, Excel or HTML**, or read them through the API.

#### Input example

```json
{
    "urls": ["https://www.shopify.com", "wordpress.org/news", "https://www.bbc.com"],
    "minConfidence": 50
}
```

| Field | What it does | Default |
|---|---|---|
| `urls` | Domains or URLs, one per line. Strings or `{"url": "..."}` objects both work. | three example sites |
| `minConfidence` | Hide weak single-signal guesses below this confidence (0-100). `0` returns everything. | `50` |
| `includeDescriptions` | Add a one-paragraph description of each technology | `false` |
| `maxConcurrency` | Websites fetched in parallel | `10` |
| `requestTimeoutSecs` | Give up on a website that does not answer in time (not charged) | `20` |
| `proxyConfiguration` | Optional Apify Proxy for sites that block datacenter traffic | off |

### Output example

One dataset item per website. This is real output from a cloud run of this actor
(the `technologies` array is trimmed to 2 of its 8 entries):

```json
{
    "inputUrl": "https://www.shopify.com",
    "url": "https://www.shopify.com",
    "domain": "www.shopify.com",
    "statusCode": 200,
    "title": "Shopify: The All-in-One Commerce Platform for Businesses - Shopify",
    "server": "cloudflare",
    "technologyCount": 8,
    "technologyNames": ["Cart Functionality", "Cloudflare", "HSTS", "HTTP/3", "Open Graph",
                        "Priority Hints", "Shopify", "Tailwind CSS"],
    "categories": {
        "CDN": ["Cloudflare"],
        "CMS": ["Shopify"],
        "Ecommerce": ["Cart Functionality", "Shopify"],
        "Miscellaneous": ["HTTP/3", "Open Graph"],
        "Performance": ["Priority Hints"],
        "Security": ["HSTS"],
        "UI frameworks": ["Tailwind CSS"]
    },
    "technologies": [
        {
            "name": "Cart Functionality",
            "version": null,
            "confidence": 100,
            "categories": ["Ecommerce"],
            "website": "https://www.wappalyzer.com/technologies/ecommerce/cart-functionality",
            "cpe": null,
            "detectedBy": ["dom"]
        },
        {
            "name": "Cloudflare",
            "version": null,
            "confidence": 100,
            "categories": ["CDN"],
            "website": "https://www.cloudflare.com",
            "cpe": null,
            "detectedBy": ["headers"]
        }
    ],
    "responseTimeMs": 2108,
    "error": null
}
```

In a test run, `wordpress.org/news` returned 12 technologies, including `WordPress` with
version `7.2`, `PHP`, `MySQL`, `Nginx` and `Google Tag Manager`.

In CSV/Excel exports, `technologyNames` gives you one flat, filterable column per site.
A site that cannot be reached is still listed, with the reason in `error`.

### How much does it cost?

**$3 per 1,000 analyzed websites** ($0.003 per site), pay-per-event. Apify platform compute is
included in that price, so the per-site fee is what you pay. There is also a one-off start fee of
$0.00005 per GB of run memory (the default 1 GB run = $0.00005 per run).

| You analyze | You pay |
|---|---|
| 1 website | $0.003 |
| 100 websites | $0.30 |
| 1,000 websites | $3.00 |
| 25,000 websites | $75.00 |

**What is free:** websites that cannot be reached at all - DNS failure, timeout, refused connection,
TLS error. Those rows are returned with an `error` message and cost nothing. A site that does answer
(even with a 403 or a bot-check page) is analyzed and charged once; its `statusCode` tells you what it
returned.

**Cost cap:** set *Maximum cost per run* in the run options and the actor stops cleanly when it is
reached, so a large list can never cost more than you decided. Apify's free plan includes monthly
platform credit you can use to try it.

### How it compares

| | This actor | Browser extensions | Headless-browser scanners |
|---|---|---|---|
| Bulk lists (1,000s of domains) | Yes | One tab at a time | Yes |
| Output | JSON, CSV, Excel, API | On-screen | Varies |
| Speed per site | One HTTP request | Page load | Full page render |
| Technologies that only appear after JavaScript runs | Not detected | Detected | Detected |
| Compute per site | Lowest (no browser) | Your own browser | Higher (a browser renders every page) |

Pick this actor when you want **breadth and a low per-site price**. If you need trackers that only load
after a user interaction, a browser-based scanner will see more.

### How it works

The actor makes **one ordinary HTTP GET request** per site and matches the response against the
fingerprint database:

| Signal | Example |
|---|---|
| HTTP headers | `server: cloudflare`, `x-shopify-stage` |
| Cookies | `_shopify_y`, `_ga`, `wp-settings` |
| Meta tags | `<meta name="generator" content="WordPress 6.5">` |
| Script URLs | `googletagmanager.com/gtag/js`, `/wp-includes/` |
| Inline scripts and CSS | framework markers, tracking snippets |
| HTML and DOM selectors | `link[href*="/wp-content/"]`, `div[data-reactroot]` |
| Implied technologies | WordPress implies PHP and MySQL |

### Integrations and API

- **API**: `POST https://api.apify.com/v2/acts/kantolabs~website-tech-stack-detector/run-sync-get-dataset-items?token=YOUR_TOKEN`
  with the input JSON as the body returns the results in one call. Python and JavaScript clients: `apify-client`.
- **AI agents (MCP)**: available through the Apify MCP server, so Claude, ChatGPT, Cursor or any MCP client can ask "what is example.com built with?".
- **No-code**: Make, Zapier, n8n, Google Sheets, webhooks and scheduled runs work out of the box.

### FAQ

**Which technologies can it detect?**
7,600+ from the Wappalyzer-format database: CMS (WordPress, Drupal, Webflow, Wix...), ecommerce
(Shopify, WooCommerce, Magento, BigCommerce...), analytics and tag managers, JavaScript frameworks,
CDNs, hosting providers, web servers, payment providers, marketing automation, chat widgets and more.

**How accurate is it?**
Technologies that leave a trace in the page the server sends - CMS, ecommerce platform, CDN, web
server, tag manager, analytics loaded from a script URL - are detected reliably. Libraries that only
appear after JavaScript runs in a browser are not reported. `minConfidence` lets you trade recall for
precision.

**Do I pay for sites that fail?**
No. Unreachable sites (DNS error, timeout, refused connection) are returned with an `error` and are
not charged. Only sites that were actually analyzed count.

**Can I pass `{"url": "..."}` objects instead of strings?**
Yes. Both `["example.com"]` and `[{"url": "https://example.com"}]` are accepted.

**Is it legal to use?**
The actor makes one normal page request per site and reads only publicly served markup and headers,
the same as any browser visit. It collects no personal data. You are responsible for how you use the
results.

**Where does the fingerprint data come from?**
From the open-source [wappalyzergo](https://github.com/projectdiscovery/wappalyzergo) project (MIT
licence), which maintains the Wappalyzer-format technology database. The actor's copy is refreshed
from that project periodically.

**Something is missing or wrong?**
Open an issue on the **Issues** tab with the URL and what you expected.

# Actor input Schema

## `urls` (type: `array`):

Domains or full URLs to analyze, one per line. `example.com` and `https://example.com/pricing` both work. Duplicates are removed.

## `minConfidence` (type: `integer`):

Only report technologies detected with at least this confidence. 50 removes most weak single-signal guesses; 0 returns everything.

## `includeDescriptions` (type: `boolean`):

Add a one-paragraph description of each detected technology (makes the output larger).

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

How many websites are fetched in parallel.

## `requestTimeoutSecs` (type: `integer`):

Give up on a website that does not respond within this time. Failed websites are not charged.

## `proxyConfiguration` (type: `object`):

Optional. Route requests through Apify Proxy if some websites block datacenter traffic.

## Actor input object example

```json
{
  "urls": [
    "https://www.shopify.com",
    "wordpress.org/news",
    "https://www.bbc.com"
  ],
  "minConfidence": 50,
  "includeDescriptions": false,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "urls": [
        "https://www.shopify.com",
        "wordpress.org/news",
        "https://www.bbc.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kantolabs/website-tech-stack-detector").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 = {
    "urls": [
        "https://www.shopify.com",
        "wordpress.org/news",
        "https://www.bbc.com",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kantolabs/website-tech-stack-detector").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 '{
  "urls": [
    "https://www.shopify.com",
    "wordpress.org/news",
    "https://www.bbc.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kantolabs/website-tech-stack-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kantolabs/website-tech-stack-detector"
        }
    }
}
```

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/Y0DoZXDHAxMi26edH/builds/KbgApnjM0JwcxdWUL/openapi.json