# Website Tech Stack API — Wappalyzer & BuiltWith Alternative (`nexgensignal/website-tech-stack-api`) Actor

Detect any website tech stack (CMS, frameworks, analytics, payments, server) with hosting/CDN detection and per-technology confidence. Keyless Wappalyzer/BuiltWith alternative, pay per site.

- **URL**: https://apify.com/nexgensignal/website-tech-stack-api.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $67.00 / 1,000 tech detections

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?

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

## Website Tech Stack API — Wappalyzer & BuiltWith Alternative

**Pay per site. A developer drop-in for detecting any website's technology stack — now with hosting/CDN detection and a per-technology confidence score.**

Point this actor at one URL or ten thousand and get back, for each, a clean JSON record of the technologies it runs — CMS, JavaScript framework, analytics, payments, web server, ecommerce platform — plus the hosting/CDN provider behind it and a confidence score on every detection. It is a direct, keyless alternative to Wappalyzer and BuiltWith that you can call from code, an AI agent, or an automation flow.

### What this is, in one paragraph

Every website announces a surprising amount about how it is built, right in its public HTTP response: the `Server` header, the cookies it sets, the scripts and meta tags in its HTML, the CDN fingerprints in its headers. This actor fetches each site's public homepage (following redirects, with retry-in-front hardening), reads those signals, and matches them against a signature library spanning content-management systems, website builders, ecommerce platforms, JavaScript frameworks and libraries, analytics and tag managers, live-chat and marketing tools, payment SDKs, CDNs, hosting providers, web servers, and back-end languages. Each match carries a confidence score, and — the upgrade over a plain Wappalyzer clone — the hosting/CDN provider is surfaced as its own field so you can see not just *what* a site runs but *where* it runs. No login, no headless browser, no personal data.

### Who buys this and for what job

- **Sales and go-to-market teams** qualifying prospects by the tech they run — "show me every prospect on Shopify" or "who is still on WordPress".
- **Competitive-intelligence analysts** profiling a market's technology choices across hundreds of domains at once.
- **Security and due-diligence teams** taking a first-pass inventory of a target's public stack and hosting footprint.
- **Developers** who want a keyless Wappalyzer/BuiltWith replacement they can call directly from code or an agent.

### The upgrade over a plain detector

Two things set this apart from a straight Wappalyzer clone. First, **hosting/CDN detection**: the record carries a dedicated `hosting_cdn` field that names the edge/hosting provider (Cloudflare, CloudFront, Fastly, Akamai, Vercel, Netlify, GitHub Pages, Amazon S3, and more) inferred from response headers — the layer a category-only detector blurs into "CDN". Second, a **per-technology confidence score** (0–100) on every detection, so you can keep only high-confidence matches when accuracy matters and treat weaker HTML-pattern hits with appropriate caution.

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `tech-detection` | $0.10 | $0.09 | $0.08 | $0.067 |

One `tech-detection` per site delivered. Delivered before charged — a site that fails to fetch still returns a record (with the error captured) and is billed as a delivered detection, exactly as a Wappalyzer-style API would count a scanned URL.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `urls` | array/string | — | One or more site URLs or domains to scan. |
| `domains` / `websites` / `targetUrls` | array | — | Aliases for `urls` (bare domains are accepted and normalised to https). |
| `url` | string | — | A single site URL or domain. |
| `categories_filter` | array | `[]` | Keep only technologies in these categories (e.g. `CDN`, `CMS`, `Analytics`). Empty = all. |
| `include_confidence` | boolean | `true` | Add a per-technology confidence score (0–100). |
| `include_versions` | boolean | `true` | Add a per-technology version where detectable. |
| `timeout_seconds` | integer | `15` | Per-site fetch timeout (1–60). |

Provide URLs through whichever field your workflow prefers — `urls`, `domains`, `websites`, `targetUrls`, or a single `url`. Bare domains like `example.com` are normalised to `https://example.com`, and duplicates are removed.

### Output

One JSON object per site. Real example (values as detected):

```json
{
  "record_id": "https://www.shopify.com",
  "url": "https://www.shopify.com",
  "final_url": "https://www.shopify.com/",
  "status_code": 200,
  "tech_count": 3,
  "categories": ["CDN", "Ecommerce", "JavaScript framework"],
  "technologies": [
    {"name": "Cloudflare", "category": "CDN", "version": null, "confidence": 100},
    {"name": "Shopify", "category": "Ecommerce", "version": null, "confidence": 100},
    {"name": "React", "category": "JavaScript framework", "version": null, "confidence": 80}
  ],
  "tech_names": ["Cloudflare", "Shopify", "React"],
  "hosting_cdn": ["Cloudflare"],
  "scan_time_ms": 496,
  "error": null,
  "source": "NexGen Signal Tech Stack Detector — public HTTP response signals",
  "observed_at": "2026-08-25T00:00:00Z"
}
```

An unbilled `RUN_RECEIPT` records how many sites were delivered and whether charged equals delivered.

### Field reference

Each record carries: `record_id` and `url` (the input URL), `final_url` (after redirects), `status_code`, `tech_count`, `categories` (the distinct category list), `technologies` (the detailed list — each with `name`, `category`, optional `version`, and optional `confidence`), `tech_names` (the flat name list for quick filtering), `hosting_cdn` (the inferred hosting/CDN providers), `scan_time_ms`, and `error` (null on success, or the fetch error). Provenance travels on every record: `source`, `source_url`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

For each URL, the actor issues a single GET with a real browser User-Agent, following redirects, with **retry-in-front hardening** — up to four attempts with a short backoff before a site is recorded as failed. It reads the response's status, final URL, headers, cookies, and HTML, then runs the signature library over those signals. Header and cookie signatures (a `CF-RAY` header, a `_shopify` cookie, `Server: nginx`) score highest; HTML-pattern signatures (a `__NEXT_DATA__` blob, a `js.stripe.com` script) score a notch lower. The detected technologies are de-duplicated to the highest-confidence hit per technology, categories and hosting/CDN are rolled up, and one record is delivered and charged.

### Working with the data

Because every technology carries a `confidence`, a pipeline can keep only detections at or above a threshold — high-confidence header and cookie hits — when precision matters, and fall back to the full list when recall matters. The `hosting_cdn` field lets you segment a domain list by where it is hosted, not just what it runs, which is often the more actionable cut for infrastructure and security work. The `tech_names` array is the quick filter — "give me every domain where `tech_names` contains Shopify" — while the `technologies` array carries the structured detail for reporting. Feed a list of ten thousand domains and get a complete technographic table back in one run.

### Honest limitations

- **Heuristic, not certified.** Detections are inferred from public HTTP signals and carry a confidence score; they are best-effort, not a guarantee. Treat low-confidence HTML-pattern hits accordingly.
- **Homepage-scoped.** The scan reads each site's public homepage response; technologies only loaded on inner pages or behind a login are not seen.
- **No bot-detection circumvention.** The actor makes an honest browser-headed request and retries transient failures; it does not attempt to defeat anti-bot systems, so a hard-blocked site returns a record with the error captured.
- **No person data.** Only public technical signals are read; no login is performed and no personal data is emitted.

### Use with AI agents

Point Claude, an OpenAI Agents SDK tool, an n8n or Make flow, or any MCP-aware client at this actor and hand it a list of domains. Because the output is clean, flat JSON with a `tech_names` array and a `hosting_cdn` field, an agent can filter and reason over the result without any post-processing — "which of these prospects run Shopify and sit behind Cloudflare?" is answerable directly from one run's dataset. A typical agent prompt is simply: *run the tech-stack detector on my list of domains and return the structured results, keeping only detections with confidence 90 or above.*

### Differentiation

A direct **Wappalyzer / BuiltWith alternative**, upgraded with a dedicated hosting/CDN field and a per-technology confidence score. Keyless, pay-per-site, callable from code or an AI agent, and priced per site with a Gold-tier discount ladder for volume.

***

*Technology detection derived from each site's own publicly served HTTP response (headers, cookies, HTML). Public technical signals only; no login, no personal data. Detection is heuristic and provided as-is.*

# Actor input Schema

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

One or more site URLs or domains to detect the tech stack for.

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

Alias for urls (bare domains accepted).

## `websites` (type: `array`):

Alias for urls.

## `targetUrls` (type: `array`):

Alias for urls.

## `url` (type: `string`):

A single site URL or domain.

## `categories_filter` (type: `array`):

Only keep technologies in these categories (e.g. CDN, CMS, Analytics). Empty = all.

## `include_confidence` (type: `boolean`):

Add a per-technology confidence score (0-100).

## `include_versions` (type: `boolean`):

Add a per-technology version where detectable.

## `timeout_seconds` (type: `integer`):

Per-site fetch timeout.

## Actor input object example

```json
{
  "urls": [
    "https://stripe.com",
    "https://shopify.com"
  ],
  "categories_filter": [],
  "include_confidence": true,
  "include_versions": true,
  "timeout_seconds": 15
}
```

# Actor output Schema

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

Delivered records.

# 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 = {
    "timeout_seconds": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/website-tech-stack-api").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 = { "timeout_seconds": 15 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/website-tech-stack-api").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 '{
  "timeout_seconds": 15
}' |
apify call nexgensignal/website-tech-stack-api --silent --output-dataset

```

## MCP server setup

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

```

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/8ubxVaqYC6F5qbp12/builds/aff6FCwCzAutVecdJ/openapi.json