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

Detect the tech stack of many websites at once: CMS, ecommerce, analytics, CDN, web server, frameworks and 3,600+ technologies with versions. Wappalyzer-style fingerprints over plain HTTP, no browser. $0.50 per 1,000 sites, failures free.

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

## Pricing

$0.50 / 1,000 analyzed sites

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

## Tech Stack Detector: Bulk Website Technology & CMS Lookup

Find out **what any website is built with**, for thousands of sites in one run. This bulk **tech stack detector** and **website technology checker** returns the **CMS**, **ecommerce platform**, **analytics**, **CDN**, **web server**, **frameworks** and 3,600+ other technologies, with **versions** and **confidence**. It's a Wappalyzer-style (and BuiltWith-style) checker that works over **plain HTTP, with no browser, no login and no personal data**. **$0.50 per 1,000 analyzed sites. Invalid, blocked and unreachable sites are free.**

### What does this tech stack detector do?

For each website or domain you give it, the Actor:

- Fetches the public homepage once (it follows redirects, reads up to about 1 MB of HTML, and sends no cookies or credentials)
- Matches **3,600+ technology fingerprints** against the response headers, cookie names, `<meta>` tags, `<script src>` URLs, inline scripts, HTML, DOM selectors, robots.txt and, optionally, public **DNS records** (MX, TXT, NS, CNAME, SOA)
- Returns one row per site with `technologies` (`name`, `categories`, `version`, `confidence`, `website`), a `categories` map, and ready-to-filter summary columns: `cms`, `ecommerce`, `analytics`, `cdn`, `server`, `frameworks`
- Respects **robots.txt** by default, and refuses private, local and internal addresses as well as login, account, admin and checkout pages
- Flags bot-protection challenge pages (Cloudflare, Vercel and similar) as `BOT_CHALLENGE` and doesn't charge for them

Examples of what it finds: WordPress (with version), WooCommerce, Shopify, Magento, BigCommerce, Squarespace, Wix, Webflow, Drupal, Joomla, Ghost, Next.js, Nuxt.js, React, Vue.js, Angular, Svelte, Astro, Gatsby, Hugo, Jekyll, Docusaurus, Google Analytics, Google Tag Manager, Hotjar, Microsoft Clarity, Facebook Pixel, HubSpot, Klaviyo, Cloudflare, Amazon CloudFront, Fastly, Akamai, Vercel, Netlify, Nginx, Apache, LiteSpeed, PHP, jQuery, Bootstrap, and payment, chat, consent, CRM and email tools.

### Who is it for?

- **Agencies and lead-gen teams:** find every Shopify, WooCommerce or WordPress site on a prospect list, or every site that's missing analytics, then segment with the `cms` and `ecommerce` columns. Company websites only; the Actor collects no personal data.
- **SEO, CRO and competitive research:** see what competitors run (frameworks, CDNs, A/B testing and analytics tools) across hundreds of domains at once
- **AI agents and automations:** a stable JSON schema through the Apify API or MCP, a clear `status` field, and a flat price per site

### Quick start

1. Paste websites or bare domains, one per line (for example `wordpress.org`). The form comes prefilled, so **Start** works right away.
2. Optionally lower `maxSites` to cap spend, or raise `maxConcurrency` for a long list.
3. Click **Start**, then download the results as JSON, CSV or Excel, or read them through the API. The **Overview** view shows one line per site; **All technologies** shows the full list.

Feeding it a domain list from another tool? Run the [Bulk Domain Availability Checker](https://apify.com/hillcountrybots/domain-availability-checker) first to drop unregistered domains, so you don't pay for nothing. (Failed sites are free here anyway.)

#### Sample output

This table is from a real run on **November 10, 2026, at 9:34 PM CT** (America/Chicago). You pay about **$0.50 per 1,000** sites that are successfully analyzed. Unreachable and blocked sites are free.

![Sample output from a real Tech Stack Detector run](https://api.apify.com/v2/key-value-stores/2kusIBSeqRffwM3Q9/records/techstack-sample-output.png?signature=1EjQTmwOK1JgyMO0ToRx6)

| Site | CMS | Ecommerce | Analytics | CDN | Server | Frameworks | Techs |
|---|---|---|---|---|---|---|---:|
| wordpress.org | WordPress | n/a | n/a | n/a | Nginx | n/a | 12 |
| allbirds.com | n/a | Shopify | Microsoft Clarity | Cloudflare | n/a | n/a | 13 |
| nextjs.org | n/a | n/a | n/a | n/a | n/a | Next.js, React | 10 |

"Techs" is the number of technologies detected on the homepage. If a site cannot be analyzed, the run writes a row with `status: "error"`, `errorCode` and `errorMessage` instead of finishing as a silent success with empty data. Those rows are not charged.

#### Example inputs

Detect the tech stack of a few websites:

```json
{
  "urls": ["wordpress.org", "https://www.allbirds.com/", "https://nextjs.org/"]
}
```

A bulk lookup of a lead list, capped at 5,000 sites ($2.50 maximum):

```json
{
  "urls": ["example-store-1.com", "example-store-2.com", "example-agency.com"],
  "maxSites": 5000,
  "maxConcurrency": 25
}
```

HTTP only, without DNS lookups (slightly faster):

```json
{
  "urls": ["https://www.squarespace.com/", "https://webflow.com/"],
  "checkDns": false
}
```

Scan your own staging site even if robots.txt blocks crawlers:

```json
{
  "urls": ["https://staging.your-own-site.com/"],
  "respectRobotsTxt": false
}
```

Ready-to-run example tasks (pre-filled inputs on this Actor's Store page):

- [Detect CMS, ecommerce and frameworks on a short site list](https://apify.com/hillcountrybots/tech-stack-detector/examples/techstack-cms-ecommerce-frameworks)
- [Bulk tech stack lookup of a short lead list](https://apify.com/hillcountrybots/tech-stack-detector/examples/techstack-lead-list-capped)

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `urls` | array of strings | (required, prefilled) | Websites or bare domains. The homepage (or the exact public page given) is analyzed. |
| `maxSites` | integer | `1000` | Max sites analyzed and charged in this run. Caps spend at `maxSites` × $0.0005. Failed sites don't count. |
| `maxConcurrency` | integer 1-50 | `10` | Sites fetched in parallel. |
| `requestTimeoutSecs` | integer 5-60 | `20` | Seconds per homepage, including redirects. One retry on timeouts, network errors, 429 and 5xx. |
| `respectRobotsTxt` | boolean | `true` | Skip (free) any page robots.txt disallows for our crawler or for all crawlers. |
| `checkDns` | boolean | `true` | Read public MX/TXT/NS/CNAME/SOA records to detect email, DNS and hosting providers. |

### Output example

```json
{
  "input": "wordpress.org",
  "url": "https://wordpress.org/",
  "finalUrl": "https://wordpress.org/",
  "statusCode": 200,
  "pageTitle": "Blog Tool, Publishing Platform, and CMS | WordPress.org",
  "technologyCount": 12,
  "technologies": [
    { "name": "WordPress", "categories": ["CMS", "Blogs"], "version": "7.2", "confidence": 100, "website": "https://wordpress.org" },
    { "name": "Gutenberg", "categories": ["WordPress plugins", "Editors"], "version": "24.3.1", "confidence": 100, "website": "https://github.com/WordPress/gutenberg" },
    { "name": "Nginx", "categories": ["Web servers", "Reverse proxies"], "version": null, "confidence": 100, "website": "http://nginx.org/en" },
    { "name": "Google Tag Manager", "categories": ["Tag managers"], "version": null, "confidence": 100, "website": "http://www.google.com/tagmanager" }
  ],
  "categories": { "CMS": ["WordPress"], "Blogs": ["WordPress"], "Web servers": ["Nginx"], "Tag managers": ["Google Tag Manager"] },
  "cms": "WordPress",
  "ecommerce": null,
  "analytics": [],
  "cdn": [],
  "server": "Nginx",
  "frameworks": [],
  "status": "ok",
  "errorCode": null,
  "errorMessage": null,
  "analyzedAt": "2026-11-10T23:30:00.000Z"
}
```

(The `technologies` list is shortened above. A real row lists everything that was detected.)

A site that could not be analyzed is **not charged** and looks like this:

```json
{"input": "this-domain-does-not-exist-12345.com", "status": "error", "errorCode": "DNS_NOT_FOUND", "errorMessage": "Domain does not resolve (ENOTFOUND)", "technologies": []}
```

The key-value store also gets a `RUN_SUMMARY` record with totals (`analyzed`, `failed`, `skippedOverCap`, `technologiesFound`).

#### Output fields (for AI agents and integrations)

- `status`: `ok` means the homepage was fetched and analyzed (one `site-analyzed` charge). `error` means it wasn't analyzed and isn't charged.
- `technologies[]`: `name`, `categories` (category names), `version` (string or `null`), `confidence` (0-100; 100 = definite), `website`.
- `cms`, `ecommerce`, `server`: the main one or `null`. `analytics`, `cdn`, `frameworks`: arrays.
- `errorCode` is one of: `INVALID_URL`, `PRIVATE_URL`, `BLOCKED_PATH`, `ROBOTS_DISALLOWED`, `DNS_NOT_FOUND`, `TIMEOUT`, `TLS_ERROR`, `NETWORK_ERROR`, `TOO_MANY_REDIRECTS`, `UNSAFE_REDIRECT`, `HTTP_<code>`, `NOT_HTML`, `REDIRECTED_TO_LOGIN`, `BOT_CHALLENGE`.

### Use it from the API, MCP or an AI agent

- **Actor ID:** `hillcountrybots/tech-stack-detector`
- **One API call** returns the rows:

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

- **MCP (Claude, Cursor, ChatGPT and other MCP clients):** add `https://mcp.apify.com?tools=hillcountrybots/tech-stack-detector`.
- **For agents:** branch on `status`, and filter on `cms` / `ecommerce`. Each `ok` row is one charged site. Error rows are free.

### How much does it cost?

**$0.50 per 1,000 analyzed sites**, which is $0.0005 per `site-analyzed` event. You pay nothing for:

- invalid, private or blocked inputs
- sites that are unreachable, time out, return an error status, are not HTML, redirect to a login page, or show a bot-protection challenge
- pages skipped because of robots.txt or because the `maxSites` cap was reached

The Actor's compute is included, so there's no separate platform usage charge. For example, a 2,000-site lead list costs at most $1.00. To cap spend, use `maxSites` or the run's maximum charge setting. For comparison, other Store tech-stack Actors charge about $1.20 to $2.30 per 1,000 sites, some plus a start fee (Apify Store, Nov 2026).

### Limits

- **HTTP only, no browser.** Technologies that only show up after JavaScript runs (for example tools injected later by Google Tag Manager) can be missed. Fingerprints that need a JavaScript runtime are skipped. We add our own static-HTML patterns for popular frameworks and trackers (Next.js, Nuxt.js, Remix, Angular, Vue.js, Svelte, Squarespace, GA4, Facebook Pixel, Hotjar, HubSpot and others) to close most of that gap.
- Only one page per site is analyzed (the homepage, or the exact public URL you give). Tech that appears only on inner pages, such as checkout, won't show.
- Sites behind strong bot protection can return `BOT_CHALLENGE` or `HTTP_403`/`HTTP_429`. Those are free. We don't use proxies or try to get around protection.
- The fingerprint database is the last MIT-licensed Wappalyzer release (6.10.54, Jan 2023) plus Hill Country Bots additions. Technologies launched after that may be missing until we add them. Open an issue if one is.
- Versions appear only when the site exposes them (meta generator, file names, headers).

### FAQ

**Is this a Wappalyzer or BuiltWith alternative?** It uses Wappalyzer-format fingerprints, runs in bulk, and costs $0.50 per 1,000 sites. It reads each site live and doesn't use a historical database like BuiltWith.

**How do I check what CMS a website uses?** Paste the domain and read the `cms` column (WordPress, Drupal, Wix, Squarespace, Webflow...). For stores, read `ecommerce` (Shopify, WooCommerce, Magento, BigCommerce...).

**Can I find all Shopify stores in my list?** Yes. Run the list, then filter `ecommerce = Shopify` in the dataset or in your spreadsheet.

**Does it collect personal data?** No. It reads public homepage markup and public DNS only, and it never logs in or stores cookie values. Use it on company websites.

**Does it respect robots.txt?** Yes, by default. Disallowed pages are skipped for free.

**What's the accuracy?** In our Nov 2026 test of 50 known sites, the expected platform (WordPress, Shopify, Next.js, Squarespace, Wix, Webflow, Hugo, Nuxt and others) was detected on all 32 reachable sites where we knew it. Sites that block bots were returned as free errors. See Limits for what HTTP-only detection can miss.

### More tools from Hill Country Bots

- [Bulk PageSpeed Insights Test](https://apify.com/hillcountrybots/bulk-pagespeed-checker): Lighthouse scores and Core Web Vitals for many URLs. $3 per 1,000 audits, failures free.
- [Bulk Domain Availability Checker](https://apify.com/hillcountrybots/domain-availability-checker): Bulk available/taken checks from official registry RDAP, with registrar and expiry dates. $1 per 1,000 domains, invalid inputs and errors free.
- [Sitemap URL Extractor](https://apify.com/hillcountrybots/sitemap-url-extractor): Every URL from a site's XML sitemaps (robots.txt, indexes, gzip). $0.50 per 1,000 URLs, failures free.
- [SEO Audit Tool](https://apify.com/hillcountrybots/seo-audit): 0-100 SEO score per page, top 5 fixes and a client-ready HTML report. $2 per 1,000 pages, failures free.

### Credits and license

Fingerprint data and the matching engine come from the npm package [`wappalyzer` 6.10.54](https://www.npmjs.com/package/wappalyzer/v/6.10.54), which is MIT-licensed, © Elbert Alias / Wappalyzer. Later Wappalyzer releases and the GPL-3.0 community forks are not used. Hill Country Bots isn't affiliated with Wappalyzer or BuiltWith.

### Support

Found a missed or wrong technology? Open an issue on this Actor's **Issues** tab with the run ID and the website. We reply within 2 business days (US Central time). Built and maintained by **Hill Country Bots**.

# Actor input Schema

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

Required. Website URLs or bare domains, one per line (https://example.com/ or example.com). The homepage (or the exact public page you give) is analyzed. Private, local and internal addresses, non-http schemes and login/account/admin/checkout pages are refused for free.

## `maxSites` (type: `integer`):

Maximum number of sites analyzed and charged in this run. Caps spend at maxSites x $0.0005 (1,000 = $0.50). Failed sites do not count toward the cap. The run's own max-charge setting is also respected.

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

Sites fetched in parallel (1-50).

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

Seconds to wait for one homepage, including redirects (one retry on timeouts, network errors, 429 and 5xx).

## `respectRobotsTxt` (type: `boolean`):

Skip (free) any page that the site's robots.txt disallows for our crawler or for all crawlers. Only turn this off for sites you own or are allowed to scan.

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

Also read the domain's public DNS records (MX, TXT, NS, CNAME, SOA) to detect email, DNS and hosting providers such as Google Workspace, Microsoft 365 or Cloudflare DNS. Adds a few milliseconds per site.

## Actor input object example

```json
{
  "urls": [
    "wordpress.org",
    "https://www.allbirds.com/",
    "https://nextjs.org/"
  ],
  "maxSites": 1000,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20,
  "respectRobotsTxt": true,
  "checkDns": true
}
```

# 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": [
        "wordpress.org",
        "https://www.allbirds.com/",
        "https://nextjs.org/"
    ]
};

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

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

```

## MCP server setup

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