# Tech Stack Detector - Wappalyzer Alternative + DNS SaaS Stack (`lasting_fear_edr/tech-stack-detector`) Actor

Detect the tech stack of any website: CMS, ecommerce, analytics, marketing, CDN, hosting and 7,600+ technologies. DNS analysis also reveals email providers and SaaS tools (Google Workspace, HubSpot, Salesforce...) the page never shows. Pay only for sites that respond.

- **URL**: https://apify.com/lasting\_fear\_edr/tech-stack-detector.md
- **Developed by:** [Jannis Eggenberger](https://apify.com/lasting_fear_edr) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 website analyzeds

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

### What does Tech Stack Detector do?

Tech Stack Detector tells you **which technologies any website uses**: CMS, ecommerce platform, analytics, marketing automation, CRM, payments, CDN, hosting, frameworks and more. It checks **7,600+ technology fingerprints** (the open-source Wappalyzer dataset).

It also reads the website's **DNS records**, where companies leave traces of the SaaS tools they pay for: email provider (Google Workspace, Microsoft 365), email senders (Mailchimp, SendGrid, Amazon SES, Postmark), CRM and marketing tools (Salesforce, HubSpot, Marketo, Klaviyo), and workplace tools (Atlassian, Zoom, Slack, Notion, OpenAI, Anthropic, and many more). **None of these appear in the page HTML**, so homepage-only detectors can't see them.

In a test on 25 well-known websites, it found **25 technologies per site on average, and 16 of them came only from DNS.**

### Why use it?

- 🎯 **Lead qualification:** find every prospect that runs Shopify, uses HubSpot, or is still on Microsoft Exchange.
- 🕵️ **Competitor research:** see what your competitors build with and which SaaS they pay for.
- 📧 **Sales targeting:** know the email provider and marketing stack before you reach out.
- 🏗️ **Agency prospecting:** find WordPress or Wix sites ready for a redesign or migration.
- 🔌 **Enrichment pipelines:** clean JSON and flat CSV columns, callable via API, schedules, or integrations (Make, Zapier, n8n, Google Sheets).

### How much does it cost?

You pay **per website analyzed**. **Websites that fail are free**: domains that don't exist, don't respond or time out are never charged. The run also stops cleanly at your maximum cost per run, so you never get billed for results you didn't get. The only other charge is Apify's standard start fee of $0.00005 per run.

The detector runs without a browser, so it is fast (25 websites in about 10 seconds) and cheap on platform usage.

### How to use it

1. Add domains or URLs to **Websites** (`example.com`, `www.example.com` or `https://example.com/page`).
2. Keep **Detect email & SaaS stack from DNS** on (recommended).
3. Click **Start** and download the results as JSON, CSV, Excel or HTML.

#### Input example

```json
{
    "websites": ["vercel.com", "allbirds.com", "techcrunch.com"],
    "includeDns": true
}
```

### Output

One row per website. The **Overview** table gives one column per category (easy to filter in a spreadsheet), and `technologies` has every detection with version, confidence, categories and how it was detected.

Real result for `vercel.com` (technologies list shortened):

```json
{
    "input": "vercel.com",
    "status": "ok",
    "domain": "vercel.com",
    "finalUrl": "https://vercel.com/",
    "httpStatus": 200,
    "technologyCount": 31,
    "analytics": "Linkedin Insight Tag, Mixpanel, Ahrefs",
    "marketingAutomation": "Marketo",
    "crm": "Salesforce",
    "emailHosting": "Google Workspace, Microsoft 365",
    "emailSending": "Amazon SES, Postmark, Sendgrid",
    "payments": "Stripe",
    "hosting": "Amazon Web Services, Vercel",
    "frameworks": "Next.js, React",
    "ai": "Anthropic, Cursor, OpenAI",
    "technologies": [
        { "name": "Salesforce", "version": "", "confidence": 100, "categories": ["CRM"], "website": "https://www.salesforce.com", "detectedBy": ["dns"] },
        { "name": "Next.js", "version": "", "confidence": 100, "categories": ["JavaScript frameworks", "Web frameworks", "Web servers", "Static site generator"], "website": "https://nextjs.org", "detectedBy": ["headers"] }
    ],
    "error": null,
    "scannedAt": "2026-09-23T20:35:06.741Z"
}
```

Summary columns: `cms`, `ecommerce`, `analytics`, `tagManagers`, `advertising`, `marketingAutomation`, `crm`, `liveChat`, `emailHosting`, `emailSending`, `payments`, `cdn`, `hosting`, `webServer`, `frameworks`, `programmingLanguages`, `security`, `ai`. The full per-category breakdown is in `byCategory`.

Failed websites come back with `"status": "error"` and an error code (`DNS_NOT_FOUND`, `TIMEOUT`, `CONNECTION_FAILED`, `INVALID_INPUT`, `BLOCKED_ADDRESS`, `TOO_MANY_REDIRECTS`), and they are not charged.

### How it detects technologies

For each website it fetches the homepage (following redirects) and matches fingerprints against:

- HTTP headers and cookies
- HTML, meta tags, script URLs, inline scripts and page structure (CSS selectors)
- DNS: MX, TXT (SPF includes and domain-verification records), NS, SOA, CNAME

Detections come with a **confidence** score (0-100). Implied technologies are added too (e.g. WordPress → PHP, MySQL), and are marked `detectedBy: ["implied"]`. Use **Minimum confidence** to drop weaker signals.

### Limitations (so you know what you're getting)

- **No browser rendering.** Technologies that only show up after JavaScript runs in a browser (some tags injected by tag managers, for example) can be missed. In exchange, the Actor is much faster and cheaper than browser-based detectors.
- **Bot-protected websites** may answer with a block page (HTTP 403). You still get the full DNS stack and the protection vendor (Cloudflare, DataDome, Akamai…), and the result shows the real `httpStatus`.
- DNS records show that a company **has set up** a tool (e.g. verified its domain with it). Usually that means they use it, but not always today.

### FAQ

**Is it a Wappalyzer or BuiltWith alternative?** Yes. It uses the open-source Wappalyzer fingerprint format and data, plus DNS-based SaaS detection that Wappalyzer's browser extension doesn't do.

**Can I use it via API?** Yes. Like every Apify Actor, you can run it via the Apify API, schedule it, or connect it to Make, Zapier, n8n, Google Sheets and others.

**Is it legal?** It only reads public information: a website's public homepage and public DNS records, the same things a browser or `dig` sees.

### Credits and license

Technology fingerprints: [enthec/webappanalyzer](https://github.com/enthec/webappanalyzer) (GPL-3.0), a community-maintained continuation of the open-source Wappalyzer dataset. This Actor is licensed GPL-3.0.

# Actor input Schema

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

Domains or URLs to analyze, one per line. "example.com", "www.example.com" and "https://example.com/page" all work.

## `includeDns` (type: `boolean`):

Reads MX, TXT (SPF and domain verifications), NS and SOA records to find email providers, mail senders and SaaS tools such as Google Workspace, Microsoft 365, HubSpot, Salesforce, Mailchimp, Atlassian and Zoom that never appear in the page itself.

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

Only report technologies detected with at least this confidence (0-100). 0 reports everything.

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

How many websites to analyze in parallel.

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

Give up on a website that has not responded within this time. Timed-out websites are not charged.

## Actor input object example

```json
{
  "websites": [
    "apify.com",
    "shopify.com",
    "wordpress.org"
  ],
  "includeDns": true,
  "minConfidence": 0,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Summary table: CMS, ecommerce, analytics, marketing, CRM, email, payments, CDN, hosting and frameworks per website.

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

Every detected technology with version, confidence, categories and detection method, plus the per-category breakdown.

# 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",
        "shopify.com",
        "wordpress.org"
    ]
};

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

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

```

## MCP server setup

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