# Website Tech Stack Detector: BuiltWith/Wappalyzer Alternative (`pulsedata/website-tech-stack-detector`) Actor

Find out what any website is built with: CMS, e-commerce, frameworks, analytics, ads, tag managers, payments, CDN, hosting, email provider & 7,500+ technologies with versions and confidence. Bulk-analyze thousands of domains. BuiltWith / Wappalyzer alternative.

- **URL**: https://apify.com/pulsedata/website-tech-stack-detector.md
- **Developed by:** [PulseData](https://apify.com/pulsedata) (community)
- **Categories:** Lead generation, Developer tools, Agents
- **Features:** Limited permissions
- **Stats:** 7 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.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

## Website Tech Stack Detector: BuiltWith/Wappalyzer Alternative

This actor finds out what a website is built with. You pass a list of domains or URLs and get, per site, the detected CMS, ecommerce platform, JavaScript frameworks, analytics and advertising tags, tag manager, payment processors, CDN, hosting, web server, programming language, email provider and security tools, matched against more than 7,500 technology fingerprints with versions and confidence scores. It costs $2 per 1,000 websites analyzed, and unreachable sites are not charged.

It works over plain HTTP and DNS, without a browser, so large domain lists finish quickly.

### Features

- **Check what CMS a website uses** (WordPress, Shopify, Webflow and others in the fingerprint set).
- **Find out if a website runs on Shopify** or another ecommerce platform, for a whole list at once.
- **Bulk tech stack lookup for a list of domains**, thousands per run.
- **See which analytics and ad tags a website uses**, such as Google Tag Manager or ad pixels.
- **Detect a company's email provider and verified SaaS tools from DNS**, such as Google Workspace or Microsoft 365.
- **Export tech stack data to CSV, Excel or JSON** through the Apify dataset.

### Use cases

- **Lead generation and sales intelligence**: filter a domain list down to companies on Shopify, WooCommerce, HubSpot, Klaviyo or Intercom.
- **Market research**: count technology usage across the sites of an industry.
- **Agency prospecting**: spot old CMS versions, missing analytics, no cookie banner or no CDN.
- **Website audits and due diligence**: inventory the third-party scripts, trackers and vendors on a site.
- **CRM enrichment**: add a tech stack column to scraped or exported company domains.

### Input

```json
{
  "urls": ["allbirds.com", "https://www.nytimes.com", "apify.com"],
  "maxExternalScripts": 10,
  "fetchDns": true,
  "minConfidence": 50,
  "includeDescriptions": false,
  "concurrency": 10
}
```

| Field | Type | Default | Meaning |
|---|---|---|---|
| `urls` | array | (required) | Domains or URLs, one per line |
| `maxExternalScripts` | integer | 10 | External JavaScript files downloaded per site for deeper detection (0 to 50, 0 disables) |
| `fetchDns` | boolean | true | Resolve MX, NS, TXT and CNAME records for email, DNS and verified SaaS services |
| `minConfidence` | integer | 50 | Report only technologies at or above this confidence (0 to 100) |
| `includeDescriptions` | boolean | false | Add a short description to each technology |
| `concurrency` | integer | 10 | Websites analyzed in parallel (1 to 50) |
| `proxyConfiguration` | object | no proxy | Use Apify Proxy if target sites block datacenter traffic |

A bare domain is fetched over HTTPS first and over HTTP if that fails.

### Output

One item per website:

```json
{
  "url": "allbirds.com",
  "finalUrl": "https://www.allbirds.com/",
  "statusCode": 200,
  "title": "Allbirds: Comfortable, Sustainable Shoes & Apparel",
  "technologyCount": 6,
  "technologyNames": ["Shopify", "Cloudflare", "Google Tag Manager", "Apple Pay", "PayPal", "HSTS"],
  "technologies": [
    { "name": "Shopify", "slug": "shopify", "categories": ["Ecommerce"], "version": null, "confidence": 100,
      "website": "https://shopify.com", "icon": "https://raw.githubusercontent.com/enthec/webappanalyzer/main/src/images/icons/Shopify.svg",
      "saas": true, "oss": null, "pricing": ["low", "recurring"], "evidence": ["scriptSrc", "meta"] }
  ],
  "saasServicesFromDns": ["DocuSign", "Miro"],
  "categories": { "Ecommerce": ["Shopify"], "CDN": ["Cloudflare"], "Payment processors": ["Apple Pay", "PayPal"] },
  "summary": {
    "cms": null, "ecommerce": "Shopify", "framework": null, "programmingLanguage": null,
    "webServer": null, "cdn": "Cloudflare", "hosting": null, "analytics": [], "advertising": [],
    "tagManager": "Google Tag Manager", "payments": ["Apple Pay", "PayPal"], "marketingAutomation": [],
    "liveChat": null, "crm": null, "emailProvider": "Microsoft 365", "security": ["HSTS"],
    "cookieCompliance": null, "abTesting": null
  },
  "dns": { "mx": ["allbirds-com.mail.protection.outlook.com"], "ns": ["..."], "cname": [], "txt": ["v=spf1 ..."] },
  "headers": { "server": "cloudflare", "x-powered-by": null, "via": null },
  "scrapedAt": "2026-09-25T08:00:00.000Z"
}
```

- `technologies`: every match with categories, version when the site exposes one, confidence, vendor website, icon, SaaS and open-source flags, pricing hints and the evidence type (url, html, scriptSrc, scripts, css, text, headers, cookies, meta, dom, dns, or `implied by` another technology).
- `summary`: the first match per key category, or a list for analytics, advertising, payments, marketing automation and security.
- `saasServicesFromDns`: services detected only from DNS TXT verification records.
- `dns.txt`: only SPF, site-verification and a few vendor records (Google, Facebook, HubSpot, Stripe), up to 20.

A site that cannot be reached produces an item with an `error` field and zero technologies, and is not charged.

### How it works and limitations

The actor downloads each site's HTML, headers and cookies plus up to `maxExternalScripts` JavaScript files (same host first), resolves DNS, and matches everything against the open-source [webappanalyzer](https://github.com/enthec/webappanalyzer) fingerprint database, the community continuation of the Wappalyzer rules. Technologies that reveal themselves only through JavaScript globals are matched from script code at reduced confidence (25).

Because there is no browser, single-page apps that render everything client-side can show fewer technologies than a browser-based tool. Only the page you pass is analyzed; the actor does not crawl other pages of the site. A site that answers with an error page or a bot challenge is still analyzed and charged; check `statusCode`.

### Pricing

$0.002 per website analyzed (`website-analyzed` event). Worked example: a list of 1,000 domains where 950 respond costs 950 × $0.002 = $1.90.

### FAQ

**How is this different from BuiltWith or Wappalyzer?**
Same idea (fingerprints from HTML, scripts, headers, cookies and DNS), but pay per site with no subscription, and you get raw JSON for your own pipeline. There is no historical data; each run reads the site as it is now.

**How many technologies can it detect?**
The bundled database has about 7,500 fingerprints across CMS, ecommerce, frameworks, analytics, ads, tag managers, payments, CDN, hosting, email and more.

**Does it work on JavaScript-heavy sites?**
Partly. It reads the external scripts a page loads, which catches many frameworks and tags, but it does not execute JavaScript.

**What is the confidence score?**
Each fingerprint adds confidence up to 100. Raise `minConfidence` to hide weak matches such as a lone cookie name.

**Can I run thousands of domains?**
Yes. Paste the list into `urls` and raise `concurrency`. If the run migrates to another server mid-way, domains already processed are skipped.

**Do I need proxies?**
Usually not. Turn on Apify Proxy if many target sites block datacenter IPs.

**Can I schedule it or call it via API?**
Yes. Save a task, add an Apify schedule, and export the dataset as JSON, CSV or Excel via API, or send it to Google Sheets, Make, Zapier or n8n.

### Use it from Claude, ChatGPT or Cursor (Apify MCP server)

The actor can be called as a tool by any AI assistant that speaks the Model Context Protocol. Add the Apify MCP server to your client with this URL, which loads only this actor as a tool:

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

On first connection the client opens a browser window to sign in to Apify, or you pass your Apify API token instead. After that you can ask in plain language, for example "check which of these 50 shop domains run Shopify and which analytics tools they use", and the assistant fills `urls` and `minConfidence` itself, runs the actor and reads the sites back as JSON. Billing is the same as a normal run, at the prices listed above. The cost follows the number of URLs you hand it, so pass a short list first if you want to check the output.

### Paying from an AI agent without an Apify account (x402 and Skyfire)

An agent can buy a prepaid, spend-capped Apify token at [Apify AGI](https://agi.apify.com), paid in USDC through [x402](https://docs.apify.com/platform/integrations/x402) or from a [Skyfire](https://docs.apify.com/platform/integrations/skyfire) wallet, and use it for both the API and the MCP server. This actor runs with limited permissions, so it works with these tokens. The smallest token is $1, tokens expire 14 days after purchase, and Apify marks agentic payments as experimental.

### License

The source is licensed under GPL-3.0 and includes the webappanalyzer fingerprint database (GPL-3.0).

### Related actors

- [Google Ads Transparency Center Scraper](https://apify.com/pulsedata/google-ads-transparency-scraper): the Google ads a company with a given ad tag actually runs.
- [LinkedIn Ad Library Scraper](https://apify.com/pulsedata/linkedin-ad-library-scraper): the B2B ads of the same companies.
- [Career Page Jobs Scraper](https://apify.com/pulsedata/career-page-jobs-scraper): hiring signals from the same domains, across 12 applicant tracking systems.
- [App Store & Google Play Scraper](https://apify.com/pulsedata/app-store-google-play-scraper): the mobile apps of the companies on your list.

# Actor input Schema

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

Domains or URLs to analyze, one per line (e.g. `shopify.com`, `https://www.nytimes.com`). Thousands are fine.

## `maxExternalScripts` (type: `integer`):

Downloads up to N external JavaScript files per site to detect libraries referenced in code (improves accuracy). 0 disables.

## `fetchDns` (type: `boolean`):

Resolve MX/NS/TXT/CNAME records to detect email providers, DNS hosts and verified services (Google Workspace, Microsoft 365, Cloudflare, HubSpot …).

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

Only report technologies detected with at least this confidence.

## `includeDescriptions` (type: `boolean`):

Adds a short description for each detected technology (bigger output).

## `concurrency` (type: `integer`):

How many websites to analyze in parallel.

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

Optional. Use Apify Proxy if target sites block datacenter traffic.

## Actor input object example

```json
{
  "urls": [
    "apify.com",
    "shopify.com",
    "nytimes.com"
  ],
  "maxExternalScripts": 10,
  "fetchDns": true,
  "minConfidence": 50,
  "includeDescriptions": false,
  "concurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Websites with detected technologies stored in the default dataset (JSON/CSV/Excel via the dataset API).

# 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": [
        "apify.com",
        "shopify.com",
        "nytimes.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pulsedata/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": [
        "apify.com",
        "shopify.com",
        "nytimes.com",
    ] }

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

```

## MCP server setup

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