# Bulk Website Tech Stack Detector — CMS, Analytics, CDN (`haketa/bulk-tech-detector`) Actor

Detect the tech stack of thousands of websites at once: CMS, e-commerce platform, JS framework, analytics, marketing/chat tools, CDN, hosting and server. Fast, cheap, keyless technographics for sales intelligence and lead generation.

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

## Pricing

from $0.70 / 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.
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

## Bulk Website Tech Stack Detector — CMS, E-commerce, Analytics, CDN & Framework Technographics

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/bulk-tech-detector)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg?style=flat-square)](https://apify.com/haketa/bulk-tech-detector)
[![Data Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](https://apify.com/haketa/bulk-tech-detector)
[![Technographics](https://img.shields.io/badge/Technographics-B2B%20Leads-brightgreen?style=flat-square)](https://apify.com/haketa/bulk-tech-detector)
[![Scale](https://img.shields.io/badge/Scale-1%2C000%2B%20to%20100K%2B%20Sites-purple?style=flat-square)](https://apify.com/haketa/bulk-tech-detector)

**Detect the technology stack of thousands of websites at once.** This **website tech stack scraper** takes a list of domains and returns, for each one, the **CMS, e-commerce platform, JavaScript framework, analytics & marketing tools, payment providers, CDN, hosting, and web server** it detects — no login, no API keys, no coding. It is the fast, keyless, and cost-effective way to **scrape website technologies** and generate rich **technographic intelligence** at scale.

Export every result to **JSON, CSV, Excel, or API**.

> Built for sales and growth teams building platform-targeted prospect lists, agencies prospecting by CMS or e-commerce platform, market analysts mapping technology share, competitive-intelligence researchers, and developers auditing web software architecture.

***

### ⚡ At a glance

| Feature | Details |
| --- | --- |
| **Detection Scope** | CMS, E-commerce, JS Frameworks, Analytics, MarTech/Chat, Payments, CDN, Web Servers |
| **Fingerprint Library** | 60+ tuned signatures across HTML markers, script sources, and HTTP response headers |
| **Throughput & Speed** | High-concurrency Cheerio engine processing 100+ websites in ~20 seconds |
| **Scale & Capacity** | Supports single-domain lookups up to 100,000+ domain batches via URL lists or remote files |
| **Cost & Architecture** | Lightweight pure-HTTP engine requiring no headless browsers; minimal compute footprint |
| **Output Formats** | Clean datasets in JSON, CSV, Excel, XML, HTML, and JSON Lines |
| **Integrations** | Apify REST API, webhooks, Python Client, Node.js SDK, Make, Zapier, Google Sheets |
| **Proxy Flexibility** | Keyless datacenter execution by default; optional Apify Proxy for bot-gated corporate domains |

***

### 🔎 Why scrape website tech stacks?

Knowing what a website is built with is pure gold for B2B sales, marketing, and competitive intelligence. **Technographics** — the structured data describing which **CMS**, **e-commerce platform**, **analytics** suite, **marketing/chat** widgets, **payment** providers, and **CDN** a business relies on — allows you to qualify leads, segment addressable markets, and craft personalized outreach. A retail brand running Shopify Plus has completely different budget and software requirements than an enterprise running SAP Commerce or an agency using Webflow.

However, gathering technographics manually by inspecting page source or running single-site browser extensions is prohibitively slow. Commercial technographic database providers charge steep monthly seat licenses, gate exports, and frequently deliver stale data collected months prior.

This **bulk tech stack detector** provides a modern, autonomous alternative: paste your list of target domains (or connect a remote CSV of thousands of leads), and the Actor inspects each domain live via high-concurrency HTTP requests. It parses HTML source markers and HTTP response headers, maps them against verified signatures, and outputs normalized, structured technographic profiles directly to your dataset.

**Common reasons teams scrape website tech stacks:**

- **Sales qualification & account scoring** — identify target accounts running specific software (e.g., WooCommerce, Magento, HubSpot, Klaviyo) to prioritize high-converting leads.
- **Agency business development** — find outdated platforms (e.g., legacy Drupal or Magento 1) to pitch replatforming, migrations, and development retainers.
- **Competitive intelligence & market share** — track platform adoption across thousands of vertical competitors (e.g., Next.js vs. Nuxt.js or Shopify vs. BigCommerce).
- **Integration & partnership targeting** — identify websites already using complementary tools (such as Stripe, Segment, or Intercom) for SaaS integration partnerships.
- **Technical due diligence** — audit the infrastructure, CDN, security headers, and frontend libraries of acquisition targets or partner networks.
- **Lead enrichment pipelines** — enrich raw corporate domains in your CRM with live software stack metadata.

***

### ✨ What this website tech stack scraper does

- ✅ **High-volume bulk detection** — paste URLs or connect remote text/CSV files; effortlessly handles a handful of sites up to **100,000+ websites** in a single run.
- ✅ **Comprehensive software coverage** — detects across 9 primary architectural layers:
  - **CMS**: WordPress, Wix, Squarespace, Drupal, Joomla, Webflow, Ghost, Contentful, Framer.
  - **E-commerce**: Shopify, WooCommerce, Magento, BigCommerce, PrestaShop, Salesforce Commerce.
  - **JS Frameworks**: Next.js, Nuxt.js, React, Vue.js, Angular, Svelte, Gatsby, Astro.
  - **Analytics**: Google Analytics, Google Tag Manager, Facebook Pixel, Hotjar, Segment, Mixpanel, Amplitude, Plausible, Matomo.
  - **Marketing & Live Chat**: HubSpot, Intercom, Drift, Zendesk, Mailchimp, Klaviyo, Crisp, Tawk.to.
  - **Payments**: Stripe, PayPal, Square.
  - **Frontend Libraries**: jQuery, Bootstrap, Tailwind CSS, Font Awesome.
  - **CDN & Edge**: Cloudflare, Vercel, Netlify, Fastly, Amazon CloudFront, Akamai, GitHub Pages.
  - **Web Server**: nginx, Apache, Microsoft IIS, LiteSpeed, Caddy, Google Frontend, Vercel, Netlify.
- ✅ **Normalized categorization** — results group technologies into dedicated category columns (`cms`, `ecommerce`, `frameworks`, etc.) alongside a consolidated `allTechnologies` list and an integer `techCount`.
- ✅ **Connection diagnostics** — captures `statusCode`, a boolean `ok` success indicator, redirected `finalUrl`, and descriptive error logs for unreachable domains.
- ✅ **Configurable concurrency** — adjust `maxConcurrency` (up to 300) to maximize throughput and match network conditions.
- ✅ **Keyless & cost-effective** — pure HTTP execution without browser overhead keeps compute consumption minimal.

***

### 🎯 Use cases & workflows

#### 1. E-commerce Agency Prospecting

Filter an industry domain list for `ecommerce: "WooCommerce"` or `cms: "Magento"`. Export the qualified list to launch targeted email campaigns proposing turnkey migration to Shopify Plus or custom headless setups.

#### 2. SaaS Competitor Replacement Campaigns

Identify prospects utilizing legacy live chat or helpdesk tools (e.g., Zendesk, Drift). Pass the accounts into sales sequences highlighting your modern AI agent or cost advantages.

#### 3. Technographic CRM Enrichment

Set up an automated webhook that passes incoming lead form domain submissions to this Actor, updates HubSpot or Salesforce with detected CMS and analytics tools, and routes leads to specialized account executives.

#### 4. Market Penetration Audits

Analyze the top 10,000 retail domains in a country to measure the exact market share distribution of Cloudflare vs. CloudFront or Stripe vs. PayPal.

***

### 🛠️ Supported Technologies & Signatures Reference

The Actor evaluates websites against a curated, multi-vector library of detection signatures across 9 architectural layers:

| Category | Detectable Software & Platforms | Primary Signatures Used |
| --- | --- | --- |
| **CMS** | WordPress, Wix, Squarespace, Drupal, Joomla, Webflow, Ghost, Contentful, Framer | Asset paths (`/wp-content/`), meta generators, CDN domains, DOM data attributes |
| **E-commerce** | Shopify, WooCommerce, Magento, BigCommerce, PrestaShop, Salesforce Commerce | Platform assets (`cdn.shopify.com`), cookie markers, `/skin/frontend/`, demandware assets |
| **JS Frameworks** | Next.js, Nuxt.js, React, Vue.js, Angular, Svelte, Gatsby, Astro | `__NEXT_DATA__`, `_next/static/`, `__NUXT__`, `data-reactroot`, `data-v-`, `astro-island` |
| **Analytics** | Google Analytics, Google Tag Manager, Facebook Pixel, Hotjar, Segment, Mixpanel, Amplitude, Plausible, Matomo | Tracking script URLs (`googletagmanager.com`, `connect.facebook.net`), global object inits |
| **MarTech & Chat** | HubSpot, Intercom, Drift, Zendesk, Mailchimp, Klaviyo, Crisp, Tawk.to | Embedded widget scripts (`hs-scripts.com`, `intercomcdn.com`, `zdassets.com`) |
| **Payment Gateways** | Stripe, PayPal, Square | Hosted checkout SDKs (`js.stripe.com`, `paypal.com/sdk`, `squareup.com`) |
| **Frontend UI** | Tailwind CSS, Bootstrap, jQuery, Font Awesome | CSS CDN links (`cdn.tailwindcss.com`, `bootstrap.min.css`), bundle filenames |
| **CDN & Edge** | Cloudflare, Vercel, Netlify, Fastly, Amazon CloudFront, Akamai, GitHub Pages | Response headers (`cf-ray`, `x-vercel-id`, `x-nf-request-id`, `x-amz-cf-id`, `via`) |
| **Web Servers** | nginx, Apache, Microsoft IIS, LiteSpeed, Caddy, Google Frontend | Server header inspection (`Server: nginx`, `Server: cloudflare`, `Server: Apache`) |

***

### 🔄 End-to-End Automation & Webhook Integration

Connect this Actor directly to automated marketing and CRM operations using Apify Webhooks and modern iPaaS tools:

#### Automated Technographic Enrichment with Make or n8n

1. **Trigger on Form Submission**: Catch new company domain signups from your marketing site via webhook.
2. **Launch Actor Run**: Trigger `bulk-tech-detector` via the Apify API with the single prospect domain.
3. **Wait for Completion**: Use Apify webhooks or polling to receive the finished dataset item.
4. **Enrich CRM Record**: In HubSpot, Salesforce, or Airtable, populate custom fields (`CMS`, `E-commerce`, `Analytics`, `CDN`) with the detected values.
5. **Score & Route**: If `ecommerce == "Shopify"` and `payment == "Stripe"`, assign the lead immediately to your Tier-1 Enterprise account executive.

#### Sample CSV Export Structure

When exporting results to CSV or spreadsheet applications, the data formats into predictable columns:

```csv
url,statusCode,ok,finalUrl,cms,ecommerce,frameworks,analytics,marketing,payment,cdn,server,jsLibraries,allTechnologies,techCount,error,scrapedAt
"https://shopify.com","200","true","https://www.shopify.com/","","Shopify","React","Google Tag Manager","","","Cloudflare","Cloudflare","Tailwind CSS","Shopify, React, Google Tag Manager, Tailwind CSS, Cloudflare","5","","2026-11-10T15:55:00.000Z"
"https://wordpress.org","200","true","https://wordpress.org/","WordPress","","","Google Tag Manager","","","","nginx","jQuery","WordPress, Google Tag Manager, jQuery, nginx","4","","2026-11-10T15:55:00.000Z"
```

***

### 🎯 Filtering Strategies & Outreach Blueprints

Here is how high-growth teams filter results after export to create high-converting outreach lists:

#### 1. The Headless Commerce Migration Campaign

- **Filter**: `cms == "WordPress"` AND `ecommerce == "WooCommerce"`
- **Hook**: Propose modernizing slow monolithic WooCommerce stores into blazing fast headless storefronts (Next.js + Shopify or Medusa).

#### 2. High-Growth DTC Brand Qualification

- **Filter**: `ecommerce == "Shopify"` AND `marketing.includes("Klaviyo")` AND `payment.includes("Stripe")`
- **Hook**: Target established, high-revenue direct-to-consumer stores with specialized upsell, financing, or retention tooling.

#### 3. Enterprise Infrastructure Optimization

- **Filter**: `cdn == "Amazon CloudFront"` AND `server == "Apache"`
- **Hook**: Pitch enterprise migration to edge computing platforms like Cloudflare Workers, Fastly, or Vercel for latency reduction.

***

### 📥 Input parameters

Configure your run via the Apify Console or pass a JSON payload directly through the API. Every field is optional.

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `urls` | array (requestListSources) | `[]` | List of website URLs, bare domains (e.g., `stripe.com`), or remote CSV/text links. Leave empty for popular demo sample. |
| `maxItems` | integer | `0` | Maximum websites to analyze. `0` = unlimited (processes every input site). Supports 1,000+ to 100K+ sites. |
| `maxConcurrency` | integer | `50` | Maximum simultaneous parallel requests (1–300). Raise for larger batches on fast networks. |
| `timeoutSecs` | integer | `30` | Per-website timeout ceiling (3–120s) preventing slow servers from stalling the crawl queue. |
| `proxyConfiguration` | object | `{ "useApifyProxy": false }` | Optional Apify Proxy configuration. Enable when scanning domains with strict anti-bot protections. |

#### Example input — Targeted SaaS & e-commerce audit

```json
{
  "urls": [
    { "url": "https://www.shopify.com" },
    { "url": "https://wordpress.org" },
    { "url": "https://vercel.com" },
    { "url": "stripe.com" },
    { "url": "gymshark.com" }
  ],
  "maxItems": 0,
  "maxConcurrency": 50,
  "timeoutSecs": 30
}
```

#### Example input — 1,000+ large batch audit via remote file

```json
{
  "urls": [
    { "requestsFromUrl": "https://example.com/top-1000-retailers.csv" }
  ],
  "maxItems": 1000,
  "maxConcurrency": 100,
  "timeoutSecs": 20
}
```

***

### 📤 Output structure

Each scanned website generates a clean, single-row record in your dataset:

```json
{
  "url": "https://shopify.com",
  "statusCode": "200",
  "ok": "true",
  "finalUrl": "https://www.shopify.com/",
  "cms": "",
  "ecommerce": "Shopify",
  "frameworks": "React",
  "analytics": "Google Tag Manager",
  "marketing": "",
  "payment": "",
  "cdn": "Cloudflare",
  "server": "Cloudflare",
  "jsLibraries": "Tailwind CSS",
  "allTechnologies": "Shopify, React, Google Tag Manager, Tailwind CSS, Cloudflare",
  "techCount": "5",
  "error": "",
  "scrapedAt": "2026-11-10T15:55:00.000Z"
}
```

***

### 📊 Extracted fields & data coverage

| Field | Coverage | Type | Description |
| --- | --- | --- | --- |
| 🌐 `url` | 🟢 High (100%) | String | Original input URL or domain name submitted for analysis |
| 📡 `statusCode` | 🟢 High (100%) | String | HTTP response code (e.g., `200`, `301`, `403`, `500`) |
| 🛡️ `ok` | 🟢 High (100%) | String | Boolean status (`"true"` for 2xx/3xx, `"false"` for errors) |
| 🔗 `finalUrl` | 🟢 High (~98%) | String | Destination URL after resolving HTTP redirects |
| 📝 `cms` | 🟡 Conditional (~26%) | String | Detected Content Management Systems (e.g., WordPress, Webflow) |
| 🛍️ `ecommerce` | 🟡 Conditional (~15%) | String | Detected e-commerce software (e.g., Shopify, WooCommerce, Magento) |
| ⚛️ `frameworks` | 🟡 Conditional (~45%) | String | Detected JavaScript frontend frameworks (e.g., React, Next.js, Vue) |
| 📊 `analytics` | 🟢 High (~60%) | String | Analytics trackers (e.g., Google Analytics, Segment, Hotjar) |
| 💬 `marketing` | 🟡 Conditional (~30%) | String | Marketing automation & chat tools (e.g., HubSpot, Klaviyo, Intercom) |
| 💳 `payment` | 🟡 Conditional (~12%) | String | Payment processing libraries (e.g., Stripe, PayPal, Square) |
| ☁️ `cdn` | 🟢 High (~80%) | String | Content delivery networks (e.g., Cloudflare, CloudFront, Fastly) |
| 🖥️ `server` | 🟢 High (~78%) | String | Web server signature identified via HTTP headers (e.g., nginx, Apache) |
| 📚 `jsLibraries` | 🟡 Conditional (~50%) | String | Frontend CSS/JS utility libraries (e.g., Tailwind CSS, jQuery) |
| 📦 `allTechnologies` | 🟢 High (100%) | String | Comma-separated concatenation of all detected software names |
| 🔢 `techCount` | 🟢 High (100%) | String | Total count of distinct technologies detected on the page |
| ⚠️ `error` | ⚪ Optional | String | Diagnostic error details if the host failed to respond |
| ⏰ `scrapedAt` | 🟢 High (100%) | String | ISO 8601 UTC timestamp of execution |

***

### 🔁 Scale & 1,000+ high-concurrency batching

Designed from the ground up for high-throughput technographic pipeline operations:

- **1,000+ to 100K+ URLs**: Feed enterprise domain files via `requestListSources` without memory degradation.
- **Configurable Parallelism**: Scale `maxConcurrency` up to 300 to process thousands of domains in minutes.
- **Zero Client-Side JavaScript Overhead**: Avoids heavy Chromium browser launches, allowing 1,000 websites to be profiled for a fraction of standard compute costs.
- **Automatic De-duplication**: The engine tracks visited domains and generates clean, de-duplicated dataset records.

***

### 💻 Developer integration & code samples

#### Python SDK

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "urls": [
        {"url": "https://www.shopify.com"},
        {"url": "https://wordpress.org"},
        {"url": "https://vercel.com"}
    ],
    "maxConcurrency": 50,
    "maxItems": 100
}

run = client.actor("haketa/bulk-tech-detector").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['url']} | CMS: {item['cms']} | Ecom: {item['ecommerce']} | Techs: {item['allTechnologies']}")
```

#### Node.js SDK

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/bulk-tech-detector').call({
    urls: [{ url: 'https://shopify.com' }, { url: 'https://vercel.com' }],
    maxConcurrency: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map(i => ({ url: i.url, ecom: i.ecommerce, frameworks: i.frameworks, cdn: i.cdn })));
```

#### cURL API

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~bulk-tech-detector/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": [{"url": "https://shopify.com"}, {"url": "https://wordpress.org"}],
    "maxConcurrency": 50
  }'
```

***

### 💡 Practical tips for optimal technographic detection

1. **Bare domains work automatically**: You can submit bare domains like `airbnb.com` or `stripe.com`; the scraper automatically prepends `https://`.
2. **Handle bot-protected domains**: When scanning major enterprise portals (e.g., Bloomberg, Amazon), enable `useApifyProxy: true` in `proxyConfiguration` to prevent 403 blocks.
3. **Calibrate concurrency**: For lists under 500 domains, concurrency of 30–50 is optimal. For 10,000+ domains, increase to 100–150 for rapid completion.
4. **Export to CSV for CRM import**: Filter on specific columns (e.g., `ecommerce == "Shopify"`) before exporting to produce clean, platform-specific lead lists.

***

### ❓ Frequently Asked Questions

**How does the detector identify technologies without a browser?**\
It inspects server-rendered HTML markers (asset paths, embedded config JSON, meta generators, inline script signatures) and HTTP response headers (e.g., `server`, `cf-ray`, `x-powered-by`, `x-vercel-id`).

**Can I analyze 50,000 domains at once?**\
Yes. You can supply a remote URL hosting a text or CSV file of domains. The Actor streams results directly into the Apify dataset in parallel.

**Is there any subscription fee for third-party databases?**\
No. The detection runs locally inside the Actor using built-in, curated signature libraries. There are zero third-party API keys or recurring subscription fees.

**Does it detect client-side JavaScript injected technologies?**\
Only if their asset URLs or script tags appear in the initial HTML document payload. Deep runtime-only client injections that require full browser DOM execution are skipped to preserve high speed and low cost.

**What formats can I download?**\
You can export results in JSON, CSV, Excel, XML, HTML, or JSON Lines via the Apify Console or API.

**How does this compare to commercial services like BuiltWith or Wappalyzer?**\
Commercial services charge high monthly seat fees and restrict bulk exports. This Actor runs directly on your Apify infrastructure with zero third-party dependencies, allowing you to scan thousands or millions of websites at pure compute cost without per-lookup pricing.

**Can I run this on internal intranet sites or staging environments?**\
As long as the target domain or URL is accessible via the public internet (or reachable via a custom proxy tunnel configured in `proxyConfiguration`), the Actor can scan and detect technologies on staging or preview deployments.

**How frequently should I re-scan domains to maintain fresh data?**\
Because modern web development involves frequent framework and tooling updates, we recommend setting up an Apify monthly schedule to re-scan your account lists and capture tooling migrations or new software deployments.

***

### 🔗 Related intelligence & discovery tools

- [Bulk Metadata Extractor](https://apify.com/haketa/bulk-metadata-extractor) — extract Open Graph, Twitter Cards, meta tags, and schema.org JSON-LD in bulk.
- [Sanctions & Watchlist Screening Scraper](https://apify.com/haketa/sanctions-screening) — screen names and corporate entities against OFAC, EU, UN, and UK regimes.
- [Nevada Contractor License Scraper](https://apify.com/haketa/nevada-contractor-scraper) — extract licensed contractors, bonds, and phone contacts from the NSCB registry.
- [Treasury & Sovereign Debt Data Scraper](https://apify.com/haketa/treasury-data) — extract official US Treasury yield curves, debt metrics, and exchange rates.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked 1,000+ to 100K+ batch pagination**: added explicit `maxRequestsPerCrawl` handling and streamlined request queue allocation.
- **Enhanced fingerprint catalog**: refined regex patterns for Magento, Tailwind CSS, and Contentful to eliminate false positives on substring matches.
- **Expanded documentation**: added visual badges, `⚡ At a glance` quick reference, and developer integration snippets across Python and Node.js.

#### v1.1 (2026-07)

- Added high-concurrency CheerioCrawler architecture with parallel request pooling.
- Added categorical technology grouping and error capture fields.

#### v1.0 (2026-06)

- Initial release with keyless HTTP fingerprint detection.

# Changelog

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

# Actor input Schema

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

The websites whose tech stack you want to detect. Paste a list of URLs or bare domains (e.g. 'stripe.com'), or upload/link a text/CSV file — it handles a handful up to millions. Each entry becomes one result row. Leave empty to run a quick demo on a diverse sample of popular sites.

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

Cap the total number of websites analyzed in one run — handy for a quick, cheap test before launching a big list. Set to 0 to process every website you provided.

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

How many sites to analyze in parallel. Raise it for faster runs on large lists; lower it if you see errors.

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

Give up on a site after this many seconds so one slow website never stalls the whole run.

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

Apify Proxy. Off by default — enable it for very large runs or geo-specific checks.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://www.shopify.com"
    },
    {
      "url": "https://wordpress.org"
    },
    {
      "url": "https://vercel.com"
    }
  ],
  "maxItems": 100,
  "maxConcurrency": 50,
  "timeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

The site

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

HTTP status

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

Content management system

## `ecommerce` (type: `string`):

E-commerce platform

## `frameworks` (type: `string`):

JS frameworks

## `analytics` (type: `string`):

Analytics tools

## `marketing` (type: `string`):

Marketing & chat tools

## `payment` (type: `string`):

Payment providers

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

CDN

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

Web server

## `jsLibraries` (type: `string`):

JS libraries

## `allTechnologies` (type: `string`):

All detected technologies

## `techCount` (type: `string`):

Number of technologies

## `error` (type: `string`):

Error if failed

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

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 = {
    "urls": [
        {
            "url": "https://www.shopify.com"
        },
        {
            "url": "https://wordpress.org"
        },
        {
            "url": "https://vercel.com"
        }
    ],
    "maxItems": 100,
    "maxConcurrency": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/bulk-tech-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": [
        { "url": "https://www.shopify.com" },
        { "url": "https://wordpress.org" },
        { "url": "https://vercel.com" },
    ],
    "maxItems": 100,
    "maxConcurrency": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/bulk-tech-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": [
    {
      "url": "https://www.shopify.com"
    },
    {
      "url": "https://wordpress.org"
    },
    {
      "url": "https://vercel.com"
    }
  ],
  "maxItems": 100,
  "maxConcurrency": 50
}' |
apify call haketa/bulk-tech-detector --silent --output-dataset

```

## MCP server setup

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