# Technology Stack Detector – BuiltWith / Wappalyzer Alternative (`footage/stack-searcher`) Actor

Detects technology stacks from websites using Wappalyzer patterns. Analyzes HTML, headers, cookies, DNS records, and robots.txt to identify frameworks, CMS, analytics, hosting providers, and more.

- **URL**: https://apify.com/footage/stack-searcher.md
- **Developed by:** [.](https://apify.com/footage) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$6.00 / 1,000 domain analyzeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Technology Stack Detector – BuiltWith / Wappalyzer Alternative

Detect what technologies power any website. Identify 7,600+ frameworks, CMS platforms, analytics tools, hosting providers, payment processors, and more from any URL.

**Perfect for:** Competitive research, lead generation, security audits, market analysis, and sales intelligence.

### 🚀 Why Choose This Over BuiltWith or Wappalyzer?

| Feature | This Actor | BuiltWith Pro | Wappalyzer Pro |
|---------|-----------|---------------|----------------|
| **Pricing** | $0.006 per domain | $295-$995/month | $250-$850/month |
| **Volume** | Unlimited | 5,000-50,000/month | 5,000-50,000/month |
| **API Access** | ✅ Full API | ✅ Yes | ✅ Yes |
| **Technology Database** | 7,600+ (merged from all maintained Wappalyzer forks) | 65,000+ | 7,500+ |
| **No Monthly Commitment** | ✅ Yes | ❌ Annual only | ❌ Monthly plans |
| **Version Detection** | ✅ Yes | ✅ Yes | ✅ Yes |
| **Custom Integration** | ✅ Apify ecosystem | Limited | Limited |

**Cost Example:** Analyze 10,000 websites = $60 (vs. $295-995/month for competitors)

### 📊 Example Output

```json
{
  "url": "https://stripe.com/",
  "statusCode": 200,
  "technologies": [
    {
      "name": "React",
      "categories": ["JavaScript frameworks"],
      "confidence": 100,
      "version": "18.2.0"
    },
    {
      "name": "Next.js",
      "categories": ["Web frameworks"],
      "confidence": 100,
      "version": "13.4.0"
    },
    {
      "name": "Cloudflare",
      "categories": ["CDN", "Security"],
      "confidence": 100
    },
    {
      "name": "Google Analytics",
      "categories": ["Analytics"],
      "confidence": 95
    },
    {
      "name": "Webpack",
      "categories": ["Build tools"],
      "confidence": 90
    }
  ],
  "detectionSources": {
    "html": true,
    "headers": true,
    "cookies": true,
    "dns": true,
    "robots": false
  }
}
```

### 🎯 What Technologies Can Be Detected?

**7,600+ technologies across 109 categories:**

- **CMS & Ecommerce:** WordPress, Shopify, WooCommerce, Magento, Drupal, Wix
- **JavaScript Frameworks:** React, Vue, Angular, Next.js, Nuxt, Svelte
- **Web Frameworks:** Django, Ruby on Rails, Laravel, Express, FastAPI
- **Analytics & Marketing:** Google Analytics, HubSpot, Mixpanel, Segment
- **CDN & Hosting:** Cloudflare, AWS, Vercel, Netlify, Azure
- **Payment Processors:** Stripe, PayPal, Square, Braintree
- **And much more:** Databases, security tools, A/B testing, live chat, etc.

#### How detection works

The Actor matches fingerprints across multiple independent signals: HTML content, `<script src>` URLs, meta tags, DOM selectors, HTTP response headers, cookies, DNS records (TXT/MX/NS), and robots.txt. Detected technologies also imply their dependencies (e.g. WordPress implies PHP and MySQL), and version numbers are extracted where fingerprints support it.

The fingerprint database is merged from all actively maintained open-source Wappalyzer lineages ([enthec/webappanalyzer](https://github.com/enthec/webappanalyzer), [HTTPArchive/wappalyzer](https://github.com/HTTPArchive/wappalyzer), [Lissy93/wapalyzer](https://github.com/Lissy93/wapalyzer), [dochne/wappalyzer](https://github.com/dochne/wappalyzer)), bundled with the Actor for reliability, and automatically refreshed from upstream every 24 hours.

### 🔧 Quick Start

#### Basic Usage (Apify Console)

1. Click "Try for free"
2. The input is prefilled with `https://stripe.com` – just click "Start"
3. View results in the dataset

#### Configuration Options

```json
{
  "startUrls": [
    { "url": "https://example.com/" }
  ],
  "minConfidence": 20,
  "maxConcurrency": 20
}
```

| Parameter | Default | Description |
|-----------|---------|-------------|
| `startUrls` | `[{ "url": "https://stripe.com/" }]` | URLs to analyze |
| `minConfidence` | `0` | Filter by confidence (0-100). Use 20+ to drop weak partial matches |
| `maxConcurrency` | `20` | Parallel processing (higher = faster) |
| `requestTimeoutSecs` | `30` | Timeout per request |
| `maxRequestsPerCrawl` | `1000` | Max URLs to process |
| `proxyConfiguration` | `{ "useApifyProxy": false }` | Enable for high-volume runs |

### 💻 API Integration Examples

#### cURL

```bash
## Start a run
curl -X POST https://api.apify.com/v2/acts/footage~stack-searcher/runs \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      { "url": "https://stripe.com/" },
      { "url": "https://shopify.com/" }
    ],
    "minConfidence": 20
  }'

## Get results
curl "https://api.apify.com/v2/acts/footage~stack-searcher/runs/last/dataset/items?token=YOUR_API_TOKEN"
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

## Start the Actor
run = client.actor('footage/stack-searcher').call(run_input={
    'startUrls': [
        { 'url': 'https://stripe.com/' },
        { 'url': 'https://shopify.com/' },
    ],
    'minConfidence': 20,
})

## Fetch results
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(f"{item['url']}: {len(item['technologies'])} technologies found")
    for tech in item['technologies']:
        print(f"  - {tech['name']} ({tech['confidence']}%)")
```

#### JavaScript/Node.js

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

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

// Start the Actor
const run = await client.actor('footage/stack-searcher').call({
    startUrls: [
        { url: 'https://stripe.com/' },
        { url: 'https://shopify.com/' },
    ],
    minConfidence: 20,
});

// Fetch results
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.url}: ${item.technologies.length} technologies`);
    item.technologies.forEach(tech => {
        console.log(`  - ${tech.name} (${tech.confidence}%)`);
    });
});
```

#### n8n Integration

1. Add **HTTP Request** node
2. Set method to **POST**
3. URL: `https://api.apify.com/v2/acts/footage~stack-searcher/runs?token=YOUR_API_TOKEN`
4. Body (JSON):

```json
{
  "startUrls": [{ "url": "{{ $json.website }}" }],
  "minConfidence": 20
}
```

5. Add **Wait** node (30 seconds)
6. Add **HTTP Request** node to fetch results:
   - URL: `https://api.apify.com/v2/acts/footage~stack-searcher/runs/last/dataset/items?token=YOUR_API_TOKEN`

### 📈 Use Cases

#### 🎯 Sales & Lead Generation

Find companies using specific technologies to target your outreach:

```json
{
  "startUrls": [
    { "url": "https://competitor1.com/" },
    { "url": "https://competitor2.com/" }
  ],
  "minConfidence": 20
}
```

*Filter results for "WordPress" or "Shopify" to find potential customers*

#### 🔍 Competitive Intelligence

Research competitor technology stacks:

- What frameworks do they use?
- What analytics tools track their users?
- Which CDN/hosting provider do they use?

#### 🔒 Security Audits

Identify outdated software versions across your organization's websites:

```json
{
  "startUrls": [
    { "url": "https://subdomain1.yourcompany.com/" },
    { "url": "https://subdomain2.yourcompany.com/" }
  ],
  "minConfidence": 50
}
```

#### 📊 Market Research

Track technology adoption trends:

- Analyze 1000+ websites in your industry
- Export to CSV for analysis in Excel/Google Sheets
- Identify rising and declining technologies

### 💡 Pro Tips

✅ **Set `minConfidence: 20`** to drop weak partial matches (or `50` for multi-signal precision)\
✅ **Enable Apify Proxy** for high-volume runs (100+ URLs) to avoid rate limiting\
✅ **Export to CSV/Excel** for easy analysis and sharing\
✅ **Schedule recurring runs** to monitor technology changes over time\
✅ **Use webhooks** to integrate results into your workflow automatically

### 🎚️ Understanding Confidence Scores

Confidence reflects how many independent detection channels confirmed a technology (each channel counts once — HTML, script sources, meta tags, DOM, headers, cookies, URL, DNS, robots.txt):

| Score | Meaning | Recommendation |
|-------|---------|----------------|
| 50-100 | Multiple independent signals | Highly reliable |
| 20-49 | One solid signal (e.g. a header or script URL) | Generally accurate |
| Below 20 | Weak or partial signal | Use with caution |

**Recommendation:** The default (`minConfidence: 0`) is suitable for most uses. Set `minConfidence: 20` to drop weak partial matches, or `50` for high-precision mode requiring multiple confirming signals.

DNS-only detections (email providers, SaaS domain-verification tokens) are reported separately in the `dnsSignals` field — they show what services an organization uses, not what powers the website.

### ⚡ Performance

- **Speed:** 5-10 websites per second
- **Concurrency:** Adjust with `maxConcurrency` (default: 20)
- **Cost:** $0.006 per domain analyzed
- **Scale:** Handles 1,000s of URLs in a single run

### 🆚 Detailed Comparison

#### vs. BuiltWith

- **Pricing:** BuiltWith starts at $295/month. This Actor costs $0.006/domain with no monthly minimum
- **Database:** BuiltWith has 65k+ technologies. This Actor covers 7,600+ actively maintained fingerprints
- **Best for:** One-off analysis or variable volume (vs. BuiltWith for enterprise historical data)

#### vs. Wappalyzer

- **Pricing:** Wappalyzer starts at $250/month. This Actor has no monthly fee at $0.006/domain
- **Technology:** This Actor merges all maintained open-source Wappalyzer fork databases
- **Best for:** API integration and cost control (vs. Wappalyzer browser extension convenience)

#### vs. Manual Research

- **Time:** Analyze 100 sites in minutes vs. hours of manual work
- **Accuracy:** Automated pattern matching vs. human error
- **Scale:** Handle 1,000s of URLs easily

### 🔗 Integration Ecosystem

This Actor works seamlessly with:

- **Apify Scrapers:** Combine with Website Content Crawler for deeper analysis
- **Zapier:** Connect to 5,000+ apps
- **Make (Integromat):** Advanced workflow automation
- **n8n:** Self-hosted automation
- **Google Sheets:** Direct export
- **Slack/Discord:** Real-time notifications

### 📚 Resources

- [Apify API Documentation](https://docs.apify.com/api/v2)
- [Fingerprint Database (enthec/webappanalyzer)](https://github.com/enthec/webappanalyzer)
- [Integration Examples](https://docs.apify.com/api/client)

### 💰 Pricing

Simple, transparent pricing with no monthly commitment:

- **$0.006 per domain analyzed**
- **No monthly fees:** Pay only for what you use
- **Free tier:** $5 monthly credit on free plan (analyze ~833 domains free)
- **Volume discounts:** Available for enterprise

**Example costs:**

- 100 websites: $0.60
- 1,000 websites: $6
- 10,000 websites: $60
- 100,000 websites: $600

Compare to BuiltWith ($295-995/month) or Wappalyzer ($250-850/month) with usage limits.

### 🆘 Support

Questions? Issues?

- Check [Apify Documentation](https://docs.apify.com/)
- Contact through Apify Console
- Review [API Reference](https://docs.apify.com/api/v2)

***

**Start detecting technology stacks today** – Click "Try for free" above!

# Actor input Schema

## `startUrls` (type: `array`):

List of URLs to analyze for technology stack detection

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

Maximum number of pages to process concurrently

## `minConfidence` (type: `integer`):

Filter out technology detections below this confidence threshold (0-100)

## `requestTimeoutSecs` (type: `integer`):

Timeout for each HTTP request in seconds

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of pages to process in total

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

Proxy settings for requests

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://stripe.com/"
    }
  ],
  "maxConcurrency": 20,
  "minConfidence": 0,
  "requestTimeoutSecs": 30,
  "maxRequestsPerCrawl": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Technology stack detections with confidence scores

# 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 = {
    "startUrls": [
        {
            "url": "https://stripe.com/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("footage/stack-searcher").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 = { "startUrls": [{ "url": "https://stripe.com/" }] }

# Run the Actor and wait for it to finish
run = client.actor("footage/stack-searcher").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 '{
  "startUrls": [
    {
      "url": "https://stripe.com/"
    }
  ]
}' |
apify call footage/stack-searcher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,footage/stack-searcher"
        }
    }
}

```

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/D6IY80FfmAmZAGSx0/builds/Fd1PatjYcqaAlQHAn/openapi.json