# Tech Stack Detector (`teddythebuilder/tech-stack-detector`) Actor

Detect the technology stack of any website in bulk: CMS, ecommerce platform, analytics, tag managers, frameworks, CDN, hosting, marketing tools and email provider. 7,600+ Wappalyzer-compatible fingerprints, no browser, no login. Export JSON/CSV/Excel or call via API.

- **URL**: https://apify.com/teddythebuilder/tech-stack-detector.md
- **Developed by:** [Teddy Wasserman](https://apify.com/teddythebuilder) (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 $2.20 / 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 does Tech Stack Detector do?

**Tech Stack Detector** is a fast, low-cost **Wappalyzer and BuiltWith alternative** you can run in bulk. Give it a list of domains and it tells you which technologies each website uses: CMS, ecommerce platform, analytics and tag managers, JavaScript frameworks, CDN, hosting, web server, marketing automation, CRM, live chat, payment providers, cookie banners, and the company's **email provider** (Google Workspace, Microsoft 365 and others).

It works like a technology lookup API. It fetches each homepage once, the way a normal browser visit would, and matches the response against **7,600+ open Wappalyzer-compatible fingerprints**. It also reads the domain's public DNS records to find SaaS tools the company has verified (HubSpot, Salesforce, Zendesk, Atlassian, DocuSign, Stripe and many more). There's no browser, no login and no API key, so it's quick and cheap: 1,000 domains cost about $4.

Typical uses:

- **Sales prospecting:** "find all Shopify stores in my lead list that use Klaviyo"
- **Competitive intelligence:** "which analytics and A/B testing tools do my competitors use?"
- **Lead enrichment:** add CMS, ecommerce platform and email provider columns to your CRM
- **Agency audits:** check a client's site for outdated frameworks, missing cookie consent or a slow CDN setup

### Why use Tech Stack Detector?

- **About 25× cheaper than the market leader.** $4 per 1,000 domains instead of $100 per 1,000, with volume discounts on higher Apify plans.
- **Bulk by design.** Paste 10 or 100,000 domains. Concurrency and timeouts are configurable, and every domain becomes one clean row.
- **Website and company signals in one row.** `websiteTechnologies` holds what the homepage actually loads. `dnsVerifiedServices` holds SaaS tools the company has verified ownership for in DNS, which are strong buying signals for B2B sales.
- **Flat columns ready for your CRM.** `cms`, `ecommerce`, `analytics`, `tagManagers`, `javascriptFrameworks`, `cdn`, `hosting`, `crm`, `marketingAutomation`, `liveChat`, `paymentProcessors`, `emailProvider`. They map straight onto spreadsheet or CRM fields.
- **Versions and confidence.** Each technology includes the detected version (e.g. WordPress 6.6, jQuery 3.7.1), a confidence score and the vendor website.
- **Failed lookups are free.** Domains that don't resolve or time out are included with an `error` field and are **not charged**.
- **No browser, no proxies.** Each domain needs one HTTP request plus four tiny DNS-over-HTTPS queries, so runs finish in seconds.
- **Schedulable and API-ready.** Run it on a schedule, call it from Make, Zapier or n8n, or let an AI agent call it through the Apify API or MCP server.

### What data can you extract?

| Field | Example | Description |
|---|---|---|
| `domain` | `allbirds.com` | Normalised domain (without `www.`) |
| `finalUrl` | `https://www.allbirds.com/` | URL after redirects |
| `statusCode` | `200` | HTTP status of the homepage |
| `pageTitle` | `Allbirds: Sustainable Shoes...` | `<title>` of the page |
| `technologyCount` | `15` | Number of technologies detected |
| `technologyNames` | `Shopify, Cloudflare, PayPal, ...` | All names as one comma-separated string (handy for CSV) |
| `websiteTechnologies` | `["Shopify", "Cloudflare", ...]` | Technologies detected from the website itself |
| `dnsVerifiedServices` | `["Microsoft 365", "DocuSign", ...]` | SaaS tools detected from DNS (MX/TXT/NS/SOA) |
| `cms` | `["WordPress"]` | Content management systems and blogs |
| `ecommerce` | `["Shopify"]` | Ecommerce platforms and frontends |
| `analytics` | `["Mixpanel"]` | Analytics tools |
| `tagManagers` | `["Google Tag Manager"]` | Tag managers |
| `javascriptFrameworks` | `["React", "Next.js"]` | JS and UI frameworks |
| `webFrameworks` / `webServers` / `programmingLanguages` | `["Nginx"]`, `["PHP"]` | Server side |
| `cdn` / `hosting` | `["Cloudflare"]`, `["Vercel"]` | CDN, PaaS, IaaS, hosting |
| `marketingAutomation` / `crm` / `advertising` | `["HubSpot"]` | Marketing stack |
| `liveChat` / `paymentProcessors` / `cookieCompliance` / `security` | `["Zendesk"]`, `["Stripe"]`, `["OneTrust"]` | Other common columns |
| `emailProvider` | `Google Workspace` | Derived from MX records |
| `mxRecords` | `["aspmx.l.google.com", ...]` | Raw MX hosts |
| `technologies` | see below | Full detail: name, categories, version, confidence, website, detectedVia |
| `error` | `null` | Error message if the site could not be analysed |
| `checkedAt` | `2026-10-04T12:00:00+00:00` | Timestamp |

### How to use Tech Stack Detector (step by step)

1. Click **Try for free** (you need a free Apify account; new accounts get monthly free credits).
2. Paste your domains into **Domains or URLs**, one per line. Bare domains (`example.com`) and full URLs (`https://shop.example.com/de`) both work.
3. Optional: under **Only these categories**, enter e.g. `Ecommerce` or `CRM` to keep only those technologies.
4. Leave **Include DNS checks** on if you want the email provider and DNS-verified SaaS tools.
5. Click **Start**. A run with a few hundred domains usually finishes in under a minute.
6. Download the results as **JSON, CSV, Excel or HTML**, or open the "Marketing & sales tools" view in the dataset tab.

### Input example

```json
{
  "domains": ["allbirds.com", "gymshark.com", "wordpress.org", "vercel.com"],
  "includeDns": true,
  "onlyCategories": [],
  "minConfidence": 0,
  "maxResults": 1000,
  "concurrency": 10,
  "timeoutSecs": 15
}
```

If you start the actor with an empty input, it analyses five example sites (apify.com, shopify.com, wordpress.org, spotify.com, klarna.com) so you can see the output format straight away.

### Output example

```json
[
  {
    "input": "allbirds.com",
    "domain": "allbirds.com",
    "finalUrl": "https://www.allbirds.com/",
    "statusCode": 200,
    "pageTitle": "Allbirds: Sustainable Shoes & Clothing",
    "technologyCount": 15,
    "technologyNames": "Shopify, HSTS, HTTP/3, Open Graph, Cloudflare, Apple Pay, PayPal, Google Tag Manager, Swiper, Priority Hints, Microsoft 365, DocuSign, Miro",
    "websiteTechnologies": ["Shopify", "HSTS", "HTTP/3", "Open Graph", "Cloudflare", "Apple Pay", "PayPal", "Google Tag Manager", "Swiper", "Priority Hints"],
    "dnsVerifiedServices": ["Microsoft 365", "DocuSign", "Miro"],
    "cms": [],
    "ecommerce": ["Shopify"],
    "analytics": [],
    "tagManagers": ["Google Tag Manager"],
    "javascriptFrameworks": [],
    "cdn": ["Cloudflare"],
    "paymentProcessors": ["Apple Pay", "PayPal"],
    "emailProvider": "Microsoft 365",
    "mxRecords": ["allbirds-com.mail.protection.outlook.com"],
    "technologies": [
      {"name": "Shopify", "categories": ["Ecommerce"], "version": null, "confidence": 100, "website": "https://shopify.com", "detectedVia": "website"},
      {"name": "Cloudflare", "categories": ["CDN"], "version": null, "confidence": 100, "website": "https://www.cloudflare.com", "detectedVia": "website"}
    ],
    "error": null,
    "checkedAt": "2026-10-04T12:00:00+00:00"
  },
  {
    "input": "wordpress.org",
    "domain": "wordpress.org",
    "statusCode": 200,
    "technologyNames": "WordPress, Gutenberg, Nginx, PHP, MySQL, Google Tag Manager, ...",
    "cms": ["WordPress"],
    "webServers": ["Nginx"],
    "programmingLanguages": ["PHP"],
    "emailProvider": "Other / self-hosted",
    "error": null
  }
]
```

Every export format is available from the dataset: JSON, CSV, Excel (XLSX), XML, RSS and HTML table. Array columns become comma-separated cells in CSV and Excel.

### How much does it cost?

The actor uses **pay-per-event** pricing. You only pay for domains that were analysed successfully.

| Event | Price | When it's charged |
|---|---|---|
| Actor start | $0.0005 | Once per run |
| Domain analysed | $0.004 | Per domain with a result. Unreachable domains are free |

Apify subscribers get automatic volume discounts on the per-domain price: **Bronze −15%, Silver −30%, Gold and above −45%**.

Worked examples (Free/Starter prices):

- **100 domains** ≈ $0.40
- **1,000 domains** ≈ $4.00, against about $100 with the leading Wappalyzer-replacement actor
- **Daily check of 200 competitor domains** ≈ $0.80 a day, about $24 a month
- **Enriching a 10,000-row lead list once** ≈ $40

Platform compute is included in the price. You pay nothing extra for memory or proxies. Apify's free plan includes monthly credits, enough to analyse roughly a thousand domains a month at no cost.

### Use cases

#### Sales and lead generation

Filter lead lists by technology: "Shopify stores using Klaviyo", "WordPress sites without a cookie banner", "companies on Microsoft 365 that use HubSpot". Use `dnsVerifiedServices` as buying signals. A company with Salesforce and Zendesk verified in DNS is a mid-market B2B buyer.

#### Competitive intelligence

Track which analytics, A/B testing, personalisation and ad tools your competitors use, and schedule a weekly run to spot when they switch platforms.

#### Agencies and SEO audits

Audit client and prospect websites in bulk: CMS and version, page builders, CDN, caching, security headers (HSTS) and cookie compliance tools. Outdated versions are easy to spot in the `version` field.

#### Market research and investing

Measure technology adoption across a market segment, for example ecommerce platform share among the top 5,000 Nordic web shops.

#### Data enrichment for CRM and AI agents

Add `cms`, `ecommerce` and `emailProvider` to every account in your CRM, or let an AI agent call the actor when it needs to know "what is this company's website built with?"

### Use with AI agents, MCP and the API

The actor is easy for agents to call. The input is small, the defaults are sensible, and the output is one compact JSON row per domain.

**cURL** (synchronous, returns the dataset items):

```bash
curl -X POST "https://api.apify.com/v2/acts/teddythebuilder~tech-stack-detector/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["allbirds.com", "vercel.com"]}'
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("teddythebuilder/tech-stack-detector").call(run_input={"domains": ["allbirds.com", "vercel.com"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["domain"], row["ecommerce"], row["emailProvider"])
```

**MCP:** add the Apify MCP server (`https://mcp.apify.com`) to Claude, Cursor or any MCP client, then ask it to "use teddythebuilder/tech-stack-detector to check which CMS these 20 domains use".

### Integrations

- **Google Sheets:** export the dataset or use the Apify Google Sheets integration to append rows automatically.
- **Make, Zapier and n8n:** start runs and fetch results with the official Apify apps or nodes.
- **Webhooks:** get notified when a run finishes and push the results to your CRM (HubSpot, Pipedrive, Salesforce).
- **Schedules:** use Apify Schedules to re-check domains daily, weekly or monthly.

### Data source and legality

- **Fingerprints:** the open-source, community-maintained [webappanalyzer](https://github.com/enthec/webappanalyzer) dataset (Wappalyzer-compatible format, **GPL-3.0**), pinned to a specific version in each build. Technology names and logos belong to their respective owners.
- **Website data:** the actor makes one ordinary GET request to the homepage or URL you supply, with an honest User-Agent, and reads only what any browser receives: HTTP headers, cookie names, meta tags, script URLs and HTML.
- **DNS data:** public DNS records via Cloudflare DNS-over-HTTPS.
- **No personal data:** the output describes technologies, not people. Cookie values are never output.
- Only analyse websites you have a legitimate interest in, and respect each site's terms.

### Limitations

- Detection runs without a JavaScript-executing browser. Technologies visible only after JavaScript runs (some analytics tags injected by a tag manager, or client-side-only widgets) can be missed. Server-rendered and HTML-referenced technologies, which cover the large majority of fingerprints, are detected reliably.
- Sites behind aggressive bot protection may return a challenge page (status 403/503). The actor still reports what it can, such as CDN, bot protection and DNS services, and notes the status in `error`.
- Only the URL you provide is fetched (usually the homepage). Technologies used only on deeper pages, such as checkout, may not appear.

### FAQ

**How accurate is it?**
It uses the same fingerprint format as Wappalyzer, with 7,600+ technologies. CMS, ecommerce platforms, CDNs, web servers, frameworks and email providers are detected very reliably. Purely JavaScript-injected tools are the main blind spot (see Limitations).

**What's the difference between `websiteTechnologies` and `dnsVerifiedServices`?**
`websiteTechnologies` are found in the website's own response. `dnsVerifiedServices` come from the domain's DNS records (MX, TXT verification tokens, NS, SOA). They show tools the *company* uses, even if they don't appear on the website.

**Do I pay for domains that fail?**
No. Domains that don't resolve, refuse the connection or time out are included with an `error` field and are not charged.

**Can I check specific pages instead of homepages?**
Yes. Enter a full URL such as `https://example.com/shop` and that exact page is analysed.

**How many domains can I check per run?**
Up to 100,000 per run. For very large lists, raise `concurrency` to 20–30 and split the list into several runs.

**Can I use it on the free plan?**
Yes. Apify's monthly free credits cover roughly a thousand domains a month.

**I need a technology or field that's missing.**
Open an issue on the actor's Issues tab. We usually reply within 24 hours. If the actor saves you time, a short review helps other users find it.

### Related actors

- [Shopify & WooCommerce Products Scraper](https://apify.com/teddythebuilder/shopify-products-scraper): full product catalogues (prices, variants, SKUs, stock) from the Shopify and WooCommerce stores you find here, with a price and stock change monitor.
- [Domain WHOIS & DNS API](https://apify.com/teddythebuilder/domain-whois-dns-api): bulk WHOIS/RDAP registrar and expiry dates, domain availability, DNS records, SPF/DMARC email security grade and SSL certificate expiry in one row per domain.
- [Website SEO Audit Crawler](https://apify.com/teddythebuilder/website-seo-audit): crawl a site and audit every page for broken links, redirects, titles, meta descriptions, canonicals, noindex, schema and sitemap coverage. Pair it with Tech Stack Detector for a full website report.
- [Nordic Company Registry API](https://apify.com/teddythebuilder/nordic-company-registry): companies from Sweden, Norway and Finland with industry codes. Combine it with Tech Stack Detector to build tech-filtered Nordic lead lists.
- [Swedish Jobs Scraper](https://apify.com/teddythebuilder/swedish-jobs-monitor): job ads and hiring companies from Platsbanken.
- [Nordic Tenders Scraper](https://apify.com/teddythebuilder/nordic-public-tenders-monitor): public procurement notices from Nordic buyers.
- [Career Site Jobs API](https://apify.com/teddythebuilder/career-site-jobs-api): jobs straight from company career sites on Greenhouse, Lever, Ashby, Workable, Recruitee and Teamtailor in one schema, with new/removed-job tracking.

### Changelog and support

- **1.0 (2026-10):** first release. 7,600+ fingerprints, DNS-based email provider and SaaS detection, flat category columns, free failed lookups.

Questions or bugs? Open an issue. We reply within 24 hours.

# Actor input Schema

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

Websites to analyse, one per line, e.g. "shopify.com" or "https://www.example.com/shop". The homepage (or the exact URL you give) is fetched once.

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

Looks up MX, TXT, NS and SOA records via DNS-over-HTTPS to detect the email provider (Google Workspace, Microsoft 365...) and DNS-verified tools such as HubSpot or Salesforce.

## `onlyCategories` (type: `array`):

Optional. Keep only technologies in these categories, e.g. "Ecommerce", "CMS", "Analytics", "CRM", "Marketing automation". Leave empty for all.

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

Drop technologies detected with lower confidence. Most detections are 100.

## `maxResults` (type: `integer`):

Maximum number of domains to analyse in this run (each successfully analysed domain is one billable result).

## `concurrency` (type: `integer`):

How many websites are fetched in parallel.

## `timeoutSecs` (type: `integer`):

Per-website HTTP timeout.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "shopify.com",
    "wordpress.org",
    "spotify.com",
    "klarna.com"
  ],
  "includeDns": true,
  "minConfidence": 0,
  "maxResults": 1000,
  "concurrency": 10,
  "timeoutSecs": 15
}
```

# Actor output Schema

## `results` (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 = {
    "domains": [
        "apify.com",
        "shopify.com",
        "wordpress.org",
        "spotify.com",
        "klarna.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("teddythebuilder/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": [
        "apify.com",
        "shopify.com",
        "wordpress.org",
        "spotify.com",
        "klarna.com",
    ] }

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

```

## MCP server setup

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