# Tech Stack Detector - Bulk BuiltWith & Wappalyzer Alternative (`lost.fany/website-tech-stack-detector`) Actor

Detect what any website is built with: CMS, ecommerce, JavaScript frameworks, analytics, tag managers, CDN, hosting, payments and 100+ categories, with versions and evidence. dryRun prices a run before you pay; charged only for sites analysed.

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

## Pricing

from $4.30 / 1,000 site analyzeds

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

## Tech Stack Detector - Bulk BuiltWith & Wappalyzer Alternative

Find out **what any website is built with** — CMS, ecommerce platform, JavaScript frameworks and libraries, analytics and tag managers, marketing and chat tools, CDN, hosting, web server, programming language, fonts, payment providers and 100+ other categories. Feed it one domain or ten thousand; each site comes back as one row with the detected technologies, their categories, versions where visible, a confidence score and the evidence used.

A drop-in alternative to Wappalyzer / BuiltWith lookups at a fraction of the price: the Actor downloads one page per site and matches it against the open-source **webappanalyzer** fingerprint database (the community-maintained successor of Wappalyzer's open rules, 3,000+ technologies, refreshed daily). No browser, no API keys.

### What you can do with it

- **Lead lists by technology** — "all Shopify stores in my CRM export", "agencies still on WordPress 5.x", "sites using Intercom but not HubSpot".
- **Competitor and market research** — what stacks do the top 500 sites in a niche use; share of Next.js vs Nuxt; which analytics tools dominate.
- **Sales enrichment** — add `technologies` to every account before outreach; trigger sequences on a tech change.
- **Migration and security audits** — spot outdated CMS or library versions across a portfolio of client sites.
- **AI agents** — let an agent answer "what is example.com built with?" through the Apify MCP server.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `websites` | array | — | Domains or URLs, one per line. |
| `maxConcurrency` | number | `10` | Parallel fetches. |
| `requestTimeoutSecs` | number | `20` | Per-site timeout. |
| `minConfidence` | number | `0` | Drop weak matches below this confidence (0–100). |
| `includeTechnologyDetails` | boolean | `true` | Keep the detailed `technologies` array. |
| `maxItems` | number | `10000` | Cap on websites. |
| `proxyConfiguration` | object | off | Enable Apify Proxy if sites block datacenter IPs. |

```json
{ "websites": ["apify.com", "wordpress.org", "shopify.com", "https://github.com"], "maxConcurrency": 10 }
```

### Output

```json
{
  "url": "https://wordpress.org",
  "finalUrl": "https://wordpress.org/",
  "domain": "wordpress.org",
  "status": 200,
  "title": "Blog Tool, Publishing Platform, and CMS – WordPress.org",
  "technologies": [
    { "name": "WordPress", "categories": ["CMS", "Blogs"], "version": "6.7", "confidence": 100, "website": "https://wordpress.org", "detectedBy": ["meta", "html", "dom"] },
    { "name": "PHP", "categories": ["Programming languages"], "version": null, "confidence": 100, "website": "http://php.net", "detectedBy": ["implied by WordPress"] },
    { "name": "jQuery", "categories": ["JavaScript libraries"], "version": "3.7.1", "confidence": 100, "website": "https://jquery.com", "detectedBy": ["script"] }
  ],
  "technologyNames": ["WordPress", "PHP", "jQuery", "MySQL", "Nginx"],
  "byCategory": { "CMS": ["WordPress"], "Programming languages": ["PHP"], "JavaScript libraries": ["jQuery"], "Databases": ["MySQL"], "Web servers": ["Nginx"] },
  "server": "nginx",
  "poweredBy": null,
  "generator": "WordPress 6.7",
  "techCount": 5,
  "error": null,
  "scrapedAt": "2026-09-10T16:20:11Z"
}
```

Sites that cannot be fetched are returned with `error` filled in and are **not charged**.

### How detection works

For each site the Actor requests the home page once (following redirects, falling back to `http://` if `https://` fails) and checks the HTML source, `<script src>` URLs, `<meta>` tags, response headers, cookies and the final URL against every fingerprint. Rules can imply other technologies (WordPress → PHP, MySQL) or exclude them; confidence adds up when several hints agree. Because there is no browser, technologies that reveal themselves only through JavaScript globals or network calls after page load may be missed — that is the trade-off for speed and price. Enable the proxy option if a site returns a bot challenge instead of the page.

### Use cases

Ready-made examples you can run without configuring anything:

- [Bulk CMS detector for a domain list](https://apify.com/lost.fany/website-tech-stack-detector/examples/bulk-cms-detector) — ready-made task, run it as is
- [BuiltWith alternative without a subscription](https://apify.com/lost.fany/website-tech-stack-detector/examples/builtwith-alternative) — ready-made task, run it as is

#### Bulk CMS detector for a domain list

Feed ten thousand domains and get the CMS, ecommerce platform and page builder for each, with confidence and the evidence behind the call.

```json
{ "websites": ["example.com", "shop.example.org"] }
```

#### BuiltWith alternative without a subscription

The same question — what is this site built with — answered per run instead of per seat, with no monthly minimum.

```json
{ "websites": ["example.com"] }
```

#### Wappalyzer alternative at scale

Open fingerprints, 100+ categories, versions where the site exposes them, and a row per site instead of a browser extension.

```json
{ "websites": ["example.com"], "includeTechnologyDetails": true }
```

### Pricing

Pay per event: a small fee per Actor start plus a fee per successfully analyzed site. Failed fetches are free. Current prices are in the **Pricing** tab.

### Use with AI agents (MCP)

Add the Actor to the [Apify MCP server](https://apify.com/apify/actors-mcp-server) and ask "What is competitor.com built with?" — tool input `{ "websites": ["competitor.com"] }`.

### Credits and licence

Fingerprints come from the [webappanalyzer](https://github.com/enthec/webappanalyzer) project (GPL-3.0) and are loaded from its repository at run time; this Actor contributes no rules and is not affiliated with Wappalyzer or BuiltWith. Detection is best-effort and may be incomplete or wrong for heavily customized sites.

### Related Actors

- [Sitemap URL Extractor](https://apify.com/lost.fany/sitemap-url-extractor)
- [Bulk URL Status Checker](https://apify.com/lost.fany/bulk-url-status-checker)
- [SEC EDGAR API](https://apify.com/lost.fany/sec-edgar-filings)

### Cost control

Pay per event only works if you can see the bill before you pay it:

- Set `dryRun` to count every result and print what a full run would cost - nothing is charged, and only a few sample rows are stored.
- You are charged only for rows actually delivered to the dataset; a run that finds nothing costs nothing beyond the start event.
- `maxItems` is respected exactly, and the run stops before the platform's Max total charge for the run.
- Every run writes a `COST` record to the key-value store: chargeable events, charged events, the amount in USD and whether a limit was hit.

# Actor input Schema

## `websites` (type: `array`):

Domains or URLs, one per line (example.com, https://shop.example.com/). Thousands are fine.

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

How many sites to fetch in parallel.

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

Per-site timeout for downloading the home page.

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

Drop technologies detected with lower confidence (0–100). 0 keeps everything, including weak single-hint matches.

## `includeTechnologyDetails` (type: `boolean`):

Keep the `technologies` array (categories, version, confidence, evidence). Off = only names and byCategory, a smaller dataset.

## `maxItems` (type: `integer`):

Stop after this many websites.

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

Optional. Enable Apify Proxy if target sites block datacenter IPs (Cloudflare challenges, 403s).

## `dryRun` (type: `boolean`):

Count every result and show what a full run would cost, without charging for it. Only a few sample rows are stored. Use it to check the price before you pay.

## Actor input object example

```json
{
  "websites": [
    "apify.com",
    "wordpress.org",
    "shopify.com",
    "github.com"
  ],
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20,
  "minConfidence": 0,
  "includeTechnologyDetails": true,
  "maxItems": 10000,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "dryRun": false
}
```

# Actor output Schema

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

One item per website: detected technologies with categories, versions, confidence and evidence; server, generator, status.

## `summary` (type: `string`):

Counts and errors of the run.

# 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 = {
    "websites": [
        "apify.com",
        "wordpress.org",
        "shopify.com",
        "github.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lost.fany/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 = { "websites": [
        "apify.com",
        "wordpress.org",
        "shopify.com",
        "github.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lost.fany/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 '{
  "websites": [
    "apify.com",
    "wordpress.org",
    "shopify.com",
    "github.com"
  ]
}' |
apify call lost.fany/website-tech-stack-detector --silent --output-dataset

```

## MCP server setup

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