# Tech Stack Detector — 7,600+ technologies, $0.01 per domain (`theaisololab/tech-stack-detector`) Actor

Find the CMS, e-commerce platform, analytics, ad pixels, live chat, payments, CDN and hosting behind any list of websites. Wappalyzer/BuiltWith alternative — you pay only for websites actually analysed.

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

## Pricing

from $10.00 / 1,000 domain analyseds

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 — 7,600+ technologies, $0.01 per domain

Paste a list of websites, get back what each one is built with: **CMS, e-commerce platform, analytics, ad pixels, tag managers, live chat, payment processors, JavaScript frameworks, CDN and hosting** — with versions when the site exposes them.

A fast, cheap alternative to Wappalyzer and BuiltWith lookups, built for lists: 10 domains or 100,000.

- **$0.01 per domain that responds.** Domains that time out, don't resolve, answer with an error or only show a bot-protection challenge are **free** — they still appear in the results, with the reason.
- **7,641 technology fingerprints** (6,494 of them detectable over plain HTTP).
- **One clean row per domain**, with ready-made columns (`cms`, `ecommerce`, `analytics`, `advertising`, `liveChat`, `payments`, `cdn`, `hosting`) and a one-sentence `summary` that people and LLMs can read directly.
- **No browser, no login, no cookies stored** — so it's fast (~20 domains in parallel by default) and cheap.
- **Built not to hang.** Matching runs on RE2, a regular-expression engine whose time grows linearly with the page, so a heavy page (megabytes of minified JavaScript) can't stall your run. Every download and every analysis has a deadline.

### What people use it for

- **Lead generation by technology** — find the Shopify stores, WordPress sites or HubSpot users in a list of prospects.
- **Competitor research** — see which analytics, ad networks and chat tools your competitors run.
- **Agency audits** — check a client portfolio for outdated CMS versions or missing analytics.
- **AI agents** — call it from Claude, ChatGPT, Cursor or any MCP client through the Apify MCP server; the `summary` field is written for LLMs.

### Input

```json
{
  "domains": ["wordpress.org", "shopify.com", "https://vercel.com/pricing"],
  "onlyCategories": [],
  "maxConcurrency": 20
}
```

| Field | What it does | Default |
|---|---|---|
| `domains` | Domains or URLs, one per line. Duplicates are removed. | — |
| `onlyCategories` | Keep only these categories, e.g. `CMS`, `Ecommerce`, `Analytics`. | everything |
| `minConfidence` | Drop detections below this confidence (0-100). | 0 |
| `maxConcurrency` | Websites fetched in parallel (1-100). | 20 |
| `requestTimeoutSecs` | Give up on a website after this many seconds. | 20 |
| `proxyConfiguration` | Optional Apify Proxy, for lists where many sites block the default IP. | off |

### Output

One item per domain:

```json
{
  "domain": "acme-bakery.example",
  "finalUrl": "https://acme-bakery.example/",
  "statusCode": 200,
  "ok": true,
  "blocked": false,
  "partial": false,
  "technologyCount": 9,
  "cms": ["WordPress"],
  "ecommerce": [],
  "analytics": ["Facebook Pixel", "Google Analytics"],
  "advertising": [],
  "liveChat": ["Tidio"],
  "payments": ["Stripe"],
  "cdn": ["Cloudflare"],
  "hosting": [],
  "technologies": [
    { "name": "WordPress", "version": "6.6.2", "confidence": 100, "categories": ["CMS", "Blogs"], "website": "https://wordpress.org", "implied": false },
    { "name": "MySQL", "version": null, "confidence": 100, "categories": ["Databases"], "website": "https://mysql.com", "implied": true }
  ],
  "summary": "acme-bakery.example — CMS: WordPress 6.6.2; Analytics: Facebook Pixel, Google Analytics ga4; Live chat: Tidio; Payment processors: Stripe; CDN: Cloudflare; Programming languages: PHP; Databases: MySQL; JavaScript libraries: jQuery.",
  "checkedAt": "2026-09-26T09:00:00+00:00"
}
```

`implied: true` means the technology wasn't seen directly but follows from another one (WordPress runs on PHP and MySQL, Next.js on React and Node.js).

Unreachable domains come back with `ok: false`, `statusCode` (if any) and `error` — and are not charged.

`blocked: true` means the site answered with a bot-protection challenge (Cloudflare, AWS WAF, Imperva, DataDome, HUMAN, Sucuri, Vercel, Akamai) instead of its page — even when the status code says 200 or 202. You get what the response headers reveal (CDN, hosting), and you don't pay. Re-run those domains with **Apify Proxy (residential)** in `proxyConfiguration` if you need them.

`partial: true` is a safety net you should rarely see: if a page is so heavy that its analysis hits the 20-second budget, you get what was found up to then — free of charge.

### How it works

Each website is fetched once, like a browser would, following redirects. The response is matched against the fingerprint database: HTTP headers, cookies, `<meta>` tags, script URLs, inline scripts and styles, the HTML itself and DOM selectors. Technologies imply others (Next.js → React), and versions are extracted when the page shows them.

Under the hood, each part of the page is scanned once for the literal strings the fingerprints need (RE2's FilteredRE2), and only the fingerprints whose strings are present run in full. A typical page takes a few milliseconds of matching; a 600 KB page full of inline JavaScript, well under a second.

**Limits, stated plainly:** there's no JavaScript execution, so technologies that can only be seen by running the page's scripts (a minority) are not detected. Sites behind aggressive bot protection answer with a challenge instead of the page — you'll see `blocked: true` in the results and you won't pay for it.

### Pricing

Pay per event: **$0.01 per domain analysed** (a 2xx/3xx response with the real page, fully analysed). Failed, blocked and partial results are free. A list of 1,000 responsive domains costs $10. You can cap spending per run in the run options.

### FAQ

**Is this legal?** It reads the same public homepage any visitor's browser receives, once per domain. It doesn't log in, bypass paywalls or collect personal data. Use the results in line with the laws that apply to you.

**How fresh is the fingerprint database?** It's refreshed monthly. The version in use is recorded in the Actor's changelog.

**Can I run it on a schedule?** Yes — use Apify Schedules to re-check a list weekly and watch for changes.

### Changelog

- **0.1** — first release: 7,641 fingerprints, versions, implied technologies, category filter, LLM-ready summary. Linear-time matching (RE2), deadlines on downloads and analysis, cookie values matched against fingerprints, bot-protection challenges reported as `blocked` and never charged.

### Credits

Technology fingerprints from [projectdiscovery/wappalyzergo](https://github.com/projectdiscovery/wappalyzergo) (MIT licence).

# Actor input Schema

## `domains` (type: `array`):

Bare domains (example.com) or full URLs (https://example.com/pricing). Duplicates are removed. Up to 100,000 per run.

## `onlyCategories` (type: `array`):

Keep only technologies in these categories, e.g. CMS, Ecommerce, Analytics, Advertising, Live chat, Payment processors, CDN. Leave empty to get everything.

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

Drop detections below this confidence (0-100). Most detections are 100.

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

How many websites to fetch in parallel.

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

Give up on a website after this many seconds.

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

Not needed for most websites. Turn on Apify Proxy if many sites block the default IP.

## Actor input object example

```json
{
  "domains": [
    "wordpress.org",
    "shopify.com",
    "vercel.com"
  ],
  "minConfidence": 0,
  "maxConcurrency": 20,
  "requestTimeoutSecs": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per domain: CMS, e-commerce, analytics, advertising, live chat, payments, CDN, hosting and a one-sentence summary. The 'Full detail' view adds every technology with version and confidence, plus the error, blocked and partial flags.

# 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 = {
    "domains": [
        "wordpress.org",
        "shopify.com",
        "vercel.com"
    ]
};

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

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

```

## MCP server setup

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