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

Uncover the technologies powering any website with the Website Tech Stack Detector. Instantly identify frameworks, CMS, and analytics tools. Lightweight and fast, it is perfect for market research and competitive analysis. For large-scale bulk scanning, residential proxies are recommended.

- **URL**: https://apify.com/shahidirfan/website-tech-stack-detector.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Developer tools, Automation, SEO tools
- **Features:** Limited permissions
- **Stats:** 131 total users, 6 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

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

## Website Tech Stack Scanner

> **Identify technologies used on any website** - Fast, efficient tech stack detection with smart fallback mechanisms. Detect frameworks, libraries, CMS, WAFs, APIs, and more.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com)
[![Tech Detection](https://img.shields.io/badge/Detection-TechStack-green)](https://apify.com)
[![Fast & Reliable](https://img.shields.io/badge/Speed-Optimized-orange)](https://apify.com)

### 📋 What This Actor Does

Website Tech Stack Scanner efficiently identifies technologies powering any website. Using a smart multi-tier approach, it prioritizes fast, resource-light methods before resorting to browser rendering. Perfect for:

- **Technology Research** - Discover what technologies competitors use
- **Lead Generation** - Find websites built with specific tech stacks
- **Security Analysis** - Identify WAFs and security layers
- **Development Planning** - Research technology choices for projects
- **Market Intelligence** - Track technology adoption trends

#### ✨ Key Features

- **Smart Detection Strategy** - HTTP headers → Static HTML → API probes → Browser rendering
- **Comprehensive Analysis** - Frameworks, CMS, libraries, WAFs, analytics, hosting
- **WAF Detection** - Identifies Cloudflare, Akamai, PerimeterX, Imperva, and more
- **API Endpoint Probing** - Discovers backend APIs and frameworks
- **Fast & Efficient** - Lightweight analysis before browser usage
- **Structured Data** - Extracts JSON-LD and Open Graph metadata

### 🚀 Quick Start

#### Basic Usage - Single Website

```json
{
  "urls": ["https://example.com"]
}
```

#### Advanced Usage - Multiple Sites with Deep Analysis

```json
{
  "urls": [
    "https://example.com",
    "https://another-site.com"
  ]
}
```

#### Batch Analysis

```json
{
  "urls": [
    "https://site1.com",
    "https://site2.com",
    "https://site3.com"
  ]
}
```

### 📊 Input Parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `urls` | array | Website URLs to analyze (required) | `[]` |
| `proxyConfiguration` | object | Optional proxy settings | `{"useApifyProxy": false}` |

#### Internal Runtime Defaults

The actor now manages advanced runtime tuning internally for consistent output quality:

- **Concurrency** — fixed internally
- **Browser fallback** — enabled internally
- **API endpoint probing** — enabled internally
- **Request timeout** — fixed internally

### 📈 Output Data Structure

Each website analysis includes:

```json
{
  "url": "https://example.com",
  "status": "success",
  "technologies": {
    "frontend": ["React 18.2.0", "Next.js 13.4.0"],
    "backend": ["Node.js", "Express"],
    "cms": ["WordPress 6.3"],
    "analytics": ["Google Analytics", "Hotjar"],
    "hosting": ["Vercel"],
    "cdn": ["Cloudflare"],
    "libraries": ["jQuery 3.6.0", "Bootstrap 5.2"]
  },
  "waf": {
    "detected": true,
    "provider": "Cloudflare",
    "confidence": "high"
  },
  "apis": {
    "graphql": true,
    "rest": true,
    "endpoints": ["/api/v1", "/graphql"]
  },
  "metadata": {
    "title": "Example Website",
    "description": "Example description",
    "structuredData": {...}
  },
  "server": {
    "software": "nginx/1.21.0",
    "headers": {...}
  },
  "detectionMethod": "static",
  "scannedAt": "2024-12-11T10:30:00.000Z"
}
```

#### Output Fields

- **`url`** - Analyzed website URL
- **`status`** - Analysis status (success/failed/partial)
- **`technologies`** - Categorized tech stack
- **`waf`** - Web Application Firewall details
- **`apis`** - Discovered API endpoints
- **`metadata`** - Page metadata and structured data
- **`server`** - Server and hosting information
- **`detectionMethod`** - How technologies were detected (static/browser/mixed)
- **`scannedAt`** - Analysis timestamp

### 🎯 Detection Methods

#### 1. HTTP Headers Analysis (Fastest)

- Server headers
- X-Powered-By headers
- Set-Cookie patterns
- Security headers

#### 2. Static HTML Parsing

- Meta tags
- Script src attributes
- Link tags (stylesheets, fonts)
- HTML comments and patterns

#### 3. API Endpoint Probing

- Common API paths: `/api`, `/graphql`, `/_next/static`
- CMS endpoints: `/wp-json`, `/admin`
- Framework-specific paths: `/_nuxt/`, `/__nextjs_`

#### 4. Browser Rendering (Fallback)

- Window object inspection
- Dynamic content loading
- Client-side frameworks (React, Vue, Angular)
- JavaScript libraries

### 🔍 Detected Technologies

#### Frameworks & Libraries

- **Frontend**: React, Vue, Angular, Svelte, Next.js, Nuxt.js, Gatsby
- **Backend**: Express, Django, Laravel, Ruby on Rails, ASP.NET
- **UI**: Bootstrap, Tailwind CSS, Material-UI, Ant Design

#### CMS & Platforms

- WordPress, Drupal, Joomla, Shopify, Magento, Wix, Squarespace

#### WAFs & Security

- Cloudflare, Akamai, PerimeterX, Imperva, Kasada, Datadome

#### Analytics & Marketing

- Google Analytics, Tag Manager, Facebook Pixel, Hotjar, Mixpanel

#### Hosting & CDN

- Vercel, Netlify, AWS, GCP, Azure, Cloudflare, Fastly

### ⚡ Performance Tips

#### Recommended Settings

| Use Case | URLs | Concurrency | Playwright | API Probe | Est. Time |
|----------|------|-------------|------------|-----------|-----------|
| Quick Check | 1-5 | 5 | `false` | `false` | ~5-10s |
| Standard Analysis | 5-20 | 3-5 | `true` | `true` | ~30-60s |
| Batch Processing | 20-100 | 5-10 | `true` | `true` | ~2-5m |

#### Cost Optimization

1. **Disable Playwright** for static sites (faster, cheaper)
2. **Reduce concurrency** to avoid rate limits
3. **Use proxies** for large batches
4. **Filter URLs** to analyze only relevant pages

### 🔧 Configuration Examples

#### Security Audit

```json
{
  "urls": ["https://target-site.com"]
}
```

#### Competitor Analysis

```json
{
  "urls": [
    "https://competitor1.com",
    "https://competitor2.com",
    "https://competitor3.com"
  ]
}
```

#### Lead Generation (Find WordPress Sites)

```json
{
  "urls": ["https://site1.com", "https://site2.com"]
}
```

### 🆘 Troubleshooting

#### Common Issues

**Detection Incomplete**

- The actor already runs browser fallback automatically for SPA sites
- Some sites may block automated detection
- Try enabling proxy configuration

**Timeout Errors**

- Retry with fewer URLs in a single run
- Check if site is accessible

**WAF Blocking**

- Enable Apify Proxy
- Reduce request frequency
- Some WAFs may block all automated access

### 📄 License & Terms

This actor analyzes publicly accessible website information in accordance with ethical web scraping practices and applicable regulations.

***

**Keywords**: tech stack detection, technology scanner, framework detection, CMS detection, WAF detection, website analysis, technology research, competitor analysis

# Actor input Schema

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

List of website URLs to analyze for technology stack detection.

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

Use Apify Proxy to avoid blocking and rate limits.

## Actor input object example

```json
{
  "urls": [
    "https://www.thelibrarypk.com",
    "https://www.php.net",
    "https://techcrunch.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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": [
        "https://www.thelibrarypk.com"
    ]
};

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

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

```

## MCP server setup

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