# Website Technology Detector & Tech Stack Finder (`aurelmark/tech-stack-finder`) Actor

Tech stack detector for lists of websites: finds the CMS, shop platform, analytics, payment and chat tools. One row per site, each tool with its proof from the home page. $2 per 1,000 websites with a technology found. Nothing found, no charge.

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

## Pricing

from $2.00 / 1,000 website with technology founds

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 Technology Detector & Tech Stack Finder

**TL;DR: a website tech stack detector and technology finder for lists of websites: get one row per site with the technologies its home page shows, each with the evidence that proves it.** CMS and site builders, ecommerce platforms, analytics and marketing tags, tag managers, CDNs, frameworks, payment providers and chat widgets. You pay only for websites where at least one technology is found. It reads pages without a browser, so tools that scripts load later, or that load only after a cookie consent, are missed (see [What it cannot do](#what-it-cannot-do)).

### Example result

Three real websites, run on 15 Nov 2026 (each finding trimmed to its first piece of evidence):

| website | status | technologies found | evidence (first item) |
|---|---|---|---|
| gymshark.com | found | Shopify (ecommerce, high), Cloudflare (cdn, high), Shop Pay (payment, medium) | Shopify: script `https://cdn.shopify.com/shopifycloud/shop-js/modules/v2/loader.init-shop-cart-sync.en.esm.js`; Cloudflare: header `cf-ray` |
| allbirds.com | found | Shopify, Google Ads, Microsoft Clarity, Google Tag Manager, Cloudflare, Shop Pay (6 in all) | Shopify: script `https://www.allbirds.com/cdn/shop/t/4159/assets/theme2.js`; Google Tag Manager: the `googletagmanager.com/gtm.js` snippet in the page |
| bbc.co.uk | found | Fastly (cdn, high) | Fastly: header `x-served-by` |

Rows where a site refuses us, cannot be reached or shows nothing are free and say why. Try it free: Apify's free plan includes $5 of monthly credit.

### Example output

Two rows for the input `{"websites": [{"website": "northfield-outdoor.example", "crmId": "ACC-1042"}, "harbour-dental.example"], "categories": ["ecommerce", "analytics", "payment", "cdn"]}`. The shape and wording are the tool's own; the websites are made up (reserved `.example` names).

```json
[
  {
    "website": "northfield-outdoor.example",
    "domain": "northfield-outdoor.example",
    "finalUrl": "https://northfield-outdoor.example/",
    "status": "found",
    "statusReason": "4 technologies found on the home page, each with its evidence.",
    "technologies": [
      { "name": "Shopify", "category": "ecommerce", "confidence": "high", "evidence": [
        { "kind": "header", "detail": "x-shopid: 61234567", "sourceUrl": "https://northfield-outdoor.example/" },
        { "kind": "cookie", "detail": "set-cookie: _shopify_y", "sourceUrl": "https://northfield-outdoor.example/" } ] },
      { "name": "Klaviyo", "category": "analytics", "confidence": "high", "evidence": [
        { "kind": "script", "detail": "https://static.klaviyo.com/onsite/js/klaviyo.js?company_id=NfX4kQ", "sourceUrl": "https://northfield-outdoor.example/" } ] },
      { "name": "Cloudflare", "category": "cdn", "confidence": "high", "evidence": [
        { "kind": "header", "detail": "cf-ray: 8e2a41f0c9b17d3a-LHR", "sourceUrl": "https://northfield-outdoor.example/" } ] },
      { "name": "Stripe", "category": "payment", "confidence": "high", "evidence": [
        { "kind": "script", "detail": "https://js.stripe.com/v3/", "sourceUrl": "https://northfield-outdoor.example/" } ] }
    ],
    "categoriesFound": ["ecommerce", "analytics", "cdn", "payment"],
    "techCount": 4,
    "checkedAt": "2026-11-12T09:00:00.000Z",
    "charged": true,
    "input": { "crmId": "ACC-1042" },
    "schemaVersion": "1.0"
  },
  {
    "website": "harbour-dental.example",
    "domain": "harbour-dental.example",
    "finalUrl": "https://harbour-dental.example/",
    "status": "none_detected",
    "statusReason": "The home page was read; none of the technologies this tool knows was seen in the categories asked for (ecommerce, analytics, payment, cdn) at medium or high confidence. Tools loaded later by a tag manager or only after a click are not visible without a browser. Nothing was charged.",
    "technologies": [],
    "categoriesFound": [],
    "techCount": 0,
    "checkedAt": "2026-11-12T09:00:01.000Z",
    "charged": false,
    "input": {},
    "schemaVersion": "1.0"
  }
]
```

(Evidence lists are shortened here; a real row keeps up to a few items per technology.)

### Who needs it

Agencies and B2B sellers who sort lead lists by what a website runs: "all Shopify shops that use Klaviyo", "WordPress sites with no analytics", "who takes payments with Stripe". Every finding carries its proof, so you can check a row before you act on it.

### Price

One charge per website where at least one technology is found. Nothing for a site where nothing is found, a site that refuses us, a site that cannot be reached, a site that needs a browser, or a site whose robots.txt asks tools not to read it. The only other charge is Apify's standard start fee per run. The price per 1,000 websites is shown on this page's pricing tab.

### How to run it

1. Paste your websites, one per line (domains or full addresses, up to 1,000 a run).
2. Optional: choose categories and the lowest confidence you want.
3. Start. Each website gets one row; the run summary says how many had technologies and what was charged.

### Inputs

| Field | What it does |
|---|---|
| `websites` | 1 to 1,000 websites. `startUrls` is accepted too. Items may be rows such as `{"website": "example.com", "id": "A-17"}`; your other columns come back under `input`. |
| `categories` | Only these kinds: `cms`, `ecommerce`, `analytics`, `tag_manager`, `cdn`, `framework`, `payment`, `chat`. Empty means all. |
| `minConfidence` | `high`, `medium` (default) or `low`. Findings below it are left out. |
| `respectRobotsTxt` | On by default. Off only for sites whose owners allow you to check them. |
| `readTagManager` | On by default (not used when `minConfidence` is `high`). When a home page loads Google Tag Manager, the tool also reads that site's public Tag Manager file from googletagmanager.com: one extra request (one try, at most 8 s, within the site's 20 s), at most 1 MB (a larger file is skipped and counted in the SUMMARY's `tagManagerFiles`), with googletagmanager.com's robots.txt obeyed; a file it cannot read gives no findings and never fails the row. It reads the file's tag list and firing rules exactly: an ad or analytics tag it reads there (Google Analytics, Google Ads, Microsoft Advertising, LinkedIn Insight, Hotjar, Pinterest, and the like) is reported at `low`, however surely it fires, because it is not seen on the page itself; if the page also shows the tag directly, the finding keeps the confidence that direct evidence earns. Other tags (Custom HTML or template tags that load a CMS, shop, chat or similar) that fire on every page load, or on the home page's own address, are `medium`; ones that wait for cookie consent, or that a condition the tool cannot judge might stop, are `low`. Paused tags and tags that fire only on a click or another page are not reported. Tag types read: Google Analytics, Google Ads, Microsoft Advertising, LinkedIn Insight, Hotjar, Pinterest, and Custom HTML or template tags matched with our own rules. Off: only the home page is read. |

An input name the tool does not know stops the run before any work, with one `input_error` row that lists the accepted names. Nothing is charged.

### Run it every week

This tool has no "only new" option: every website you send is checked and, when a technology is found, charged. So schedule it on a list that holds only this week's new leads.

1. Open the Actor, go to **Schedules** and create one with the cron expression `0 7 * * 1` (every Monday at 07:00).
2. Give it the new leads' websites, for example `{"websites": ["gymshark.com", "bbc.co.uk"], "categories": ["ecommerce", "analytics"]}` (replace them with your own websites).
3. Under **Integrations**, send each finished run to Slack or Gmail, or append the rows to Google Sheets; for a CRM, call a webhook, Make or n8n and map `technologies` back by the id you sent under `input`.

### Outputs

One row per website: `website`, `domain`, `finalUrl`, `status`, `statusReason`, `technologies`, `categoriesFound`, `techCount`, `checkedAt`, `charged`, `input`, `schemaVersion`.

Each technology has a `name`, a `category`, a `confidence` and `evidence`: what was seen (`kind` is `header`, `cookie`, `meta`, `script`, `html` or `url`), the `detail`, and the `sourceUrl` it was seen on. Cookies are reported by name only, never by value.

**Confidence.** `high`: a header, cookie or script address only that vendor uses (for example Shopify's `x-shopid` header or `js.stripe.com`). `medium`: a distinctive meta tag or page marker (for example `<meta name="generator" content="WordPress">`), or a non-analytics tag the site's Tag Manager file fires on every page load. `low`: one generic pattern, a Tag Manager ID with no loader script or snippet on the page, or an ad or analytics tag known only from the site's Tag Manager file (or one that waits for cookie consent). Google Tag Manager itself is `medium` or `high` only when the page has a real loader script, snippet or noscript frame. When one tool implies another (WooCommerce runs on WordPress), the implied one is listed at the implying one's confidence, and its evidence says "implied by".

**Statuses.** `found` (the only charged status), `none_detected`, `blocked`, `unreachable`, `needs_browser`, `robots_disallowed`, `invalid_input` (not a usable address, or a repeat in your list), `not_checked` (the run stopped at your spending limit first) and the run-level `input_error`.

### Measured accuracy

Measured on 15 Nov 2026 on this release, on a held-out set of 350 websites drawn at random and never used for tuning: 300 live company sites from the US and the EU and 50 addresses that should not answer. A separate reviewer labelled each live home page in a real browser without seeing the detection rules, and a second reviewer checked a sample of those labels before the run. 285 sites could be read by the reviewer and are scored. The tool ran once, with its default input (`minConfidence` medium, robots.txt respected), and that one run is the number.

| | Result (default `minConfidence` medium) |
|---|---|
| Precision of `high` findings | **97.6%** (598 right, 15 wrong) |
| Precision of all reported findings | **95.3%** (913 right, 45 wrong) |
| Recall (labelled technologies our rules cover that were found) | **66.8%** (913 of 1,366) |

**How to read it.** When the tool names a technology, it is right about 95 times in 100, and about 98 in 100 for `high` findings. It does **not** find everything: it finds about 2 in 3 of the covered technologies on a site. Our recall target was 80% and it was **not met**.

**Labels the reviewer could not settle.** 207 technologies the reviewer could not settle are left out of the numbers above; the tool named 33 of them. Counting all 33 as wrong and all 207 as present, the range is 92.1% precision for all findings (913 right, 78 wrong), 96.8% for `high` findings (598 right, 20 wrong) and 60.1% recall (946 of 1,573).

**Why it misses some.** The 453 misses fall into four groups:

- **Loaded later by scripts (148).** A tag manager or another script adds the tool after the page loads, or only after a visitor accepts cookies. A page read without a browser cannot see these.
- **Reported only at `low` (128).** The tool saw it, but only through a hint it does not trust enough for `medium`, such as an ad or analytics tag known only from the site's Tag Manager file. Set `minConfidence` to `low` to see these, with more wrong findings among them.
- **Site not read (89).** The site did not answer, refused the request or showed an "are you human" check, or its robots.txt asked tools not to read it. Those rows say so, and are not charged.
- **In the page but not matched (88).** No detection rule matched what was on the page.

**Earlier tests.** On 14 Nov 2026 the previous release scored 99.3% precision for `high` findings (561 right, 4 wrong), 97.1% across all findings (983 right, 29 wrong) and 63.2% recall (983 of 1,555) on another held-out set. On 15 Nov a trial version with an extra browser pass, which is not in this release, scored 94.4%, 89.8% and 67.6% on a third. Each number belongs to the version measured; a later version is measured the same way on a new held-out set before any number here changes.

### What it cannot do

- **It reads pages without a browser.** It does not run JavaScript. Tools that a tag manager or another script loads later, tools that load only after a visitor accepts cookies, and tools that appear only after a click cannot be seen. A page that is built only in the browser gets `needs_browser` and is not charged.
- **Home page only.** A tool used only on the checkout, blog or help pages is missed.
- It uses no proxies, does not imitate a browser and does not solve "are you human" checks. A site that answers with one gets `blocked` and is not charged.
- It reports no version numbers, no traffic figures and no personal data.
- It knows a fixed list of technologies, chosen for sales use (CMS, shop, analytics, tag manager, CDN, framework, payment, chat). A technology outside that list is not reported.

**How it reads a site.** It asks for robots.txt and then the home page, following redirects on the same site (at most 5). The only other request is the site's own Google Tag Manager file, when the page loads one (see `readTagManager`). A redirect to another site is followed once: that site's own robots.txt is obeyed, the row's `finalUrl` and `statusReason` name the site that was read, and its technologies are reported (and charged as found). A second redirect to yet another site is not followed; the row names that site so you can add it. It names itself in every request (User-Agent `aurelmark-tech-stack/1.0` with a contact address), waits between requests to the same host and slows down when a site asks it to. At most 10 sites are read at once.

### Troubleshooting

**A tool I know a site uses is missing.** It is most likely loaded by a script after the page opens, after a cookie consent, or only on another page. This tool reads the home page without running scripts. If the site uses Google Tag Manager, try `minConfidence` `low` to also see the Tag Manager tags that wait for cookie consent, as hints.

**Many rows say `needs_browser`.** Those sites are built in the browser and show almost nothing to a plain page read. They are not charged.

**Rows say `blocked`.** The site refused us or showed an "are you human" check. We do not get around these; nothing is charged.

**Rows say `robots_disallowed`.** The site's robots.txt asks tools not to read it. Turn off `respectRobotsTxt` only for sites whose owners allow you to check them.

**Why was I not charged for some rows?** Only `found` rows are charged.

**The run stopped with one `input_error` row.** An input name was not recognised; the row lists the accepted names. Nothing was charged.

**A technology it named is wrong.** Open an issue with the website and the technology name. A wrong finding becomes a test before it is fixed.

**Something is wrong or missing. Where do I write?** Open an issue on this Actor's page on the Apify Store. Please give the run link or run ID, the website the question is about, and what you expected. We answer issues within 24 hours. We cannot give legal advice, and we do not ask for your Apify login or API token.

### Other Actors by Aurelmark

- [Contact Details Scraper & Website Email Finder](https://apify.com/aurelmark/website-contact-finder) (`aurelmark/website-contact-finder`): the same list of websites, with each company's best business email and its proof page.
- [UK & EU Contract Awards: Tender Winners as Leads](https://apify.com/aurelmark/contract-winners) (`aurelmark/contract-winners`): new UK and EU public contract winners as sales leads, one row per award.

### Detection rules and licence

The detection rules are our own, written from the vendors' own public documentation and the headers, cookies and script addresses the vendors document. Each rule names its public source. No third-party fingerprint database was copied or used.

### Use with the API, MCP and automation tools

Run it through the Apify API, Apify's MCP server, n8n, Make or Zapier like any Apify Actor. The input names above are the whole interface.

# Changelog

This Actor's version history is a separate document: https://apify.com/aurelmark/tech-stack-finder/changelog.md

# Actor input Schema

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

Websites or bare domains, one per line, for example example.com or https://www.example.com. 1 to 1,000 in one run. Through the API each item may also be a row such as {"website": "example.com", "id": "A-17"}: your other columns come back unchanged under input. The name startUrls is accepted for this field too. One output row per website; a website that appears twice is read once.

## `startUrls` (type: `array`):

For automations moving from another tool: the same list under the name startUrls, as \[{"url": "https://example.com"}] or as plain strings. Send either websites or startUrls, not both. Not shown in the form.

## `categories` (type: `array`):

Only these kinds of technology are returned. Leave empty for all eight. A website whose technologies are all outside these categories gets none_detected and is not charged.

## `minConfidence` (type: `string`):

Findings below this confidence are left out. High: a header, cookie or script host only that vendor uses. Medium: a distinctive meta tag or page marker. Low: one generic pattern.

## `respectRobotsTxt` (type: `boolean`):

On (recommended): the tool reads each site's robots.txt first and does not read a home page it disallows; that row is robots_disallowed and not charged. Switch off only for sites whose owners allow you to check them.

## `readTagManager` (type: `boolean`):

On (not used when minConfidence is high): when a home page loads Google Tag Manager, the tool reads that site's public Tag Manager file from googletagmanager.com (one extra request, at most 1 MB, each file once per run) and its firing rules: tags that fire on every page load are reported at medium, tags that wait for cookie consent at low; paused and click-only tags are not reported. Off: only the home page is read.

## Actor input object example

```json
{
  "websites": [
    "shopify.com",
    "wordpress.org",
    "stripe.com"
  ],
  "minConfidence": "medium",
  "respectRobotsTxt": true,
  "readTagManager": true
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per website with the categories and the number of technologies found.

## `technologies` (type: `string`):

Every technology with its category, confidence and evidence.

## `summary` (type: `string`):

Rows by status, the amount charged for results and the time taken.

# 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 = {
    "websites": [
        "shopify.com",
        "wordpress.org",
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("aurelmark/tech-stack-finder").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 = { "websites": [
        "shopify.com",
        "wordpress.org",
        "stripe.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("aurelmark/tech-stack-finder").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 '{
  "websites": [
    "shopify.com",
    "wordpress.org",
    "stripe.com"
  ]
}' |
apify call aurelmark/tech-stack-finder --silent --output-dataset

```

## MCP server setup

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

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/57DfahhurfGq6GRfk/builds/jUXhGxaqcaIhmrJ3l/openapi.json
