# Website Tech Stack Detector (Wappalyzer Alternative) (`jtpalms/tech-stack-detector`) Actor

Find the technology behind any website in bulk: CMS, ecommerce platform, analytics, frameworks, CDN, hosting, payment, email and marketing tools, plus the SaaS a company uses from its DNS records. 7,600+ fingerprints. Pay only per website scanned.

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

## Pricing

from $4.00 / 1,000 website scanneds

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

## Website Tech Stack Detector: bulk Wappalyzer and BuiltWith alternative

Paste a list of websites and get back what each one is built with: CMS, ecommerce platform, analytics, tag managers, JavaScript frameworks, CDN, hosting, payment processors, email provider and marketing tools. It also lists the SaaS a company has verified its domain with, read from public DNS records (for example HubSpot, Atlassian, DocuSign, Microsoft 365).

**USD 5 per 1,000 websites.** You pay only for websites that were scanned successfully. Unreachable sites are reported free.

### What people use it for

- **Lead lists by technology.** Keep only the Shopify stores, the WordPress sites running WooCommerce, or the companies on HubSpot, before you spend on outreach.
- **Competitor research.** See which analytics, A/B testing, chat and payment tools competitors run.
- **Sales qualification.** Add a tech-stack column to a CRM export and route accounts by platform.
- **Agency audits.** Check a client's stack, versions and CDN in seconds.
- **Market sizing.** Count how many sites in a list use a given platform.

### Sample output

One result per website:

```json
{
  "domain": "allbirds.com",
  "url": "https://www.allbirds.com/",
  "statusCode": 200,
  "title": "Allbirds: Comfortable, Sustainable Shoes & Apparel",
  "technologyCount": 16,
  "technologies": [
    { "name": "Cloudflare", "version": null, "confidence": 100, "categories": ["CDN"], "detectedVia": ["headers"] },
    { "name": "Shopify", "version": null, "confidence": 100, "categories": ["Ecommerce"], "detectedVia": ["meta", "scripts"] },
    { "name": "Google Tag Manager", "version": null, "confidence": 100, "categories": ["Tag managers"], "detectedVia": ["scripts"] },
    { "name": "Microsoft 365", "version": null, "confidence": 100, "categories": ["Webmail", "Email"], "detectedVia": ["dns"] }
  ],
  "categories": {
    "Ecommerce": ["Shopify"],
    "CDN": ["Cloudflare"],
    "Payment processors": ["Apple Pay", "PayPal"],
    "Tag managers": ["Google Tag Manager"]
  },
  "saasFromDnsRecords": ["DocuSign", "Miro", "Microsoft 365"],
  "dns": { "mx": ["allbirds-com.mail.protection.outlook.com"], "ns": ["ns4.markmonitor.com"] },
  "tlsIssuer": "Let's Encrypt",
  "scannedAt": "2026-09-28T17:59:18.033Z"
}
```

Export as JSON, CSV or Excel, or pull the results through the Apify API.

### How to use it

1. Put your websites in **Websites**, one per line. Bare domains (`example.com`) and full URLs both work.
2. Click **Start**.
3. Download the results, or connect the actor to Make, Zapier, n8n, Google Sheets or your own code through the Apify API.

For large lists (10,000+ sites), raise **Parallel scans** to 30 to 50.

### What it checks

For each website it fetches the homepage over HTTP(S) and matches it against more than 7,600 technology fingerprints:

- HTTP headers and cookies
- HTML, meta tags and page structure (DOM selectors)
- Script and stylesheet URLs, and inline scripts
- `robots.txt`
- TLS certificate issuer
- DNS: MX (email provider), NS (DNS host) and TXT (SPF and domain verification records)

`detectedVia` tells you which signal found each technology. Technologies found only in DNS records appear last, and are also listed in `saasFromDnsRecords`.

### Pricing

| What | Price |
|---|---|
| Website scanned successfully | USD 0.005 (USD 5 per 1,000) |
| Website unreachable, invalid or failed | Free |

Set a maximum cost per run in the run options and the actor stops cleanly when it reaches it. Results collected before that are kept.

### Limits and accuracy

- It reads what a website serves to a normal browser request. It does not run the page's JavaScript, so technologies that only appear after scripts load (some single-page-app libraries and tag-manager-injected tools) can be missed.
- A few sites block automated requests. Those come back with a `warning`; this actor does not get around such blocks.
- Detection is only as good as the fingerprints. The database is the open community-maintained Wappalyzer format and is refreshed regularly.

### FAQ

**Is this the same data as Wappalyzer or BuiltWith?** It uses the same open fingerprint format Wappalyzer used, from the community-maintained successor database. It is not affiliated with Wappalyzer or BuiltWith.

**Can I search for all sites that use a technology?** No. This actor scans the websites you give it. It does not have an index of the whole web.

**Is it legal?** It requests each site's public homepage and `robots.txt` and reads public DNS records, the same as a browser and `nslookup`. It does not log in, bypass protections, or collect personal data.

**Something is detected wrongly or missing?** Open an issue with the domain and the technology.

### License

Detection engine and fingerprint data are GPL-3.0 (wappalyzer-core and [enthec/webappanalyzer](https://github.com/enthec/webappanalyzer)). This actor's code is GPL-3.0.

# Actor input Schema

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

Domains or full URLs to scan, one per line. Examples: allbirds.com, https://www.example.com/shop. Duplicates are removed automatically.

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

Also read public DNS records (MX, TXT, NS). Reveals email provider, DNS host and SaaS tools the company has verified its domain with (for example HubSpot, Atlassian, DocuSign). No extra cost.

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

Hide technologies detected with lower confidence than this.

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

How many websites to scan at the same time.

## `timeoutSecs` (type: `integer`):

How long to wait for one request before giving up.

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

Optional. Only needed if some sites block requests from data centers.

## Actor input object example

```json
{
  "urls": [
    "allbirds.com",
    "vercel.com",
    "wordpress.org"
  ],
  "includeDns": true,
  "minConfidence": 50,
  "maxConcurrency": 10,
  "timeoutSecs": 20
}
```

# Actor output Schema

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

All output rows in the default dataset (JSON, CSV, Excel via the format parameter).

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

Counts and per-input status for this 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 = {
    "urls": [
        "allbirds.com",
        "vercel.com",
        "wordpress.org"
    ]
};

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

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

```

## MCP server setup

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