# Website Tech Stack Detector: BuiltWith & Wappalyzer Alternative (`afterstar/tech-stack-detector`) Actor

Shows which technologies (shop system, CMS, analytics, frameworks) each website in your list uses, and what changed.

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

## Pricing

from $7.00 / 1,000 websites

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

**Pricing: $10.00 per 1,000 websites checked, in every mode.**

### What does Website Tech Stack Detector do?

For each website: every technology it detects (CMS, shop system, analytics and tag managers, JavaScript frameworks, CDN, hosting, payment, marketing tools and more, from the fingerprints of 6,500+ technologies), with categories and versions where visible, grouped by category. On a schedule it lists only the sites whose stack changed, with the technologies added and removed.

Run it once, or **schedule it to tell you when a site adds or drops a technology**. The tool remembers what it has seen, in a storage in your own Apify
account.

### What you get

|  |  |
|---|---|
| **Detects** | CMS, shop systems, analytics and tag managers, JavaScript frameworks, CDN, hosting, payment, marketing tools and more |
| **Fingerprints** | 6,500+ technologies (the open-source webappanalyzer project), with categories and versions where visible |
| **Per site** | Technologies grouped by category; on a schedule, the technologies added and removed |
| **Speed** | One request per site (no browser), up to 25 seconds of analysis |
| **Price** | $10.00 per 1,000 websites checked, in every mode |

### Use cases

- Lead generation: find shops on a given platform, or sites using a competitor's tool.
- Watch competitors and get alerted when they add or drop a tool.
- Audit a portfolio of sites.

### Input

| Field | What it does |
|---|---|
| URLs | Websites, one per line |
| Track versions | Count version changes as changes (off by default) |
| Max websites | The most websites per run |
| Output mode | All results, only new results, or new + changed + removed results |

### Output

One row per website:

```json
{
  "id": "site:apify.com",
  "changeType": "changed",
  "technologyNames": ["Cloudflare", "Google Tag Manager", "Next.js", "React"],
  "categories": {"JavaScript frameworks": ["Next.js", "React"], "Tag managers": ["Google Tag Manager"]},
  "added": ["Next.js"],
  "removed": ["Gatsby"]
}
```

Every row has every key (`null` when there's no value). `changeType` is `new`, `changed`, `unchanged` or
`removed`; a `changed` row lists `changedFields` and the `previous` values. If a source fails or rate-limits the
request, you get one row with `changeType: "status"` and a `statusCode` instead of an error, and it's free.

### Schedule it

1. Fill in the input and **save it as a task**.
2. Run it once with **Baseline only** switched on: it remembers the current results and lists nothing. Or skip this
   and accept that the first scheduled run lists everything once.
3. Set **Output mode** to **Only new results** or **New, changed and removed**, and add a **schedule**.
4. Connect an **integration** (Slack, Google Sheets, Zapier, Make, n8n), or put a **webhook URL** in the input.

Each saved task keeps its own memory; switching a task between modes keeps it. Each run saves a summary (`OUTPUT` in
the run's key-value store) with the counts.

**Apify webhook template** (Integrations → Webhook → payload):

```json
{"datasetUrl": "https://api.apify.com/v2/datasets/{{resource.defaultDatasetId}}/items?clean=true&format=json"}
```

### How much does it cost?

- **$10.00 per 1,000 websites checked** (on paid Apify plans 10-30% less). In 'changes' mode you pay for every website checked, but only the changes are listed.
- **Example:** checking 1,000 websites costs $10.00; checking 50 websites every day costs about $15.00 a month (plus Apify's start fee: $0.00010 per run).
- Status rows (errors) are free. Set a spending limit on the run and the tool stops there.

### Good to know

- Detection reads the page, its headers, cookies and scripts in one request (no browser), so technologies that only show up after JavaScript runs can be missed: most often analytics, chat and A/B-testing tools that a tag manager loads later (the tag manager itself is found).
- Each site gets up to 25 seconds of analysis; a page that takes longer is listed with an error, free.
- You pay for every item checked in every mode. 'New, changed and removed' only filters the output to what changed since the last run, so a scheduled check lists nothing when all is the same.
- You choose the sites to check; check only sites you're allowed to. The tool makes one normal request per page (no crawling) with a clear bot name.

### How it compares

| Instead of | With this tool |
|---|---|
| Checking sites one by one in a browser extension | A whole list in one run, as a table you can filter |
| A headless-browser crawl | One normal request per site: fast and light, but tools loaded later by JavaScript can be missed |
| Re-checking a list by hand | 'Changes' mode lists only the sites whose stack changed, with what was added or removed |

### FAQ

**How accurate is it?** It matches the page, its headers, cookies and scripts against the fingerprints of 6,500+ technologies. Tools that a tag manager loads later with JavaScript (often analytics, chat and A/B testing) can be missed; the tag manager itself is found.

**Can I find all sites that use a technology?** No: you give the websites, and it tells you what each one uses. Filter the results to build lists, for example all Shopify shops in your list.

**Can it alert me when a competitor changes tools?** Yes. Save the list as a task, set Output mode to 'New, changed and removed results' and add a schedule.

**What does it cost on a schedule?** Every website checked costs $0.01, in every mode; the 'changes' mode only filters the output to what changed.

**Can I check a site by hand?** For one site, yes: open the page source and the response headers and look for known traces, such as `wp-content` (WordPress), `cdn.shopify.com` (Shopify), `gtag(` (Google Analytics) or an `x-powered-by` header. Doing that well across 6,500+ technologies is the job of the open-source webappanalyzer fingerprint set, which this tool runs on every site in your list. It costs $10.00 per 1,000 websites checked, in every mode, including scheduled 'changes' runs.

**Source:** the websites you provide. Fingerprints: the open-source webappanalyzer project by Enthec (GPL-3.0), pinned to commit eea872a. Not affiliated with Enthec or Wappalyzer.

### More Afterstar tools

- [Website Screenshots - Bulk, Full Page & Visual Change Alerts](https://apify.com/afterstar/website-screenshots): Screenshots of many web pages (desktop or mobile, full page), and alerts when a page visually changes.

Found a problem or need a field? Open an issue on the Issues tab.

# Actor input Schema

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

One per line: the websites to check.

## `trackVersions` (type: `boolean`):

By default only technologies added or removed count as a change, not version bumps.

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

The most websites per run.

## `outputMode` (type: `string`):

'All' lists everything found now. 'Only new' lists results never seen in earlier runs. 'New, changed and removed' also lists results that changed or disappeared. The first scheduled run counts everything as new; use 'Baseline only' to start cheaply.

## `baselineOnly` (type: `boolean`):

Saves what exists now without listing it, so the next scheduled run shows only what's new. Charged like a run with nothing new.

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

Leave empty: each saved task keeps its own memory. Set a name to share one memory between tasks, or a new name to start over.

## `resetState` (type: `boolean`):

Starts from an empty memory: every result counts as new again.

## `webhookUrl` (type: `string`):

We POST a summary plus up to 100 new, changed or removed results here when something changed. Works with Slack incoming webhooks (choose the Slack format), Zapier, Make and n8n.

## `webhookFormat` (type: `string`):

JSON for automation tools; 'Slack message' sends one line of text.

## `webhookAlways` (type: `boolean`):

By default the webhook is called only when something changed or a source failed.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com"
  ],
  "trackVersions": false,
  "maxItems": 1000,
  "outputMode": "all",
  "baselineOnly": false,
  "stateKey": "",
  "resetState": false,
  "webhookUrl": "",
  "webhookFormat": "json",
  "webhookAlways": 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://apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("afterstar/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://apify.com"] }

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

```

## MCP server setup

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