# Website Tech Stack Detector: CMS, Analytics & CDN per URL (`pennydata/website-tech-stack-detector`) Actor

Website tech stack detector, a Wappalyzer and BuiltWith alternative: finds the CMS, ecommerce platform, analytics, CDN and JS framework of any site list from headers, meta, scripts and cookies. Failed URLs are free.

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

## Pricing

$5.00 / 1,000 url 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

## Website Tech Stack Detector - Wappalyzer & BuiltWith Alternative

**Website tech stack detector**, a Wappalyzer and BuiltWith alternative (not affiliated with either): find out what any website runs on, such as WordPress, Shopify, Magento, Next.js, Cloudflare, Google Analytics and about 60 more. One plain HTTP request per site, no browser, and every detection lists its evidence (header, meta tag, script URL or cookie name). Failed URLs are not charged.

**Free to try:** a new Apify account includes free monthly platform credit, enough to validate the output on a few dozen sites before you pay anything. This Actor has no hidden minimums: failed items are never billed.

### How to use Website Tech Stack Detector

1. Paste public URLs or bare domains into **urls**.
2. Leave **respectRobotsTxt** on unless you are entitled to switch it off.
3. Click **Start**.
4. Use `technologyNames` for quick filtering or `technologies` for category and evidence.

### Pricing

Pay per event, no subscription and no compute fees on top. Price: **$5.00 per 1,000 sites**.

| Event | When it is charged | Price |
|---|---|---|
| `url-analyzed` | One website URL fetched successfully (HTTP below 400) and analyzed for technologies. | $0.005 |

Failed, blocked or unknown items are not billed. Set a maximum cost per run in the run options to cap spend.

### Example input

```json
{
  "urls": [
    {
      "url": "https://nextjs.org"
    }
  ],
  "respectRobotsTxt": true
}
```

### Example output

Sample output item (from the Actor README).

```json
{
  "input": "https://nextjs.org",
  "finalUrl": "https://nextjs.org/",
  "httpStatus": 200,
  "technologyNames": [
    "Vercel",
    "Next.js"
  ],
  "technologies": [
    {
      "name": "Vercel",
      "category": "Hosting",
      "evidence": "header x-vercel-id"
    }
  ]
}
```

### Details and limits

Give it a list of public website URLs and get back the technologies each site appears to use: **CMS, ecommerce platform, analytics and tag managers, CDN and hosting, web server, JS frameworks and libraries, payments, cookie-consent tools**. It makes one plain HTTP request per site (no browser), so runs are fast and cheap.

### What it does

- Input: a list of public `http(s)` URLs (bare domains such as `example.com` are accepted and fetched over https).
- For each URL it fetches the page once (following up to 5 redirects) and inspects only:
  - **response headers** (`server`, `x-powered-by`, `cf-ray`, `x-vercel-id`, ...),
  - **HTML meta tags** (`<meta name="generator">`),
  - **script `src` URLs** and well-known HTML markers (for example `__NEXT_DATA__`, `/wp-content/`),
  - **cookie names** from `Set-Cookie` (names only; cookie values are never read or stored).
- Output per URL: `input`, `finalUrl`, `httpStatus`, `technologyNames` (flat list) and `technologies` (name, category, and the evidence that triggered it), `capturedAt`.
- About 60 technologies are recognised, e.g. WordPress, Shopify, WooCommerce, Magento, Wix, Squarespace, Webflow, Drupal, Next.js, Nuxt, React, Vue.js, Angular, Cloudflare, CloudFront, Fastly, Vercel, Netlify, Google Analytics, Google Tag Manager, Meta Pixel, Hotjar, Stripe.

### Limits and honesty notes

- Detection is based on **one HTTP request to the URL you give**, with no JavaScript execution. Technologies that only show up after client-side rendering, or on other pages of the site, can be missed. A site with no visible signals returns an empty list; that does not prove nothing is used.
- Detection is signature-based and can produce false positives or negatives (for example a CDN header that only reflects a proxy in front of the site, or a site that hides its headers). Treat results as strong hints, not an audit. No version numbers are reported.
- Only the first 1 MB of each page is inspected.
- **robots.txt** is respected by default (the wildcard `*` group; switch off with `respectRobotsTxt: false` only for sites you are entitled to analyze). The actor identifies itself with the user agent `TechStackDetectorBot`.
- Only public `http(s)` URLs: localhost, private and link-local IP ranges, and non-http schemes are rejected, and every redirect hop is re-checked.
- Sites behind bot walls, logins or captchas may return an error page or a block status; no proxies, no captcha solving and no evasion are used.
- You are responsible for having the right to analyze the URLs you submit. The actor collects no personal data: only technology signals are extracted, and cookie values are discarded.

### More from PennyData

- [Website Screenshot & URL to PDF](https://apify.com/pennydata/shot-pdf): Full-page screenshots and URL/HTML to PDF with headless Chromium.
- [Bulk Email Validator (No SMTP)](https://apify.com/pennydata/bulk-email-validator-no-smtp): Syntax, MX, disposable, role and typo checks for email lists.
- [App Store Reviews Scraper](https://apify.com/pennydata/appstore-reviews-rss): Apple app reviews by app ID and country from the public RSS feed.
- [Bulk Domain WHOIS & DNS Lookup](https://apify.com/pennydata/bulk-domain-whois-dns-lookup): Availability, registrar, expiry, nameservers, MX and TXT via RDAP.

### FAQ

**How accurate is it?**\
Signature-based on one HTTP request without JavaScript execution, so client-rendered or hidden technologies can be missed. Treat results as strong hints, not an audit.

**Is it legal?**\
It requests only the URL you provide, respects robots.txt by default, stores no cookie values and no personal data.

**Need a custom field, a higher volume or a different source?**\
Open an issue on the Actor page and describe what you need; custom variants are possible.

**Is it maintained?**\
Yes. Reports of breakage are answered through the Issues tab, and runs that fail are not billed.

Built with AI assistance (Claude); maintained by the publisher.

# Actor input Schema

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

Public http(s) pages to analyze (bare domains like example.com are accepted).

## `respectRobotsTxt` (type: `boolean`):

Skip URLs disallowed for all bots in the site's robots.txt (skipped URLs are not charged).

## `maxConcurrency` (type: `integer`):

Maximum number of sites analyzed in parallel (1-20).

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

Per-request timeout in seconds (5-60).

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://wordpress.org"
    },
    {
      "url": "https://www.shopify.com"
    }
  ],
  "respectRobotsTxt": true,
  "maxConcurrency": 5,
  "timeoutSecs": 20
}
```

# Actor output Schema

## `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": [
        {
            "url": "https://wordpress.org"
        },
        {
            "url": "https://www.shopify.com"
        }
    ]
};

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

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

```

## MCP server setup

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