# Website Tech-Stack Detector — Find Any Site's Technologies (`bovi/builtwith-tech-stack-scraper`) Actor

Detect the technology stack of any domain: ecommerce platform, CMS, JS framework, analytics, ad pixels, CDN, payments, marketing & support tools. Live detection with confidence scores. No API key. Pay per domain.

- **URL**: https://apify.com/bovi/builtwith-tech-stack-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.45 / 1,000 domain-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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

**Find out exactly what technology stack any website runs — ecommerce platform, CMS, JavaScript framework, analytics, ad pixels, CDN, payments, marketing automation, and more — with live detection, per-technology confidence scores, and zero API keys required.**

### Features

- **Live detection, not a cached database.** The actor visits the target domain right now and fingerprints what is actually deployed today — not what a commercial directory last indexed weeks or months ago.
- **Confidence score per technology.** Every technology in the output carries a `confidence` value (0–1) derived from the signal type that matched. Headers and cookies are high-confidence; inline HTML body matches are lower.
- **Evidence field.** Each detected technology tells you *which signal fired*: `header`, `cookie`, `meta`, `scriptSrc`, `js`, or `html`. No other public tech-lookup tool exposes this.
- **No API key.** No BuiltWith.com subscription, no Wappalyzer API token, no external credentials of any kind. Just paste in domains and run.
- **Runs on a residential proxy for reliable access.** Every request exits through a residential IP, so rate limits and lightweight bot-mitigation on the target site do not block the actor.
- **Flexible domain input.** Pass bare domains (`shopify.com`), full URLs (`https://www.example.com/path`), or a mix — the actor normalises everything automatically and de-duplicates.
- **Scales to 10,000 domains per run.** Process a single domain or a bulk list in one job.
- **Pay-per-result, not per-run.** You are charged only for domains that return a record — failed fetches are not billed.

### What data you get

One JSON record is returned per domain. All nine top-level fields are populated on every successful fetch.

| Field | Type | Description |
|---|---|---|
| `domain` | string | Normalised domain (no `www.`, no protocol) |
| `url` | string | URL requested |
| `final_url` | string | Final URL after any redirects |
| `status_code` | integer | HTTP status code received |
| `techs` | array | Detected technologies (see sub-fields below) |
| `tech_count` | integer | Total number of technologies detected |
| `categories` | array | Union of all category labels across detected technologies |
| `parse_confidence` | float | Average confidence across all detected technologies (0–1) |
| `scraped_at` | string | ISO-8601 UTC timestamp of the run |

#### techs[] sub-fields

Each object inside `techs` describes one detected technology:

| Field | Type | Description |
|---|---|---|
| `name` | string | Display name (e.g. `"Shopify"`, `"Google Analytics 4"`) |
| `tag` | string | Primary category tag (e.g. `"Ecommerce"`, `"Analytics"`) |
| `categories` | array | Full list of category labels for this technology |
| `link` | string | Reference URL for this technology |
| `confidence` | float | Detection confidence for this specific technology (0–1) |
| `evidence` | string | Signal type that matched: `header`, `cookie`, `meta`, `scriptSrc`, `js`, or `html` |

The `evidence` field is particularly useful for verifying detections programmatically. A `header`-based match (confidence ≥ 0.95) is extremely reliable; an `html`-based match (confidence 0.72) means a body pattern matched and may warrant a manual check.

### Input

```json
{
  "startDomains": [
    "shopify.com",
    "wordpress.org",
    "stripe.com"
  ],
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

- **`startDomains`** (required): List of domains or URLs to analyse.
- **`maxItems`** (optional, default `0`): Cap the number of domains processed. `0` means no cap.
- **`proxyConfiguration`** (optional): Defaults to Apify RESIDENTIAL — the recommended setting for reliable access to most target sites.

### Pricing

**Pay-per-result.** The charge event is `domain-result` — one charge per domain record delivered to the dataset. The price is **$0.0015 per domain** (roughly $1.50 per 1,000 domains), which is approximately 25% less than the comparable pay-per-result competitor.

You are never charged for domains that fail to fetch or return an error.

### FAQ

**Do I need an API key or any external account?**

No. The actor uses Apify's built-in residential proxy, which is included in your Apify platform usage. There is no BuiltWith.com API key, no Wappalyzer subscription, no external proxy account, and no external credentials of any kind required. Simply run the actor.

**How is this different from BuiltWith.com?**

BuiltWith.com queries a pre-built database of technology signatures collected in the past. That database is large — covering tens of thousands of technologies — but the data can be days, weeks, or even months old. Our actor fetches the target domain *right now* and detects what is actually live today. We also expose a `confidence` score and an `evidence` field for every technology row, which BuiltWith's export does not provide.

The honest trade-off: our in-house ruleset covers approximately 89 high-precision technology signatures, which is narrower than a giant commercial database. If you need raw breadth across thousands of obscure technologies, a commercial subscription may be a better fit. If you need **freshness** (what the site runs today), **confidence scores** (how certain is the detection), **evidence transparency** (which signal fired), and **price** ($0 setup + pay-per-result), this actor wins.

**What technologies does the detector cover?**

The ruleset focuses on the technologies buyers most commonly care about for lead generation and competitive intelligence: ecommerce platforms (Shopify, WooCommerce, Magento, BigCommerce, Salesforce Commerce Cloud, PrestaShop, and more), CMS (WordPress, Drupal, Joomla, Webflow, Squarespace, Wix), JavaScript frameworks (React, Vue, Angular, Next.js, Nuxt), analytics (Google Analytics 4, Segment, Mixpanel, Heap), ad pixels (Meta Pixel, TikTok Pixel, Google Ads), CDN providers, payment processors (Stripe, Braintree, PayPal), marketing automation (HubSpot, Mailchimp, Klaviyo), live chat and support tools, web servers, and font services.

**What happens if a domain is unreachable or returns an error?**

The record is still written to the dataset with a populated `error` field (e.g. `fetch_failed`, `access_challenge`) and `status_code` if available — so you get a full picture of your domain list. You are **not charged** for records where the fetch failed entirely.

### Use cases

**Lead generation and sales prospecting.** Feed a list of company domains from a CRM or prospecting tool, filter for `techs[].name == "Shopify"` or `categories` containing `"Ecommerce"`, and build a segmented outreach list in minutes. Identify which prospects run legacy Magento and are ripe for a migration pitch.

**Competitive intelligence.** Monitor a set of competitor domains on a schedule to detect when a rival switches CDN, adopts a new marketing automation platform, adds a live chat widget, or migrates their ecommerce stack. The `scraped_at` timestamp makes change-detection trivial when you diff two runs.

**Technology-stack analytics.** Analyse the tech distribution across an industry vertical. Which analytics tools dominate fintech startups? What CMS is most common among D2C brands above $10M revenue? Combine this actor with a company-list scraper to answer those questions at scale without a BuiltWith Enterprise subscription.

# Actor input Schema

## `startDomains` (type: `array`):

Domains or URLs to analyse, e.g. "shopify.com" or "https://www.example.com". One technology-stack row is returned per domain.

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

Optional cap on how many domains to process (0 = no cap).

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

Proxy used to reach the target sites. A residential exit is recommended for reliable access; it defaults to Apify RESIDENTIAL.

## Actor input object example

```json
{
  "startDomains": [
    "shopify.com",
    "wordpress.org"
  ],
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of detected tech-stack records, one per domain.

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

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/builtwith-tech-stack-scraper").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 = { "startDomains": [
        "shopify.com",
        "wordpress.org",
        "stripe.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("bovi/builtwith-tech-stack-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startDomains": [
    "shopify.com",
    "wordpress.org",
    "stripe.com"
  ]
}' |
apify call bovi/builtwith-tech-stack-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bovi/builtwith-tech-stack-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Tech-Stack Detector — Find Any Site's Technologies",
        "description": "Detect the technology stack of any domain: ecommerce platform, CMS, JS framework, analytics, ad pixels, CDN, payments, marketing & support tools. Live detection with confidence scores. No API key. Pay per domain.",
        "version": "0.1",
        "x-build-id": "dTdzZl2u39fAW3M0z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~builtwith-tech-stack-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-builtwith-tech-stack-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/bovi~builtwith-tech-stack-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-builtwith-tech-stack-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/bovi~builtwith-tech-stack-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-builtwith-tech-stack-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startDomains"
                ],
                "properties": {
                    "startDomains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "Domains or URLs to analyse, e.g. \"shopify.com\" or \"https://www.example.com\". One technology-stack row is returned per domain.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max domains",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional cap on how many domains to process (0 = no cap).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach the target sites. A residential exit is recommended for reliable access; it defaults to Apify RESIDENTIAL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```