# Website Technology Detector – Tech Stack, CMS & Analytics (`forevertools/website-tech-stack-detector`) Actor

Tech stack detection & technology lookup & analysis for any list of websites: 130+ technologies — CMS detection, ecommerce platform, JS framework identification, hosting/CDN, analytics & ad pixels, chat, payments, cookie consent — plus email provider from MX records. Fast, no browser.

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

## Pricing

$2.00 / 1,000 site 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

## Website Tech Stack Detector

Find out what any website is built with. Paste a list of domains and get, for each one, the detected **CMS or site builder, ecommerce platform, JavaScript framework, web server, hosting and CDN, analytics and ad pixels, tag manager, live chat, payment provider, cookie-consent tool, A/B testing and fonts**, with version numbers where the page exposes them and the evidence behind each detection. It also infers the domain's **email provider** (Google Workspace, Microsoft 365 and others) from MX records.

It is a plain HTTP fetch plus fingerprint matching, with no browser, so it is fast and cheap enough to run over long lead lists.

### Find out what CMS a website uses

Enter one or more domains and read the `technologyNames` and `categories` fields. WordPress, Drupal, Joomla, Ghost, Webflow, Wix, Squarespace, Framer and Shopify-style platforms are matched from headers, cookies, script URLs, meta tags (such as `generator`) and page HTML. Each detection in `technologies` lists its `category`, a `version` when one is exposed, and the `evidence` sources (`header:*`, `cookie`, `script`, `meta:*`, `html`).

### Bulk technology lookup for lead lists

Feed a column of domains from a CRM or spreadsheet and get one row per site. Filter the dataset afterwards, for example for rows whose `technologyNames` include a given ecommerce platform and a given email marketing or chat tool. Results export as JSON, CSV, Excel or via the API.

### Use cases

- **Lead qualification and segmentation:** find sites on a specific platform, or still on an older stack, before you reach out.
- **Competitor research:** see which analytics, chat, payment and tag-manager tools a competitor loads.
- **Agency prospecting:** shortlist sites by CMS or by missing tools (for example no cookie-consent tool detected).
- **Migration planning:** inventory the platforms across a portfolio of domains.
- **Security and tech audits:** spot exposed `server` and `poweredBy` header values and framework versions.
- **CRM enrichment:** add technology and email-provider columns to existing records.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `urls` | array of strings | required | Domains or URLs. Bare domains get `https://` added. Duplicates are removed. |
| `detectEmailProvider` | boolean | `true` | Look up MX records to identify the email provider. |
| `maxConcurrency` | integer | `10` | Sites analyzed in parallel, 1 to 25. |

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

### Output

One dataset row per site. Fields: `input`, `url`, `finalUrl`, `statusCode`, `title`, `technologies`, `technologyNames`, `categories`, `server`, `poweredBy`, `mx`, `emailProvider` and `error`. The values below are illustrative of the shape.

```json
{
  "input": "example.com",
  "url": "https://example.com",
  "finalUrl": "https://www.example.com/",
  "statusCode": 200,
  "title": "Example Store",
  "technologies": [
    { "name": "Next.js", "category": "JS framework", "version": null, "evidence": ["html"] },
    { "name": "Google Tag Manager", "category": "Tag manager", "version": null, "evidence": ["script"] }
  ],
  "technologyNames": ["Next.js", "Google Tag Manager"],
  "categories": ["JS framework", "Tag manager"],
  "server": "nginx",
  "poweredBy": null,
  "mx": ["aspmx.l.google.com"],
  "emailProvider": "Google Workspace"
}
```

If a site cannot be fetched, the row contains `input`, `url`, an `error` (such as a network error code) and an empty `technologies` array. `emailProvider` is `Other` when MX records exist but match no known provider, and `null` when none are found.

### Pricing

Pay per event: **$0.002 per site analyzed** ($2 per 1,000 sites), no subscription.

- 500 sites: $1.00
- 5,000 sites: $10.00
- 50,000 sites: $100.00

One charge is made per site analyzed successfully; rows that returned an `error` are free. Apify platform usage is billed by Apify per its plan. Set a maximum charge per run in the run options and the actor stops when it is reached.

### How it works and limitations

- Only the URL you give is fetched (the homepage), one request per site, following redirects, with a 25-second timeout. The first 3 MB of HTML is examined.
- Detection uses 130+ hand-written fingerprints. Patterns are kept specific, so a miss is more likely than a false positive.
- Technologies injected only by client-side JavaScript after page load may be missed, since no browser runs.
- Inner pages are not crawled, so tools used only on checkout or blog pages will not appear.
- Sites that block automated requests may return an error or a challenge page instead of the real site.
- Email provider comes from MX records only and shows who receives mail, not who sends it.

Built and maintained with AI assistance. Missing a technology? Request it in the Issues tab.

### FAQ

**How do I find out what CMS a website is using?**
Run the actor with the domain and check `technologyNames` for a CMS or site builder such as WordPress, Drupal, Webflow or Wix, and `technologies[].evidence` to see why it matched.

**Can I check thousands of websites at once?**
Yes. Pass them in `urls` and raise `maxConcurrency` up to 25. Cost is $0.002 per site.

**How can I tell which email provider a domain uses?**
Leave `detectEmailProvider` on. The `mx` and `emailProvider` fields show the MX hosts and the provider inferred from them.

**Why was a technology on a site not detected?**
It may be loaded only by client-side JavaScript, appear only on inner pages, or not have a fingerprint yet. Report it in the Issues tab.

**Does it detect version numbers?**
Where the page exposes them (for example in a `generator` meta tag or a script URL), they appear in `version`; otherwise `version` is `null`.

**Is this a Wappalyzer or BuiltWith replacement?**
It is an independent tool with its own, smaller fingerprint set focused on common technologies, priced per site with no subscription.

### Related tools

Other actors by the same developer (same flat pay-per-result pricing, no subscription):

- [Apple App Store Reviews Scraper (Multi-Country)](https://apify.com/forevertools/apple-app-store-reviews)
- [Article Extractor – Clean Text & Markdown for LLM/RAG](https://apify.com/forevertools/article-extractor)
- [Company Jobs Scraper: Workday, Greenhouse, Lever, Ashby](https://apify.com/forevertools/ats-company-jobs)
- [Bulk Domain Checker — WHOIS/RDAP, DNS, SPF/DMARC, SSL Expiry](https://apify.com/forevertools/domain-whois-dns-ssl)
- [Bulk PageSpeed Insights & Core Web Vitals Checker](https://apify.com/forevertools/pagespeed-core-web-vitals)
- [PDF to Text Extractor (Bulk, with Metadata)](https://apify.com/forevertools/pdf-to-text-extractor)
- [Website SEO Audit Crawler](https://apify.com/forevertools/website-seo-audit)
- [Sitemap Extractor & Bulk URL Status Checker](https://apify.com/forevertools/sitemap-url-status-checker)
- [Website Screenshot – Bulk Full Page PNG, JPEG & PDF](https://apify.com/forevertools/website-screenshot)

### Integrations

Run it from the Apify API, a schedule, or no-code tools: the Apify apps for **Zapier**, **Make** and **n8n** can start any public actor ("Run Actor") and read its dataset. AI agents can call it through the **Apify MCP server**.

# Actor input Schema

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

Domains or URLs of websites to analyze (example.com, https://shop.example.com). Duplicates are removed. One row per site: detected technologies with categories (CMS, ecommerce, framework, analytics, CDN, payments...), server and X-Powered-By headers, and optionally the email provider from MX records. Sites that fail to load return a row with `error` and are not charged.

## `detectEmailProvider` (type: `boolean`):

Look up MX records to identify Google Workspace, Microsoft 365, etc.

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

Sites analyzed in parallel.

## Actor input object example

```json
{
  "urls": [
    "apify.com",
    "vercel.com"
  ],
  "detectEmailProvider": true,
  "maxConcurrency": 10
}
```

# 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": [
        "apify.com",
        "vercel.com"
    ]
};

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

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

```

## MCP server setup

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