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

Detect the technologies powering any website — CMS, web framework, analytics, JavaScript libraries, CDN, e-commerce and server — by inspecting its HTML, meta tags, scripts and HTTP headers. Returns a clean per-site technology list as JSON. No login required.

- **URL**: https://apify.com/receptional\_blender/website-tech-stack-detector.md
- **Developed by:** [Assia Fadli](https://apify.com/receptional_blender) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Find out what any website is built with. Give it a list of URLs and it fetches each page, inspects the **HTML, meta tags, inline scripts and HTTP response headers**, and returns a clean, flat JSON record naming the technologies it detected. There is nothing to configure — no API key, no login and no proxy.

Under the hood it uses [`got-scraping`](https://github.com/apify/got-scraping) for a realistic browser fingerprint (so more sites answer normally) and [`cheerio`](https://cheerio.js.org/) to read the markup.

### Features

- Detects technologies across these categories:
  - **CMS** — WordPress, Wix, Squarespace, Drupal, Joomla, Ghost.
  - **JavaScript frameworks & libraries** — React, Next.js, Vue.js, Angular, jQuery, Svelte, Gatsby, Bootstrap.
  - **Analytics & tag managers** — Google Analytics, Google Tag Manager, Facebook Pixel, Hotjar, Segment, Plausible.
  - **CDN** — Cloudflare, Fastly, Amazon CloudFront, Vercel, Netlify, jsDelivr.
  - **Server** — Nginx, Apache, Microsoft IIS, Express, PHP.
  - **E-commerce & payments** — Shopify, WooCommerce, Magento, Stripe.
- Follows redirects and reports the final URL and HTTP status code.
- Processes URLs concurrently in small batches to stay fast and polite.
- Emits one flat, ready-to-use JSON record per site.
- Skips gracefully over unreachable sites — they are recorded with an `error` field so a single bad URL never stops the run.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `urls` | array | — | The website URLs to analyze. A bare domain like `example.com` is treated as `https://example.com`. |
| `maxItems` | integer | `100` | Maximum number of URLs to analyze. |

#### Example input

```json
{
  "urls": ["https://www.wordpress.org", "https://shopify.com"],
  "maxItems": 100
}
```

### Output

Each dataset record looks like this:

```json
{
  "url": "https://www.wordpress.org",
  "finalUrl": "https://wordpress.org/",
  "statusCode": 200,
  "server": "nginx",
  "poweredBy": null,
  "generator": "WordPress",
  "title": "Blog Tool, Publishing Platform, and CMS – WordPress.org",
  "technologies": [
    { "name": "jQuery", "category": "JavaScript Framework" },
    { "name": "WordPress", "category": "CMS" }
  ]
}
```

| Field | Description |
| --- | --- |
| `url` | The URL exactly as requested in the input. |
| `finalUrl` | The URL after following redirects. |
| `statusCode` | Final HTTP status code. |
| `server` | Value of the `Server` response header (or `null`). |
| `poweredBy` | Value of the `X-Powered-By` response header (or `null`). |
| `generator` | Content of `<meta name="generator">` (or `null`). |
| `title` | The page `<title>` (or `null`). |
| `technologies` | Array of `{ name, category }`, sorted by category then name. |

If a URL can't be fetched (e.g. DNS failure or timeout), the row is `{ "url": "<url>", "error": "<message>" }` instead.

### Pricing

This actor uses the **pay-per-event** model: you are charged once per site successfully analyzed (the `site-analyzed` event). URLs that can't be fetched produce an error row and are never charged.

### How detection works

For each URL the actor performs a single `GET` request (following redirects, 20s timeout) and captures the response headers, status code, final URL and HTML body. The HTML is parsed with cheerio, and each entry in a curated signature map is tested against the markup, a header value, or a CSS selector. All matches are collected and de-duplicated by name. Detection is heuristic — it reflects what a site exposes publicly and may miss technologies that are lazy-loaded or hidden behind a bot wall.

### License

MIT © Assia Fadli

# Actor input Schema

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

The website URLs to analyze. Each one is fetched and inspected for the technologies it uses. A bare domain like example.com is treated as https://example.com.

## `maxItems` (type: `integer`):

Maximum number of URLs to analyze.

## Actor input object example

```json
{
  "urls": [
    "https://www.wordpress.org",
    "https://shopify.com"
  ],
  "maxItems": 100
}
```

# 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 = {
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("receptional_blender/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 = { "maxItems": 100 }

# Run the Actor and wait for it to finish
run = client.actor("receptional_blender/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 '{
  "maxItems": 100
}' |
apify call receptional_blender/website-tech-stack-detector --silent --output-dataset

```

## MCP server setup

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