# Website Tech Stack Detector (`wiry_kingdom/website-tech-stack-detector`) Actor

Detect 70+ technologies on any website - CMS, JS frameworks, CDN, analytics, hosting, ecommerce platform, UI libraries and more. Fast, accurate, no headless browser needed. Perfect for lead generation, competitive research and sales prospecting.

- **URL**: https://apify.com/wiry\_kingdom/website-tech-stack-detector.md
- **Developed by:** [Mohieldin Mohamed](https://apify.com/wiry_kingdom) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

**Identify the technologies powering any website in seconds.** Website Tech Stack Detector analyzes HTTP headers, HTML markup, scripts, and cookies to uncover the CMS, JavaScript frameworks, CDN, hosting provider, analytics tools, ecommerce platform, and marketing stack behind any public URL. Perfect for **lead generation, competitive research, sales prospecting, and market analysis**.

Run it on a single URL or thousands in one batch - results come back as structured JSON you can export to CSV, Excel, JSON, or pipe directly into your CRM via the Apify API.

### What does Website Tech Stack Detector do?

Website Tech Stack Detector fetches a website's homepage (or any URL you provide), parses the response, and matches against 70+ technology signatures across these categories:

- **CMS** - WordPress, Drupal, Joomla, Ghost, Wix, Squarespace, Webflow, Contentful, Sanity
- **Ecommerce** - Shopify, WooCommerce, Magento, BigCommerce, PrestaShop
- **JS Frameworks** - Next.js, Nuxt.js, React, Vue, Angular, Svelte, SvelteKit, Gatsby, Astro, Remix
- **Backend** - Express, PHP, ASP.NET, Ruby on Rails, Django, Laravel
- **Servers & Hosting** - nginx, Apache, IIS, LiteSpeed, Vercel, Netlify, GitHub Pages, Cloudflare Pages
- **CDN** - Cloudflare, CloudFront, Fastly, Akamai
- **Analytics** - Google Analytics, GTM, Plausible, Fathom, Mixpanel, Segment, Hotjar, Amplitude, PostHog
- **Marketing** - HubSpot, Intercom, Drift, Mailchimp
- **UI Libraries** - Tailwind, Bootstrap, Material UI, Chakra UI, jQuery
- **Fonts** - Google Fonts, Adobe Fonts

Every detection includes a confidence score based on how many signature rules matched.

### Why use Website Tech Stack Detector?

- **Lead generation** - Find prospects that use a specific technology (e.g., "all Shopify stores in my niche") and target them with relevant outreach
- **Competitive research** - Understand what tech stack your competitors rely on before planning a migration or redesign
- **Sales enablement** - Qualify inbound leads automatically by knowing their stack before the first call
- **Market analysis** - Study technology adoption trends across thousands of domains in minutes
- **Due diligence** - Audit a portfolio of websites before acquisition or partnership
- **Cheap and fast** - Uses HTTP + Cheerio (no headless browser), so scans complete in a fraction of the cost and time of browser-based detectors

Built on the Apify platform, you get scheduling, API access, proxy rotation, webhook integrations, and monitoring out of the box.

### How to use Website Tech Stack Detector

1. Click **Try for free** and sign in to Apify (or create a free account in seconds)
2. Paste the URLs you want to scan into the **Start URLs** field
3. Click **Start** - the actor fetches each homepage and runs all signatures
4. Wait a few seconds per URL, then open the **Output** tab to view the detected technologies
5. Export results as JSON, CSV, Excel, or fetch them via the Apify API

You can also schedule recurring scans (daily, weekly) and get notified via webhook whenever a site's stack changes.

### Input

The actor accepts a list of URLs to scan plus an optional safety limit. Input is defined by `input_schema.json`:

```json
{
    "startUrls": [
        { "url": "https://apify.com" },
        { "url": "https://vercel.com" },
        { "url": "https://stripe.com" }
    ],
    "maxRequestsPerCrawl": 100
}
````

| Field | Type | Description |
|-------|------|-------------|
| `startUrls` | array | List of URLs to scan. Each entry is `{ "url": "https://..." }`. Required. |
| `maxRequestsPerCrawl` | integer | Upper bound on the number of requests processed. Default: 100, max: 1000. |

### Output

Every scanned URL produces one dataset item:

```json
{
    "url": "https://apify.com",
    "statusCode": 200,
    "title": "Apify: Full-stack web scraping and data extraction platform",
    "technologies": [
        { "name": "Next.js", "category": "frameworks", "confidence": 0.67, "rulesMatched": 2, "rulesTotal": 3 },
        { "name": "Cloudflare", "category": "cdn", "confidence": 1, "rulesMatched": 2, "rulesTotal": 2 },
        { "name": "Google Tag Manager", "category": "analytics", "confidence": 0.5, "rulesMatched": 1, "rulesTotal": 2 }
    ],
    "categorized": {
        "frameworks": ["Next.js"],
        "cdn": ["Cloudflare"],
        "analytics": ["Google Tag Manager"]
    },
    "scannedAt": "2026-04-13T19:42:17.301Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from the Output tab or via the Apify API.

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | The final URL after any redirects |
| `statusCode` | integer | HTTP response status code |
| `title` | string | Contents of the `<title>` tag |
| `technologies` | array | Every detected technology with its category and confidence score (0-1) |
| `categorized` | object | Technologies grouped by category for quick filtering |
| `scannedAt` | string | ISO timestamp of the scan |

### How much does it cost to detect tech stacks?

The actor uses a lightweight Cheerio crawler with 10 concurrent requests and no headless browser, so it is cheap to run. A scan of 100 URLs typically consumes a few cents of platform credit. Apify offers a free tier that covers several thousand scans per month.

### Tips and advanced options

- **Scan multiple pages per domain** - Some technologies are only visible on product pages or checkout. Add the most relevant URLs per domain.
- **Schedule recurring scans** - Use Apify Schedules to rescan your lead list weekly and detect when sites migrate to new platforms.
- **Integrate with your CRM** - Use Apify webhooks to push detections to HubSpot, Salesforce, or Airtable in real time.
- **Custom signatures** - Need a signature we don't cover yet? Open an issue and we will add it.

### FAQ

**Does this hit my API rate limits?** No. The actor runs inside Apify's infrastructure and respects polite crawl delays.

**Is it legal to scan a website's tech stack?** The actor only requests publicly served HTML and inspects information the site voluntarily returns in response headers and markup. This is the same information your browser's DevTools show you. No terms of service are bypassed.

**What if the technology I need isn't detected?** The signature database is growing. Open an issue describing the technology and the URL where it should be detected, and we will add a signature in the next release.

**Can I self-host this?** Yes - the source is a standard Node.js Apify actor. Clone it, run `npm install`, and run `apify run` locally.

### Support

Found a false positive or a missing technology? Open an issue on the Issues tab and we will look at it. For custom signatures or bulk scanning over 100,000+ URLs, contact the author directly.

# Actor input Schema

## `startUrls` (type: `array`):

The list of websites to scan. You can enter any public URL — the actor will fetch the homepage and analyze the response.

## `maxRequestsPerCrawl` (type: `integer`):

Upper bound on requests processed by the crawler (safety cap).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com"
    },
    {
      "url": "https://vercel.com"
    }
  ],
  "maxRequestsPerCrawl": 100
}
```

# Actor output Schema

## `dataset` (type: `string`):

One row per scanned URL with all detected technologies grouped by category

# 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 = {
    "startUrls": [
        {
            "url": "https://apify.com"
        },
        {
            "url": "https://vercel.com"
        }
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Tech Stack Detector",
        "description": "Detect 70+ technologies on any website - CMS, JS frameworks, CDN, analytics, hosting, ecommerce platform, UI libraries and more. Fast, accurate, no headless browser needed. Perfect for lead generation, competitive research and sales prospecting.",
        "version": "0.1",
        "x-build-id": "vIxOcXYDhRs7YhCyh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/wiry_kingdom~website-tech-stack-detector/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-wiry_kingdom-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/wiry_kingdom~website-tech-stack-detector/runs": {
            "post": {
                "operationId": "runs-sync-wiry_kingdom-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/wiry_kingdom~website-tech-stack-detector/run-sync": {
            "post": {
                "operationId": "run-sync-wiry_kingdom-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "The list of websites to scan. You can enter any public URL — the actor will fetch the homepage and analyze the response.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max requests per crawl",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper bound on requests processed by the crawler (safety cap).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```