# Website Technology Detector (Tech Stack Lookup) (`jakob_jerich/tech-stack-detector`) Actor

Detect the CMS, e-commerce platform, analytics, CDN, frameworks, hosting and email/DNS providers behind a list of websites, with versions, categories and evidence. $0.20 per 1,000 sites, failed sites free.

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

## Pricing

$0.20 / 1,000 website checkeds

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

## Website Technology Detector (Tech Stack Lookup)

Give it a list of websites and get back the technologies each one uses: CMS, e-commerce platform, analytics and tag managers, CDN, JavaScript frameworks, web server, hosting, payment providers, email provider (from MX records) and SaaS tools that left domain-verification TXT records. Each technology comes with its version (when the site exposes it), categories, a confidence score and the evidence it was detected from.

Detection uses the open [webappanalyzer](https://github.com/enthec/webappanalyzer) fingerprint set (the community continuation of Wappalyzer's open-source rules, GPL-3.0): **7,647 technologies**, of which **6,801** can be detected without running a browser.

### What it checks

For each website the Actor makes one page request (plus a robots.txt check) and, optionally, a few DNS lookups. It matches:

- response headers and cookies
- `<meta>` tags, the HTML source and visible text
- `<script src>` URLs and inline scripts
- CSS selectors against the page (for example a `link[href*='cdn.shopify.com']`)
- DNS records: MX, TXT, NS, SOA, CNAME (when **Check DNS records** is on)
- implied technologies (WordPress implies PHP and MySQL, and so on)

### Input

| Field | Default | What it does |
|---|---|---|
| `urls` | – | Websites to check: full URLs or bare domains. Duplicates are removed. |
| `checkDns` | `true` | Look up DNS records to detect email, DNS and SaaS providers. |
| `maxConcurrency` | `10` | Websites checked in parallel (1–50). |
| `requestTimeoutSecs` | `20` | Seconds to wait for a site before reporting a timeout. |

```json
{
  "urls": ["https://wordpress.org", "https://www.shopify.com", "https://apify.com"],
  "checkDns": true
}
```

### Output

One dataset row per input entry, including entries that failed (with an `error` and no charge). Example row from a real run (`technologies` shortened here to the first 3 of 13 items; `technologyNames` is complete):

```json
{
  "inputUrl": "https://wordpress.org",
  "url": "https://wordpress.org/",
  "domain": "wordpress.org",
  "statusCode": 200,
  "technologyCount": 13,
  "technologyNames": [
    "Google Font API",
    "Google Tag Manager",
    "Gutenberg 24.3.0",
    "HSTS",
    "MySQL",
    "Nginx",
    "Open Graph",
    "PHP",
    "Priority Hints",
    "RSS",
    "WordPress 7.2",
    "WordPress Block Editor",
    "WordPress Site Editor"
  ],
  "technologies": [
    {
      "name": "Google Font API",
      "version": null,
      "confidence": 100,
      "categories": [
        "Font scripts"
      ],
      "website": "https://fonts.google.com/",
      "detectedBy": [
        "dom:link[href*='fonts.g']"
      ]
    },
    {
      "name": "Google Tag Manager",
      "version": null,
      "confidence": 100,
      "categories": [
        "Tag managers"
      ],
      "website": "https://www.google.com/tagmanager",
      "detectedBy": [
        "html"
      ]
    },
    {
      "name": "Gutenberg",
      "version": "24.3.0",
      "confidence": 100,
      "categories": [
        "WordPress plugins",
        "Editors"
      ],
      "website": "https://github.com/WordPress/gutenberg",
      "detectedBy": [
        "script src",
        "dom:link[href*='/wp-content/plugins/gutenberg/']"
      ]
    }
  ],
  "htmlTruncated": false,
  "error": null,
  "checkedAt": "2026-11-01T01:38:34.541Z"
}
```

`detectedBy` tells you why a technology was reported: `header:server`, `meta:generator`, `script src`, `html`, `dom:<selector>`, `dns:MX`, `dns:TXT` or `implied by <technology>`.

The **Overview** tab of the dataset shows domain, status, technology count and the detected names, which is the easiest view to export to CSV or Excel. A `SUMMARY` record in the key-value store gives the counts for the run.

### Pricing

Pay per event: **$0.0002 per website checked** ($0.20 per 1,000 websites). There is no start fee.

You are not charged for invalid URLs, sites that fail, time out, block the request or are disallowed by robots.txt, or sites skipped because your maximum cost per run was reached. In our test run of 160 popular websites, 130 were analysed and charged ($0.026 at today's price) and 30 were blocked, timed out or disallowed (free). That run took 141 seconds.

### Use cases

- Lead qualification: find which prospects run Shopify, WordPress, HubSpot or Microsoft 365.
- Market research: count CMS or analytics usage across a list of sites.
- Competitor monitoring: schedule a run and compare versions and tools over time.
- Security and IT audits: spot outdated software versions (jQuery, WordPress, Apache) across your own sites.

### Limits

- **No JavaScript is executed.** Rules that need a browser (JavaScript variables, rendered DOM properties, network requests made by scripts) are skipped, so 846 of the 7,647 technologies have no rule this Actor can check. Single-page apps that render everything client-side show fewer results.
- **Only the URL you give is fetched.** Tools used only on other pages (checkout, blog) are found only if you add those URLs.
- **Blocked sites are reported, not bypassed.** Sites behind strict bot protection answer `HTTP 403` or `429`; the row says so and is free. In the 160-site test this was 21 sites (13%), mostly large retailers and news sites. No proxies or browser disguises are used.
- **robots.txt is respected.** If it disallows the URL for all bots, the site is skipped (free).
- **DNS TXT matches mean "verified with"**: a `google-site-verification` or `openai-domain-verification` record shows the domain was verified with that service, which usually but not always means it is in use. Turn off `checkDns` if you only want what the website itself shows.
- Pages larger than 2 MB are analysed from their first 2 MB; such rows have `htmlTruncated: true`.
- Versions are reported only when a site exposes them.

### FAQ

**How accurate is it?** It uses the open rules the Wappalyzer project published before it went closed-source, kept up to date by the community, minus the browser-only checks. Each technology carries `detectedBy` evidence, so you can verify any result.

**Why is a technology I know the site uses missing?** Either it is only detectable in a browser, it is used on a different page, or the site hides it (for example, server headers removed). Try the specific page URL.

**Does it collect personal data?** No. It reads public page code, response headers and DNS records only, and outputs technology names.

**Can I run thousands of sites?** Yes. Raise `maxConcurrency` for bigger lists. Set a maximum cost per run in the run options if you want a hard spending cap; sites not reached are listed with `"error": "Not checked: the maximum cost per run was reached"`.

**Where do the fingerprints come from?** The [webappanalyzer](https://github.com/enthec/webappanalyzer) repository (GPL-3.0), pinned to a fixed commit for each build. Two rules are patched locally: Next.js is also detected from `/_next/static/` script URLs (newer Next.js sites are otherwise only detectable in a browser), and an `apple-domain-verification` TXT record no longer counts as Apple iCloud Mail.

# Actor input Schema

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

Websites to check. Use full URLs (https://www.example.com/shop) or bare domains (example.com). Each entry is fetched once; duplicates are removed. Invalid entries are reported in the output and not charged.

## `checkDns` (type: `boolean`):

Also look up MX, TXT, NS, SOA and CNAME records to detect email providers (Google Workspace, Microsoft 365), DNS/hosting providers and SaaS tools that leave domain-verification TXT records. Adds well under a second per site.

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

How many websites are checked at the same time. Each website still receives only one page request (plus robots.txt).

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

How long to wait for a website to respond before reporting it as timed out. Timed-out sites are not charged.

## Actor input object example

```json
{
  "urls": [
    "https://wordpress.org",
    "https://www.shopify.com",
    "https://apify.com"
  ],
  "checkDns": true,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20
}
```

# 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": [
        "https://wordpress.org",
        "https://www.shopify.com",
        "https://apify.com"
    ],
    "checkDns": true,
    "maxConcurrency": 10,
    "requestTimeoutSecs": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jakob_jerich/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://wordpress.org",
        "https://www.shopify.com",
        "https://apify.com",
    ],
    "checkDns": True,
    "maxConcurrency": 10,
    "requestTimeoutSecs": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jakob_jerich/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://wordpress.org",
    "https://www.shopify.com",
    "https://apify.com"
  ],
  "checkDns": true,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20
}' |
apify call jakob_jerich/tech-stack-detector --silent --output-dataset

```

## MCP server setup

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