# Website Tech Stack Detector - CMS, Analytics, Frameworks, CDN (`kadi_bence/tech-stack-detector`) Actor

Detect the technology stack of websites (Wappalyzer/BuiltWith alternative). Input: URLs or domains; optional category filter. Returns per site: CMS, ecommerce, analytics, frameworks, CDN, server and payment processors with versions and confidence, from 7,600+ fingerprints. No API key.

- **URL**: https://apify.com/kadi_bence/tech-stack-detector.md
- **Developed by:** [Bence Kadi](https://apify.com/kadi_bence) (community)
- **Categories:** Lead generation, Developer tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 site analyseds

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?

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 Tech Stack Detector: Wappalyzer & BuiltWith alternative

Find out **what any list of websites is built with**: CMS, ecommerce platform, analytics and marketing tags, JavaScript framework, CDN, hosting, web server, payment providers and more. One clean row per website, with **versions** and a **confidence score** for each technology, for **$1.50 per 1,000 websites**.

### 🔎 What is Website Tech Stack Detector?

It checks **7,600+ technology fingerprints** (the open-source Wappalyzer-format database, not the 50-250 that many cheap detectors know) against each site's live HTML, headers, cookies, script URLs, meta tags and CSS selectors. It adds its own rules for modern frameworks (Next.js app router, Nuxt, Astro, Remix, SvelteKit). Plain HTTP, no browser, no API key. Sites that fail or show no technology are listed with the reason and **not charged**.

#### 🎯 Use cases

- **Agencies (prospect qualification):** check prospect websites before you pitch. Find WooCommerce or Shopify shops, sites without analytics, or sites on an outdated CMS version.
- **Sales teams (lead lists by technology):** filter thousands of domains down to **Shopify stores** or **HubSpot / Klaviyo users**, and add CMS, ecommerce and marketing tools to CRM accounts before outreach.
- **Competitor research:** see what competitors use for analytics, A/B testing, payments, live chat and hosting. Re-run on a schedule to spot switches.
- **Developers and security teams (version tracking):** list exposed versions like `WordPress 7.2`, `jQuery 3.6.0` or `Angular 22.2.1` and find outdated software across client sites.
- **Market research:** measure technology adoption across a niche. The run summary lists the 25 most common technologies.

#### 📊 Output fields

| Field | Description | Example |
|---|---|---|
| `url` | Website as analysed | `https://www.allbirds.com/` |
| `domain` | Domain without `www.` | `allbirds.com` |
| `finalUrl` | URL after redirects (null if not fetched) | `https://www.allbirds.com/` |
| `status` | HTTP status, or null | `200` |
| `error` | Why the site failed, null on success | `Domain not found (DNS lookup failed)` |
| `title` | Page title | `Allbirds: Comfortable, Sustainable Shoes & Apparel` |
| `description` | Meta description | `Allbirds: The world's most comfortable shoes...` |
| `language` | Page language | `en-US` |
| `technologyCount` | Number of technologies found | `10` |
| `technologyNames` | All technology names | `["Shopify", "PayPal", ...]` |
| `technologies` | `name`, `categories`, `version`, `confidence` (0-100), `website`, optional `evidence` | see Output |
| `cms` | CMS, blogs, page builders | `["WordPress"]` |
| `ecommerce` | Ecommerce platforms | `["Shopify"]` |
| `analytics` | Analytics | `["Leadfeeder"]` |
| `cdn` | CDNs | `["Cloudflare"]` |
| `framework` | JavaScript and web frameworks | `["Next.js", "React"]` |
| `server` | Web servers, reverse proxies | `["Nginx"]` |
| `paymentProcessors` | Payments, buy now pay later | `["Apple Pay", "PayPal"]` |
| `hosting` | PaaS, IaaS, hosting | `["Vercel"]` |
| `tagManagers` | Tag managers | `["Google Tag Manager"]` |
| `marketingAutomation` | Marketing automation, email | `["HubSpot"]` |
| `advertising` | Advertising, retargeting | `[]` |
| `liveChat` | Live chat | `[]` |
| `programmingLanguages` | Server-side languages | `["PHP"]` |
| `pagesAnalyzed` | Pages analysed for this site | `1` |
| `scrapedAt` | Time of analysis (UTC) | `2026-10-05T00:56:25Z` |

**Use cases:** Analyze SEO & marketing (extract website metadata & tech stacks) · Generate leads (lead enrichment & validation, build B2B prospect lists) · Research markets & competitors (track competitors, profile companies & due diligence).

### 🚀 How to use it

1. Open [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) and click **Try for free**.
2. Enter your **websites** as a list, e.g. `["allbirds.com", "wordpress.org"]`, or as one text value with one site per line (a whole CSV column works).
3. Optional: pick **Only these categories**, more **Pages per website**, or **Include evidence**.
4. Click **Start**. The prefilled example (5 sites) finishes in about 10 seconds.
5. Download CSV, Excel or JSON, or use the API, Google Sheets, Make, Zapier or n8n.

### 🔧 Input guide

**Websites (`urls`)** - required. A list of domains (`example.com`) or full URLs (`https://example.com/shop`), or a single string (`"stripe.com"`, or several sites separated by commas or new lines).

- ✅ Good: `allbirds.com`, `www.bbc.com`, `https://vercel.com`
- ❌ Bad: `localhost`, `192.168.1.10`, `ftp://example.com` (private addresses and other schemes are rejected)
- `https://` is added when missing, with fallback to `www.` (if DNS fails) and `http://` (if HTTPS fails). URLs with a scheme are used as written.
- Lines are also split on spaces, commas and semicolons; `#` lines are ignored; duplicates (`www.` or not) are skipped. Invalid lines go to `invalidInputs` in the run summary.
- Max **100,000 websites per run**; extra lines are ignored.
- Via API you can also use the field names `url`, `startUrls` (strings or `{"url": ...}` objects), `domains`, `domain`, `websites` or `website`: they are merged with `urls` and de-duplicated. With no website in any of them, the run fails with a status message naming these fields.

**Pages per website (`maxPagesPerSite`)** - `1` (default) = only your URL. `2`-`10` = also same-site pages linked from it, preferring pricing, plans, product, shop, features and blog pages, one per section. Login, admin, account, search and file links are skipped. Use 3-5 for tools that load only on inner pages; keep 1 for a quick CMS check of big lists. You still pay once per website.

**Only these categories (`onlyCategories`)** - return only matching technologies. Leave empty for all 100+ categories.

- ✅ Shopify lead list: `["Ecommerce"]`, then filter rows where `ecommerce` contains `Shopify`.
- ✅ Marketing stack: `["Analytics", "Tag managers", "Marketing automation", "Advertising", "Live chat"]`.
- ⚠️ Via API, names must match the form list (case-insensitive); an unknown name fails the run with `Invalid input: Unknown categories: ...`. Sites with nothing in your categories are not charged.

**Include versions (`includeVersions`)** - on by default; adds versions when exposed, e.g. `WordPress 7.2`.

**Include evidence (`includeEvidence`)** - off by default; adds up to 5 strings per technology showing what matched, e.g. `scriptSrc: https://cdn.shopify.com/...`. Bigger dataset.

**Minimum confidence (`minConfidence`)** - hide detections below this score (0-100, default 0). Most score 100; weak signals (a generic script name, a domain seen only in a Content-Security-Policy header) score lower. Try `75` for a stricter list.

**Parallel websites (`maxConcurrency`)** - 1-50, default 10. robots.txt and crawl-delay (capped at 30 s) are still respected per site.

**Request timeout (`requestTimeoutSecs`)** - 5-60 s, default 20. 429/5xx answers get one retry. Pages are read up to 3 MB; non-HTML files are not downloaded.

**Proxy (`proxyConfiguration`)** - off by default. If many sites answer 403, try **Apify Proxy (datacenter)**. Residential proxies are not supported (the run fails with "Invalid input").

```json
{
  "urls": ["https://apify.com", "wordpress.org", "www.allbirds.com", "vercel.com", "www.bbc.com"],
  "maxPagesPerSite": 1,
  "onlyCategories": ["CMS", "Ecommerce", "Analytics"],
  "includeVersions": true,
  "includeEvidence": false,
  "minConfidence": 0,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### 📦 Output

A real row from a run on 2026-10-05 (prefilled input, technologies list shortened):

```json
{
  "url": "https://www.allbirds.com/",
  "domain": "allbirds.com",
  "finalUrl": "https://www.allbirds.com/",
  "status": 200,
  "error": null,
  "title": "Allbirds: Comfortable, Sustainable Shoes & Apparel",
  "description": "Allbirds: The world’s most comfortable shoes, flats, and clothing ... (shortened)",
  "language": "en-US",
  "technologyCount": 10,
  "technologyNames": ["Shopify", "Apple Pay", "PayPal", "Cloudflare", "Google Tag Manager",
                      "HSTS", "Priority Hints", "Swiper", "HTTP/3", "Open Graph"],
  "technologies": [
    { "name": "Shopify", "categories": ["Ecommerce"], "version": null, "confidence": 100, "website": "https://shopify.com" },
    { "name": "PayPal", "categories": ["Payment processors"], "version": null, "confidence": 100, "website": "https://paypal.com" },
    { "name": "Cloudflare", "categories": ["CDN"], "version": null, "confidence": 100, "website": "https://www.cloudflare.com" }
  ],
  "cms": [],
  "ecommerce": ["Shopify"],
  "analytics": [],
  "cdn": ["Cloudflare"],
  "framework": [],
  "server": [],
  "paymentProcessors": ["Apple Pay", "PayPal"],
  "hosting": [],
  "tagManagers": ["Google Tag Manager"],
  "marketingAutomation": [],
  "advertising": [],
  "liveChat": [],
  "programmingLanguages": [],
  "pagesAnalyzed": 1,
  "scrapedAt": "2026-10-05T00:56:25Z"
}
```

**Failed sites** are still listed with `status` and `error`, and are **free**. Examples: `HTTP 403 - the site blocks automated requests (try a proxy)`, `Bot protection challenge (HTTP 202) - try again later or with a proxy`, `robots.txt of this site does not allow automated access to this page (or could not be read) - skipped`, `Domain not found (DNS lookup failed)`, `Timed out`, `Not an HTML page (...)`.

**Dataset views** in Apify Console:

- **Tech stack overview:** CMS, ecommerce, analytics, framework, CDN, server, payments, count
- **All technologies:** every technology name per site
- **Marketing stack:** analytics, tag managers, marketing / email, advertising, live chat, payments
- **Infrastructure:** final URL, server, CDN, hosting, languages, framework, site language
- **Status and errors:** HTTP status, error, final URL, time

**Run summary:** the `RUN_SUMMARY` record in the key-value store has `sitesRequested`, `sitesAnalysed`, `sitesWithoutTechnologies`, `sitesFailed`, `errors` by type, `invalidInputs`, `duplicatesSkipped`, `pagesFetched`, `chargeLimitReached`, `sitesNotProcessed`, the 25 `topTechnologies`, `durationSecs` and the fingerprint database version.

**Export:** JSON, CSV, Excel, XML, RSS or HTML table from the Storage tab, or via API (`/v2/datasets/{datasetId}/items?format=csv&view=overview`).

### 💵 Pricing: $1.50 per 1,000 websites

One pay-per-event event, `site` ($0.0015): charged **once per website that was analysed and has at least one detected technology**, plus Apify's $0.00005 per-run start fee. Platform compute is included. Pages per website don't change the price. Other full-database detectors on the Store charge $5-100 per 1,000.

**Free:** failed, blocked, robots.txt-disallowed, non-HTML and empty sites, invalid lines and duplicates.

| Run | Charged websites | Cost |
|---|---|---|
| Prefilled example | 5 | $0.0075 |
| Prospect list | 100 | $0.15 |
| Lead list | 1,000 | $1.50 |
| Market research | 10,000 | $15.00 |

(Each run also pays the $0.00005 start fee.) Cap spending with **Max charge per run**: the run stops cleanly at your limit.

### 🔌 Use it via API

Get your token in Apify Console under **Settings → API & Integrations**.

The main input field is `urls` (a list, or one string with sites separated by commas or new lines). For AI agents and scripts, the aliases `url`, `startUrls` (strings or `{"url": ...}` objects), `domains`, `domain`, `websites` and `website` work too, so `{"url": "stripe.com"}` or `{"domains": ["stripe.com"]}` run as expected. Bare domains get `https://`; duplicates across all fields are skipped.

**JavaScript**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('kadi_bence/tech-stack-detector').call({
    urls: ['allbirds.com', 'wordpress.org'],
    onlyCategories: ['CMS', 'Ecommerce'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((i) => [i.domain, i.cms, i.ecommerce]));
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('kadi_bence/tech-stack-detector').call(run_input={'urls': ['allbirds.com', 'wordpress.org']})
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['domain'], item['technologyNames'])
```

**cURL** (runs and returns items in one call; best for small lists)

```bash
curl -X POST "https://api.apify.com/v2/acts/kadi_bence~tech-stack-detector/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" -d '{"urls": ["allbirds.com", "wordpress.org"]}'
```

**Apify CLI**

```bash
apify call kadi_bence/tech-stack-detector --input '{"urls": ["allbirds.com"]}'
apify call kadi_bence/tech-stack-detector -f input.json
```

**MCP for AI agents** (Claude, Cursor, VS Code and other MCP clients):

```json
{"mcpServers": {"apify": {"url": "https://mcp.apify.com/?actors=kadi_bence/tech-stack-detector"}}}
```

Then ask your agent: "Which of these 20 domains run on Shopify?"

### 🔁 Integrations & scheduling

Use **Apify Schedules** (any cron) on a saved task, **webhooks** ("Run succeeded" → your URL), the Apify app in **Zapier, Make and n8n**, and **Google Sheets, Slack or email** through Apify integrations.

1. **Shopify lead list:** run your domain list with `onlyCategories: ["Ecommerce", "Payment processors"]`, export the **Tech stack overview** view to Google Sheets, filter `ecommerce` for `Shopify`.
2. **CRM enrichment:** when a company is added to your CRM, a Make / Zapier / n8n flow calls `run-sync-get-dataset-items` with its website and writes `cms`, `ecommerce` and `marketingAutomation` back.
3. **Competitor watch:** a weekly schedule on competitor domains with `maxPagesPerSite: 3`, results to Google Sheets or Slack.
4. **Version tracking:** a monthly run on client sites with `onlyCategories: ["CMS", "JavaScript libraries", "WordPress plugins"]`; compare `version` values with last month.

### 🧰 Related tools by the same developer

**Website due diligence**

- [SEO Site Audit Crawler](https://apify.com/kadi_bence/seo-site-audit): broken links, redirects, titles/meta, canonical, hreflang on every page; $1.50 / 1,000 pages.
- [Website Screenshot & PDF API](https://apify.com/kadi_bence/website-screenshot): full-page/mobile PNG, JPEG, WebP and PDF captures; $2.50 / 1,000 screenshots.
- [Bulk WHOIS & RDAP Domain Lookup](https://apify.com/kadi_bence/domain-whois-lookup): registrar, age, expiry, DNS/MX/SPF/DMARC; $1.50 / 1,000 domains.

**Content pipelines**

- [Document to Markdown](https://apify.com/kadi_bence/document-to-markdown): PDF/Word/PowerPoint/Excel/OCR to Markdown and RAG chunks; $2 / 1,000 documents.
- [Bulk Image Downloader](https://apify.com/kadi_bence/bulk-image-downloader): all images/files from pages into a ZIP; $0.80 / 1,000 files.

### ❓ FAQ

**How does it work, and how accurate is it?**
It fetches each page with plain HTTP and matches fingerprints against the HTML, headers, cookies, script URLs (including scripts injected by inline loaders like Google Tag Manager or Hotjar), meta tags and CSS selectors. Without a browser it cannot see tools that load only after JavaScript runs or after user consent, or only on inner pages (set **Pages per website** > 1). In our tests the CMS, ecommerce platform, framework, CDN and server were found reliably. **Include evidence** shows why each one matched.

**What are the limits?**
100,000 websites per run, 10 pages per website, 50 websites in parallel, 3 MB per page.

**How fast is it?**
In our test, 100 websites took about 15 seconds with 20 in parallel (1 page each, desktop CPU). On Apify with the default 1 GB of memory, expect a few minutes per 1,000 websites. For 10,000+ sites, give the run 4 GB: up to about 4x faster for the same price.

**Why are some sites "blocked" or skipped?**
Some large sites (Amazon, eBay, Etsy, NYTimes...) block automated requests with 403/429 or bot challenges, and some forbid all bots in robots.txt. Those rows show the reason and are not charged. Challenge pages are reported, never solved. On a top-100 test list, 73% of sites were analysed; normal business and shop websites succeed far more often. Usually no proxy is needed; if many sites answer 403, try Apify Proxy (datacenter).

**Is it legal?**
The Actor requests only the pages you list (plus, if asked, a few same-site pages), like a browser would. It respects **robots.txt** (RFC 9309) and crawl-delay, collects no personal data (no e-mails, names or form data) and never logs in. You are responsible for using the results in line with the sites' terms and your local laws; this is not legal advice.

**Can I use it from Python, JavaScript, an AI agent, or no-code tools?**
Yes: see **Use it via API** (JavaScript, Python, cURL, CLI, MCP) and **Integrations & scheduling** (Sheets, Make, Zapier, n8n).

**What does a big job cost?**
10,000 analysed sites ≈ $15; 100,000 (the per-run maximum) ≈ $150, plus the start fee. Failed and empty sites are free. Set **Max charge per run** as a hard cap.

**What if something fails or is wrong?**
Failed sites carry an `error` and are free. If a whole run fails, read the status message (e.g. `Invalid input: ...`) and `RUN_SUMMARY`. For a missing or wrong technology, open an issue on the **Issues** tab with the website and technology; fixes usually land within 24-48 hours. See the **Changelog** for updates.

**Where do the fingerprints come from?**
From [webappanalyzer](https://github.com/enthec/webappanalyzer), the open-source continuation of the Wappalyzer technology database (GPL-3.0, © its contributors), plus a few rules of our own. See **Credits** below.

### 📝 Changelog

- **2026-10-05:** Input aliases for API and AI-agent calls: `urls` also takes a single string or a comma/newline-separated list, and `url`, `startUrls`, `domains`, `domain`, `websites` and `website` are accepted and merged. A run with no website fails with a clear message naming the accepted fields.
- **2026-10-05:** Store page rewritten.
- **1.0 (2026-10-05):** First release. 7,600+ fingerprints (webappanalyzer snapshot of 2026-09-16), versions, confidence scores, evidence, multi-page scanning, robots.txt per RFC 9309, failed and blocked sites not charged.

### 🤝 Need a custom version?

I build custom scrapers, scheduled data feeds and integrations (CSV, Excel, Google Sheets, API, MCP for AI agents). Tell me the sites and fields you need:

- Email: bence.kadi@gmail.com
- Apify profile: https://apify.com/kadi_bence

### Credits and licence notice

Technology fingerprints: **webappanalyzer** by Enthec and contributors, https://github.com/enthec/webappanalyzer, licensed under the **GNU GPL v3.0**. The data is used unmodified, and the licence text ships with the Actor. This Actor is not affiliated with or endorsed by Wappalyzer, BuiltWith, Enthec or any vendor whose technology it detects. All product names are trademarks of their owners.

### Related Actors

More low-cost Actors by the same developer, built on official APIs and public data:

- [SEO Site Audit](https://apify.com/kadi_bence/seo-site-audit) — 0-100 SEO score per page, broken links and fix hints
- [Bulk WHOIS & RDAP Domain Lookup](https://apify.com/kadi_bence/domain-whois-lookup) — registrar, dates and DNS for many domains
- [PageSpeed Insights Bulk Checker](https://apify.com/kadi_bence/pagespeed-checker) — Core Web Vitals and Lighthouse scores in bulk
- [Website Screenshot & PDF API](https://apify.com/kadi_bence/website-screenshot) — full-page screenshots and PDFs of any URL
- [AI Visibility Tracker](https://apify.com/kadi_bence/ai-visibility-tracker) — how ChatGPT, Perplexity, Gemini and Claude mention your brand
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper) — all open jobs of a company from 6 applicant systems, plus Workday
- [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding) — new startup funding rounds from SEC EDGAR

All my Actors: [apify.com/kadi_bence](https://apify.com/kadi_bence)

# Actor input Schema

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

Websites to analyse: a JSON list like \["example.com", "https://example.com/shop"], or one string ("example.com", or several separated by commas or new lines). https:// is added when missing (with fallbacks to www. and http://). Duplicates are skipped. Max 100,000 per run. Also accepted under the aliases url, startUrls (strings or {"url": ...} objects), domains, domain, websites, website.

## `onlyCategories` (type: `array`):

Return only technologies in these categories, e.g. CMS, Ecommerce, Analytics. Leave empty for all 100+ categories. Sites with nothing found in your categories are not charged.

## `includeVersions` (type: `boolean`):

Add the version number when the site exposes it (e.g. WordPress 7.2, jQuery 3.6.0).

## `includeEvidence` (type: `boolean`):

Add up to 5 "evidence" strings per technology showing what matched (header, script URL, meta tag, cookie...), e.g. scriptSrc: https://cdn.shopify.com/... Useful to audit detections; makes the dataset bigger.

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

Hide technologies detected with a lower confidence score. Most detections are 100; weaker signals (e.g. a generic script name) score 25-75. Example: 75 for a stricter list.

## `maxPagesPerSite` (type: `integer`):

1 = only the URL you give (usually the homepage), fastest. 2-10 = also analyse a few same-site pages linked from it (pricing, shop, blog...), which finds tools that are loaded only on inner pages. You still pay once per website. Example: 3

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

How many websites are analysed at the same time. Each website is still fetched politely (robots.txt, crawl-delay). Example: 20-50 for large lists.

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

Give up on a slow website after this many seconds (one retry on 429/5xx answers). Pages are read up to 3 MB.

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

Usually not needed. If some sites answer 403 "blocked", you can try Apify Proxy (datacenter). Residential proxies are not supported.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "wordpress.org",
    "www.allbirds.com",
    "vercel.com",
    "www.bbc.com"
  ],
  "includeVersions": true,
  "includeEvidence": false,
  "minConfidence": 0,
  "maxPagesPerSite": 1,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

CMS, ecommerce, analytics, framework, CDN, server and payments per website.

## `technologies` (type: `string`):

Every detected technology per website.

## `full` (type: `string`):

All fields incl. versions, confidence and categories.

## `summary` (type: `string`):

Counts, errors, top technologies and the fingerprint database version.

# 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": [
        "https://apify.com",
        "wordpress.org",
        "www.allbirds.com",
        "vercel.com",
        "www.bbc.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kadi_bence/tech-stack-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": [
        "https://apify.com",
        "wordpress.org",
        "www.allbirds.com",
        "vercel.com",
        "www.bbc.com",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kadi_bence/tech-stack-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": [
    "https://apify.com",
    "wordpress.org",
    "www.allbirds.com",
    "vercel.com",
    "www.bbc.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kadi_bence/tech-stack-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kadi_bence/tech-stack-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/FyqKTfGEVtr8MzarL/builds/2des0T6CMccReplus/openapi.json