# Website Technology & Tech Stack Detector (`sitegauge/website-technology-detector`) Actor

Find the CMS, ecommerce platform, frameworks, analytics, marketing tools, hosting and email provider behind any list of websites. Every technology comes with its evidence. Reads only the home page, the public tag manager container and DNS records. You pay only for websites that were analyzed.

- **URL**: https://apify.com/sitegauge/website-technology-detector.md
- **Developed by:** [John](https://apify.com/sitegauge) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 analyzed websites

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

## Website Technology & Tech Stack Detector

Find out what any list of websites is built with: CMS, ecommerce platform, website builder, JavaScript frameworks, analytics, advertising and marketing tools, live chat, payments, hosting, CDN, and the email and DNS providers behind the domain.

Paste domains, get one row per website with the technologies found and the evidence for each one. You pay only for websites that were actually analyzed.

### Who it is for

- **Sales and marketing teams** who qualify leads by technology, for example Shopify stores that use Klaviyo, or WordPress sites without a cookie banner.
- **Agencies and freelancers** who want to know a prospect's stack before the first call.
- **Market researchers and product teams** who measure how widely a tool is used across a list of sites.
- **Developers and AI agents** that need a site's tech stack as structured data (JSON, CSV, Excel).

### What you get

1. **One dataset row per website** with ready-to-filter columns (`cms`, `ecommerce`, `websiteBuilder`, `frameworks`, `analytics`, `tagManagers`, `advertising`, `marketing`, `liveChat`, `payments`, `cookieConsent`, `hosting`, `emailProvider`), the full technology list, and every technology with its category, version when it is visible, and the evidence it was recognised by.
2. **What the domain's DNS shows about the organisation**, in columns of their own: the email provider (`emailProvider`), the DNS provider or providers (`dnsProvider`), the services allowed to send email for the domain (`emailSenders`, from SPF), the services the domain has been verified with (`connectedServices`, for example Atlassian, DocuSign, Zoom or OpenAI), and the DMARC policy.
3. **WordPress and Shopify details**: the theme and every plugin folder found on a WordPress page, and the theme of a Shopify store.
4. **An HTML report** (`REPORT` in the key-value store) with the most used technologies across your list, by category.
5. **A JSON summary** (`OUTPUT` in the key-value store) with the same counts.

### What it detects

About 500 technologies in more than 60 categories, including:

| Area | Examples |
|---|---|
| CMS and site builders | WordPress, Drupal, Joomla, HubSpot CMS, Webflow, Wix, Squarespace, Ghost, Framer |
| Ecommerce | Shopify, WooCommerce, Magento, BigCommerce, PrestaShop, Salesforce Commerce Cloud |
| Frameworks and libraries | Next.js, Nuxt, React, Vue.js, Angular, Svelte, Astro, jQuery, Bootstrap, Tailwind CSS |
| Analytics and tag managers | Google Analytics, Google Tag Manager, Matomo, Plausible, Hotjar, Microsoft Clarity, Segment |
| Advertising | Meta Pixel, Google Ads, LinkedIn Insight Tag, TikTok Pixel, Microsoft Advertising |
| Marketing and CRM | HubSpot, Klaviyo, Mailchimp, ActiveCampaign, Marketo, Salesforce |
| Chat and support | Intercom, Zendesk, Drift, Tawk.to, Crisp, LiveChat |
| Payments | Stripe, PayPal, Klarna, Afterpay, Square |
| Cookie consent | OneTrust, Cookiebot, CookieYes, Usercentrics, Termly |
| Hosting, CDN and security | Cloudflare, Vercel, Netlify, Amazon CloudFront, Fastly, Akamai, WP Engine |
| From DNS | Email providers such as Google Workspace, Microsoft 365 and Zoho Mail, DNS providers such as Cloudflare DNS and Amazon Route 53, about 50 email sending services and more than 90 services that leave a verification record |

On WordPress sites every plugin and theme folder that the page loads is listed, also the ones that are not in the fingerprint list.

### How it works

For each website the Actor:

1. Reads `robots.txt` and then requests the **home page once**. Redirects are followed.
2. Compares the response headers, cookie names, meta tags, script and stylesheet addresses, inline scripts and HTML with its fingerprints.
3. If the page uses Google Tag Manager, reads the public container file to find tags that are not in the page itself.
4. Looks up the domain's public DNS records (MX, TXT, NS, DMARC and the CNAME of `www`).

No browser is used and no JavaScript is run. That is why a run gets through hundreds of websites per minute (see [Speed](#speed)).

### How to use it

1. Paste your domains or URLs into **Websites**, one per line. `example.com`, `www.example.com` and `https://example.com/` all work.
2. Run the Actor.
3. Open the **Output** tab for the table, export it as CSV, Excel or JSON, or open the `REPORT` record in the key-value store.

#### Input options

| Field | What it does | Default |
|---|---|---|
| `websites` | Domains or URLs to check | required |
| `checkDns` | Read the domain's DNS records | `true` |
| `readTagManager` | Read the Google Tag Manager container when a page uses one | `true` |
| `includeEvidence` | Add the matching signals to every technology | `true` |
| `maxConcurrency` | The most websites worked on at the same time | 30 |

#### Example input

```json
{
    "websites": ["example.com", "https://www.example.org/", "shop.example.net"],
    "checkDns": true
}
```

### Example output (one row, shortened)

```json
{
    "input": "shop.example.net",
    "url": "https://shop.example.net/",
    "finalUrl": "https://shop.example.net/",
    "status": "analyzed",
    "statusCode": 200,
    "title": "Example Shop",
    "language": "en",
    "technologyCount": 10,
    "technologyList": "Shopify; Cloudflare; Meta Pixel; Klaviyo; Stripe; Microsoft 365; Amazon Route 53; Judge.me; HSTS; Shopify theme: Dawn",
    "cms": null,
    "ecommerce": "Shopify",
    "analytics": null,
    "advertising": "Meta Pixel",
    "marketing": "Klaviyo",
    "payments": "Stripe",
    "hosting": "Cloudflare",
    "emailProvider": "Microsoft 365",
    "dnsProvider": "Amazon Route 53",
    "emailSenders": "Microsoft 365; Klaviyo",
    "connectedServices": "Meta Business",
    "technologies": [
        { "name": "Shopify", "category": "Ecommerce", "version": null, "evidence": ["header x-shopid", "cookie: _shopify_y", "loads: cdn.shopify.com/"] },
        { "name": "Klaviyo", "category": "Email marketing", "version": null, "evidence": ["loads: static.klaviyo.com/onsite/js/"] }
    ],
    "shopify": { "theme": "Dawn", "themeBase": "Dawn 15.0.0" },
    "dns": {
        "domain": "example.net",
        "emailProvider": "Microsoft 365",
        "dnsProvider": "Amazon Route 53",
        "hasSpf": true,
        "emailSenders": ["Microsoft 365", "Klaviyo"],
        "dmarcPolicy": "quarantine",
        "connectedServices": ["Meta Business"]
    },
    "checkedAt": "2026-11-18T09:00:00.000Z"
}
```

#### Status of a row

| Status | Meaning | Charged |
|---|---|---|
| `analyzed` | The home page was read and compared with the fingerprints. | yes |
| `blocked` | The site refused an automated request (for example 403, 429 or a bot challenge). | no |
| `robots_disallowed` | The site's robots.txt does not allow the page to be read. | no |
| `unreachable` | The domain does not resolve, did not answer within 20 seconds or has a certificate problem. | no |
| `http_error` | The page returned an error such as 404 or 500. | no |
| `not_html` | The address returned something other than a web page. | no |
| `invalid` | The line is not a website address. | no |
| `error` | Something unexpected went wrong while this website was checked. The message says what. | no |

Rows that were not analyzed still show what could be seen without the page, for example the CDN from the response headers and the email provider from DNS.

### Pricing

You pay per result: **$2 per 1,000 analyzed websites**, plus Apify's small Actor start fee. Customers on Apify's paid plans pay less: $1.90 per 1,000 on Starter, $1.80 on Scale and $1.60 on Business. There is no monthly rental and you do not pay for platform compute separately.

Websites that could not be analyzed (blocked, unreachable, disallowed by robots.txt, invalid) are in the results but are **not charged**.

Set a maximum cost per run in Apify Console to cap your spend. The Actor never analyzes more websites than your limit can pay for.

| Analyzed websites | Approximate cost |
|---|---|
| 1,000 | $2 |
| 10,000 | $20 |
| 100,000 | $200 |

### Speed

How fast a run goes depends on its memory, because Apify gives a run processor time in proportion to its memory. Measured in November 2026 on a mixed list of 736 well-known websites:

| Memory of the run | Websites per minute |
|---|---|
| 1 GB | about 120 |
| 4 GB (default) | about 550 |
| 8 GB | about 1,000 |

Slow and unreachable websites lower these figures, because each of them is given up to 20 seconds to answer. The price per analyzed website is the same at every memory setting, so the default is a good choice for most lists. Choose 8 GB under **Run options** for very long lists.

The Actor never asks for more processor time than the run has. Websites are started at the pace the processor allows, so a busy run does not mistake its own slowness for a slow website.

### Good to know

- **Only what a visitor's first request shows is detected.** Tools that load after a click, after consent, or only on inner pages such as the checkout are not seen. Tags loaded through Google Tag Manager are found by reading the container.
- **No technology is guessed.** Every entry comes with the signal it was recognised by. Server-side software that leaves no public trace cannot be detected by any tool of this kind.
- **Platform folder names only count in a page's own scripts and stylesheets.** A picture or a text link that points at another website's WordPress folder does not make the page WordPress.
- **The crawler is polite.** It identifies itself as `SiteAuditBot`, respects robots.txt, sends at most two requests per second to one host and makes no attempt to get around blocks.
- **Account identifiers are left out.** The evidence shows that a site uses a tool, not the account or tracking ID it uses.
- **DNS records describe the organisation, not the page.** Mail senders and verification records are therefore kept out of the technology list and the technology count: a company that has verified its domain with Shopify does not necessarily run this website on Shopify. On host names that belong to a platform, such as `example.myshopify.com`, DNS is skipped.
- **Bare domains get a second chance.** If `example.com` does not answer, `www.example.com` is tried before the website is reported as unreachable. A website that accepts the connection and then stays silent is not tried again.
- **Limits:** up to 200,000 websites per run and 2 MB of HTML per page.
- **Aborted and timed-out runs keep their results.** Rows are saved while the run is going. When a run is aborted gracefully or reaches its time-out it stops starting websites, saves what is finished and writes the report.
- This is an independent tool. It is not affiliated with or endorsed by any of the technologies it detects.

### FAQ

**Why is a technology I know is there not listed?**
It may load only after JavaScript runs, after cookie consent, or on a page other than the home page. Open an issue with the website and the technology and it will be looked at.

**Why was a website not analyzed?**
The `status` and `message` columns say why. The most common reasons are a firewall that refuses automated requests and a domain that no longer resolves. These rows are free.

**Can it check inner pages?**
Give the full URL of the page instead of the domain. That page is then read instead of the home page.

**How many websites can I check in one run?**
Up to 200,000. With the default memory a run checks about 550 websites per minute, so 10,000 websites take about 20 minutes. A run stops at its time-out, which is one hour unless you change it, and keeps what it has checked. For more than about 30,000 websites raise the time-out or the memory under **Run options**. See [Speed](#speed).

**Can I schedule it?**
Yes. Use Apify schedules to re-check a list every month and compare the results.

### Related tools

- [Technical SEO Audit & Site Crawler](https://apify.com/sitegauge/seo-audit-crawler): crawls a site and audits every URL with 57 technical and on-page SEO checks, a score per page and an HTML report.
- [Broken Link Checker & Bulk URL Status Checker](https://apify.com/sitegauge/broken-link-checker): checks every link on a site, or a list of URLs, and reports the broken ones with the pages that link to them.

### Feedback

Missing a technology or found a wrong match? Open an issue on the Issues tab and it will be looked at.

Source code: [github.com/sitegaugeHQ/website-technology-detector](https://github.com/sitegaugeHQ/website-technology-detector) (MIT licence).

# Actor input Schema

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

Domains or URLs to check, one per line, for example example.com or https://www.example.com. The home page of each website is read once.

## `checkDns` (type: `boolean`):

Look up the public DNS records of each domain to find its email provider, DNS provider, email sending services and services connected through verification records.

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

Analytics and advertising tags are often loaded through Google Tag Manager and do not appear in the page itself. When a page uses a container, read it to find them.

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

Add to every technology the signals it was recognised by, such as a header, a cookie name or a script address.

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

The most websites worked on at the same time. A run starts websites at the pace its share of processor time allows, so giving the run more memory makes it faster. Each website still gets at most two requests per second.

## Actor input object example

```json
{
  "websites": [
    "apify.com",
    "crawlee.dev",
    "wordpress.org"
  ],
  "checkDns": true,
  "readTagManager": true,
  "includeEvidence": true,
  "maxConcurrency": 30
}
```

# Actor output Schema

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

No description

## `report` (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 = {
    "websites": [
        "apify.com",
        "crawlee.dev",
        "wordpress.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sitegauge/website-technology-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 = { "websites": [
        "apify.com",
        "crawlee.dev",
        "wordpress.org",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sitegauge/website-technology-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 '{
  "websites": [
    "apify.com",
    "crawlee.dev",
    "wordpress.org"
  ]
}' |
apify call sitegauge/website-technology-detector --silent --output-dataset

```

## MCP server setup

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