# Website Tech Stack Scraper (`silentflow/website-tech-stack-scraper`) Actor

Detect the full technology stack of any website from a list of domains: frameworks, analytics, CMS, ecommerce, CDN, payments and 6000+ more, with versions. Plus the email provider and DNS provider resolved from live DNS. No login or API key. Export to JSON, CSV or Excel for lead enrichment.

- **URL**: https://apify.com/silentflow/website-tech-stack-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.15 / 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/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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Website Tech Stack Scraper

**Find out what any website is built with, in bulk.** Give it a list of domains and get back the technologies behind each one: CMS, ecommerce platform, analytics, ad pixels, JavaScript frameworks, CDN, hosting, payment providers, live chat, and more. A fast, reliable alternative to BuiltWith and Wappalyzer, with no account or API key required.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/Kb2co1eQFSOItSEa2/records/how-it-works-v1.png)

### ✨ Why teams choose this over other website technology scrapers

- 🎯 **Real per-site detection, not stale directory data.** Every result comes from analyzing the live website right now, so you see the stack as it is today, not a cached snapshot.
- 📚 **Thousands of technologies, with versions.** A library of 6,000+ fingerprints across every major category, and it reports version numbers when the site exposes them.
- 🌐 **Beyond the page: email, DNS and SSL.** It also reads DNS records to reveal the email provider (Google Workspace, Microsoft 365), the DNS provider, and the SaaS a company uses (from domain-verification records), plus the SSL certificate authority, signals a page scrape alone can never see.
- ⚡ **Built for bulk.** Feed it thousands of domains and it works through them in parallel, returning a tidy row per site.
- 🧩 **Rich categories out of the box.** Technologies are grouped into meaningful buckets like Ecommerce, Analytics, Advertising, CDN, Payment, and Live Chat, so you can filter and segment immediately.
- 🔓 **No account, no API key, no credits elsewhere.** Everything runs inside the actor. You only pay for the results you get.
- 💸 **Priced to run at scale.** Pay per result, with no monthly commitment.
- 🛠️ **Clean, predictable output.** One flat record per domain, ready for a spreadsheet, a CRM, or a data pipeline.

### 🎯 What you can do with website technology data

| Team | What they build |
| --- | --- |
| Sales | Lead lists filtered by the exact platforms a prospect uses, so outreach lands on the right accounts |
| Marketing | Market share reports on ecommerce platforms, analytics tools, or ad pixels across a segment |
| Competitive intelligence | A live map of which technologies competitors and their customers adopt |
| Agencies | Instant tech audits of prospects before a pitch, and monitoring of client sites over time |
| Investors | Signal on technology adoption across a portfolio or a target market |
| Recruiters | Company shortlists built from the frameworks and languages a site runs |

### 📥 Input parameters

| Field | Type | Description |
| --- | --- | --- |
| `startDomains` | array | One or more domains or website URLs to analyze (for example `shopify.com`). URLs are accepted, the host is extracted automatically. |
| `maxItems` | integer | The maximum number of domains to analyze in this run. Default 100. |

Example input:

```json
{
  "startDomains": ["shopify.com", "stripe.com", "nike.com"],
  "maxItems": 100
}
````

### 📊 Output data

One record per domain. Example:

```json
{
  "domain": "shopify.com",
  "url": "https://www.shopify.com/",
  "statusCode": 200,
  "title": "Shopify: The All-in-One Commerce Platform",
  "technologyCount": 5,
  "technologies": [
    { "name": "Shopify", "categories": ["Ecommerce"], "website": "https://www.shopify.com", "confidence": 100 },
    { "name": "Cloudflare", "categories": ["CDN"], "website": "https://www.cloudflare.com", "confidence": 100 },
    { "name": "Google Analytics 4", "categories": ["Analytics"], "website": "https://marketingplatform.google.com", "confidence": 80 },
    { "name": "PayPal", "categories": ["Payment"], "website": "https://www.paypal.com", "confidence": 80 }
  ],
  "categoriesSummary": { "Ecommerce": 1, "CDN": 1, "Analytics": 1, "Payment": 1 },
  "emailProvider": "Google Workspace",
  "dnsProvider": "Cloudflare",
  "scrapedAt": "2026-07-04T19:12:36Z"
}
```

### 🗂️ Data fields

| Field | Description |
| --- | --- |
| `domain` | The domain you requested |
| `url` | The final URL analyzed after redirects |
| `statusCode` | HTTP status returned by the website |
| `title` | The website's page title |
| `technologyCount` | Number of technologies detected |
| `emailProvider` | Detected email host (from DNS), e.g. Google Workspace |
| `dnsProvider` | Detected DNS provider (from DNS), e.g. Cloudflare |
| `technologies` | List of detected technologies |
| `technologies[].name` | Technology name (for example WordPress, Stripe, React) |
| `technologies[].categories` | One or more categories for the technology |
| `technologies[].website` | Official website of the technology vendor |
| `technologies[].version` | Version number when the site exposes one |
| `technologies[].confidence` | Signal strength from 0 to 100 |
| `categoriesSummary` | Count of detected technologies per category |
| `scrapedAt` | Timestamp of the analysis |

### 🚀 Examples

**Audit a list of prospects**

```json
{ "startDomains": ["acme.com", "globex.com", "initech.com"], "maxItems": 500 }
```

**Check a single site**

```json
{ "startDomains": ["example.com"], "maxItems": 1 }
```

### 💻 Integrations

Results are available as JSON, CSV, or Excel from the dataset, and through the Apify API. Connect the output to Google Sheets, Airtable, a CRM, or any data warehouse using Apify integrations and webhooks.

### 📈 Performance

The scraper analyzes many domains in parallel, so large lists complete quickly. A run of a few hundred domains typically finishes in a couple of minutes.

### 💡 Tips for best results

- Pass clean domains such as `example.com`. Full URLs work too, the host is extracted for you.
- Use `maxItems` to keep runs scoped and predictable when testing.
- Some technologies only appear on specific pages. The homepage is analyzed by default, which covers the vast majority of stacks.
- De-duplicate your input list to avoid paying for the same domain twice.

### ❓ FAQ

**Which technologies can it detect?**
A library of 6,000+ fingerprints across CMS, ecommerce, analytics, monitoring, tag managers, advertising, JavaScript frameworks and libraries, UI frameworks, web servers, programming languages, hosting and CDN, bot management, payment providers, marketing and CRM tools, live chat, A/B testing, cookie consent, fonts, video, search, reviews, and accessibility.

**Do I need a BuiltWith or Wappalyzer account?**
No. Everything runs inside the actor.

**How fresh is the data?**
It reflects the website at the moment of the run, not a cached directory.

**Do you detect email and DNS providers?**
Yes. The scraper reads MX, NS and TXT records to identify the email host, the DNS provider, the SSL certificate authority, and SaaS tools that publish domain-verification records.

**What does confidence mean?**
A score from 0 to 100 indicating how strong the detection signal is. Matches from response headers and cookies score highest.

### 📬 Support

Have a technology you would like added to the detection library, or a question about a result? Reach out through the actor's Apify page and we will help.

***

Detection is powered in part by the open-source Wappalyzer fingerprint database (via projectdiscovery/wappalyzergo, MIT licensed).

# Actor input Schema

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

Domains or website URLs to analyze (e.g. shopify.com). URLs are accepted too, the host is extracted automatically.

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

The maximum number of domains to analyze in this run.

## `debugMode` (type: `boolean`):

Activate to see detailed logs.

## Actor input object example

```json
{
  "startDomains": [
    "shopify.com"
  ],
  "maxItems": 100,
  "debugMode": false
}
```

# Actor output Schema

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

One record per domain: domain, url, statusCode, title, technologyCount, technologies (name, categories, website, confidence), categoriesSummary, scrapedAt.

# 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"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/website-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"],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/website-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"
  ],
  "maxItems": 100
}' |
apify call silentflow/website-tech-stack-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Tech Stack Scraper",
        "description": "Detect the full technology stack of any website from a list of domains: frameworks, analytics, CMS, ecommerce, CDN, payments and 6000+ more, with versions. Plus the email provider and DNS provider resolved from live DNS. No login or API key. Export to JSON, CSV or Excel for lead enrichment.",
        "version": "1.0",
        "x-build-id": "kmKhXhBZ8vKCuSk9e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~website-tech-stack-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-website-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/silentflow~website-tech-stack-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-website-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/silentflow~website-tech-stack-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-website-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 website URLs to analyze (e.g. shopify.com). URLs are accepted too, the host is extracted automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum number of domains",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "The maximum number of domains to analyze in this run.",
                        "default": 100
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Activate to see detailed logs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
