# Website Tech Stack Detector (`subimpact/website-tech-stack-detector`) Actor

Find the stack behind any website: CMS, ecommerce platform, CDN, analytics and 3,500+ more fingerprints, with versions and per-hit evidence. From $1.00 per 1,000 domains, platform usage included.

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

## Pricing

from $0.70 / 1,000 analysed domains

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?

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

## Website Tech Stack Detector

Find out what a website is built with, one row per domain: CMS, ecommerce platform, CDN, analytics, tag managers, payment providers, hosting, JavaScript frameworks and more. Every detection carries a confidence score and, unless you turn it off, the exact evidence behind it (the response header, cookie, script URL, meta tag or HTML snippet).

3,588 fingerprint technologies from the MIT-licensed Wappalyzer 6.10.54 snapshot, plus 25 clean-room rules we wrote ourselves for things that snapshot misses, such as Payload CMS and Fastly.

### What it does

- Fetches one page per domain over plain HTTP, with no browser, so it is fast and cheap.
- Reads every response header (including 103 Early Hints and redirect hops), cookies, meta tags, script URLs, inline scripts, raw HTML, the final URL and static CSS selectors.
- Reports versions where the page exposes them (WordPress 7.1.5, WooCommerce 11.4.0, Magento 2, jQuery 3.5.1, Sentry 7.120.3).
- Marks dead, parked, expired, off-site and blocked domains with a `siteState` instead of guessing, and never charges for them.
- Optionally reads up to two more pages per domain (shop, blog, about, contact) when the homepage is thin.

### Input

```json
{
  "domains": ["allbirds.com", "https://woocommerce.com/", "vercel.com", "coxandcox.co.uk"],
  "maxPagesPerDomain": 1,
  "includeEvidence": true,
  "includeFeatures": false,
  "minConfidence": 50,
  "maxDomains": 100
}
```

| Field | Type | Default | Notes |
|---|---|---|---|
| `domains` | list | `allbirds.com`, `webflow.com` | Bare domains or full URLs. Only the host is used, so `example.com` and `www.example.com` are one row. One unreadable entry becomes its own uncharged error row and the run continues. |
| `maxPagesPerDomain` | number | `1` | 1 to 3. Extra pages are picked from same-site shop, blog, about or contact links and fetched one second apart. |
| `maxDomains` | number | `100` | Global cap. Domains past the cap are not fetched and not charged. |
| `minConfidence` | number | `50` | 0 to 100. The default already drops detections that come only from a Content-Security-Policy allow-list. |
| `includeEvidence` | boolean | `true` | Turn it off to make rows smaller. |
| `includeFeatures` | boolean | `false` | Adds HSTS, HTTP/2, HTTP/3, Open Graph, PWA and RSS to a separate `features` list. They never count as technologies. |
| `proxyConfiguration` | object | empty | Optional. Most sites answer a plain request from Apify's servers. See Limits. |

### Output

One dataset item per domain, written as soon as that domain is analysed. This is a real row from coxandcox.co.uk, trimmed to two of its fourteen technologies:

```json
{
  "domain": "coxandcox.co.uk",
  "inputUrl": "https://www.coxandcox.co.uk/",
  "finalUrl": "https://www.coxandcox.co.uk/",
  "statusCode": 200,
  "siteState": "ok",
  "pagesFetched": 1,
  "technologies": [
    {
      "name": "Magento",
      "slug": "magento",
      "category": "Ecommerce",
      "categories": ["Ecommerce"],
      "version": "2",
      "confidence": 100,
      "evidence": ["type=\"text/x-magento-init\"", "/static/version1794967550/frontend/"],
      "source": "subimpact-rules",
      "website": "https://business.adobe.com/products/magento/magento-commerce.html"
    },
    {
      "name": "Fastly",
      "slug": "fastly",
      "category": "CDN",
      "categories": ["CDN"],
      "version": null,
      "confidence": 100,
      "evidence": ["header x-served-by: cache-lhr-egwu1540075-LHR", "header x-timer: S1795083700.670329,VS0,VE3281"],
      "source": "subimpact-rules",
      "website": "https://www.fastly.com"
    }
  ],
  "technologyCount": 14,
  "categories": {"Ecommerce": ["Magento"], "CDN": ["Fastly"]},
  "cms": null,
  "ecommerce": "Magento",
  "cdn": ["Fastly"],
  "analytics": [],
  "features": [],
  "fingerprintDatasetVersion": "wappalyzer-mit-6.10.54+subimpact-2026.11",
  "checkedAt": "2026-11-20T04:50:14Z",
  "error": null
}
```

`cms`, `ecommerce`, `cdn` and `analytics` are convenience columns for CSV users. `siteState` is one of `ok`, `redirected-offsite`, `expired`, `parked`, `blocked`, `dns-error`, `timeout` or `http-error`. Rows that are not `ok`, and rows with no technology, are never charged.

### Pricing

- **$0.001 per analysed domain** ($1.00 per 1,000 domains), platform usage included.
- **$0.0004 per extra page** when `maxPagesPerDomain` is 2 or 3.
- No start fee. A default run with the two prefilled domains costs $0.002.

You are only charged for a domain that answered, was analysed and produced at least one technology. Blocked, dead, timed-out, expired and empty domains produce a row with `error` or a `siteState` and cost nothing.

### How this compares

Free-plan list prices on the Apify Store, read on 2026-11-20. This actor includes platform usage in its price; for competitors' usage terms, see each listing.

| Actor | Price | What you get |
|---|---|---|
| **this actor** | **$0.001 per domain, usage included, no start fee** | 3,588 technologies plus clean-room rules, versions, confidence, per-hit evidence, live fetch |
| `builtwith/builtwith-official-technology-scraper` | $0.002 per item ($2.00 per 1,000) | BuiltWith's crawl database, not a live fetch, so it also shows DNS and NS records. No version, confidence or evidence |
| `rl1987/wappalyzer-tech-lookup` | from $0.63 per 1,000 rows, one row per technology (roughly $6 or more per 1,000 domains) | Wappalyzer API results, defaults to a residential proxy |
| `scrapemint/website-tech-stack-detector` | $0.01 per detection row ($10 per 1,000) | Live fetch with about 100 rules |
| `motivational_nickel/website-technology-detector` | $0.0015 per item plus $0.002 per start | Live fetch |
| `automation-lab/tech-stack-detector` | $0.0023 per URL plus $0.035 per start | "85+ technologies" |
| `apivault_labs/tech-stack-lookup` | $0.003 per item | Live fetch |
| `misterkhan/website-tech-stack-scanner` | $0.10 per item | Live fetch |

Our price is half the lane leader's. The small live-fetch actors advertise about 85 to 100 rules; this one runs 3,588 fingerprints plus 25 clean-room rules, and it publishes the evidence behind every hit, which BuiltWith does not.

### Limits

- **Plain HTTP, no JavaScript.** The headline platform (CMS, ecommerce, CDN) came from plain HTTP on every reachable homepage we tested. What we cannot see: tags injected later by a tag manager (for example a pixel that only exists inside a Google Tag Manager container), 382 fingerprints that only expose a JavaScript global or an XHR endpoint, and versions that only exist as a JS global.
- **One to three pages per domain.** A homepage has the platform; `/shop` or `/blog` occasionally adds a widget. We do not crawl further.
- **DNS is not visible.** BuiltWith shows NS and DNS records (Route 53, Cloudflare DNS) from its own crawler. We read the response.
- **Some sites block datacenter IPs.** In our fixture set 1 of 11 domains refused a datacenter IP (an Akamai-style reset followed by a timeout). Those rows come back as `siteState: blocked` and are not charged. If you hit them often, add a proxy in the input; residential traffic is billed separately by Apify and can cost more than the run.
- **The fingerprint snapshot is from January 2023** plus our own rules for the products that matter most. New products released after 2023 are only covered once we add a rule.
- **Expired and parked pages** are reported from headers only, because the page body is not the buyer's site.

### Responsible use

The actor fetches the public homepage of each domain you give it, plus at most two same-site pages, one second apart. That is normal browser-like traffic. Please keep it that way: do not point it at systems you are not allowed to query, and keep `maxDomains` in line with the sites you actually need. It does not log in, fill in forms or bypass access controls.

### Data licence

Fingerprint data: Wappalyzer 6.10.54, MIT licence as declared in the package.json of that npm release, vendored unmodified with a NOTICE file. Additional rules are our own, written from vendor documentation and response headers we observed ourselves.

# Actor input Schema

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

Websites to analyse. Bare domains (allbirds.com) or full URLs (https://www.coxandcox.co.uk/) both work. Only the host is used for de-duplication: one row per domain. One unreadable entry costs only that entry, never the run.

## `maxPagesPerDomain` (type: `integer`):

How many pages to read per domain (1-3). 1 = the homepage only, which finds the platform for almost every site. 2 or 3 adds same-site /shop, /products, /collections, /blog, /about or /contact pages, fetched one second apart, and each extra page is charged $0.0004.

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

Drop detections below this confidence (0-100). The default of 50 already removes hits that come only from a Content-Security-Policy allow-list, because an allow-list is not usage.

## `includeEvidence` (type: `boolean`):

Adds the header, cookie, script URL, meta tag or HTML snippet behind each detection. Turn it off to shrink rows.

## `includeFeatures` (type: `boolean`):

Also report generic protocol facts (HSTS, HTTP/2, HTTP/3, Open Graph, PWA, RSS) in a separate features list. They are never counted as technologies.

## `maxDomains` (type: `integer`):

Global cap on domains fetched in one run (1-100000). Bill-shock guard: anything past the cap is not fetched and not charged.

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

Optional. Most sites answer a plain request from Apify's servers, so no proxy is the cheapest and fastest choice. Add a proxy only for domains that block datacenter IPs: those rows come back with siteState "blocked" and are not charged. Residential traffic is billed separately by Apify and can cost more than the run itself.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com",
    "webflow.com"
  ],
  "maxPagesPerDomain": 1,
  "minConfidence": 50,
  "includeEvidence": true,
  "includeFeatures": false,
  "maxDomains": 100
}
```

# Actor output Schema

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

One dataset item per domain, in the order the domains finished: domain, siteState, technologies with version and evidence, cms, ecommerce, cdn and analytics columns.

# 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": [
        "allbirds.com",
        "webflow.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/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 = { "domains": [
        "allbirds.com",
        "webflow.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("subimpact/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 '{
  "domains": [
    "allbirds.com",
    "webflow.com"
  ]
}' |
apify call subimpact/website-tech-stack-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,subimpact/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/RW5Y7GA53Rh9M8Gh5/builds/uhv5OU1jnslwdVZrb/openapi.json
