# Tech Stack Scanner | BuiltWith Alternative + Payments (`commit_dev/website-technology-detector`) Actor

Detect the full technology stack of any website. Bulk scan thousands of domains for CMS, e-commerce, payment processors (Stripe, PayPal, Klarna), JS frameworks, analytics, CDN, and more. Deep scan of /cart and /checkout pages catches 30-40% more payment processors.

- **URL**: https://apify.com/commit_dev/website-technology-detector.md
- **Developed by:** [Commit Dev](https://apify.com/commit_dev) (community)
- **Categories:** Lead generation, E-commerce, Developer tools
- **Features:** Limited permissions
- **Stats:** 31 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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

Detect the full technology stack of any website — CMS, e-commerce platforms, payment processors, JavaScript frameworks, analytics tools, CDNs, security, and hosting infrastructure.

Powered by the [Wappalyzer](https://www.wappalyzer.com/) engine with **enhanced detection** that goes beyond standard Wappalyzer: scans `/cart` and `/checkout` pages, resolves implied technology chains, and uses 20+ custom regex fingerprints for CMS, e-commerce platforms, and payment processors.

### What's New (v2.0)

- **Much better CMS / e-commerce detection** — custom fingerprints for Magento, PrestaShop, OpenCart, Shopware, Sitecore, Adobe Experience Manager, TYPO3, Bitrix, Joomla, Drupal, WordPress, Shopify, WooCommerce, BigCommerce, Wix, Squarespace, Webflow, Ghost, HubSpot CMS, ModX and more.
- **Expanded payment processors** — added Adyen, Worldpay, Authorize.Net, 2Checkout, Amazon Pay, Sezzle, Affirm, Mollie, Razorpay.
- **Full category mapping** — all 108 Wappalyzer categories now routed to the right output column (was: only 15 categories mapped, rest fell through to "other").
- **Implied technology resolution** — when a parent technology (e.g. Hyva Themes) implies a child (e.g. Magento), the child now inherits its proper categories instead of landing empty.
- **Case-insensitive HTTP header matching** — fixes silent misses on sites that return mixed-case header names.

### Key Features

- **Bulk scanning** — process hundreds or thousands of domains in one run
- **Deep payment detection** — scans `/cart` + `/checkout` pages, not just the homepage
- **Anti-bot bypass** — browser-like headers with Chrome/Safari UA rotation, HTTPS/HTTP fallback
- **Structured output** — technologies pre-categorized into columns (CMS, E-commerce, Payment, Analytics, CDN, Security, Hosting)
- **Proxy support** — works with Apify residential proxies for geo-restricted or protected sites
- **Fast** — concurrent scanning with configurable parallelism (up to 50 threads)

### Use Cases

- **Lead generation**: Find e-commerce stores using specific payment processors (Stripe, PayPal, Klarna)
- **Competitive analysis**: See what technology stack your competitors use
- **Market research**: Analyze CMS and e-commerce platform market share across an industry
- **Sales prospecting**: Target businesses using outdated or specific technologies
- **Security auditing**: Identify technology versions for vulnerability assessment

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `domains` | array | required | List of domains to scan (e.g. `["shopify.com", "amazon.com"]`) |
| `deepScan` | boolean | `true` | Scan /cart and /checkout pages for payment processor detection |
| `concurrency` | integer | `10` | Parallel scans (1-50) |
| `timeout` | integer | `15` | Seconds per domain |
| `proxyConfiguration` | object | none | Apify proxy settings |

#### Example Input

```json
{
    "domains": [
        "shopify.com",
        "wordpress.org",
        "stripe.com",
        "amazon.com",
        "etsy.com"
    ],
    "deepScan": true,
    "concurrency": 10,
    "timeout": 15
}
```

### Output

Each domain produces a structured result in the dataset:

```json
{
    "url": "https://shopify.com",
    "domain": "shopify.com",
    "tech_count": 18,
    "technology_names": ["Cloudflare", "Google Analytics", "React", "Shopify", "Stripe", ...],
    "cms": "Shopify",
    "ecommerce": "Shopify",
    "payment_processors": "Stripe, Shop Pay",
    "js_frameworks": "React",
    "analytics": "Google Analytics, Segment",
    "cdn": "Cloudflare",
    "security": "HSTS, Cloudflare Bot Management",
    "hosting": "Cloudflare",
    "other": "HTTP/3, webpack",
    "technologies_by_category": {
        "Ecommerce": ["Shopify"],
        "Payment processors": ["Stripe", "Shop Pay"],
        "CDN": ["Cloudflare"],
        "...": "..."
    },
    "status": "success",
    "scanned_at": "2026-02-28T12:00:00+00:00"
}
```

#### Output Fields

| Field | Description |
|-------|-------------|
| `domain` | Normalized domain name |
| `tech_count` | Total number of detected technologies |
| `cms` | Content management systems (WordPress, Joomla, Drupal, etc.) |
| `ecommerce` | E-commerce platforms (Shopify, WooCommerce, Magento, etc.) |
| `payment_processors` | Payment systems (Stripe, PayPal, Klarna, Apple Pay, etc.) |
| `js_frameworks` | JavaScript frameworks and libraries (React, Vue, jQuery, etc.) |
| `analytics` | Analytics & marketing (Google Analytics, Hotjar, Segment, etc.) |
| `cdn` | Content delivery networks (Cloudflare, Fastly, Akamai, etc.) |
| `security` | Security features (HSTS, Cloudflare Bot Management, etc.) |
| `hosting` | Hosting infrastructure (AWS, Nginx, Apache, etc.) |
| `other` | Everything else (HTTP/3, fonts, miscellaneous) |
| `technology_names` | Full list of all detected technology names |
| `technologies_by_category` | Detailed breakdown by Wappalyzer category |

### How It Works

1. **Fetches homepage** with realistic browser headers (Chrome 124 User-Agent, Sec-Fetch headers)
2. If blocked, **retries with Safari UA** and **HTTP fallback**
3. Runs **Wappalyzer analysis** on HTML + HTTP headers
4. Applies **custom regex patterns** for payment processors often missed by standard Wappalyzer
5. If deep scan enabled: fetches **/cart** and **/checkout** pages for additional payment detection
6. **Categorizes** all technologies into structured columns for easy analysis

### Tips

- **Large lists (1000+ domains)**: Use concurrency 20-30 with Apify residential proxies for best speed and reliability
- **Payment processor research**: Keep `deepScan` enabled — it catches 30-40% more payment processors
- **Export**: Results are in Apify Dataset — export to CSV, JSON, or Excel with one click
- **Filtering**: Use the "Overview" tab to quickly see payment processors and CMS across all domains

### Cost Estimation

This actor uses minimal compute resources (no browser needed — pure HTTP requests). Typical costs:

| Domains | Estimated Time | Estimated Cost |
|---------|---------------|----------------|
| 100 | ~30 sec | ~$0.01 |
| 1,000 | ~3 min | ~$0.05 |
| 10,000 | ~20 min | ~$0.40 |

*Costs depend on Apify plan and proxy usage. Estimates based on concurrency=10 without proxies.*

### Limitations

- **JavaScript-only sites**: Some modern SPAs render content entirely in JavaScript. This actor analyzes static HTML + HTTP headers (same as Wappalyzer browser extension's initial scan). Headless browser rendering is not included to keep costs low and speed high.
- **Anti-bot systems**: Most sites work fine with the built-in UA rotation. For heavily protected sites, use Apify residential proxies.
- **Rate limiting**: Some hosting providers may rate-limit rapid requests. If you see many errors, reduce concurrency or add proxies.

# Actor input Schema

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

List of domains to analyze. Enter bare domains without protocol (e.g. shopify.com, amazon.com). URLs with https:// are also accepted and will be normalized automatically.

## `deepScan` (type: `boolean`):

When enabled, also scans /cart and /checkout pages to detect payment processors (Stripe, PayPal, Klarna, etc.). Slightly slower but catches more payment systems.

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

Number of domains to scan in parallel. Higher values are faster but use more memory. Recommended: 5-10 for small lists, 20-50 for large lists.

## `timeout` (type: `integer`):

Maximum time to wait for each domain response. Increase for slow or geo-restricted sites.

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

Optional proxy settings. Use Apify residential proxies for best results with anti-bot protected sites.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "github.com",
    "amazon.com"
  ],
  "deepScan": true,
  "concurrency": 10,
  "timeout": 15
}
```

# 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": [
        "stripe.com",
        "github.com",
        "amazon.com"
    ]
};

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

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

```

## MCP server setup

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