# Bulk Website Tech Stack Detector (7,000+ technologies) (`lindenbyte/bulk-website-tech-stack-detector`) Actor

Detect the technologies behind any list of websites (CMS, ecommerce platform, analytics, CDN, frameworks, versions) with ~7,700 open-source fingerprints, no browser. Schedule 'changes' mode to see which technologies each site added or dropped since the last run.

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

## Pricing

Pay per event

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

## Bulk Website Tech Stack Detector: 7,700 technologies, no browser, with change tracking

Paste a list of domains and get the **technology stack of every website** as clean spreadsheet-ready rows: CMS, ecommerce platform, analytics, tag managers, CDN, web server, frameworks, payment providers, chat widgets, marketing tools, with **versions** and a **confidence score**. Matching uses about **7,700 open-source fingerprints** (the community webappanalyzer set, a fork of the Wappalyzer rules) and runs on plain HTTP: no browser, fast and cheap.

Then switch to **changes mode** and schedule it: each run tells you which technologies each site **added or dropped** since the last run (for example "just installed Shopify", "removed Intercom", "jQuery 3.5 to 3.7"). That is a ready-made trigger for lead generation, competitor monitoring and agency prospecting.

### Use cases

- **Lead generation**: find every store on Shopify, WooCommerce or Magento, every site running HubSpot, Klaviyo or Stripe, from a list of prospects.
- **Sales triggers**: be told when a prospect adds or removes a tool you sell against or integrate with.
- **Competitor monitoring**: watch which analytics, payment, chat and marketing tools competitors adopt.
- **Agency and SEO audits**: bulk-check CMS, outdated library versions and tracking setup across client sites.
- **Market research**: market share of platforms inside a segment, built from your own domain list.
- **Security hygiene**: spot visible outdated versions (server, CMS, jQuery) on your own portfolio.

### Input

| Field | What it does |
|---|---|
| `urls` | Domains (`example.com`) or URLs. One analysis per domain, duplicates removed |
| `mode` | `detect` (default) or `changes` (adds added / removed / version changes since the last run) |
| `includeCategories` | Optional: keep only these categories, e.g. `CMS`, `Ecommerce`, `Analytics`, `CDN` |
| `stateKey` | Name of the monitor for `changes` mode; different names keep separate memories |
| `concurrency` | Sites analysed in parallel (default 5) |
| `requestTimeoutSecs` | Per-site timeout (default 25) |

#### Example: weekly competitor tech watch

```json
{
  "urls": ["competitor-a.com", "competitor-b.com", "https://competitor-c.com"],
  "mode": "changes",
  "includeCategories": ["Ecommerce", "Analytics", "Marketing automation", "Payment processors"]
}
```

Create a schedule (Console > Schedules) and connect an integration (email, Slack, webhook) to receive the rows where `hasChanges` is true.

### Output

One row per domain (real example, filtered to three categories):

```json
{
  "domain": "wordpress.org",
  "url": "https://wordpress.org/",
  "finalUrl": "https://wordpress.org/",
  "status": "ok",
  "httpStatus": 200,
  "technologies": [
    { "name": "MySQL", "categories": ["Databases"], "version": null, "confidence": 100, "website": "https://mysql.com" },
    { "name": "PHP", "categories": ["Programming languages"], "version": null, "confidence": 100, "website": "https://php.net" },
    { "name": "WordPress", "categories": ["CMS", "Blogs"], "version": null, "confidence": 100, "website": "https://wordpress.org" }
  ],
  "techCount": 3,
  "analyzedAt": "2026-11-13T20:09:25.650Z"
}
```

In `changes` mode each row also has `baseline` (true on the first run for that domain), `added`, `removed` (technology names), `versionChanged` (`{name, from, to}`), `hasChanges` and `previousCheck`. Sites that fail (DNS error, timeout, HTTP 4xx/5xx, empty page) appear as `status: "error"` with the reason and are **not charged**. A run summary is saved to the key-value store record `SUMMARY`.

### Pricing

**Pay per site analysed**: you pay for each website that was successfully fetched and analysed (also in changes mode), plus a small start fee per run. Failed sites are free. Set a max charge per run in the run options to cap your spend.

### How detection works, and its limits (honest)

- The Actor downloads each page **once** (HTML, response headers, cookies) and matches it against the fingerprints: HTML patterns, response headers, cookies, script URLs, inline scripts, meta tags, URL patterns, page text and CSS selectors, plus "implies", "excludes" and "requires" rules and version extraction.
- **No JavaScript is executed.** Fingerprints that need a real browser (JavaScript globals such as `window.Shopify`, network requests made after load, DNS records, TLS data) are **not evaluated**. Technologies that only reveal themselves that way can be missed, and sites that render everything client-side (some SPAs) show fewer technologies than a browser-based tool would find.
- Only the page you give is analysed (the homepage for a bare domain), not the whole site.
- Some sites block non-browser requests (bot protection, HTTP 403); they are reported as errors and not charged.
- Detection is pattern-based: a match is strong evidence, not proof. Check `confidence` and `version`.
- In `changes` mode a "change" can also be a difference in what the site served that time (A/B tests, geo or consent banners). State is kept in your account's named key-value store `tech-stack-detector-state`.

### Legal and attribution

Public pages only: one standard page request per domain, like a browser visit. No personal data is collected. **Not affiliated with, endorsed by or a reseller of Wappalyzer, BuiltWith or any website analysed.**

Technology fingerprints come from the open-source [enthec/webappanalyzer](https://github.com/enthec/webappanalyzer) project, licensed under **GPL-3.0**, and are downloaded at build time from a pinned commit. All credit to its authors and contributors; the licence text is shipped with the Actor. Detection code and this Actor wrapper are by Lindenbyte.

# Actor input Schema

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

Domains (example.com) or URLs (https://example.com). Each domain is analysed once, from the page you give (a bare domain means its homepage). Duplicates by domain are removed. Hundreds or thousands are fine.

## `mode` (type: `string`):

'changes' remembers the technologies of every domain in a named key-value store ('tech-stack-detector-state') and adds 'added', 'removed' and 'versionChanged' to each row. The first run for a domain is its baseline (nothing added or removed). Schedule it daily or weekly.

## `includeCategories` (type: `array`):

Keep only technologies in these categories, for example: CMS, Ecommerce, Analytics, CDN, Payment processors, Marketing automation, JavaScript frameworks, Live chat. Matching is case-insensitive. Empty = all categories. In 'changes' mode the snapshot holds only these categories, so changing the filter changes what is compared.

## `stateKey` (type: `string`):

Only for 'changes' mode. Separate monitors (for example one per client or schedule) keep separate memories when they use different names. Change it to start a fresh baseline.

## `concurrency` (type: `integer`):

How many websites are fetched and analysed at the same time (each site is fetched once). Analysis uses CPU: above 10 give the run 1 GB memory.

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

Maximum time to wait for a website to answer. Sites that time out or return an HTTP error are listed with an error and are not charged.

## Actor input object example

```json
{
  "urls": [
    "shopify.com",
    "wordpress.org",
    "github.com"
  ],
  "mode": "detect",
  "stateKey": "default",
  "concurrency": 5,
  "requestTimeoutSecs": 25
}
```

# Actor output Schema

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

No description

## `summary` (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": [
        "shopify.com",
        "wordpress.org",
        "github.com"
    ]
};

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

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

```

## MCP server setup

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