# Tech Stack Detector: Bulk Website Technology & CMS Lookup (`datawright-labs/tech-stack-detector`) Actor

Bulk tech stack detector: find the CMS, ecommerce platform, frameworks, analytics, CDN, hosting and email provider of any list of websites, with versions and evidence, from 7,600+ fingerprints plus DNS. Wappalyzer/BuiltWith alternative, callable by AI agents via MCP. $1 per 1,000 sites.

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

## Pricing

from $0.80 / 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.
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

**For AI agents:** Use when asked what technology, CMS, ecommerce platform, framework, analytics, CDN, hosting or email provider a website uses, or to find which sites in a list run a given technology (Shopify, WordPress, HubSpot...). Call with `urls` (required), optional `technologies` (only save sites using these), `minConfidence` (default 50), `checkDns` (default true) and `includeEvidence`. Returns one row per site: `technologyNames`, `technologies` (name, version, confidence, categories, evidence), `cms`, `ecommerce`, `jsFrameworks`, `analytics`, `tagManagers`, `marketingAutomation`, `cdn`, `hosting`, `webServers`, `emailHosting`, `payments`, `byCategory`. Cost: $0.001 per site ($1 per 1,000); unreachable, blocked and 4xx/5xx sites and invalid inputs free.

**For people:** Tell your AI agent "find out which of these 500 prospect websites run Shopify and what email and analytics tools they use" and it hands the list to this tool, then reads back the answer. No pasting domains into a Wappalyzer or BuiltWith lookup one at a time, and 1,000 sites cost $1.

**Bulk tech stack detector for hundreds or thousands of websites in one run.** Paste a list of domains or URLs and this website technology lookup loads each home page (following redirects) and matches it against **7,600+ technology fingerprints**: the **CMS** (WordPress, Drupal, Webflow, Wix, Squarespace...), **ecommerce platform** (Shopify, WooCommerce, Magento, BigCommerce...), **JavaScript frameworks** (React, Next.js, Vue, Nuxt, Angular, Svelte), **analytics and tag managers** (Google Analytics, GTM, Segment, Hotjar, Mixpanel), **marketing automation and CRM** (HubSpot, Klaviyo, Marketo, Salesforce), **CDN and hosting** (Cloudflare, Fastly, CloudFront, Vercel, Netlify, AWS), **web servers and languages** (Nginx, Apache, PHP, Node.js), **payments**, **live chat** and **cookie consent** tools, with **versions** where the site exposes them and the **evidence** for every detection.

It also reads the domain's **DNS records and TLS certificate**, which page-only detectors miss: the **email provider** from MX records (Google Workspace, Microsoft 365, Proton Mail...), the DNS host, the certificate authority and the **SaaS tools that verified the domain** in TXT records (Atlassian, Zoom, Notion, Stripe, OpenAI, DocuSign...). No proxies, no API keys and no browser: results export to **CSV, Excel, JSON or Google Sheets**, or run on a **schedule** to spot sites that switch platforms.

### What does this tech stack detector do?

- 🧱 **Full stack per website**: every technology with its **categories**, **version** (WordPress 6.x, jQuery, Bootstrap, PHP, Nginx...), **confidence** and the **evidence** that matched (HTTP header, cookie, script URL, meta generator, DOM element, DNS record), so each detection can be verified.
- 🗂️ **Ready-made columns**: `cms`, `ecommerce`, `jsFrameworks`, `webFrameworks`, `programmingLanguages`, `analytics`, `tagManagers`, `advertising`, `marketingAutomation`, `cdn`, `hosting`, `webServers`, `emailHosting`, `payments`, `liveChat`, `cookieConsent`, `security`, plus `byCategory` for all 100+ categories.
- 📬 **DNS-based detection**: email provider from MX, DNS hosting from NS/SOA, CNAME targets, certificate issuer, and SaaS tools from domain verification records (listed separately in `dnsVerifiedServices`).
- 🎯 **Lead-generation filter**: set **Only save websites using these technologies** (e.g. `Shopify`, `Klaviyo`) and only the matching sites are saved and charged.
- 🧹 **Bulk-friendly**: domains, URLs or email addresses, de-duplicated, up to 50 sites in parallel (at most 4 per host). Unreachable sites, bot-challenge pages and 4xx/5xx errors are reported **free**, still with any technologies visible in their headers and DNS.
- 📊 **SUMMARY** record with the most common technologies across the whole list (market-share style counts).

### Use cases

- **Sales prospecting and lead generation**: find which companies in a list use Shopify, WooCommerce, HubSpot or Salesforce, or a competitor's product, and segment them by platform.
- **Competitor research**: see the framework, hosting, analytics and marketing tools behind competitors' sites.
- **Market research**: count CMS, ecommerce or analytics market share across thousands of domains with the SUMMARY record.
- **Agency and SEO audits**: know a client's CMS, CDN, tag manager and consent tool before the kickoff call.
- **Security and IT inventory**: list web servers, languages and versions exposed across your own domains.
- **Data enrichment**: add `cms`, `ecommerce` and `emailHosting` columns to a CRM export or lead list.

### How to use it

1. Paste websites into **Websites**, one per line (domains, URLs or emails).
2. Optionally set **Only save websites using these technologies**, the **Minimum confidence** or turn off **DNS and TLS** detection.
3. Click **Start**, then open the **Overview**, **Marketing stack** or **Infrastructure** table, or export the results.

#### Input example

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

### Output example

```json
{
  "url": "https://allbirds.com/",
  "domain": "allbirds.com",
  "status": "ok",
  "finalUrl": "https://www.allbirds.com/",
  "statusCode": 200,
  "technologyCount": 16,
  "technologyNames": "Shopify, Apple Pay, PayPal, Cloudflare, Google Tag Manager, HSTS, Let's Encrypt, Swiper, HTTP/3, Open Graph, ...",
  "cms": [],
  "ecommerce": ["Shopify"],
  "analytics": [],
  "tagManagers": ["Google Tag Manager"],
  "cdn": ["Cloudflare"],
  "emailHosting": ["Microsoft 365"],
  "payments": ["Apple Pay", "PayPal"],
  "dnsVerifiedServices": ["Apple iCloud Mail", "Cursor", "DocuSign", "Miro"],
  "technologies": [
    {
      "name": "Shopify",
      "version": null,
      "confidence": 100,
      "categories": ["Ecommerce"],
      "website": "https://shopify.com",
      "implied": false,
      "detectedVia": ["header", "cookie", "script"],
      "evidence": ["header x-shopid", "cookie _shopify_y", "script https://cdn.shopify.com/..."]
    }
  ],
  "server": "cloudflare",
  "tlsIssuer": "Let's Encrypt / YE2",
  "checkedAt": "2026-10-26T15:00:00.000Z"
}
```

Sites that can't be loaded (DNS failure, timeout, refused) come back with `status: "error"`, bot-challenge pages with `"blocked"` and HTTP 4xx/5xx pages with `"http-error"`; all are **free**. The **SUMMARY** record in the key-value store has the counts and the top technologies across the run.

### How much does a tech stack lookup cost?

You pay **$0.001 per website analyzed** ($1 per 1,000 sites), DNS and TLS detection included. **Unreachable, blocked and 4xx/5xx sites and invalid inputs are free**, and sites skipped by the technology filter are **free** too. No start fee.

| Job | Websites | Cost |
|---|---|---|
| Check 100 competitor or prospect sites | 100 | **$0.10** |
| Find the Shopify stores in a 5,000-domain list | 5,000 | **$5** (only matching stores are charged) |
| Monthly platform tracking of 20,000 domains | 20,000 | **$20** |

- Apify's **free plan includes $5 of monthly credit**, enough for about **5,000 websites a month**.
- Paid Apify plans get automatic discounts: **Silver -10%**, **Gold and above -20%**.
- Set **Maximum cost per run** to cap spend; the Actor stops cleanly at the limit.

### Tech stack detector vs. the alternatives

| | This Actor | Wappalyzer / BuiltWith lookups | Browser extensions | Other Store detectors |
|---|---|---|---|---|
| Thousands of sites per run | ✅ | paid API plans | ❌ one tab at a time | ✅ |
| 7,600+ fingerprints with versions and categories | ✅ | ✅ | ✅ | varies |
| Evidence for every detection | ✅ | ❌ | ❌ | rarely |
| Email provider and SaaS tools from DNS | ✅ | partly | ❌ | rarely |
| Only-matching-sites filter for lead lists | ✅ | ✅ (paid) | ❌ | rarely |
| CSV / Excel / JSON / Sheets export, schedules, webhooks | ✅ | ✅ (paid) | ❌ | ✅ |
| Callable by AI agents (MCP) | ✅ | ❌ | ❌ | varies |
| Cost model | $1 per 1,000 sites, no start fee | monthly subscription | free, manual | $1.50-$100 per 1,000 + start fees |

### Use it as an API (Python, JavaScript, cURL)

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("datawright-labs/tech-stack-detector").call(run_input={"urls": ["apify.com", "allbirds.com"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["domain"], item.get("cms"), item.get("ecommerce"), item.get("technologyNames"))
```

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('datawright-labs/tech-stack-detector').call({ urls: ['apify.com'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/datawright-labs~tech-stack-detector/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d '{"urls":["apify.com","allbirds.com"]}'
```

### Use it from your AI agent (MCP)

Your AI assistant or agent can run this Actor as a tool through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp), so it can look up any website's tech stack on its own while you chat. Add this server to any MCP client that supports remote (Streamable HTTP) servers:

```json
{
  "mcpServers": {
    "datawright-tech-stack-detector": {
      "url": "https://mcp.apify.com?tools=datawright-labs/tech-stack-detector"
    }
  }
}
```

On first use your browser opens to sign in to Apify (OAuth). If your client can't do OAuth, add `"headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }` instead. The tool shows up as `datawright-labs--tech-stack-detector`, with the same input fields as above, and the agent reads the results with `get-dataset-items`. Then just ask, for example:

> Check these 40 prospect websites, tell me which ones run Shopify or WooCommerce, and list the email provider and analytics tools of each.

Want several Datawright tools at once? Comma-separate them: `https://mcp.apify.com?tools=datawright-labs/tech-stack-detector,datawright-labs/email-domain-dns-checker`. Runs are billed per result, exactly like normal runs.

### FAQ

#### How do I find out what technology a website uses?

Paste the domain and run. The row lists every detected technology with its category and version, and ready-made columns such as `cms`, `ecommerce`, `jsFrameworks`, `analytics`, `cdn`, `hosting` and `emailHosting`. Paste thousands of domains to do the same in bulk.

#### How do I find out which CMS or ecommerce platform a site is built with?

Look at the `cms` and `ecommerce` columns (WordPress, Drupal, Webflow, Wix, Squarespace, Shopify, WooCommerce, Magento, BigCommerce, PrestaShop...). Versions are filled in when the site exposes them, e.g. in the meta generator tag.

#### Is this a Wappalyzer or BuiltWith alternative?

Yes. It uses the same open fingerprint format as Wappalyzer (from the open-source webappanalyzer project, 7,600+ technologies) and adds DNS and TLS signals, evidence per detection and a pay-per-result price with no subscription. It doesn't have BuiltWith's historical database: it reports what each site runs today.

#### Can I find all websites using Shopify (or WordPress, HubSpot...) in my list?

Yes. Put the technology names into **Only save websites using these technologies**. Only matching sites are saved and charged; every other site is free. The `matchedTechnologies` field shows which of your technologies each site uses.

#### How does it detect the email provider?

From the domain's MX records (Google Workspace, Microsoft 365, Proton Mail, Zoho and others) in `emailHosting`. SaaS tools found only through TXT domain verification records (Atlassian, Zoom, Notion, Stripe...) are listed in `dnsVerifiedServices`, since a verification record means the company uses the service, not that it runs on the website.

#### Does it render JavaScript?

No, it reads the HTML, headers and cookies the server sends plus DNS, which is fast and cheap and detects the vast majority of CMS, ecommerce, CDN, analytics and framework technologies. Tools that only appear after client-side JavaScript runs (fingerprints based on window variables) aren't detected.

### More tools from Datawright Labs

- [Meta Tags & Open Graph Checker](https://apify.com/datawright-labs/meta-tags-checker): bulk title, meta description, canonical, noindex, hreflang, Open Graph / Twitter card and schema.org checks with an SEO problems list per URL.
- [SPF, DMARC & DKIM Checker](https://apify.com/datawright-labs/email-domain-dns-checker): bulk email domain audit of SPF (10-lookup limit), DMARC, DKIM, MX provider, BIMI and MTA-STS.
- [WHOIS Domain Lookup (RDAP)](https://apify.com/datawright-labs/whois-rdap-domain-lookup): bulk registrar, domain age, expiry date, nameservers, EPP status and availability from official registry RDAP.
- [Security Headers Checker](https://apify.com/datawright-labs/security-headers-checker): bulk HTTP security headers audit (HSTS, CSP, X-Frame-Options, cookies, HTTPS redirect) with an A-F grade per URL.
- [SSL Certificate Checker](https://apify.com/datawright-labs/ssl-certificate-checker): bulk SSL certificate and domain expiry checks with alerts for expiring, invalid or outdated TLS.
- [Redirect Checker](https://apify.com/datawright-labs/redirect-checker): bulk redirect chains (301, 302, meta refresh), final URL and status, loops and old-to-new migration checks.
- [Broken Link Checker](https://apify.com/datawright-labs/broken-link-checker): find broken links, images and redirects across a whole site.
- [Sitemap URL Extractor](https://apify.com/datawright-labs/sitemap-url-extractor): get every URL of a site from its sitemaps.
- [Bulk PageSpeed & Core Web Vitals Checker](https://apify.com/datawright-labs/pagespeed-auditor): audit PageSpeed / Lighthouse scores for many URLs.
- [Website Screenshot API](https://apify.com/datawright-labs/website-screenshot): bulk full-page screenshots and PDFs.
- [Google Autocomplete Keyword Scraper](https://apify.com/datawright-labs/autocomplete-keyword-scraper): long-tail keyword ideas from Google, YouTube and Bing.
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/datawright-labs/ats-jobs-scraper): normalized job feeds from 5 ATS platforms.
- [App Store Top Charts & Rank Tracker](https://apify.com/datawright-labs/app-store-top-charts): daily top free/paid/grossing app rankings with rank changes.

Tip: pair it with the **SPF, DMARC & DKIM Checker** and **WHOIS Domain Lookup** for a full company domain profile, or the **Website Screenshot API** to capture each site you've profiled.

Technology fingerprints come from the open-source [webappanalyzer](https://github.com/enthec/webappanalyzer) project. Made by **Datawright Labs**: reliable, fairly priced web data tools. Questions or a missing feature? Open an issue on the Issues tab; we usually reply within a day.

# Actor input Schema

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

Websites to analyze, one per line: full URLs, bare domains (example.com is checked as https://example.com/) or email addresses (their domain is used). Redirects are followed and the final page is analyzed. Duplicates are merged.

## `technologies` (type: `array`):

Lead-generation filter: when set, only websites that use at least one of these technologies are saved and charged (all others are free). Use the exact technology names, e.g. Shopify, WordPress, WooCommerce, Webflow, Wix, HubSpot, Klaviyo, Google Analytics, Cloudflare, Next.js. Case-insensitive.

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

Hide detections below this confidence. Most fingerprints are 100%; a few weak signals (a generic cookie or class name) score 25-50%. Set 0 to see everything.

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

Also look up the domain's MX, TXT, NS, SOA and CNAME records and the TLS certificate issuer: reveals the email provider (Google Workspace, Microsoft 365...), DNS host, certificate authority and SaaS tools that verified the domain (Atlassian, Zoom, HubSpot, Stripe...). Adds no cost.

## `includeEvidence` (type: `boolean`):

For each technology, list what matched (header, cookie, script URL, meta tag, DOM element, DNS record), so every detection can be verified.

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

Per request.

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

Websites analyzed in parallel (max 4 at a time per host).

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://wordpress.org",
    "https://www.allbirds.com"
  ],
  "technologies": [],
  "minConfidence": 50,
  "checkDns": true,
  "includeEvidence": true,
  "timeoutSecs": 20,
  "concurrency": 10
}
```

# Actor output Schema

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

Per-website technology results.

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

SUMMARY record with counts and the most common technologies across the 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": [
        "https://apify.com",
        "https://wordpress.org",
        "https://www.allbirds.com"
    ],
    "technologies": []
};

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

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

```

## MCP server setup

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