# Tech Stack Detector: Website Technology Lookup (`rimulabs/tech-stack-detector`) Actor

Find the technology behind any website: CMS, ecommerce platform, analytics, marketing tools, payments, hosting, CDN and email provider. Check thousands of domains per run against 7,600+ fingerprints, with versions and a monitor mode that flags stack changes.

- **URL**: https://apify.com/rimulabs/tech-stack-detector.md
- **Developed by:** [Rimu Labs](https://apify.com/rimulabs) (community)
- **Categories:** Lead generation, Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 site checkeds

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

## Tech Stack Detector: website technology lookup for lead lists and competitor monitoring

Find out what any website is built with: **CMS, ecommerce platform, analytics, tag managers, marketing automation, ad pixels, payments, live chat, hosting, CDN and the company's email provider**. Paste a list of domains (one or 100,000) and get one clean row per site, with versions where the site reveals them. The Actor matches **7,600+ technology fingerprints** against each site's HTML, scripts, headers, cookies and public DNS records.

Turn on **monitor mode** to get alerts when a competitor or prospect adds or drops a tool, such as switching from Mailchimp to Klaviyo or adding a new chat widget.

### What you get for each site

| Field | Example |
|---|---|
| `domain`, `finalUrl`, `status` | `example-store.com`, `https://www.example-store.com/`, `ok` |
| `cms`, `ecommerce` | `WordPress`, `Shopify` |
| `analytics`, `tagManagers` | `Google Analytics, Hotjar`, `Google Tag Manager` |
| `marketingAutomation`, `advertising`, `crm` | `Klaviyo`, `Meta Pixel, TikTok Pixel`, `HubSpot` |
| `payments`, `liveChat`, `reviews` | `Stripe, PayPal`, `Intercom`, `Trustpilot` |
| `email` (from MX/SPF records) | `Google Workspace, Sendgrid` |
| `verifiedSaas` (from DNS verification records) | `Atlassian Cloud, DocuSign, Notion, Zoom` |
| `hosting`, `cdn`, `webServer`, `frameworks` | `Vercel`, `Cloudflare`, `Nginx`, `Next.js` |
| `techStack` | every technology in one string, ready for a spreadsheet |
| `technologies` | name, version, categories, confidence, website and `foundIn` (the evidence: html, scripts, headers, cookies, meta, or a DNS record such as dns:mx) |
| `byCategory` | technologies grouped under all 100+ categories |
| `changes` (monitor mode) | `{ "added": ["Klaviyo"], "removed": ["Mailchimp"] }` |

#### Sample output

```json
{
  "domain": "example-store.com",
  "finalUrl": "https://www.example-store.com/",
  "status": "ok",
  "httpStatus": 200,
  "title": "Example Store: Handmade Ceramics",
  "technologyCount": 14,
  "techStack": "Cloudflare, Google Analytics GA4, Google Tag Manager, Google Workspace, Klaviyo, Meta Pixel, PayPal, Shop Pay, Shopify, Stripe, Trustpilot, ...",
  "cms": "",
  "ecommerce": "Shopify",
  "analytics": "Google Analytics",
  "marketingAutomation": "Klaviyo",
  "advertising": "Meta Pixel",
  "payments": "PayPal, Shop Pay, Stripe",
  "email": "Google Workspace",
  "cdn": "Cloudflare",
  "technologies": [
    { "name": "Shopify", "version": null, "confidence": 100, "categories": ["Ecommerce"], "website": "https://shopify.com", "foundIn": ["cookies", "scripts"] },
    { "name": "Google Workspace", "version": null, "confidence": 100, "categories": ["Webmail", "Email"], "website": "https://workspace.google.com/", "foundIn": ["dns:mx"] }
  ],
  "checkedAt": "2026-10-18T09:00:00.000Z"
}
```

### Use cases

- **Lead lists for agencies and SaaS sales.** Check a list of prospect domains and keep only the sites running a given platform: every Shopify store that also uses Klaviyo, every WordPress site, every company sending email through HubSpot. Use **Only return sites using** (with **Require all of them** for combinations).
- **Account research.** DNS records show the email provider and the SaaS tools a company has verified its domain with (Atlassian, Notion, Zoom, DocuSign and more), a signal of what it pays for internally.
- **Competitor research.** See which analytics, ad pixels, A/B testing and personalisation tools competitors pay for. Pair it with our [Google Ads Transparency Scraper](https://apify.com/rimulabs/google-ads-transparency-scraper) to see their ads too.
- **Stack change alerts.** Schedule a weekly monitor run on competitors or key accounts and get only the sites whose stack changed: a new CRM, a replatform, a new payment provider. A change is often a buying signal.
- **Market sizing and research.** Count how many sites in a list use each CMS, ecommerce platform or analytics tool.
- **Due diligence and audits.** Inventory the third-party tools on your own sites or a portfolio, with versions.
- **AI agents.** The structured output (with categories and evidence) is easy for an agent to reason over. Runs are pay-per-site, so agents can call it on demand.

### How to use it

1. Paste domains or URLs into **Websites**, one per line. A bare domain checks its home page; a full URL checks that page.
2. Keep **Check DNS records** on to also get the email provider, email-sending services and SaaS tools from public DNS.
3. Run it. Export the **Overview** view as CSV or Excel, or use the **One row per technology** view for pivot tables.

#### Monitor mode: get only changes

1. Enter a **Monitor name**, such as `competitors`.
2. Turn on **Only return sites whose stack changed**.
3. Schedule the run weekly. The first run records each site's stack (`firstCheck: true`). Later runs return only sites with technologies added or removed, listed in `changes`. A site that can't be read on a given day keeps its last known stack, so an outage never looks like a change.

Use a different monitor name for each list.

### Pricing

You pay per site checked: **$3.00 per 1,000 sites**.

- You pay only for sites the Actor could read. Sites that are unreachable, closed to crawlers by robots.txt, or behind a bot check are returned with an explanation and are **free**.
- Apify also charges a small fee when a run starts. You can cap the cost of any run with **Max total charge**.
- With the technology filter or monitor mode, every site checked is billed, including ones that aren't returned, because each one was checked.

Examples: 500 prospect domains cost **$1.50**. A weekly monitor of 50 competitors costs **$0.60 a month**.

### How it works, and its limits

- Each site is fetched **once, directly and politely**: the home page (or the URL you give), plus robots.txt. If robots.txt closes the whole site to crawlers, the page isn't fetched and only public DNS is reported.
- Sites that refuse automated visits (HTTP 401/403/429, or a bot check such as a "Just a moment..." page) are reported as `blocked`, with what headers and DNS reveal. The Actor never tries to get around bot protection.
- The Actor reads the page as served, without running JavaScript. Most technologies leave traces in the HTML, scripts, headers or cookies, but tools that only appear after scripts run (some tag-manager-loaded pixels) can be missed. Run it on a specific URL, such as a product page, to find tools used only there.
- Confidence: most detections are 100%. Weaker signals count 25-75% each and add up when several agree. The default threshold is 50%.

### FAQ

**Where do the fingerprints come from?** From the open-source [webappanalyzer](https://github.com/enthec/webappanalyzer) project (GPL-3.0), the community-maintained successor to the original Wappalyzer fingerprints, plus our own additions for email and DNS signals. The fingerprint version used is in the run summary.

**Does it collect personal data?** No. It reports technology names only. It doesn't extract emails, phone numbers, names or social profiles, even when a page shows them, and it keeps no copy of the pages.

**How is this different from BuiltWith or Wappalyzer?** It is a pay-per-use Apify Actor with no subscription: you pay per site checked, export to any format, schedule runs, and connect it to Make, Zapier, n8n, Google Sheets or your own code through the Apify API. It checks the live site at the time of the run rather than a database of past crawls.

**How fast is it?** About 1,000 sites in 10 minutes at the default 2 GB memory (measured on 200 well-known sites). Detection is CPU-bound, so a 4 GB run is roughly twice as fast at the same price.

**What do the statuses mean?** `ok` (checked and billed); `blocked` (the site refused automated visits with HTTP 401/403/429 or a bot check, so only headers and DNS are reported); `http-error` (the site answered with another error page); `unreachable` (no DNS record, no response within 30 seconds, or a page over 10 MB); `robots-disallowed` (the site asks all crawlers to stay out). Only `ok` is billed. On big consumer brands behind enterprise firewalls, expect around 1 in 10 to be `blocked`; small and mid-size business sites rarely are.

**Something missing or wrong?** Open an issue on the Issues tab with the domain and the technology. Issues are answered within 24 hours.

***

Built and maintained by [Rimu Labs](https://rimulabs.com). Questions: support@rimulabs.com.

# Actor input Schema

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

Domains or URLs to check, one per line, for example shopify.com or https://example.com/pricing. A bare domain checks its home page. Duplicates are skipped.

## `includeDns` (type: `boolean`):

Also read public DNS records (MX, SPF/TXT, NS) to find the email provider, email-sending services and SaaS tools the company has verified its domain with. Adds no cost.

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

Leave out detections below this confidence. Most detections are 100%; some weaker signals count 25-75% each and add up when several agree.

## `onlyWithTechnologies` (type: `array`):

Optional lead-list filter: return only sites that use at least one of these technologies, written as in the output (for example Shopify, Klaviyo, HubSpot, WordPress). Every site checked is still billed, because it was checked.

## `requireAllTechnologies` (type: `boolean`):

Return only sites that use every technology in the list (for example Shopify and Klaviyo), instead of any one of them.

## `monitorName` (type: `string`):

Give a name (for example competitors) to remember each site's stack. Every later run with the same name adds the technologies added and removed since the last check. Schedule a weekly run to get change alerts.

## `onlyChanges` (type: `boolean`):

With a monitor name: return a site only on its first check or when technologies were added or removed.

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

Each site is fetched once, politely. Higher values finish large lists sooner.

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

Off by default: each site is fetched directly, once. Turn a proxy on only to see the version of sites served to a particular country. Proxies are never used to get past a site's bot protection.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com",
    "wordpress.org",
    "hubspot.com"
  ],
  "includeDns": true,
  "minConfidence": 50,
  "requireAllTechnologies": false,
  "onlyChanges": false,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per site: status, CMS, ecommerce platform, analytics, marketing tools, payments, email provider, hosting, CDN and the full stack.

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

One row per technology found: name, version, categories, confidence and where the evidence came from.

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

Counts of sites checked, blocked, unreachable and changed, plus the fingerprint version used.

# 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": [
        "allbirds.com",
        "wordpress.org",
        "hubspot.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rimulabs/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 = { "domains": [
        "allbirds.com",
        "wordpress.org",
        "hubspot.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("rimulabs/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 '{
  "domains": [
    "allbirds.com",
    "wordpress.org",
    "hubspot.com"
  ]
}' |
apify call rimulabs/tech-stack-detector --silent --output-dataset

```

## MCP server setup

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