# Website Technology Detector | Tech Stack API, $3/1K (`berkaydev/website-technology-detector`) Actor

Website technology lookup for any list of domains: CMS, shop system, analytics, ad pixels, chat, cookie banner, CDN, server and mail provider, each with evidence, plus sales signals like outdated PHP or tracking without consent. Bulk, fast, no browser.

- **URL**: https://apify.com/berkaydev/website-technology-detector.md
- **Developed by:** [Gezgin Data](https://apify.com/berkaydev) (community)
- **Categories:** Lead generation, SEO tools, Agents
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 website 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

**Website technology detector for any list of domains.** For each website you get the CMS, shop system, website builder, analytics, ad pixels, live chat, cookie banner, CDN, web server and the company's mail provider. Every technology comes with the evidence it was recognised by. You also get plain sales signals, such as an outdated PHP version, a WordPress site that has not been updated, or tracking that runs without a cookie banner. Bulk lookups are fast and need no browser and no API key, and you pay only for websites that could be analysed.

### Who uses it

Web agencies use it to find businesses on Wix, an old WordPress version or without HTTPS. SaaS sales teams look for shops on Shopware, WooCommerce or Magento, or for companies running HubSpot or Intercom. Marketers check which competitors run Meta or TikTok ads. For lead lists, combine it with a Google Maps or website contact scraper: first the businesses, then their technology, then the right pitch.

### What you get for each website

The overview shows one field per question: `cms`, `ecommerce`, `websiteBuilder`, `analytics`, `advertising`, `cookieConsent`, `liveChat`, `emailProvider` and more. The `technologies` list holds everything found (over 150 technologies are recognised), each with category, version where visible, and evidence such as `page: cdn.shopify.com` or `header: server: nginx/1.18.0`.

The `signals` list turns this into conversation openers:

- `php_end_of_life`: PHP 8.0 or older, without security updates
- `old_wordpress`: WordPress older than 6.0
- `old_jquery`: jQuery 1.x or 2.x
- `no_https`: the site does not use HTTPS
- `no_analytics_found`: no analytics or tag manager in the page source (only reported for plain sites without a consent tool, since big sites load analytics after consent)
- `tracking_without_known_cookie_banner`: cookie-setting analytics or ad pixels, but no known cookie consent tool (cookieless tools like Matomo or Plausible do not count)
- `runs_ads`: at least one ad pixel is installed
- `website_builder`: built with Wix, Jimdo, Squarespace or similar
- `not_mobile_friendly`: no mobile viewport set

### Example

Input:

```json
{ "domains": ["example-bakery.de", "example-shop.com"], "requireTechnologies": ["WordPress", "Shopify"] }
```

Output (shortened):

```json
{
  "domain": "example-bakery.de",
  "cms": "WordPress 5.8.3",
  "ecommerce": "WooCommerce",
  "analytics": ["Google Analytics"],
  "advertising": ["Meta Pixel"],
  "cookieConsent": null,
  "emailProvider": "IONOS",
  "server": "Apache",
  "signals": ["php_end_of_life", "old_wordpress", "tracking_without_known_cookie_banner", "runs_ads"],
  "technologies": [
    { "name": "WordPress", "category": "CMS", "version": "5.8.3", "evidence": "page: /wp-content/" },
    { "name": "PHP", "category": "Programming language", "version": "7.4.33", "evidence": "header: x-powered-by: PHP/7.4.33" }
  ]
}
```

### How it works

The Actor loads each homepage once and checks it against its own fingerprints: script and asset URLs, response headers, cookies and generator tags. A brand name that only appears in the text does not count, so a blog post about Shopify does not make a site a Shopify store. The mail provider comes from the domain's public MX records. About 100 websites take one to two minutes.

### Input

- `domains` (required): websites, one per line.
- `requireTechnologies`: return only sites that use one of these, e.g. `["Shopify", "Shopware"]`.
- `checkMx`: detect the mail provider (default on).
- `includeEvidence`: show how each technology was recognised (default on).
- `compact`: short rows for AI agents.

### Chain it with other Actors

You do not have to copy websites between tools. Pass the dataset ID of an earlier run in `datasetId` and the Website Technology Detector reads the websites from it. It finds the website column on its own (website, url, domain and similar); set `datasetField` if the column has another name, and `maxDomains` for a small first test.

A typical chain: run the [Google Maps Email Scraper](https://apify.com/berkaydev/google-maps-email-scraper-business-leads) for a trade and city, pass its dataset to the Website Technology Detector and its results to the [Company Email Finder](https://apify.com/berkaydev/company-email-finder-by-domain), and you end up with businesses, their technology and their company mailboxes without touching a spreadsheet. AI agents can do the same in three calls. To know which of these companies are hiring right now, pass the same dataset to [Company Hiring Signals](https://apify.com/berkaydev/company-hiring-signals).

### FAQ

#### Can the Website Technology Detector read websites from another Actor's results?

Yes. Pass the dataset ID of an earlier run in datasetId. The Website Technology Detector detects the website column automatically and reads only that dataset, which you grant access to by passing it.

#### What does the Website Technology Detector return?

The Website Technology Detector returns, per website, the CMS, shop system, website builder, analytics, ad pixels, live chat, cookie banner, CDN, web server and mail provider, each technology with the evidence it was recognised by.

#### How does the Website Technology Detector recognise technologies?

The Website Technology Detector checks script and asset URLs, response headers, cookies and generator tags against its own fingerprints. A brand name that only appears in the page text does not count.

#### What input does the Website Technology Detector need?

The Website Technology Detector needs a list of websites in domains. Optionally, requireTechnologies keeps only sites that use one of the named technologies, for example \["Shopify"].

#### What does the Website Technology Detector cost?

The Website Technology Detector charges per website that could be analysed. Dead domains and sites that refuse the request are free. The price is in the Pricing tab.

#### What are the sales signals of the Website Technology Detector?

The Website Technology Detector adds plain facts such as php_end_of_life, old_wordpress, no_https or tracking_without_known_cookie_banner, which agencies use to open a conversation.

#### Why does the Website Technology Detector miss some tools?

The Website Technology Detector checks the homepage only. Tools that load after cookie consent or only on sub-pages may not be visible, so a missing technology means not found, not certainly absent.

### Use it from an AI agent (MCP)

Connect this Actor to Claude, ChatGPT, Cursor or any other MCP client with one URL:

```
https://mcp.apify.com/?tools=berkaydev/website-technology-detector
```

Then ask in plain words, for example: *"Which of these 50 websites run WordPress and have no cookie banner?"* The agent fills in the input, runs the Actor and reads the results.

### Pricing

You pay per website that could be analysed. Dead domains and sites that refuse the request are free. The current price is shown in the Pricing tab.

### Good to know

- Only the homepage is checked. A tool that loads only on a sub-page (for example a booking widget on /contact) may be missed.
- Some technologies hide themselves: servers can drop version headers, and tracking can load only after consent. A missing technology means it was not visible, not that it is certainly absent.
- Versions are shown only when the website reveals them.

Questions or a technology you would like added? Open an issue on the Issues tab.

# Actor input Schema

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

One website per line: a domain like example.com or a full URL. Or leave this empty and use the dataset of an earlier run below.

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

Chain Actors: pick or paste the dataset ID of an earlier run, for example from Google Maps Email Scraper or any scraper with a website column. The website field is detected automatically. Pass it in this field (datasetId) so the Actor is allowed to read it.

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

Optional. Name of the column holding the website if it is not detected automatically, e.g. companyUrl.

## `maxDomains` (type: `integer`):

Process at most this many websites (0 = all). Useful for a cheap first test on a large dataset.

## `requireTechnologies` (type: `array`):

Optional filter. Return only websites that use at least one of these, e.g. "Shopify", "WordPress", "Matomo". Leave empty to return all.

## `checkMx` (type: `boolean`):

Look up the domain's MX records to name the mail provider (Google Workspace, Microsoft 365, IONOS ...).

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

Show for every technology how it was recognised (script URL, header or cookie).

## `compact` (type: `boolean`):

Return only domain, cms, ecommerce, websiteBuilder, analytics, advertising, emailProvider, signals, techCount and statusNote.

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

How many websites are analysed at the same time.

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

Usually not needed. Some sites refuse datacenter IPs; a proxy can help there.

## `maxRunTimeSecs` (type: `integer`):

The run stops cleanly before this limit and keeps everything found so far.

## Actor input object example

```json
{
  "domains": [
    "wordpress.org",
    "shopify.com"
  ],
  "maxDomains": 0,
  "checkMx": true,
  "includeEvidence": true,
  "compact": false,
  "maxConcurrency": 10,
  "maxRunTimeSecs": 3000
}
```

# Actor output Schema

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

One row per website with the technologies found, evidence and sales signals.

## `runStatus` (type: `string`):

Websites processed and analysed, rows returned, and the reason if nothing came back.

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,berkaydev/website-technology-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/5uDgfGEx53md7MxFa/builds/2p1FtbH2lziF4qwKg/openapi.json
