# Website Tech Stack Detector - CMS, Ecommerce & Martech (`webdata_labs/website-tech-stack-detector`) Actor

\[💵 $2.00 / 1K] Detect the technologies a website runs - CMS, ecommerce platform, analytics, marketing, chat, payments, frameworks, CDN - with lead-qualifier tags.

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

## Pricing

from $1.25 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Website Tech Stack Detector - CMS, Ecommerce & Martech

**Find out what technologies any website runs - CMS, ecommerce platform, analytics, marketing, chat, payments, JavaScript frameworks, and CDN - with ready-made lead-qualifier tags.**

Website Tech Stack Detector takes a list of domains and returns each site's technology profile as clean JSON/CSV rows. Built for B2B sales, agencies, competitive-intelligence, and recruiters who want to qualify and segment companies by the tools their websites use - not screenshots or guesswork.

### ✅ What you get / ❌ what this isn't

| This Actor gives you | This Actor is not |
|---|---|
| One row per site with detected technologies grouped by category | Not a full historical technology archive |
| Single-value fields for ecommerce platform, CMS, framework, and CDN | Not a vulnerability scanner |
| Lead-qualifier tags (is_ecommerce, has_live_chat, takes_payments, and more) | Not affiliated with Wappalyzer or BuiltWith |
| Confidence-scored, precise detection that avoids naive false positives | Not a guarantee of every tool a site uses internally |
| Graceful handling of bot-protected sites (status + partial detection) | Not a private-data scraper |

### 🔎 Why use this Actor

- Qualify and segment a lead list by ecommerce platform, CRM, or martech.
- Build a target list of sites using a specific technology (Shopify, HubSpot, Intercom).
- Audit a competitor's marketing and analytics stack.
- Enrich CRM records with technographic data.
- Feed technology rows into spreadsheets, BI tools, or LLM workflows.

### 🗂️ What data you get

| Field | Type | Description |
|---|---|---|
| `domain` | string | Normalized domain |
| `statusCode` | number | HTTP status of the fetch |
| `technologies` | array | Detected tech: name, category, confidence |
| `byCategory` | object | Technologies grouped by category |
| `categories` | array | Categories present on the site |
| `ecommercePlatform`, `cms`, `jsFramework`, `cdn` | string | Convenience single-value fields |
| `leadTags` | array | Qualifier tags such as is_ecommerce, has_live_chat |
| `server` | string | Server header when present |
| `protected` | boolean | Whether the site returned a bot-protection status |

### 👥 Who it's for

- B2B sales and SDR teams building technographic target lists.
- Agencies auditing prospect and competitor stacks.
- Competitive-intelligence and market-research analysts.
- Recruiters sourcing companies by tech stack.
- Data teams enriching CRM or lead datasets.

### Example tasks

- [Detect the tech stack of a list of websites](https://apify.com/webdata_labs/website-tech-stack-detector/examples/detect-the-tech-stack-of-a-list-of-websites)
- [Find websites using Shopify](https://apify.com/webdata_labs/website-tech-stack-detector/examples/find-websites-using-shopify)
- [Audit a competitor marketing and analytics stack](https://apify.com/webdata_labs/website-tech-stack-detector/examples/audit-a-competitor-marketing-and-analytics-stack)

### ⚙️ How to detect a website's tech stack

1. Open the Actor on Apify.
2. Paste one or more domains or URLs.
3. Keep Apify Proxy on for the most reliable fetches.
4. Run the Actor.
5. Open the dataset `Websites` view.
6. Export JSON, CSV, Excel, HTML, RSS, or XML, or call the Actor through the Apify API.

### 📥 Input

```json
{
  "urls": ["stripe.com", "gymshark.com", "notion.so"],
  "proxyConfiguration": { "useApifyProxy": true }
}
````

### 📤 Output

```json
{
  "recordType": "website",
  "domain": "gymshark.com",
  "statusCode": 200,
  "ecommercePlatform": "Shopify",
  "jsFramework": null,
  "cdn": "Cloudflare",
  "technologies": [
    { "name": "Shopify", "category": "Ecommerce", "confidence": "high" },
    { "name": "Zendesk", "category": "Chat & support", "confidence": "high" }
  ],
  "leadTags": ["has_live_chat", "is_ecommerce"]
}
```

### 💵 How much does it cost?

The launch price is about `$2.00 / 1,000 websites analyzed`, tier-discounted for higher Apify plans. One analyzed website is one charged result.

### 🔁 Run it on the Apify platform

Schedule recurring technographic refreshes, call it from the Apify API, export to CSV/JSON/Excel, or connect the dataset to Make, Zapier, webhooks, a warehouse, or an LLM pipeline.

### ⚠️ Limits and caveats

- This Actor reads a site's public homepage and response metadata. It detects technologies that leave public fingerprints; server-side or internal tools may not be visible.
- Some sites use bot protection and may return a 401/403/429/503. The Actor records the status and any technologies detectable from headers instead of failing.
- Detection is intentionally precise to avoid false positives, so a tool that is present but not referenced on the homepage may not appear.
- Technology fingerprints drift over time; the signature set is maintained, but occasional gaps are expected.

### 🧩 Related Actors

- Website Contact Extractor - turn the same domains into outreach-ready emails and socials.
- Shopify Store Analyzer - deep catalog and contact intelligence for Shopify stores.
- Lead List Deduplicator - clean and merge enriched lead rows before CRM import.
- Bulk URL Status Checker - audit URLs and redirects across a domain list.

### ❓ FAQ

#### How is this different from a Wappalyzer clone?

It uses precise, confidence-scored signatures to avoid the false positives naive detectors produce (for example matching a brand word that only appears in an "integrations" mention), and it adds lead-qualifier tags and convenience fields for sales workflows.

#### Can it process many domains at once?

Yes. Add up to 200 domains per run. Each analyzed website is one result.

#### Does it use a browser?

No. It fetches the homepage over HTTP and inspects the HTML, headers, and cookies, which keeps runs fast and cheap.

#### Why is a technology I expected missing?

The Actor only reports technologies with a clear public fingerprint on the page it fetched. Tools loaded later, behind login, or only on inner pages may not appear.

### 🛠️ Support

For bugs or missing signatures, open an Actor issue with the run URL, the domain, and the technology you expected.

# Actor input Schema

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

Websites to analyze. Domains or full URLs, for example stripe.com or https://gymshark.com.

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

Proxy used to fetch sites. Apify datacenter proxy is recommended; it rotates IPs and improves reliability on sites that block direct requests.

## Actor input object example

```json
{
  "urls": [
    "stripe.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `OUTPUT` (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": [
        "stripe.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/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": ["stripe.com"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/website-tech-stack-detector").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "stripe.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call webdata_labs/website-tech-stack-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=webdata_labs/website-tech-stack-detector",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Tech Stack Detector - CMS, Ecommerce & Martech",
        "description": "[💵 $2.00 / 1K] Detect the technologies a website runs - CMS, ecommerce platform, analytics, marketing, chat, payments, frameworks, CDN - with lead-qualifier tags.",
        "version": "0.1",
        "x-build-id": "xrm0xuiqFx6d7OtxT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~website-tech-stack-detector/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-website-tech-stack-detector",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/webdata_labs~website-tech-stack-detector/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-website-tech-stack-detector",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/webdata_labs~website-tech-stack-detector/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-website-tech-stack-detector",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "URLs or domains",
                        "type": "array",
                        "description": "Websites to analyze. Domains or full URLs, for example stripe.com or https://gymshark.com.",
                        "default": [
                            "stripe.com",
                            "gymshark.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy used to fetch sites. Apify datacenter proxy is recommended; it rotates IPs and improves reliability on sites that block direct requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
