# Bulk Tech Stack Detector - BuiltWith/Wappalyzer Alternative (`smiling_jubilance/website-tech-intelligence`) Actor

Enter domains, get the full website technology stack: CMS detection, analytics and pixel detection, categories, versions, confidence and buying signals. A BuiltWith and Wappalyzer alternative at $0.008 per domain - charged only when a row is written.

- **URL**: https://apify.com/smiling\_jubilance/website-tech-intelligence.md
- **Developed by:** [Lake Sky](https://apify.com/smiling_jubilance) (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 $4.70 / 1,000 domain 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 is Bulk Tech Stack Detector - BuiltWith/Wappalyzer Alternative?

**Website Tech Stack Detector** takes a list of domains and tells you what each site is **actually
built with** — the CMS, the e-commerce engine, the payment processor, the analytics and tag manager,
the CDN, the framework — with **categories, versions and a confidence score** per finding.

It is a practical **BuiltWith alternative** for enrichment work: same job, priced per domain, and
automatable from the Apify API or a schedule.

Alongside the raw stack, it derives **buying signals** — for example, a site running Shopify *and* a
payment processor *and* a review platform is a very different prospect from a brochure site on
WordPress with nothing attached. The `signals` object exposes those so you can segment without
hand-writing the rules.

### What can this Actor do?

- ✅ **235 technology signatures** matched against HTML, headers, scripts, cookies and meta tags
- ✅ **Categories** — CMS, e-commerce, payment, analytics, CDN, framework, tag manager and more, as
  separate fields so you can filter directly
- ✅ **Version detection** for technologies that expose one (toggle with `detectVersion`)
- ✅ **Confidence score** per match, with a tunable floor (`minConfidence`) so you choose the
  precision/recall trade-off
- ✅ **Buying signals** derived from the combination of technologies found
- ✅ **Meta and social link extraction** (toggle with `extractMeta`)
- ✅ **Optional Apify Proxy** for targets that geo-block or rate-limit datacenter IPs
- ✅ Built on Apify: schedule it, webhook the results, or pull the dataset from the API — storage,
  monitoring and retries are handled by the platform

### How to use it

1. Open the **Input** tab.
2. Add domains to `domains`, or paste a newline/CSV list into `domainsCsv`.
3. Set `maxDomains` to the ceiling you want (default `1000`) and `minConfidence` to taste.
4. Click **Start**.
5. Open the **Overview** dataset view for a flat table of domain, tech count and categories.

```json
{
  "domains": [{ "url": "https://example.com" }],
  "detectVersion": true,
  "minConfidence": 50,
  "maxDomains": 1000
}
```

### Pricing

This Actor is **pay-per-event**, billed **per domain analyzed**.

| Event | When it is charged | Price |
|---|---|---|
| **Domain analyzed** | A domain was successfully fetched and fingerprinted | **$8** per 1,000 domains ( = $0.008 each ) |
| **Actor start** | Once per run, per GB of memory | **$0.00005** per GB |

Domains that fail to fetch are **not charged**. Apify's BRONZE, SILVER, GOLD, PLATINUM and DIAMOND
plans lower the unit price automatically.

Rough budgeting, assuming every domain resolves:

| Domains in | Cost |
|---|---|
| 1,000 | $8 |
| 5,000 | 5 × $8 |
| 10,000 | 10 × $8 |

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `domains` | array | empty | Domains or URLs as request objects |
| `domainsCsv` | string | empty | Same list as CSV or newline-separated text |
| `maxConcurrency` | integer | `20` | Parallel domain fetches |
| `timeoutSec` | integer | `15` | Per-domain timeout |
| `maxDomains` | integer | `1000` | Hard cap per run |
| `detectVersion` | boolean | `true` | Attempt version detection |
| `minConfidence` | integer | `50` | Minimum confidence to report a technology |
| `extractMeta` | boolean | `true` | Extract meta tags and social links |
| `useApifyProxy` | boolean | `false` | Route requests through Apify Proxy |

### Output

One dataset item per analyzed domain:

```json
{
  "domain": "example.com",
  "title": "Example Domain",
  "httpStatus": 200,
  "techs": [
    { "name": "Cloudflare", "category": "cdn", "version": null, "confidence": 90 }
  ],
  "categories": {
    "cms": [],
    "ecommerce": [],
    "payment": [],
    "analytics": []
  },
  "signals": {
    "techCount": 1
  }
}
```

### Other Actors you may like

- **[Bulk On-Page SEO Audit](https://apify.com/store)** — 26 on-page checks plus tech detection, when
  you want an SEO score too.
- **[Bulk Email Verifier](https://apify.com/store)** — verify the contacts you found on the site.
- **[ATS Job Board Feed Sync - Greenhouse, Lever, Ashby](https://apify.com/store)** — convert a tech signal into a hiring signal.

### FAQ

**How is this different from BuiltWith?** Same category of data, delivered as an Actor: priced per
domain, scriptable through the Apify API, and schedulable without a separate subscription.

**Why does a domain return an empty tech list?** Either nothing matched above `minConfidence`, or the
page is rendered entirely client-side. Lower `minConfidence` first; if that does not help, the site
really is JS-only.

**Do failed domains cost anything?** No. Only successful fingerprints emit the billing event.

**Can I detect versions?** Yes, `detectVersion` is on by default. Not every technology exposes a
version, so `version` is `null` in those cases.

# Actor input Schema

## `domains` (type: `array`):

List of domains or full URLs, e.g. \["stripe.com", "https://shopify.com"].

## `domainsCsv` (type: `string`):

Bulk input alternative: paste domains separated by comma or new line.

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

Number of domains fetched in parallel.

## `timeoutSec` (type: `integer`):

How long to wait for each domain to respond before giving up. Raise it for slow or heavily CDN-fronted sites; lower it for faster runs on large lists.

## `maxDomains` (type: `integer`):

Hard cap to protect against accidental giant runs.

## `detectVersion` (type: `boolean`):

Also try to read each detected technology's version string (for example WordPress 6.5). Adds a small amount of parsing time per page.

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

Technologies detected below this confidence are dropped.

## `extractMeta` (type: `boolean`):

Also collect the page's meta title, meta description and social links into the output item, in addition to the detected technologies.

## `useApifyProxy` (type: `boolean`):

Off by default to keep costs low. Turn on only for bot-protected sites.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "stripe.com"
  ],
  "domainsCsv": "",
  "maxConcurrency": 20,
  "timeoutSec": 15,
  "maxDomains": 1000,
  "detectVersion": true,
  "minConfidence": 50,
  "extractMeta": true,
  "useApifyProxy": false
}
```

# Actor output Schema

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

Per-domain record: domain, title, httpStatus, techs (name, category, version, confidence), categories (cms, ecommerce, payment, analytics, ...), signals (techCount and derived buying signals).

# 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 = {
    "domains": [
        "example.com",
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("smiling_jubilance/website-tech-intelligence").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 = { "domains": [
        "example.com",
        "stripe.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("smiling_jubilance/website-tech-intelligence").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 '{
  "domains": [
    "example.com",
    "stripe.com"
  ]
}' |
apify call smiling_jubilance/website-tech-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,smiling_jubilance/website-tech-intelligence"
        }
    }
}
```

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/aDIlOXw6uMdmFqdYB/builds/zJezT0djLmeL2xElG/openapi.json