# Tech Stack Detector - BuiltWith & Wappalyzer Alternative (`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
- **Features:** Limited permissions
- **Stats:** 6 total users, 0 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/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

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

### 🧩 Related Actors

- [AI Crawler Policy Audit API](https://apify.com/webdata_labs/ai-crawler-policy-audit-api) - what a site's robots rules allow AI crawlers to do.
- [Google Merchant Feed Audit API](https://apify.com/webdata_labs/feedfix-api) - find what is breaking a shopping feed before Google disapproves it.
- [PDF Text Extractor](https://apify.com/webdata_labs/pdf-text-extractor) - get clean text out of multi-column and scanned PDFs.
- [Shopify Store Analyzer](https://apify.com/webdata_labs/shopify-store-analyzer) - a store's whole catalogue, contact details and revenue signals.
- [Website Change Intelligence API](https://apify.com/webdata_labs/website-change-intelligence-api) - watch pages and report what actually changed.

### 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`):

Websites to analyze. Domains or full URLs, for example stripe.com or https://gymshark.com.

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

Proxy used to fetch sites. Apify datacenter proxy is recommended; it rotates IPs and improves reliability on sites that block direct requests.

## Actor input object example

```json
{
  "urls": [
    "stripe.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `OUTPUT` (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"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// 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"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# 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(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": [
    "stripe.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call webdata_labs/website-tech-stack-detector --silent --output-dataset

```

## MCP server setup

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