# Tech Stack Detector: Wappalyzer & BuiltWith Alternative (`secula/tech-stack-detector`) Actor

Wappalyzer and BuiltWith alternative: detect the tech stack of any website in bulk. 7,600+ technologies: CMS, Shopify and ecommerce, analytics, payments, frameworks, hosting, email provider and SaaS tools. Versions and evidence. $3 per 1,000 sites, failed sites free.

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

## Pricing

from $3.00 / 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.

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

## Tech Stack Detector: Wappalyzer & BuiltWith Alternative

**Find out what any website is built with.** This website technology detector takes a list of domains and returns each site's CMS, ecommerce platform, analytics, payment providers, JavaScript frameworks, CDN, hosting, email provider and SaaS tools. It knows **7,600+ technologies**, with versions and the evidence behind every detection.

**$3 per 1,000 websites. No subscription.** You pay only for websites that served their page and were analyzed. Unreachable, refusing, rate-limiting and bot-protected sites are free.

### What you get for every website

- **Technologies** with name, version (when exposed), confidence (0–100) and category
- **Grouped by category:** `{"Ecommerce": ["Shopify"], "Analytics": ["Google Analytics", "Hotjar"], ...}`
- **Evidence:** the header, script, meta tag, HTML element or DNS record that triggered each detection
- **Email provider and SaaS tools** from DNS records (see below)
- **Status, redirects and page title**, plus a clear error for sites that failed

### A Wappalyzer and BuiltWith alternative

Like Wappalyzer, this Actor recognizes technologies by their fingerprints. It uses the open-source fingerprint databases in the Wappalyzer format maintained by HTTP Archive and the community. Unlike a database lookup tool, it **scans every website live** when you run it, so new and small sites work too.

| | This Actor |
|---|---|
| Technologies recognized | 7,600+ |
| How | Live scan of each website, plus DNS records |
| Price | $3 per 1,000 websites, pay per website, no subscription or API plan |
| Failed or blocked websites | Free |
| Output | JSON, CSV, Excel, API, integrations, AI agents (MCP) |

*Not affiliated with Wappalyzer or BuiltWith. Their names are used only to describe what this Actor does.*

### Shopify store detector: find Shopify stores and the apps they use

Paste a list of shops and keep only the ones on Shopify, or only Shopify stores that also use a specific app:

```json
{
  "urls": ["allbirds.com", "skims.com", "example.com"],
  "technologyFilter": ["Shopify", "Klaviyo"],
  "filterMode": "all"
}
```

Large Shopify stores often refuse cloud servers. This Actor retries refused sites once through a residential proxy, at no extra charge. In our test, 9 of 10 refused Shopify stores were analyzed this way.

### What CMS does a website use?

The same scan answers the most common lookups in one go. Is a site built with **WordPress, Shopify, WooCommerce, Wix, Squarespace, Webflow, Drupal or Joomla**? Does it use **Google Analytics, Google Tag Manager, HubSpot, Klaviyo, Hotjar or Stripe**? Is it hosted on **Cloudflare, Vercel, Netlify or AWS**, and built with **React, Next.js, Vue or Angular**?

### Email provider and SaaS tools from DNS

Domain-verification and mail records reveal tools a company uses even when they aren't visible on its homepage: **Google Workspace, Microsoft 365, HubSpot, DocuSign, Atlassian, SendGrid, Mailchimp** and many more. That's useful for sales prospecting and account research.

### How to use it

1. Add websites to **Websites**, one per line: `shopify.com`, `https://www.example.com`, …
2. Optional: set **Only websites using these technologies** (e.g. `Shopify`, `Klaviyo`) and **Filter mode**.
3. Click **Start**. Results appear in the **Overview** table and can be exported as JSON, CSV or Excel.

#### Tech stack lookup API

```bash
curl -X POST "https://api.apify.com/v2/acts/secula~tech-stack-detector/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["allbirds.com", "nextjs.org"]}'
```

AI agents can also call it through Apify's MCP server and pay per run.

### Input

| Field | Default | What it does |
|---|---|---|
| `urls` | – | Domains or URLs to scan (duplicates and invalid entries are skipped) |
| `technologyFilter` | `[]` | Keep only websites using these technologies (exact names, case-insensitive) |
| `filterMode` | `any` | `any` = at least one of them, `all` = every one of them |
| `categoryFilter` | `[]` | Report only technologies in these categories (e.g. `Ecommerce`, `Analytics`) |
| `minConfidence` | `50` | Hide detections below this confidence |
| `includeEvidence` | `true` | Add what triggered each detection |
| `detectDns` | `true` | Check MX/TXT/NS/SOA/CNAME records (email providers, DNS hosts, verified SaaS) |
| `fetchRobotsTxt` | `false` | Also fetch `/robots.txt` |
| `includeFailed` | `true` | Add rows for websites that failed (never charged) |
| `residentialFallback` | `true` | Retry websites that refuse cloud servers once via residential proxy (no extra charge) |
| `maxConcurrency` | `20` | Websites scanned in parallel |
| `requestTimeoutSecs` | `20` | Time limit per website |
| `proxyConfiguration` | off | Optional Apify Proxy for all requests (billed by Apify) |

### Output example

```json
{
  "input": "gymshark.com",
  "url": "https://gymshark.com/",
  "finalUrl": "https://us.checkout.gymshark.com/",
  "domain": "gymshark.com",
  "statusCode": 200,
  "technologyCount": 7,
  "technologyNames": ["Apple Pay", "Cloudflare", "HSTS", "HTTP/3", "Open Graph", "PayPal", "Shopify"],
  "categories": {
    "Ecommerce": ["Shopify"],
    "Payment processors": ["Apple Pay", "PayPal"],
    "CDN": ["Cloudflare"]
  },
  "technologies": [
    {
      "name": "Cloudflare",
      "version": null,
      "confidence": 100,
      "categories": ["CDN"],
      "website": "https://www.cloudflare.com",
      "evidence": [{"type": "header", "key": "server", "match": "cloudflare"}]
    }
  ],
  "viaProxy": false,
  "blocked": null,
  "error": null,
  "scanTimeMs": 530,
  "scannedAt": "2026-10-04T18:23:34+00:00"
}
```

### Pricing

**$0.003 per analyzed website ($3 per 1,000)**, charged as the event `website-analyzed`.

- **You pay for:** websites that served their page (HTTP 2xx/3xx) and were analyzed.
- **You don't pay for:** unreachable websites, timeouts, invalid entries, error answers (HTTP 4xx/5xx, including rate limits and "forbidden"), and websites that showed a bot-protection page instead of their content. Those rows still show whatever headers and DNS revealed, for free.
- **Filter mode:** websites that are analyzed but filtered out are still charged, because the scan was done.
- **Spending cap:** set a maximum cost per run in Apify, and the Actor stops exactly there.

### Use cases

- **Sales prospecting and lead generation:** find shops on Shopify or WooCommerce that use, or don't use, a given tool
- **Lead enrichment:** add tech stack columns to a CRM or spreadsheet of domains
- **Competitor analysis:** see which CMS, analytics and marketing tools your competitors run
- **Market research:** measure how widely a technology is used across a list of websites
- **Security and IT audits:** inventory frameworks, servers and versions across your own domains
- **AI agents:** a single API call answers "what is this website built with?"

### Limitations (honest)

- **No JavaScript is executed.** Technologies that reveal themselves only when scripts run (some React apps, single-page apps, tag-manager-loaded tools) can be missed. In a benchmark of well-known sites, 13 of 15 expected technologies were found on pages that weren't bot-blocked.
- **Bot protection and rate limits:** some websites answer cloud servers with a challenge page or "too many requests". The Actor first retries a rate limit once, waiting as long as the site asks (up to 5 s), then retries once more through a residential proxy (`viaProxy: true` in the output). If the site still refuses, the row is marked `blocked` and not charged. A few sites (e.g. behind strict bot checks) still can't be analyzed.
- **DNS detections are domain-level.** A Google Workspace MX record means the company's email runs on Google, not that the website uses it.

### FAQ

**Is this a Wappalyzer API alternative?** Yes, for the main job: give it websites and get their technologies as JSON, priced per website instead of a monthly plan. It uses fingerprints in the open-source Wappalyzer format. Detections that need a real browser (JavaScript variables) aren't included.

**How is it different from BuiltWith?** It scans each website live when you run it, instead of looking it up in a historical database. It doesn't provide historical data or spend estimates.

**Can I check thousands of websites?** Yes. Paste or send the full list; up to 100 websites are scanned in parallel. Set a maximum cost per run if you want a hard budget.

**Is this legal?** The Actor requests each website's public homepage once (plus optional robots.txt) and reads public DNS records, like a browser visit. It doesn't log in, bypass protections or collect personal data. Use the results in line with the laws that apply to you.

**Where do the fingerprints come from?** From [HTTPArchive/wappalyzer](https://github.com/HTTPArchive/wappalyzer) and [enthec/webappanalyzer](https://github.com/enthec/webappanalyzer). The exact source versions used are recorded in each run's `SUMMARY` record.

**Can I request a technology?** Open an issue on the Actor's Issues tab with the technology and an example website.

### Open source

This Actor is free software under the **GNU GPL-3.0**, the same license as the fingerprint data it uses. You pay for the hosted, maintained service, not for a license.

# Actor input Schema

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

Domains or URLs to scan, one per line (e.g. shopify.com or https://www.example.com/shop). Duplicates and invalid entries are skipped.

## `technologyFilter` (type: `array`):

Optional. Keep only websites that use these technologies (exact names as in the output, e.g. Shopify, Klaviyo, HubSpot). Websites that do not match are still analyzed and charged, but left out of the results.

## `filterMode` (type: `string`):

With several technologies in the filter: 'any' keeps websites using at least one of them, 'all' keeps websites using all of them.

## `categoryFilter` (type: `array`):

Optional. Report only technologies in these categories (e.g. Ecommerce, Analytics, CMS, Email, Marketing automation).

## `minConfidence` (type: `integer`):

Report a technology only if its detection confidence (0-100) is at least this value. Lower values show more, less certain results.

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

Add the header, script, meta tag or HTML fragment that triggered each detection.

## `detectDns` (type: `boolean`):

Also look at the domain's MX, TXT, NS, SOA and CNAME records. This finds email providers (e.g. Google Workspace, Microsoft 365), DNS hosts and verification services.

## `fetchRobotsTxt` (type: `boolean`):

Also fetch /robots.txt (one extra request per website) for the few technologies identified there.

## `includeFailed` (type: `boolean`):

Add a result row with the error for websites that could not be reached. Failed websites are never charged.

## `residentialFallback` (type: `boolean`):

Websites that refuse cloud servers (rate limits, bot checks) are retried once through Apify's residential proxy. Included in the price; no extra charge to you.

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

How many websites to scan in parallel.

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

Give up on a website after this many seconds.

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

Optional proxy for websites that block cloud servers. Apify Proxy usage is billed separately by Apify.

## Actor input object example

```json
{
  "urls": [
    "wordpress.org",
    "allbirds.com",
    "nextjs.org"
  ],
  "technologyFilter": [],
  "filterMode": "any",
  "categoryFilter": [],
  "minConfidence": 50,
  "includeEvidence": true,
  "detectDns": true,
  "fetchRobotsTxt": false,
  "includeFailed": true,
  "residentialFallback": true,
  "maxConcurrency": 20,
  "requestTimeoutSecs": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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": [
        "wordpress.org",
        "allbirds.com",
        "nextjs.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("secula/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": [
        "wordpress.org",
        "allbirds.com",
        "nextjs.org",
    ] }

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

```

## MCP server setup

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