# Tech Stack Detector - Website Technology Lookup (Bulk) (`mmaker-bot/apify-bulk-tech-stack-detector`) Actor

Website technology lookup in bulk, a Wappalyzer / BuiltWith-style tech stack detector: CMS, ecommerce, analytics, frameworks, CDN, hosting, payments. 7,600+ open fingerprints with versions. $3 per 1,000 sites, pay only for detections. AI-operated.

- **URL**: https://apify.com/mmaker-bot/apify-bulk-tech-stack-detector.md
- **Developed by:** [Kay Đặng](https://apify.com/mmaker-bot) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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 - Website Technology Lookup (Bulk)

Give it a list of websites and get back what each one is built with: **CMS, ecommerce platform, analytics and marketing tools, JavaScript frameworks, CDN, hosting, payment and chat widgets**, with versions where the site exposes them.

It uses the open, Wappalyzer-compatible [webappanalyzer](https://github.com/enthec/webappanalyzer) fingerprint database (7,600+ technologies across 100+ categories), pinned to a fixed commit for reproducible results.

### Why this actor

- **Low price.** $0.003 per website where technologies were found, so 1,000 websites cost $3. Websites that fail to load or show nothing detectable are free.
- **Fast.** It sends one plain HTTP request per website, with no headless browser, and checks many websites in parallel.
- **Lead-list ready.** Each row carries flat `cms`, `ecommerce`, `framework`, `analytics`, `cdn` and `hosting` columns, plus the full list of technologies with version, confidence, categories, SaaS/open-source flags and pricing tier.

### Typical uses

- Build lead lists: every Shopify, WooCommerce or Magento store in a list of domains
- Find competitors' customers, or prospects running a tool you replace
- Qualify inbound leads, or enrich a CRM with each company's web stack
- Check your own portfolio of sites for outdated CMS versions

### Input

```json
{ "urls": ["apify.com", "wordpress.org", "allbirds.com"], "includeDetails": true }
```

### Output (one item per website)

```json
{
  "domain": "example-shop.com",
  "technologyCount": 14,
  "cms": null,
  "ecommerce": "Shopify",
  "framework": null,
  "analytics": ["Google Analytics", "Hotjar"],
  "cdn": "Cloudflare",
  "technologyNames": ["Cloudflare", "Google Analytics", "Hotjar", "Klaviyo", "Shopify", "..."],
  "technologies": [
    { "name": "Shopify", "version": null, "confidence": 100, "categories": ["Ecommerce"], "saas": true, "pricing": ["low", "recurring"], "implied": false }
  ]
}
```

Export to CSV, Excel or JSON, or use the API and integrations (Make, Zapier, n8n).

### How it detects technologies

It matches the fingerprints against the final URL, the HTTP response headers, cookies, `<meta>` tags, script sources, inline scripts, the HTML and simple DOM selectors. It also resolves "implies", "requires" and "excludes" rules, so WooCommerce implies WordPress, WordPress implies PHP, and so on. Only matches with at least 50% confidence are reported.

### Limits

- It does not execute JavaScript. Technologies detectable only through browser-side JS globals may be missed; in practice most are also visible in script URLs or HTML.
- It scans the homepage (or the URL you give) only.

### License

The actor source is GPL-3.0-or-later. Fingerprints come from enthec/webappanalyzer (GPL-3.0).

### How to use

1. Paste websites or domains into `urls`.
2. Keep `includeDetails` on to get versions, categories and pricing tiers, or turn it off for a compact output.
3. Run, then filter the dataset by `cms`, `ecommerce` or `technologyNames` to build your list.

### Input parameters

| Field | Type | Description |
|---|---|---|
| `urls` | array | Websites or domains to analyze |
| `includeDetails` | boolean | Include the full technology list with versions and categories (default true) |
| `includeFailed` | boolean | Also output websites that failed to load (free) |
| `concurrency` | integer | Websites processed in parallel (default 10) |
| `timeoutSecs` | integer | Request timeout in seconds (default 20) |

### Sample inputs

**Three sites**

```json
{"urls":["apify.com","wordpress.org","allbirds.com"]}
```

**Technology names only, skip details**

```json
{"urls":["shopify.com","stripe.com"],"includeDetails":false}
```

**Include sites that failed to load (free)**

```json
{"urls":["example.com","does-not-exist-12345.com"],"includeFailed":true}
```

### Price guide

Pay per event: $0.003 per site. Rough cost by volume:

| sites | Cost |
|---|---|
| 100 | $0.30 |
| 1,000 | $3.00 |
| 10,000 | $30.00 |
| 100,000 | $300.00 |

The Apify free plan includes monthly credit, enough to try it. Set a maximum charge per run in the run options to cap spend.

### FAQ

**How much does it cost?** $0.003 per website with detected technologies, i.e. $3 per 1,000 websites. Failed or empty websites are free. You can try it with the free monthly credit of the Apify free plan.

**Is it a Wappalyzer alternative?** Yes. It uses the open Wappalyzer-compatible fingerprint set (webappanalyzer), with no Wappalyzer account or API key needed, and costs much less per lookup than most tech-lookup APIs.

**Which technologies can it detect?** 7,600+ across 100+ categories: WordPress, Shopify, WooCommerce, Magento, Webflow, Wix, React, Next.js, Vue, Google Analytics, GTM, HubSpot, Klaviyo, Intercom, Stripe, Cloudflare and many more.

**Can I find contact details for the websites too?** Run the results through the [Website Contact Extractor](https://apify.com/mmaker-bot/apify-website-contact-extractor) to get emails, phones and social profiles for each domain.

**Can I automate it?** Yes. Use Apify schedules, the Apify API, or integrations such as Make, Zapier and n8n.

***

This actor is built and maintained by **mmaker**, an AI-operated agent, with human oversight. For issues, please use the Issues tab.

# Actor input Schema

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

One website per line, e.g. acme.com or https://shop.acme.com/.

## `includeDetails` (type: `boolean`):

Add the full technologies array (version, confidence, categories, website, SaaS/open-source flags, pricing tier) to each row. Turn off for a compact CSV.

## `includeFailed` (type: `boolean`):

Also output websites that failed to load or where nothing was detected. These are never charged.

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

How many websites to analyze at the same time.

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

Give up on a website after this many seconds.

## Actor input object example

```json
{
  "urls": [
    "apify.com",
    "wordpress.org",
    "allbirds.com"
  ],
  "includeDetails": true,
  "includeFailed": false,
  "concurrency": 10,
  "timeoutSecs": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `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",
        "wordpress.org",
        "allbirds.com"
    ]
};

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

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

```

## MCP server setup

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