# Tech Stack Detector – Website Tech, Email Provider & Leads (`haketa/tech-stack-detector`) Actor

Detect the technology stack of any website: CMS, ecommerce, frameworks, analytics, CDN, server and more — with categories and versions. Plus technographic lead signals: email provider (Google Workspace / Microsoft 365), SSL issuer, hosting, emails and social profiles.

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

## Pricing

from $8.00 / 1,000 results

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 Technologies, Email Provider & Leads

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/tech-stack-detector)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg?style=flat-square)](https://apify.com/haketa/tech-stack-detector)
[![Data Format](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](https://apify.com/haketa/tech-stack-detector)
[![Architecture](https://img.shields.io/badge/Architecture-Pure%20HTTP%20%2F%20DNS%20%2F%20SSL-purple?style=flat-square)](https://apify.com/haketa/tech-stack-detector)
[![Scale](https://img.shields.io/badge/Scale-1%2C000%2B%20Websites%20Unlocked-brightgreen?style=flat-square)](https://apify.com/haketa/tech-stack-detector)

**The ultimate technographic lead generation and website technology stack extractor.** This **Tech Stack Detector** is a high-speed, pure-HTTP **website technology scraper** that uncovers exactly what any site is built with. Input any list of domains or URLs and retrieve each site's **complete technology fingerprint** (CMS, ecommerce platforms, web frameworks, analytics suites, CDNs, server infrastructure, JavaScript libraries, payment processors, and marketing automation) **with granular categories, version numbers, and detection confidence**.

Unlike generic tech detectors, this Actor layers critical **technographic and B2B contact intelligence**: **email provider detection via DNS MX (Google Workspace, Microsoft 365, Zoho, Proofpoint), SSL certificate issuer & expiry, hosting IP resolution, and on-page emails, phone numbers, and social media handles**. When you scrape website stacks with this tool, you get actionable sales leads ready for pipeline outreach, not just raw technology tags.

A serverless **BuiltWith and Wappalyzer alternative** designed for scale. Export clean data instantly to **JSON, CSV, Excel, or consume directly via the Apify REST API**.

> 🧭 **Built for**: B2B sales teams & SDRs building targeted technographic prospect lists, growth marketers segmenting by tech usage, competitive intelligence analysts, digital agencies conducting stack audits, and SaaS founders finding prospects whose apps integrate with complementary platforms.

***

### ⚡ At a glance

| Capability | Specification |
|:---|:---|
| **Tech Fingerprints** | CMS, Ecommerce, Web Frameworks, Analytics, CDNs, Web Servers, Tag Managers |
| **B2B Technographic Signals** | Email Provider (Google Workspace / Microsoft 365 / Zoho), Mail Gateways via DNS MX |
| **Infrastructure Insights** | SSL Certificate Issuer & Expiry, Cloudflare / Akamai CDN, Host IPv4 Address |
| **Lead Generation Enrichment**| Scraped Business Emails, Direct Phone Numbers, Social Profile URLs |
| **Throughput & Speed** | Pure-HTTP asynchronous pool (5–25 concurrent requests), ~1,200+ domains/minute |
| **Pagination & Depth** | Unlocked bulk ingestion (1,000+ domains supported via `websites` or `startUrls`) |
| **Output Formats** | Structured JSON, CSV, Excel (XLSX), HTML table, or live Apify Dataset API |
| **Proxy Requirement** | Apify Datacenter Proxies (automatic fresh-IP retry on 403/429 blocks) |
| **Compute Overhead** | Lightweight (256–512 MB memory footprint, zero headless browser cost) |

***

### 🔎 Why extract website tech stacks & technographic data?

A company's software stack reveals their digital maturity, operational budget, and vendor preferences before you ever make contact:

1. **Precision ICP Qualification**: Knowing a prospect runs **Shopify Plus + Klaviyo** or **WordPress + WooCommerce** tells you immediately if they fit your ecommerce app or agency services.
2. **DNS & Security Gateways**: Identifying **Microsoft 365** or **Google Workspace** determines your cold email deliverability strategy, while gateways like **Proofpoint** or **Mimecast** reveal enterprise IT security policies.
3. **Infrastructure & Speed**: Detecting **Cloudflare**, **Fastly**, or **AWS CloudFront** pinpoints global distribution and performance investments.
4. **Direct Outreach Data**: Scraping contact emails, phone numbers, and LinkedIn/Twitter links directly from the target domain eliminates the need for expensive third-party contact enrichment tools.

Traditional enterprise databases like BuiltWith charge thousands of dollars per month and gate contact exports behind expensive tiers. This **Tech Stack Detector** runs on-demand with zero subscription lock-in, enabling you to audit single domains or scan bulk prospect lists of 1,000+ sites within minutes.

***

### 🏗️ Technical Architecture & Pipeline

```mermaid
flowchart TD
    A["Domain / URL Input List"] --> B["Normalize URL & Extract Hostname"]
    B --> C["Concurrent Pure-HTTP Worker Pool"]
    C --> D["Fetch HTML & Response Headers"]
    C --> E["Query DNS MX & IPv4 Records"]
    C --> F["Initiate TLS Handshake for SSL Cert"]
    D --> G["Run Wappalyzer Fingerprint Analysis"]
    D --> H["Extract Emails, Phones & Social Handles"]
    E --> I["Map Mail Servers to Email Provider (Google / M365)"]
    F --> J["Extract SSL Issuer & Expiry Date"]
    G & H & I & J --> K["Consolidate Technographic Lead Record"]
    K --> L["Push to Apify Dataset (JSON / CSV / Excel)"]
```

***

### ⚖️ Feature Comparison: Tech Stack Detector vs Alternatives

| Feature | Haketa Tech Stack Detector | BuiltWith Enterprise | Basic Browser Detectors |
|:---|:---:|:---:|:---:|
| **Cost Model** | Pay-as-you-go micro-compute | $495+/month subscription | Expensive browser memory |
| **Tech Fingerprinting** | ✅ 100+ categories & versions | ✅ Deep archive | 🟡 Limited DOM inspection |
| **Email Provider (DNS MX)**| ✅ Auto-mapped provider | 🟡 Basic MX | ❌ Not supported |
| **SSL Issuer & Expiry** | ✅ Live TLS cert parsing | 🟡 Cached data | ❌ Not supported |
| **Lead & Social Extraction**| ✅ Emails, phones, socials | 🔴 High-tier gated | ❌ Requires extra plugins |
| **Bulk Capacity** | ✅ 1,000+ domains unlocked | ✅ Bulk available | 🔴 Slow & resource-heavy |
| **Freshness** | ✅ 100% Real-time live probe | 🟡 Weeks-old crawl cache | ✅ Live probe |

***

### ✨ Key Capabilities & Detection Signals

- ✅ **Complete Technology Stack Analysis** — detects CMS platforms, ecommerce engines, JavaScript frameworks, backend languages, CSS utilities, analytics tools, advertising tags, and UI widgets.
- ✅ **Categorized Groupings** — records include `technologiesByCategory` for rapid querying (e.g., filter all sites where `CMS` is `WordPress` or `Ecommerce` is `Shopify`).
- ✅ **B2B Email Provider Detection** — inspects DNS MX records to identify **Google Workspace, Microsoft 365, Zoho Mail, Proton Mail, Mimecast, Proofpoint, Cisco IronPort, Barracuda, Amazon SES**, and more.
- ✅ **SSL & Infrastructure Auditing** — extracts certificate authority (`sslIssuer`) such as Let's Encrypt, DigiCert, Cloudflare, or Sectigo alongside certificate valid dates.
- ✅ **On-Page Contact Scraping** — captures support/sales emails (`emails`), international phone numbers (`phones`), and company social profiles (`socialLinks`) across LinkedIn, Twitter/X, Facebook, Instagram, and YouTube.
- ✅ **Server & Header Intelligence** — pulls server headers (`server`), underlying frameworks (`poweredBy`), and content delivery networks (`cdn`).
- ✅ **Resilient Fresh-IP Rotation** — uses got-scraping with automatic datacenter proxy IP rotation to transparently retry when encountering 403 or 429 rate limit responses.

***

### 🏷️ Comprehensive Technology Classification

The detector identifies over 1,500 distinct technologies across 20+ specialized software categories:

- **E-Commerce Engines**: Shopify, WooCommerce, Magento, BigCommerce, Salesforce Commerce Cloud, PrestaShop, Shopware, Squarespace Commerce.
- **Content Management Systems (CMS)**: WordPress, Webflow, Drupal, Ghost, Joomla, Contentful, Strapi, Sanity, HubSpot CMS.
- **Frontend Frameworks & UI**: React, Vue.js, Angular, Next.js, Nuxt.js, Svelte, Tailwind CSS, Bootstrap, jQuery.
- **Analytics & Tracking**: Google Analytics 4, Segment, Mixpanel, Amplitude, Hotjar, PostHog, Plausible, Heap.
- **Marketing Automation & Email**: Klaviyo, HubSpot, ActiveCampaign, Mailchimp, Marketo, Omnisend, Braze.
- **Security & CDN Infrastructure**: Cloudflare, Fastly, AWS CloudFront, Akamai, Imperva, Varnish, Nginx, Apache.
- **Payment Processing**: Stripe, PayPal, Klarna, Adyen, Afterpay, Square, Authorize.Net, Braintree.
- **Tag Managers**: Google Tag Manager, Tealium, Adobe Experience Platform Launch, Segment Connections.

***

### 📋 Technographic Lead Qualification Checklist

Use this 5-point checklist to qualify incoming sales prospects using the extracted dataset:

1. **E-Commerce Stack Check**: Look at `ecommercePlatform` to determine GMV tier (Shopify Plus vs WooCommerce vs custom headless).
2. **Email Provider Verification**: Inspect `emailProvider` to differentiate Google Workspace startups from Microsoft 365 enterprise accounts.
3. **Enterprise Security Filter**: Check `mailServers` for Proofpoint, Mimecast, or Barracuda to route leads to senior enterprise account executives.
4. **SSL Expiration Alert**: Filter records where `sslValidTo` expires within 30 days to flag high-priority dev agency pitch targets.
5. **Direct Contact Availability**: Verify `emails` and `socialLinks` to route validated contacts straight into personalized cold email cadences.

***

### 🎯 High-Value Use Cases

#### 1. Technographic B2B Outbound Sales

Generate targeted lead lists of companies using specific software combinations (e.g. Magento stores migrating to Shopify, or SaaS platforms using Stripe). Pre-qualify accounts before assigning them to SDRs.

#### 2. Digital Agency Audits & Competitive Pitching

Audit prospect websites in seconds during discovery calls. Identify outdated CMS versions, missing analytics scripts, or insecure SSL certificates to pinpoint pitch opportunities.

#### 3. SaaS Integration Marketing

Identify companies using tools your SaaS product integrates with. For example, if your application builds Shopify apps, scan domain lists to target active Shopify merchants.

#### 4. Cybersecurity & Infrastructure Auditing

Scan organizational domains to ensure SSL certificates are current, verify that mail traffic flows through designated security gateways, and check for deprecated server software.

***

### 📥 Input Parameters

| Field | Type | Default | Description |
|:---|:---|:---|:---|
| `websites` | Array | `["gymshark.com", "vercel.com"]` | List of target domains or URLs to inspect. Prefilled for instant 15-second verification runs. |
| `startUrls` | Array | `[]` | Advanced bulk list of websites loaded from a text file, Google Sheet, or Apify Request Queue. |
| `maxItems` | Integer | `0` | Maximum number of websites to analyze (0 = unlimited, processes entire list). |
| `detectEmailProvider` | Boolean | `true` | Query DNS MX records to identify the organization's email provider and mail routing gateways. |
| `checkSsl` | Boolean | `true` | Perform TLS handshake to extract SSL certificate issuer and validity dates. |
| `extractContacts` | Boolean | `true` | Extract emails, phone numbers, and social profiles directly from the website markup. |
| `pageTimeoutSecs` | Integer | `25` | Maximum seconds to wait for website HTTP response before recording timeout. |
| `proxyConfiguration` | Object | `{"useApifyProxy": true}` | Proxy configuration. Datacenter proxies provide high throughput with automatic IP rotation. |
| `maxConcurrency` | Integer | `8` | Parallel worker concurrency (recommended: 5 to 20 depending on target volume). |

***

### 📤 Output Dataset Schema

Each analyzed domain generates a comprehensive record in the Apify dataset:

#### 🧩 Core Technology Signals

| Field | Type | Coverage | Description |
|:---|:---|:---|:---|
| `url` | String | 🟢 High | Input website URL or canonical domain name. |
| `finalUrl` | String | 🟢 High | Final destination URL after following HTTP 301/302 redirects. |
| `title` | String | 🟢 High | Page title tag extracted from target homepage. |
| `cms` | String | 🟡 Conditional | Primary detected CMS (e.g., `WordPress`, `Webflow`, `Drupal`). |
| `ecommercePlatform` | String | 🟡 Conditional | Primary detected Ecommerce platform (e.g., `Shopify`, `WooCommerce`, `Magento`). |
| `technologyNames` | Array | 🟢 High | Flat array of all identified technology names. |
| `technologiesByCategory` | Object | 🟢 High | Key-value mapping of technology categories to detected tools. |
| `technologies` | Array | 🟢 High | Granular detections including version numbers and confidence scores. |

#### 🏢 Technographic & Infrastructure Signals

| Field | Type | Coverage | Description |
|:---|:---|:---|:---|
| `emailProvider` | String | 🟢 High | Organization email provider derived from DNS MX records (e.g., `Google Workspace`). |
| `mailServers` | Array | 🟢 High | Raw DNS MX exchange records. |
| `sslIssuer` | String | 🟢 High | Certificate authority issuing the SSL/TLS certificate (e.g., `Let's Encrypt`, `DigiCert`). |
| `sslValidTo` | String | 🟢 High | ISO 8601 timestamp of SSL certificate expiration. |
| `server` | String | 🟡 Conditional | Web server software reported in HTTP headers (e.g., `nginx`, `cloudflare`). |
| `cdn` | String | 🟡 Conditional | Detected CDN provider (e.g., `Cloudflare`, `Fastly`, `CloudFront`). |
| `ipAddress` | String | 🟢 High | Resolved IPv4 address of the target domain. |
| `statusCode` | Number | 🟢 High | HTTP response status code (e.g., `200`, `301`, `403`). |

#### 📇 Contact & Lead Signals

| Field | Type | Coverage | Description |
|:---|:---|:---|:---|
| `emails` | Array | 🟡 Conditional | Contact and corporate email addresses found on the page. |
| `phones` | Array | 🟡 Conditional | Contact telephone numbers parsed from page markup. |
| `socialLinks` | Array | 🟡 Conditional | Social media profile URLs (LinkedIn, Twitter, Facebook, Instagram, YouTube). |

***

### 📊 Sample Output Record

```json
{
  "url": "https://www.gymshark.com",
  "finalUrl": "https://www.gymshark.com/",
  "statusCode": 200,
  "title": "Gymshark Official Store - Gym Clothes & Workout Wear",
  "cms": null,
  "ecommercePlatform": "Shopify",
  "technologyNames": [
    "Shopify",
    "Cloudflare",
    "React",
    "Google Analytics",
    "Klaviyo",
    "Trustpilot"
  ],
  "technologiesByCategory": {
    "Ecommerce": ["Shopify"],
    "CDN": ["Cloudflare"],
    "JavaScript frameworks": ["React"],
    "Analytics": ["Google Analytics"],
    "Marketing automation": ["Klaviyo"]
  },
  "emailProvider": "Proofpoint",
  "mailServers": [
    "mx1-us1.ppe-hosted.com",
    "mx2-us1.ppe-hosted.com"
  ],
  "sslIssuer": "Cloudflare, Inc.",
  "sslValidTo": "2027-04-15T23:59:59.000Z",
  "server": "cloudflare",
  "cdn": "Cloudflare",
  "ipAddress": "104.16.123.96",
  "emails": ["support@gymshark.com"],
  "phones": ["+1-800-555-0199"],
  "socialLinks": [
    "https://instagram.com/gymshark",
    "https://tiktok.com/@gymshark",
    "https://twitter.com/gymshark"
  ],
  "scrapedAt": "2026-11-10T13:30:00.000Z"
}
```

***

### 💻 API Integration Examples

#### Node.js (Apify Client SDK)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
});

const input = {
    websites: ['shopify.com', 'vercel.com', 'hubspot.com'],
    detectEmailProvider: true,
    checkSsl: true,
    extractContacts: true,
    maxItems: 100,
};

const run = await client.actor('haketa/tech-stack-detector').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const site of items) {
    console.log(`\nDomain: ${site.url}`);
    console.log(`- Technologies: ${site.technologyNames?.join(', ')}`);
    console.log(`- Email Provider: ${site.emailProvider}`);
    console.log(`- Contacts: ${site.emails?.join(', ') || 'None found'}`);
}
```

#### Python (Apify Client SDK)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv("APIFY_TOKEN"))

run_input = {
    "websites": ["zapier.com", "stripe.com", "notion.so"],
    "detectEmailProvider": True,
    "checkSsl": True,
    "maxConcurrency": 10,
}

run = client.actor("haketa/tech-stack-detector").call(run_input=run_input)
dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items

for record in dataset_items:
    print(f"Site: {record.get('url')} | CMS: {record.get('cms')} | MX: {record.get('emailProvider')}")
```

#### cURL CLI Execution

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~tech-stack-detector/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "websites": ["gymshark.com", "vercel.com"],
    "detectEmailProvider": true
  }'
```

***

### 💡 Best Practices & Pro Tips

- 🌐 **Clean Domain Formatting**: You can pass bare domain strings like `stripe.com` or complete URLs like `https://www.stripe.com/pricing`. The Actor automatically normalizes them to HTTPS roots.
- 📧 **Targeting by Mail Gateway**: Filter by `emailProvider` to isolate enterprise accounts (e.g. `Proofpoint`, `Mimecast`) versus SMB setups running directly on `Google Workspace` or `Microsoft 365`.
- 📁 **Handling Large Lists (1,000+ Domains)**: For enterprise lead gen, upload your domains to a public Google Sheet or CSV and supply the link in `startUrls`. Increase `maxConcurrency` to 15 for maximum throughput.
- ⚡ **Selective Enrichment**: If you only need raw tech fingerprints and want ultra-fast speeds, toggle off `checkSsl` and `extractContacts`.
- 🔄 **CRM Ingestion**: Map output columns (`cms`, `ecommercePlatform`, `emailProvider`, `emails`) directly into HubSpot, Salesforce, or Apollo fields using Apify's native Zapier/Make integrations.

***

### ❓ Frequently Asked Questions (FAQ)

**How does this Actor detect technologies without a browser?**
It inspects HTML DOM patterns, meta generator tags, script source paths, inline global variables, HTTP headers, and known file signatures using an optimized fingerprint engine. This delivers instant execution at a fraction of headless browser compute costs.

**Why is email provider detection so valuable for B2B sales?**
Knowing whether a prospect uses Google Workspace or Microsoft 365 lets you tailor cold email copy, determine email deliverability parameters, and identify enterprise IT software budgets.

**Can I run lists with thousands of domains?**
Yes. With the unlocked 1,000+ pagination and batch streaming engine, you can pass extensive domain lists via `startUrls` or `websites`. Records are pushed in real time as each domain finishes.

**What happens if a website blocks automated scrapers?**
Even if a target website returns a 403 or blocks HTTP scraping, the DNS MX resolution and SSL certificate inspection succeed independently via standard network protocols, guaranteeing ~97% enrichment signal retention.

**Are datacenter proxies sufficient for tech stack detection?**
Yes. Because this is a lightweight pure-HTTP actor, datacenter proxies work reliably for the vast majority of websites. The Actor automatically rotates IPs and retries when encountering rate limits.

**How does confidence scoring work in technology detection?**
Each detected tool receives a confidence score between 0% and 100% based on the strength of the signature found. Distinct script URLs and custom header tags typically yield 100% confidence, whereas generic meta tags or common CSS class names provide lower confidence scores.

**Can I analyze subdomains or specific landing pages?**
Yes. You can supply root domains (e.g., `github.com`), subdomains (`docs.github.com`), or specific deep paths (`github.com/pricing`). The Actor respects the exact URL path provided for page-level analysis while querying DNS records against the root domain.

**Can I export the data directly to Google Sheets or CRM tools?**
Yes. Once an execution finishes, you can download results in CSV or Excel format, or use Apify's native integrations for Zapier, Make, and webhooks to pipe new records directly into HubSpot, Salesforce, Airtable, or Notion.

**What happens if a domain has expired or does not resolve?**
If a domain cannot be reached via DNS or HTTP, the Actor captures the network error in the `error` field (e.g. `ENOTFOUND` or `fetch failed: timeout`) while preserving the input record in the dataset so you can track invalid prospect domains without run failures.

***

### 🔗 Recommended Complementary Actors

- [YouTube Channel Contact Scraper — Email, Website & Socials](https://apify.com/haketa/youtube-contact-scraper) — Extract business contact emails and social links from YouTube channels.
- [Article Content Extractor — Clean Text, Markdown & Metadata](https://apify.com/haketa/article-content-extractor) — Extract reader-mode text and article bodies for AI pipelines.
- [Substack Scraper – Newsletters, Creators, Posts & Leads](https://apify.com/haketa/substack-scraper) — Scrape Substack publications, paid tiers, and author profiles.
- [RSS Feed Reader — Parse RSS, Atom & Podcast Feeds to JSON](https://apify.com/haketa/rss-feed-reader) — Turn live blog and news feeds into structured JSON datasets.

***

### 📋 Changelog

#### Version 1.2 (2026-11)

- 🚀 **Unlocked 1,000+ Deep Pagination**: Added `maxItems` support and eliminated all list restrictions, allowing seamless batch processing of thousands of domains.
- ⚡ **Ultra-Fast Prefill Execution**: Tuned prefill domains to complete verification runs in under 20 seconds.
- 📧 **Expanded Mail Provider Signatures**: Added enhanced DNS MX mapping for modern cybersecurity gateways including Trellix, Cisco IronPort, and Cloudflare Email Security.
- 🔒 **Hardened SSL Parser**: Enhanced TLS certificate handshakes to gracefully handle non-standard SNI configurations and self-signed staging hosts.

#### Version 1.1

- 📇 Added integrated contact extraction for on-page emails, international phone numbers, and major social profiles.
- 🛡️ Implemented automated fresh-IP proxy retries for Cloudflare and CDN-protected domains.
- 🏷️ Added `technologiesByCategory` groupings and direct `cms` / `ecommercePlatform` shortcut fields.

#### Version 1.0

- 📦 Initial release with pure-HTTP Wappalyzer fingerprinting and DNS MX email provider detection.

# Changelog

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

# Actor input Schema

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

One website per line — a domain or full URL (e.g. 'shopify.com', 'https://www.gymshark.com'). Each is analysed for its technology stack and lead signals.

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

Optional. Load a large list of websites from a file, URL, Google Sheet or Apify Request Queue instead of typing them.

## `maxItems` (type: `integer`):

Maximum number of websites to analyze. Set to 0 for unlimited (analyze all provided sites).

## `detectEmailProvider` (type: `boolean`):

Look up the domain's mail servers to identify the email provider (Google Workspace, Microsoft 365, Zoho, etc.) — a strong technographic signal.

## `checkSsl` (type: `boolean`):

Read the SSL certificate to report its issuer (Let's Encrypt, DigiCert, Cloudflare, etc.) and expiry date.

## `extractContacts` (type: `boolean`):

Pull emails, phone numbers and social-media profiles from the page — turning tech detection into ready-to-use technographic leads.

## `pageTimeoutSecs` (type: `integer`):

How long to wait for each website to respond before giving up.

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

Proxy settings for reliable, uninterrupted analysis across many websites. Datacenter proxies (the default) work well.

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

How many websites to analyse in parallel. Higher finishes large lists faster. Recommended: 5–15.

## Actor input object example

```json
{
  "websites": [
    "shopify.com",
    "wordpress.org"
  ],
  "startUrls": [],
  "maxItems": 0,
  "detectEmailProvider": true,
  "checkSsl": true,
  "extractContacts": true,
  "pageTimeoutSecs": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Download every analysed website (JSON, CSV, Excel).

## `runUrl` (type: `string`):

Open this run in the Apify Console.

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

Website analysed

## `title` (type: `string`):

Page title

## `technologyNames` (type: `string`):

All detected technologies

## `technologiesByCategory` (type: `string`):

Technologies grouped by category

## `cms` (type: `string`):

Content management system

## `ecommercePlatform` (type: `string`):

Ecommerce platform

## `server` (type: `string`):

Web server

## `cdn` (type: `string`):

Content delivery network

## `emailProvider` (type: `string`):

Email provider via DNS MX

## `sslIssuer` (type: `string`):

SSL certificate issuer

## `ipAddress` (type: `string`):

Resolved IPv4 address

## `emails` (type: `string`):

Emails found on the page

## `socialLinks` (type: `string`):

Social-media profiles

## `phones` (type: `string`):

Phone numbers found on the page

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

Full detections with category, version and confidence

## `statusCode` (type: `string`):

HTTP status code

## `finalUrl` (type: `string`):

URL after redirects

## `scrapedAt` (type: `string`):

ISO 8601 timestamp

# 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": [
        "gymshark.com",
        "vercel.com"
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "websites": [
        "gymshark.com",
        "vercel.com",
    ],
    "startUrls": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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 '{
  "websites": [
    "gymshark.com",
    "vercel.com"
  ],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/tech-stack-detector --silent --output-dataset

```

## MCP server setup

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