# Website Tech Stack Detector \[💵 $2 / 1K] (`webdata_labs/website-tech-stack-detector`) Actor

\[💵 $2 / 1K] Detect 60+ website technologies in bulk: CMS, ecommerce, analytics, martech, frameworks, hosting, CDN, servers, payments, and lead tags.

- **URL**: https://apify.com/webdata\_labs/website-tech-stack-detector.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Lead generation, Developer tools, SEO tools
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 1 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 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

### What does Website Tech Stack Detector do?

**Tech Stack Detector identifies 60+ public website technologies in bulk**: CMS platforms, ecommerce software, JavaScript frameworks, analytics, marketing tools, chat widgets, payment providers, CDNs, hosting, and web servers.

Use it as an affordable **BuiltWith alternative**, **Wappalyzer alternative**, or technographic-enrichment API. Paste domains, run the Actor, and export one clean row per successfully analyzed website. No browser is required and there is no Actor-level hard limit on the number of URLs in a run.

The output is built for action, not just inspection: every site includes grouped technologies, confidence scores, convenient CMS/ecommerce/framework fields, and lead tags such as `is_ecommerce`, `has_live_chat`, and `has_marketing_automation`.

### Why use this website technology detector?

- **Qualify B2B leads by technology** — find Shopify stores, WordPress sites, HubSpot users, or companies using Intercom.
- **Research competitors** — compare analytics, marketing, payments, CMS, frameworks, hosting, and support tools.
- **Build technographic datasets** — enrich thousands of company domains for sales, recruiting, market research, or investment analysis.
- **Plan migrations** — identify legacy CMS and server technologies across a portfolio.
- **Segment agency prospects** — target businesses whose current stack matches your service.
- **Monitor stack changes** — save the run as a Task and schedule recurring checks.

Runs use concurrent HTTP requests, automatic retries, duplicate removal, and optional Apify Proxy. Temporary failures are written to a separate report and are not added to the paid dataset.

### Technology coverage

| Category | Examples |
|---|---|
| CMS and site builders | WordPress, Drupal, Joomla, Ghost, Webflow, Wix, Squarespace, HubSpot CMS, Framer |
| Ecommerce | Shopify, WooCommerce, Magento, BigCommerce, PrestaShop |
| JavaScript frameworks | Next.js, Nuxt, React, Vue, Angular, Svelte, Remix, Gatsby, Astro |
| Analytics and tags | Google Analytics, Google Tag Manager, Hotjar, Segment, Plausible, Mixpanel, Matomo |
| Marketing and support | HubSpot, Klaviyo, Mailchimp, Marketo, Pardot, Intercom, Zendesk, Drift, Crisp |
| Payments | Stripe, PayPal, Braintree |
| Hosting, CDN, and servers | Cloudflare, CloudFront, AWS, Fastly, Akamai, Vercel, Netlify, Nginx, Apache, IIS |
| UI, security, and operations | Tailwind CSS, Bootstrap, jQuery, reCAPTCHA, hCaptcha, Sentry, Typeform, Calendly |

The detector reads public homepage HTML, response headers, and cookies. It cannot see private internal tools or technology that leaves no public fingerprint.

### Ready-to-run website technology research tasks

Open a task, replace the example domains with your list, and run:

- [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)
- [Find Next.js and Vercel websites](https://apify.com/webdata_labs/website-tech-stack-detector/examples/find-nextjs-and-vercel-websites)
- [Qualify B2B leads by website technology](https://apify.com/webdata_labs/website-tech-stack-detector/examples/qualify-b2b-leads-by-website-technology)

### What data does Tech Stack Detector return?

| Field | Type | Description |
|---|---|---|
| `domain`, `url`, `finalUrl` | string | Normalized domain, requested URL, and final URL after redirects |
| `statusCode`, `responseTimeMs` | number | HTTP response and request time |
| `technologies` | array | Technology name, category, confidence level, and numeric confidence score |
| `byCategory`, `categories` | object / array | Technology stack grouped into buyer-friendly categories |
| `ecommercePlatform`, `cms`, `jsFramework`, `cdn` | string | Convenient primary technology fields |
| `leadTags` | array | Sales qualifiers such as `is_ecommerce` and `has_live_chat` |
| `protected` | boolean | Whether the final response indicates access protection |
| `server`, `title` | string | Public server header and page title |

Enable **Include detection evidence** when you want each technology to include the signal sources and matched-signal count used for its confidence score.

### Example output

```json
{
  "domain": "stripe.com",
  "statusCode": 200,
  "jsFramework": "Next.js",
  "techCount": 2,
  "categories": ["JS framework", "Web server"],
  "technologies": [
    {
      "name": "Nginx",
      "category": "Web server",
      "confidence": "high",
      "confidenceScore": 0.98
    },
    {
      "name": "Next.js",
      "category": "JS framework",
      "confidence": "high",
      "confidenceScore": 0.95
    }
  ],
  "leadTags": []
}
```

Download results as **JSON, CSV, Excel, XML, RSS, or HTML**, or consume the dataset through the Apify API.

### How to detect the tech stack of a website

1. Open the Actor and click **Try for free**.
2. Paste domains or full URLs into **Websites to analyze**.
3. Keep the default settings for a normal run.
4. Click **Start**.
5. Open the **Websites** dataset view.
6. Filter by `cms`, `ecommercePlatform`, `jsFramework`, `categories`, or `leadTags`.
7. Export the results or connect the dataset to your workflow.

For large lists, start with the default 30 parallel requests. Increase concurrency only when you need more speed; lower it when many targets are slow.

### Input

```json
{
  "urls": [
    "stripe.com",
    "wordpress.org",
    "https://www.shopify.com"
  ],
  "maxConcurrency": 30,
  "requestTimeoutSecs": 20,
  "maxRetries": 1,
  "includeEvidence": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

Only `urls` is required. The remaining controls have safe defaults and can be ignored by first-time users.

### How much does Tech Stack Detector cost?

The FREE-tier price is **$2 per 1,000 successfully analyzed websites**. Failed URLs are not added to the paid dataset.

| Apify plan | Price per 1,000 websites |
|---|---:|
| FREE | $2.00 |
| BRONZE | $1.75 |
| SILVER | $1.50 |
| GOLD, PLATINUM, DIAMOND | $1.25 |

There is no start fee. A run of 100 successful websites costs about $0.20 on the FREE tier.

### Run through the Apify API

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('webdata_labs/website-tech-stack-detector').call({
  urls: ['stripe.com', 'wordpress.org', 'shopify.com'],
  maxConcurrency: 30,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("webdata_labs/website-tech-stack-detector").call(
    run_input={
        "urls": ["stripe.com", "wordpress.org", "shopify.com"],
        "maxConcurrency": 30,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/webdata_labs~website-tech-stack-detector/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls":["stripe.com","wordpress.org","shopify.com"],"maxConcurrency":30}'
```

### Integrations and scheduled monitoring

Use an Apify Task to keep a stable domain list and schedule it daily, weekly, or monthly. Send the resulting dataset to Google Sheets, Make, Zapier, Slack, a webhook, a CRM, a warehouse, or your own application.

Common automations include:

- append newly detected technologies to a CRM;
- alert when a competitor changes CMS, analytics, or ecommerce platform;
- route Shopify and WooCommerce prospects to an ecommerce sales sequence;
- assign Next.js or WordPress migration opportunities to the right agency team.

### Use with AI agents through MCP

Add the Actor-specific Apify MCP endpoint to an MCP-compatible assistant:

```text
https://mcp.apify.com?tools=webdata_labs/website-tech-stack-detector
```

Example prompts:

- “Detect the technology stack of these company domains and group them by CMS.”
- “Find ecommerce leads in this domain list and separate Shopify from WooCommerce.”
- “Compare the analytics and marketing tools used by these competitors.”

### BuiltWith and Wappalyzer alternative: what is different?

This Actor is designed for repeatable datasets and automation rather than interactive browser lookup. It combines detection with fields useful in B2B workflows:

- confidence scores instead of an unexplained yes/no;
- category rollups and convenient primary-stack columns;
- sales-oriented lead tags;
- bulk input, scheduling, API access, and exports;
- pay only for rows successfully added to the dataset.

It is not affiliated with BuiltWith or Wappalyzer.

### Limits and troubleshooting

#### Why is a technology missing?

Some tools load only after user interaction, appear only on inner pages, run entirely server-side, or intentionally hide their fingerprints. This HTTP detector prioritizes precision and may omit a weak or ambiguous match.

#### Why did a URL go to the failed report?

The website may have timed out, returned a temporary block, rejected automated requests, or used an invalid URL. The Actor retries temporary failures automatically. Failed URLs are stored in the `ERRORS` report rather than the paid dataset.

#### Can it analyze thousands of websites?

Yes. There is no Actor-level URL ceiling. Actual capacity depends on Actor memory, timeout, target response times, and Apify platform limits. For very large lists, use a longer run timeout and keep concurrency between 20 and 50.

#### Does it open every page on the website?

No. It analyzes the public homepage and its response metadata. This keeps bulk runs fast and affordable but means technologies visible only on checkout, account, or application pages may not be detected.

#### Is website technology detection legal?

The Actor requests publicly accessible website pages and does not bypass login or extract private account data. You are responsible for using the results lawfully, respecting website terms, rate limits, and applicable regulations.

### Support

If a technology is missing or a domain produces an unexpected result, open an issue on the Actor page and include the run URL, domain, and expected technology. Do not include passwords, API tokens, or private URLs.

If the Actor saved you time, a review on the **Reviews** tab helps other users evaluate it.

# Actor input Schema

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

Paste domains or full URLs, one per line. Use a small list for a quick audit or thousands of domains for bulk technographic enrichment. Exact duplicates are removed automatically.

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

How many websites to analyze at once. The default is fast and safe for most runs; lower it if target sites are slow or fragile.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to wait for one website before retrying.

## `maxRetries` (type: `integer`):

Retries temporary blocks, timeouts, and server errors with a fresh connection. Failed websites are reported separately and are not added to the paid dataset.

## `includeEvidence` (type: `boolean`):

Add buyer-readable evidence sources and matched-signal counts to each technology. Leave off for a smaller dataset.

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

Optional. Direct HTTP is faster and works for most public websites. Enable Apify Proxy when many sites in your list block datacenter traffic.

## Actor input object example

```json
{
  "urls": [
    "stripe.com",
    "wordpress.org"
  ],
  "maxConcurrency": 30,
  "requestTimeoutSecs": 20,
  "maxRetries": 1,
  "includeEvidence": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `OUTPUT` (type: `string`):

No description

## `ERRORS` (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",
        "wordpress.org"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// 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",
        "wordpress.org",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# 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",
    "wordpress.org"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
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

Download the OpenAPI definition: https://api.apify.com/v2/acts/Yr4RbhmbsdEZSApvg/builds/nvwd8K6JOefZp5qjb/openapi.json