# Tech Stack Detector: Website Technology Lookup, 360+ Techs (`joesimo/tech-stack-detector`) Actor

Find out what any list of websites is built with: CMS, ecommerce platform, frameworks, analytics, ad pixels, CDN, hosting, email and DNS providers, with versions and evidence. 360+ technologies, DNS-based email detection, a BuiltWith and Wappalyzer alternative. Failed sites are free.

- **URL**: https://apify.com/joesimo/tech-stack-detector.md
- **Developed by:** [Joe Simo](https://apify.com/joesimo) (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.00 / 1,000 websites

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 Tech Stack Detector: CMS, Hosting, Email and 360+ Technologies

**Find out what any website is built with, so you can segment leads, size a market or research competitors.** Paste a list of websites and get back the technology stack of each one: CMS, ecommerce platform, JavaScript frameworks, analytics, ad pixels, tag managers, CDN, hosting, web server, live chat, payment, email hosting, email delivery services and DNS provider. Every detection comes with its evidence, and versions are reported when the site exposes them.

It works from a single homepage request plus a few DNS lookups per site, so it is fast, cheap and does not need proxies or a browser.

### Quick start

1. Click **Try for free**, paste websites into **Websites** and press **Start**.
2. Or call the API with an empty input `{}`. That analyzes these 3 demo sites:

```json
{
    "urls": ["shopify.com", "wordpress.org", "vercel.com"]
}
```

On Nov 1, 2026 this run analyzed all 3 sites for 3 x $0.002 = $0.006. It found 18 technologies on shopify.com (Shopify, Tailwind CSS, Cloudflare, Zendesk, Google Workspace, SendGrid ...), 11 on wordpress.org (WordPress, Nginx, PHP, MySQL, Jetpack, Google Tag Manager ...) and 19 on vercel.com. The vercel.com row, with 15 of its 19 technologies cut:

```json
{
    "input": "vercel.com",
    "domain": "vercel.com",
    "status": "ok",
    "httpStatus": 200,
    "title": "Agentic Infrastructure - Vercel",
    "technologies": [
        { "name": "Next.js", "categories": ["JavaScript framework", "Web framework"], "confidence": "detected",
          "evidence": ["header x-powered-by: Next.js, Payload", "header x-nextjs-prerender"] },
        { "name": "Vercel", "categories": ["PaaS"], "confidence": "detected",
          "evidence": ["header server: Vercel", "header x-vercel-id"] },
        { "name": "Google Workspace", "categories": ["Email hosting"], "confidence": "detected",
          "evidence": ["dns mx: aspmx.l.google.com"] },
        { "name": "Postmark", "categories": ["Email delivery"], "confidence": "detected",
          "evidence": ["dns txt: v=spf1 ... include:..."] }
    ]
}
```

### What makes it different

- **DNS-based detection.** Most tech lookup tools only read the HTML. This Actor also reads MX, TXT (SPF and verification records), NS, CNAME and A records, so it finds things that never appear on the page: Google Workspace or Microsoft 365 email, SendGrid, Mailgun, Amazon SES, HubSpot, Salesforce, Zendesk, the DNS provider and the real hosting platform.
- **Evidence for every result.** Each technology says why it was detected (header, cookie, script URL, meta tag, DNS record), so you can trust or filter the results.
- **Versions** where the site reveals them (WordPress, jQuery, Bootstrap, PHP, Nginx and more).
- **Failed sites are free.** You only pay for websites that answered and were analyzed. Dead domains, invalid inputs, blocked sites and sites that disallow us in robots.txt cost nothing.
- **Polite by default.** Respects robots.txt, identifies itself with a clear User-Agent and fetches one page per site.

### Use cases

- **Lead generation and sales prospecting:** find every Shopify store, WordPress site or HubSpot customer in a list, or split leads by stack before outreach.
- **Competitor research:** see which analytics, ad networks, chat tools and hosting your competitors use.
- **Market research:** count technology adoption across thousands of domains.
- **CRM enrichment:** add CMS, ecommerce platform and email provider columns to your accounts.
- **Agencies and freelancers:** find sites on outdated platforms or old versions that need a rebuild.
- **Security and IT audits:** inventory web servers, CDNs and exposed versions across your own domains.

### What it detects

More than 360 technologies in 50 categories, including:

| Category | Examples |
|---|---|
| CMS and website builders | WordPress, Drupal, Joomla, Ghost, Webflow, Wix, Squarespace, Framer, HubSpot CMS, Elementor |
| Ecommerce | Shopify, WooCommerce, Magento, BigCommerce, PrestaShop, Shopware, Salesforce Commerce Cloud |
| JavaScript frameworks and libraries | React, Next.js, Vue.js, Nuxt.js, Angular, Svelte, Astro, Gatsby, jQuery, Alpine.js |
| UI frameworks | Bootstrap, Tailwind CSS, Font Awesome |
| Analytics and tag managers | Google Analytics, Google Tag Manager, Hotjar, Plausible, Matomo, Mixpanel, Segment, Microsoft Clarity |
| Advertising | Meta Pixel, Google Ads, LinkedIn Insight Tag, TikTok Pixel, Microsoft Advertising |
| Marketing and CRM | HubSpot, Mailchimp, Klaviyo, Marketo, Salesforce, ActiveCampaign |
| Live chat and support | Intercom, Drift, Zendesk, Crisp, Tawk.to, LiveChat, Freshdesk |
| CDN, hosting and PaaS | Cloudflare, Fastly, Akamai, Amazon CloudFront, Vercel, Netlify, GitHub Pages, AWS, Google Cloud, Heroku |
| Web servers and languages | Nginx, Apache, LiteSpeed, Microsoft IIS, PHP, ASP.NET, Node.js, Express |
| Email hosting (DNS) | Google Workspace, Microsoft 365, Zoho Mail, Proton Mail, Fastmail |
| Email delivery (DNS) | SendGrid, Mailgun, Amazon SES, Postmark, Mailchimp, Brevo |
| DNS providers | Cloudflare DNS, Amazon Route 53, GoDaddy, Namecheap, Google Cloud DNS |
| Payments, consent, captcha, video, maps, reviews, forms, scheduling | Stripe, PayPal, OneTrust, Cookiebot, reCAPTCHA, Turnstile, YouTube, Vimeo, Trustpilot, Calendly, Typeform |

### Input

| Field | Description |
|---|---|
| `urls` | Websites to analyze. Domains (`example.com`) or full URLs. |
| `urlsText` | Bulk paste: one website per line, or separated by commas. Header lines like `website` are ignored. |
| `datasetId` / `datasetField` | Read websites from a dataset, for example the output of another Actor. The field can be nested (`company.website`) and can hold a list. |
| `includeDns` | Detect email, DNS and SaaS providers from DNS records. On by default. |
| `includeEvidence` | Add the evidence list to every technology. On by default; turn it off for smaller output. |
| `respectRobotsTxt` | Skip sites whose robots.txt disallows the homepage (not charged). On by default. |
| `dedupe` | Analyze each domain only once. On by default. |
| `maxItems` | Stop after this many websites (0 = no limit). |
| `maxConcurrency` | Websites processed in parallel (max 50). Automatic by default: 20 at 1024 MB, 12 at 512 MB, 8 at 256 MB. |
| `timeoutSecs` | Timeout per website (default 20 seconds). |
| `userAgent` | Optional custom User-Agent. |

Example:

```json
{
    "urls": ["shopify.com", "wordpress.org", "https://vercel.com"],
    "includeDns": true,
    "includeEvidence": true
}
```

### Output

One dataset row per website. The most useful fields are flattened for spreadsheets (`cms`, `ecommerce`, `analytics`, `advertising`, `cdn`, `hosting`, `emailHosting`, `dnsProvider`), and the full list is in `technologies`.

```json
{
    "input": "wordpress.org",
    "domain": "wordpress.org",
    "url": "https://wordpress.org/",
    "status": "ok",
    "httpStatus": 200,
    "title": "Blog Tool, Publishing Platform, and CMS - WordPress.org",
    "technologies": [
        {
            "name": "WordPress",
            "categories": ["CMS", "Blog"],
            "version": "7.2",
            "confidence": "detected",
            "evidence": ["meta generator: WordPress 7.2-beta3-65005"]
        },
        {
            "name": "Nginx",
            "categories": ["Web server", "Reverse proxy"],
            "version": null,
            "confidence": "detected",
            "evidence": ["header server: nginx"]
        },
        {
            "name": "PHP",
            "categories": ["Programming language"],
            "version": null,
            "confidence": "implied",
            "evidence": ["implied by WordPress"]
        }
    ],
    "technologyCount": 11,
    "categories": { "CMS": ["WordPress"], "Web server": ["Nginx"] },
    "cms": ["WordPress"],
    "ecommerce": [],
    "analytics": ["Jetpack"],
    "cdn": [],
    "hosting": [],
    "emailHosting": [],
    "dnsProvider": [],
    "dns": {
        "mxHosts": ["..."],
        "nameservers": ["..."],
        "wwwCname": null,
        "ipv4": ["..."],
        "domainExists": true
    },
    "server": "nginx",
    "poweredBy": null,
    "redirects": [],
    "responseTimeMs": 310,
    "error": null,
    "checkedAt": "2026-10-29T15:00:00.000Z"
}
```

(Shortened. Real rows list every detected technology.)

`confidence` is `detected` when the technology itself left a trace, and `implied` when another detection implies it (for example WordPress implies PHP).

#### Status values

| Status | Meaning | Charged |
|---|---|---|
| `ok` | The homepage loaded and was analyzed. | Yes |
| `http_error` | The site answered with an error (403, 404, 500...). Headers, cookies and DNS are still analyzed. | No |
| `unreachable` | Timeout, connection or TLS error, or the domain does not exist. | No |
| `robots_disallowed` | robots.txt does not allow fetching the homepage. | No |
| `invalid_input` | Not a valid public website. | No |

The run also writes an `OUTPUT` record to the key-value store with counts per status and the most common technologies across all sites.

### Pricing

**Price change on Nov 16, 2026:** the price per analyzed website goes from $0.002 to **$0.0023** ($2.30 per 1,000). Failed sites stay free.

**$2.00 per 1,000 analyzed websites** ($0.002 per site), pay per event. Only websites with status `ok` are charged. Everything else is free. A small Actor start fee set by Apify applies per run.

If you set a maximum cost per run, the Actor stops cleanly when the limit is reached, and websites that were not analyzed are not charged.

### How it works

1. Each input is cleaned into a domain or URL (invalid values, IP addresses and private hosts are rejected).
2. The homepage is fetched with redirects followed. If it fails, the www or non-www variant and the other scheme are tried.
3. HTTP headers, cookies, script and stylesheet URLs, meta tags and HTML patterns are matched against a hand-written fingerprint list.
4. In parallel, MX, TXT, NS, CNAME and A records are looked up and matched too.
5. Implied technologies are added and the result is grouped by category.

Only public information is used. The Actor does not log in, solve captchas, render JavaScript or collect personal data.

### Limits

- Only the homepage (or the URL you give) is analyzed, and JavaScript is not executed. Technologies loaded only after user interaction, or only on inner pages, can be missed.
- Some sites block automated requests (often with a 403, mostly behind Cloudflare or similar bot protection). They are reported as `http_error`, their headers, cookies and DNS are still analyzed, and they are not charged. The Actor identifies itself honestly and does not try to get around these blocks.
- On random lists of domains (for example a sample of a top 1M list) expect roughly 65 to 75% `ok`: many such domains no longer resolve, are parked, or block datacenter traffic. On lists of real company websites the share is much higher.
- Long dashes in page titles and descriptions are replaced with a plain hyphen.
- Detections from DNS (for example SendGrid in an SPF record) show that the domain is set up for that service, not necessarily that it is actively used.

### FAQ

**Do I need proxies?** No. One request per site from Apify's datacenter is enough for most websites.

**How fast is it?** Roughly 200 to 300 websites per minute at the default concurrency, depending on how fast the sites answer.

**How much memory should I use?** Keep the default 1024 MB for lists of hundreds or thousands of websites. 256 MB is enough for short lists. Memory does not change the price per website.

**Can I feed it the results of another Actor?** Yes. Use `datasetId` and point `datasetField` at the field that holds the website, for example `website` or `company.domain`.

**A technology is missing or wrong.** Open an issue on the Actor page with the website and the technology, and the fingerprint will be added or fixed.

### Support

Questions or bugs: open an issue on the Actor's **Issues** tab. Contact: joesimo@mail.grokbot.com

More examples and the docs for all 6 of our Actors: [github.com/Joe-Simo/apify-actors](https://github.com/Joe-Simo/apify-actors/tree/main/tech-stack-detector). Store page: https://apify.com/joesimo/tech-stack-detector

# Actor input Schema

## `urls` (type: `array`):

Domains or URLs to analyze, for example shopify.com or https://www.example.com/pricing. A bare domain is checked at its homepage over HTTPS, with www and HTTP fallbacks. If you start a run with no websites, no bulk paste and no dataset (for example an API call with <code>{}</code>), it analyzes shopify.com, wordpress.org and vercel.com as a demo (about $0.006).

## `urlsText` (type: `string`):

Paste many domains or URLs at once, one per line or separated by commas, spaces or semicolons. Combined with the list above.

## `datasetId` (type: `string`):

Read websites from an existing Apify dataset, for example the output of another Actor. Use together with the field name below.

## `datasetField` (type: `string`):

Field in each dataset item that holds the website or domain. Dot paths such as company.website are supported. Default: url.

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

Look up public MX, NS, TXT and CNAME records to detect email hosting (Google Workspace, Microsoft 365...), email delivery services, the DNS provider and verified SaaS tools. Adds about a second per site.

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

Add up to 3 short evidence strings per technology (the header, script URL, meta tag or DNS record that matched).

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

Skip pages that the site's robots.txt disallows for this bot. Skipped sites are saved with status robots_disallowed and are not charged.

## `dedupe` (type: `boolean`):

Analyze each website only once, even if it appears several times in the input.

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

Stop after this many websites. 0 means no limit.

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

How many websites are analyzed at the same time. Leave empty for automatic: 20 at 1024 MB memory (the default), 12 at 512 MB, 8 at 256 MB. Matching large pages needs CPU, and Apify gives more CPU to runs with more memory.

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

Maximum time for loading one page, including redirects.

## `userAgent` (type: `string`):

Optional. By default the Actor identifies itself honestly as TechStackDetector with a link to this page.

## Actor input object example

```json
{
  "urls": [
    "shopify.com",
    "wordpress.org",
    "vercel.com",
    "stripe.com",
    "hubspot.com"
  ],
  "datasetField": "url",
  "includeDns": true,
  "includeEvidence": true,
  "respectRobotsTxt": true,
  "dedupe": true,
  "maxItems": 0,
  "timeoutSecs": 20
}
```

# Actor output Schema

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

One item per website: technologies with categories, versions and evidence, plus CMS, ecommerce, analytics, hosting, CDN, email and DNS provider shortcuts.

## `runSummary` (type: `string`):

Counts by status, the most common technologies across all sites, duplicates removed and DNS stats.

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

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

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

```

## MCP server setup

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