# Tech Stack Detector: $0.40 per 1,000 Websites (`zaiq/tech-stack-detector`) Actor

Detect website technologies from public pages and DNS. Get evidence, confidence, visible versions, CMS, commerce, analytics, payment tools, hosting, email providers and social links. One row per domain; blocked and unreachable sites return free notes. $0.40 per 1,000 websites.

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

## Pricing

from $0.40 / 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 Technology Detector: CMS, Analytics & Tech Stack

**Get a technology stack with evidence for each website. $0.0004 per website with detected technologies — $0.40 per 1,000, the same price on every Apify plan.** Blocked, unreachable, parked and unrecognized websites return free notes. Apify adds a $0.00005 start charge per run.

Paste a domain into `urls`, for example `{"urls":["example.com"]}`. The first output column gives a one-line verdict. Expand the row to see technologies, categories, visible versions, confidence, the exact signal matched, and where that signal was found.

Check CMS and commerce platforms, JavaScript frameworks, analytics, advertising tags, payment tools, CDNs, visible hosting signals and email providers. The Actor reads public HTML, response headers, cookie names and DNS. It uses more than 6,000 static technology definitions; it does not execute JavaScript or claim to detect every installed tool.

### What you get

| Field | What it holds |
|---|---|
| `verdict`, `status` | A short result first, followed by an explicit status such as ok, partial, blocked or parked. |
| `technologies` | Technology names and categories, visible version or null, confidence score, observed/inferred label, and up to three matched signals with source URLs. |
| Stack columns | `cms`, `ecommerce`, `frameworks`, `analytics`, `adsPixels`, `payments`, `cdn`, `hosting`, `dnsProvider`, `emailProvider` and `emailDelivery`. |
| `dns` | Public MX, SPF TXT, NS and CNAME observations with resolver and query status. Mailbox providers come from MX; sending services come from SPF. |
| `socialLinks` | Public profile links present on the pages read. Sharing buttons and login links are excluded. |
| `pages`, `coverage`, `notes` | URLs actually read, HTTP status, route, truncation and gaps. A missing technology means it was not detected in this material. |
| `resultId`, `checkedAt` | Stable domain identity within the run and the time of inspection. Already-delivered rows are skipped on restart. |
| `SUMMARY` | Results and failures, request counts, traffic, route escalations, timing and charged events. |

### What people use it for

- **Enrich a domain list:** Add technology columns to public company websites for research and segmentation.
- **Plan integrations:** Check public evidence of a CMS, commerce platform or payment tool before choosing an integration approach.
- **Track a migration:** Schedule repeat runs and compare the resulting technology rows in your own workflow.
- **Review detection evidence:** Inspect the actual header, asset path or DNS record behind a result instead of accepting an unexplained label.

### How to use it

1. Enter one or more public websites in **Website URLs or domains**. Leaving the field empty checks example.com.
2. Keep one page per website for a quick lookup. Use up to three pages to read more of the same website.
3. Set **Maximum cost per run**, then click **Start**. Open **Website technologies** for the overview or **Evidence and coverage** for detail.
4. Export JSON for nested evidence, or CSV/Excel for the summary columns.

### Input

| Field | Example | Notes |
|---|---|---|
| `urls` | `["example.com"]` | Up to 10,000 domains or HTTP(S) URLs. Exact hostname duplicates and www aliases are combined; other subdomains can have different stacks. |
| `maxPages` | `1` | From 1 to 3 linked public pages per website. DNS and robots requests are separate. |
| `includeDns` | `true` | Read MX, SPF TXT, NS and CNAME records. Public DNS answers, including errors, are cached within the run. |
| `respectRobots` | `true` | Follow readable robots.txt rules, including on redirect destinations. |
| `probePaths` | `false` | Optionally read a manifest and an already-detected CMS public index. No forms or administrative pages are submitted. |
| `allowProxyFallback` | `true` | On Apify, try datacenter and fresh residential routes after a refused or empty response. The price stays the same. Residential recovery reads a small initial fragment and can miss later signals. |
| `concurrency` | `6` | Maximum of 1–8 websites at once. The active limit drops as large DNS caches grow. Requests within a website are sequential. |
| `siteTimeoutSeconds` | `45` | From 10 to 120 seconds per website. Partial evidence is returned when the allowance is used. |

### Output

Each result is one row in the run's dataset (download it as JSON, CSV, Excel, XML or HTML, or read it through the API). An example row (values shortened):

```json
{
  "verdict": "3 technologies detected",
  "domain": "example.com",
  "status": "ok",
  "technologyCount": 3,
  "technologies": [
    {
      "name": "CDN provider",
      "category": "CDN",
      "categories": [
        "CDN"
      ],
      "version": null,
      "confidence": 100,
      "detection": "observed",
      "evidence": [
        {
          "type": "headers",
          "key": "server",
          "match": "cdn-provider",
          "sourceUrl": "https://example.com/",
          "ruleSource": "community"
        }
      ]
    },
    {
      "name": "DNS provider",
      "category": "DNS",
      "categories": [
        "DNS"
      ],
      "version": null,
      "confidence": 100,
      "detection": "observed",
      "evidence": [
        {
          "type": "dns",
          "key": "NS",
          "match": ".ns.provider.example",
          "sourceUrl": "dns:example.com",
          "ruleSource": "community"
        }
      ]
    },
    {
      "name": "HTTP/3",
      "category": "Miscellaneous",
      "categories": [
        "Miscellaneous"
      ],
      "version": null,
      "confidence": 100,
      "detection": "observed",
      "evidence": [
        {
          "type": "headers",
          "key": "alt-svc",
          "match": "h3",
          "sourceUrl": "https://example.com/",
          "ruleSource": "community"
        }
      ]
    }
  ],
  "coverage": {
    "pagesRequested": 1,
    "pagesScanned": 1,
    "htmlTruncated": false,
    "javascriptExecuted": false,
    "externalScriptsDownloaded": false,
    "dnsRequested": true,
    "dnsComplete": true,
    "staticOnly": true,
    "absenceMeans": "Not detected in the public material fetched; not proof of absence."
  }
}
```

This shortened example comes from a real direct-connection run on 25 October 2026. Names and vendor identifiers have been replaced with neutral labels, and source addresses use example domains; the counts, confidence scores, status and coverage are retained. No example company copy is included. The run’s key-value store contains a SUMMARY record with traffic, coverage, failures and charges.

### Pricing

- **$0.0004 per website with detected technologies**, including a useful result with partial coverage. Direct and recovered results have the same price on every Apify plan.
- Blocked, unreachable, parked, invalid and no-technology results are free. Retries, additional pages within the selected limit, DNS lookups and failure notes have no separate event charge.
- Apify’s **$0.00005 start charge** counts towards the buyer’s **Maximum cost per run**.
- No AI step or separate model charge.
- Launch price. It may rise later; Apify emails every user 14 days before any price increase takes effect, and a rise can happen at most once a month.

What typical jobs cost at the list price:

| Job | Cost |
|---|---|
| 1 successful website | $0.00045 including the start charge |
| 100 successful websites | $0.04005 including the start charge |
| 1,000 successful websites | $0.40 including the start charge |
| 100 inputs, 80 successful and 20 free notes | $0.03205 including the start charge |

Set Maximum cost per run to at least $0.00045 for one successful website, including the start charge. The Actor checks the remaining allowance before starting work and returns free notes for inputs it cannot inspect within that limit.

### Tips

- Use one page first; add pages when you need evidence beyond the landing page.
- Filter on observed technologies when you need direct evidence. Inferred dependencies are labelled separately.
- Treat a DNS provider as a DNS provider: nameservers alone do not establish where a website is hosted.
- Check partial-coverage notes before comparing two runs. Consent prompts, region, hidden scripts and site changes can affect results.

### Use it through the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zaiq/tech-stack-detector").call(run_input={"urls": ["example.com"], "maxPages": 1})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row)
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('zaiq/tech-stack-detector').call({"urls": ["example.com"], "maxPages": 1});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP (one call, results back)**

```bash
curl -X POST 'https://api.apify.com/v2/acts/zaiq~tech-stack-detector/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"urls": ["example.com"], "maxPages": 1}'
```

### Integrations and schedules

- **Schedules:** run it every hour, day or week from the Apify Console (Schedules) and keep a history of results.
- **Make, Zapier, n8n, Google Sheets, Slack, Airtable:** connect it through Apify's integrations, or send each finished run to a **webhook**.
- **Datasets:** results stay in the run's dataset; export them or read them by API whenever you need them.

### Use it with AI agents (MCP)

Add Apify's MCP server with this Actor already pinned (`https://mcp.apify.com?tools=zaiq/tech-stack-detector`) to Claude, ChatGPT, Cursor, VS Code or any MCP client. The agent can find this Actor and run it for you: ask it for "check the technology stack for these public website domains and show the evidence". AI agents can also pay for runs directly through Apify's agentic payments.

### Limits

- Static public signals only. No browser rendering, logged-in data, private APIs, CAPTCHA solving or hidden server inventory.
- An observed asset or tag establishes a public signal, not an active subscription or proof that a service processes transactions. Confidence is a fingerprint score, not a calibrated probability.
- Only versions present in matched public signals are returned. Unknown versions are null. Dependency inferences are explicitly marked.
- Direct pages have a 12 MB decoded-body limit and a 16 MB site allowance. Residential recovery has a much smaller traffic allowance and returns partial coverage when it can provide evidence.
- Robots restrictions and rate limits can end an inspection. The Actor stops requesting a website after a 429 response and does not rotate around it.
- At most 150 HTTP requests reach one website across a run, including shared redirects. Inputs converging on the same website can therefore receive a budget note.
- No automatic comparison or historical database is included. Schedule runs and compare their saved rows in your own system.
- Fingerprint data includes the GPL-3.0 community definitions from [enthec/webappanalyzer](https://github.com/enthec/webappanalyzer). Source attribution and the retained license are included with the Actor.

### FAQ

**What is charged?**

One event for each website with detected technologies. A partial result with evidence is charged. A blocked page, parked domain, unreachable address or page with no supported detections is a free note.

**Is this a website security scanner?**

No. It reads public technology signals and does not test vulnerabilities, submit forms or probe administrative pages.

**Why can a technology be missing?**

Some services appear only after JavaScript executes, after consent, on a different page or to a different visitor. An empty category is not proof of absence.

**Does an email provider mean a contact address was found?**

No. MX records identify mail routing providers; SPF identifies sending services. This Actor does not extract personal email addresses.

**Does a restart charge the same website twice?**

Already-delivered domain keys are read from the dataset and skipped on restart. A new, separate run performs a new lookup.

**Can the output be used without AI?**

Yes. Detection is deterministic fingerprint matching with evidence and requires no AI key.

**What happens to malformed inputs?**

They produce free notes. One malformed input or inaccessible website does not stop the rest of the list.

### Related Actors from Zaiq

- [contact-details-extractor](https://apify.com/zaiq/contact-details-extractor): public website contact details
- [contact-form-finder](https://apify.com/zaiq/contact-form-finder): public contact pages and form evidence
- [llm-website-crawler](https://apify.com/zaiq/llm-website-crawler): public website content as Markdown

### Support

Questions, a site that changed, or a field you need? Open an issue on this Actor's **Issues** tab: we answer there, usually within a day.

***

Also found as: website technology detector, tech stack detector, website technology lookup, CMS detector, bulk domain enrichment, website technology API.

# Actor input Schema

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

Up to 10,000 public websites. Enter domains or HTTP(S) URLs. One row per unique hostname; www aliases are combined. Empty input checks example.com.

## `maxPages` (type: `integer`):

Read one to three public pages per website. Additional pages come from links on the first page. Robots and DNS requests are separate.

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

Read public MX, SPF TXT, NS and CNAME records through public DNS-over-HTTPS. Mailbox providers come from MX, sending providers from SPF.

## `respectRobots` (type: `boolean`):

Follow readable robots.txt rules, including on redirected hosts. Missing robots.txt files do not block a website.

## `probePaths` (type: `boolean`):

Also try /manifest.json and, when WordPress was already detected, /wp-json/. These optional GET requests never submit forms or access admin pages.

## `allowProxyFallback` (type: `boolean`):

On Apify, retry refused or empty pages through datacenter then fresh residential routes at the same per-website price. Residential recovery reads a small initial fragment; the output marks partial coverage. No challenges are solved.

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

Upper limit of 1–8 websites processed together. The active limit drops as large DNS caches grow, to leave memory for large pages. Requests within a website are sequential.

## `siteTimeoutSeconds` (type: `integer`):

Stop starting requests after this time allowance. Partial evidence is returned with notes.

## Actor input object example

```json
{
  "urls": [
    "https://example.com"
  ],
  "maxPages": 1,
  "includeDns": true,
  "respectRobots": true,
  "probePaths": false,
  "allowProxyFallback": true,
  "concurrency": 6,
  "siteTimeoutSeconds": 45
}
```

# Actor output Schema

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

Dataset: the results.

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

What each input returned, and notes.

# 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": [
        "https://example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaiq/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": ["https://example.com"] }

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

```

## MCP server setup

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