# Website Tech Stack Detector - CMS & Framework (`logiover/website-tech-stack-detector`) Actor

Bulk BuiltWith API alternative: detect any website's CMS, framework, analytics & hosting, then export the tech stack to CSV/JSON. No browser, pay per result.

- **URL**: https://apify.com/logiover/website-tech-stack-detector.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 14 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 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/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 — CMS, Framework & BuiltWith-Style Technology Lookup (No API)

![Apify Actor](https://img.shields.io/badge/Apify-Actor-00A67E?logo=apify\&logoColor=white) ![No API key](https://img.shields.io/badge/No%20API%20key-required-2ea44f) ![Pay per result](https://img.shields.io/badge/Pricing-Pay%20per%20result-1C7ED6) ![Tech Lookup](https://img.shields.io/badge/Category-Tech%20Lookup-8B5CF6) ![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-F59E0B)

Find out **what any website is built with — in bulk.** Drop in a list of domains and get back the **CMS**, **ecommerce platform**, **JavaScript framework**, **analytics**, **marketing/CRM tools**, **payment widgets**, **CDN**, **hosting** and **web server** behind each one. A fast, **BuiltWith-style technology lookup** and **CMS detector** for **competitive intelligence**, **lead generation** and **market research** — reading response headers, set-cookies and page HTML in one pass. **Domains in → tech stack out**, as clean structured JSON, CSV or Excel. **No browser, no API key, no monthly subscription.**

> ### 🏆 Why this tech stack detector?
>
> **8+ signal fields per domain across 8 tech categories** · **hundreds of domains per run**, parallelized · header + cookie + HTML fingerprinting (catches signals single-source scrapers miss) · HTTP-only, no headless browser · grouped **and** flat output for one-click filtering · export to JSON / CSV / Excel. The pay-per-result **BuiltWith / Wappalyzer API alternative** — no seat fees, no per-lookup credits.

***

### ✨ What this Actor does / Key features

- 🧱 **Detects the full stack** — CMS, ecommerce, JS framework, analytics, marketing/CRM, payments, CDN/hosting and web server, per domain.
- 📦 **Bulk-first** — hundreds of domains per run, parallelized for speed; paste a list or pipe one in via **Start URLs**.
- 🕵️ **Header + cookie + HTML fingerprinting** — reads response headers, set-cookies and page markup, so it catches signals single-source scrapers miss.
- 🎯 **Precision-tuned** — detection patterns are kept specific to avoid the false positives that plague naive keyword matching; when a signal is ambiguous, it's omitted rather than guessed.
- 🗂️ **Grouped output** — technologies organized `byCategory` **plus** a flat `technologies` list, so you can filter prospect lists in one click.
- ⚡ **HTTP-only & cheap** — no browser needed, low cost per result.
- 🌐 **Optional proxy** — Apify Proxy integration; datacenter proxy is enough for most sites.
- 🔀 **Flexible input** — accepts domains with or without `https://`, plus a `startUrls` list for piping from another Actor or an uploaded file.

### ✅ What it detects

| Category | Examples |
|---|---|
| **CMS** | WordPress, Shopify, Wix, Squarespace, Webflow, Framer, Drupal, Joomla, Ghost, HubSpot CMS, Contentful, Sitecore |
| **Ecommerce** | Shopify, WooCommerce, Magento, BigCommerce, PrestaShop, Salesforce Commerce, Ecwid |
| **JS frameworks** | Next.js, Nuxt, React, Vue, Angular, Svelte, Gatsby, Astro, jQuery |
| **Analytics** | Google Analytics, GTM, Meta Pixel, Hotjar, Segment, Mixpanel, Plausible, Matomo, Amplitude |
| **Marketing / CRM** | HubSpot, Mailchimp, Klaviyo, Intercom, Drift, Zendesk, Tawk.to, Crisp |
| **Payments** | Stripe, PayPal, Klarna |
| **CDN / hosting** | Cloudflare, Fastly, Akamai, Vercel, Netlify, CloudFront, GitHub Pages, S3 |
| **Web server** | Nginx, Apache, IIS, LiteSpeed, OpenResty, Caddy |

### 🚀 Quick start (3 steps)

1. **Add your domains** — paste them into **Domains** (`shopify.com`, `https://www.bbc.com` — with or without `https://`). Big list? Pipe it via **Start URLs**.
2. **Run** — click **Start**. The Actor fetches each site in parallel and streams one row per domain into your dataset.
3. **Get your data** — open the **Output** tab and export to **JSON, CSV, Excel or XML**, or pull it via the Apify API. Filter by `cms`, `ecommerce` or any value in `technologies` to build a laser-targeted prospect list.

### 📥 Input

Provide domains in **Domains** and/or **Start URLs**. Everything else is optional.

#### Example — quick domain list

```json
{
  "domains": ["shopify.com", "techcrunch.com", "gatsbyjs.com", "stripe.com"],
  "concurrency": 10
}
```

#### Example — bulk prospecting run (find the ecommerce stacks)

```json
{
  "domains": [
    "store-one.com", "store-two.com", "store-three.com", "store-four.com"
  ],
  "concurrency": 20,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

#### Example — pipe a URL list from another Actor / uploaded file

```json
{
  "startUrls": [
    { "url": "https://www.wordpress.org" },
    { "url": "https://www.vercel.com" }
  ],
  "concurrency": 15
}
```

| Field | Type | Description |
|-------|------|-------------|
| `domains` | array | Domains or URLs to analyze (e.g. `shopify.com`, `https://www.bbc.com`). With or without `https://`. |
| `startUrls` | array | Alternative URL list input (e.g. from another Actor or an uploaded file). Merged with `domains`. |
| `concurrency` | integer | Parallel requests (1–30). Higher = faster on large lists. Default `10`. |
| `proxyConfiguration` | object | Optional Apify Proxy settings. Datacenter is enough for most sites. Default: Apify Proxy on. |

> **Tip:** you don't need a fully-formed URL — bare domains like `example.com` work fine, and `domains` + `startUrls` are merged, so you can combine a quick paste with a piped list.

#### Additional input fields

These optional fields are also available in the input form and API:

| Field | Type | Default | Description |
|---|---|---|---|
| `maxResults` | integer | `1000` | Maximum number of sites to fingerprint in one run. Keeps empty/large runs fast and cheap; raise it to analyze more. |

### 📤 Output

One row per domain — technologies detected across all categories, both grouped and flat, exportable to JSON, CSV, Excel or XML. Here is a sample record:

```json
{
  "domain": "techcrunch.com",
  "statusCode": 200,
  "title": "TechCrunch | Startup and Technology News",
  "cms": "WordPress",
  "ecommerce": null,
  "server": "Nginx",
  "generator": "WordPress 6.x",
  "technologies": ["WordPress", "HubSpot", "Google Tag Manager", "Cloudflare"],
  "byCategory": {
    "CMS": ["WordPress"],
    "Analytics": ["Google Tag Manager"],
    "Marketing": ["HubSpot"],
    "CDN/Hosting": ["Cloudflare"]
  },
  "technologyCount": 4
}
```

<details>
<summary><b>📋 Full field reference (click to expand)</b></summary>

| Field | Description |
|-------|-------------|
| `domain` | The domain that was analyzed (normalized) |
| `statusCode` | HTTP status code returned by the site |
| `title` | The page `<title>` of the fetched homepage |
| `cms` | Detected content-management system (e.g. `WordPress`, `Shopify`, `Wix`), or `null` |
| `ecommerce` | Detected ecommerce platform (e.g. `Shopify`, `WooCommerce`, `Magento`), or `null` |
| `server` | Web server from response headers (e.g. `Nginx`, `Apache`, `LiteSpeed`) |
| `generator` | Value of the HTML `generator` meta tag when present (often exposes CMS + version) |
| `technologies` | Flat, de-duplicated list of **all** detected technologies — ideal for `contains` filtering |
| `byCategory` | Technologies grouped by category (`CMS`, `Ecommerce`, `Frameworks`, `Analytics`, `Marketing`, `Payments`, `CDN/Hosting`, `Server`) |
| `technologyCount` | Total number of technologies detected on the site |

</details>

#### Additional output fields

These fields are also present in the dataset:

| Field | Type | Description |
|---|---|---|
| `poweredBy` | string | Value of the X-Powered-By header. |
| `finalUrl` | string | URL after following redirects. |
| `error` | string | Error message if the site could not be fetched. |
| `scrapedAt` | string | ISO timestamp of when the site was analyzed. |

### 💡 Use cases

- **B2B prospecting** — build target lists by technology: "all Shopify + Klaviyo stores", "Magento merchants", "sites on HubSpot", "WooCommerce shops".
- **Competitive intelligence** — see what stack competitors and their customers run.
- **Agencies & SaaS sales** — find sites using (or missing) a specific tool you replace, integrate with, or migrate from.
- **Market research** — measure technology adoption across an industry, niche or country.
- **Lead enrichment** — append tech-stack signals to your CRM records for sharper targeting and messaging.
- **Recruiting & sourcing** — find companies running the stack you hire for.

#### Prospecting recipes

- **Find Shopify stores to pitch** → run your domain list, filter `ecommerce = Shopify`.
- **Target WordPress sites for a plugin/migration offer** → filter `cms = WordPress`.
- **Sell a Klaviyo/HubSpot competitor** → filter `technologies` contains `Klaviyo` or `HubSpot`.
- **Find sites with NO analytics** → filter rows where `byCategory.Analytics` is empty (an easy upsell).
- **Map a competitor's customer base** → scrape their "customers" page for domains, then detect each one's stack.

### 👥 Who uses it

B2B sales & outbound teams · agencies and SaaS vendors targeting a specific stack · competitive-intelligence and market researchers · growth/RevOps enriching CRM records · recruiters sourcing by technology — anyone who needs to know **what a website is built with** at scale.

### 💰 Pricing

This Actor runs on a simple **pay-per-result** model — you pay for the domains you fingerprint, with no separate Apify platform fees to calculate, no seat fees and no per-lookup credits. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.

### ❓ Frequently Asked Questions

**Is it legal to detect a website's tech stack?**
Yes. The Actor fetches each site's public homepage and reads publicly served headers, cookies and HTML — the same signals your own browser receives. You are responsible for using the data in compliance with the target sites' terms and applicable laws.

**Is there a BuiltWith / Wappalyzer public API — is this an API alternative?**
BuiltWith and Wappalyzer are paid tools with monthly subscriptions and per-lookup credits. This Actor does the same job — identify the technologies a site runs — as a **bulk Apify Actor with pay-per-result pricing and full API access**, no subscription. It's a drop-in **BuiltWith API alternative** you can call from your own code via the Apify API.

**Do I need an API key or a login?**
No. There is no third-party API key, login or account to configure — only an Apify account. Paste your domains and run.

#### Does it render JavaScript?

It fingerprints the **served HTML, headers and cookies**, which reveals the vast majority of stacks (CMS, ecommerce, frameworks, analytics, marketing, payments, CDN/hosting, server) without the cost of a full headless browser. For most prospecting and intelligence use cases this is both faster and cheaper.

#### How accurate is it?

Detection patterns are deliberately **specific to minimize false positives** — this is a paid tool, so it favours accuracy over guesses. When a signal is ambiguous, the Actor prefers to omit it rather than report a technology that isn't there.

#### Can I detect a website's CMS in bulk?

Yes. Paste hundreds of domains and the Actor returns each site's CMS, ecommerce platform and framework in one run, so you can build lists like "all Shopify stores" or "WordPress sites running WooCommerce".

#### How do I find all Shopify or WooCommerce stores in a domain list?

Run your domains through the detector, then filter the output by `ecommerce = Shopify` or `technologies` containing `WooCommerce` to build a targeted store list.

#### Can I detect the analytics and marketing tools a website uses?

Yes. The detector fingerprints headers, cookies and HTML to report analytics and marketing tools like Google Analytics, GTM, HubSpot, Klaviyo and Meta Pixel per domain, grouped under `byCategory.Analytics` and `byCategory.Marketing`.

#### Can I feed it a big domain list without an API or login?

Yes. Paste hundreds of domains into `domains`, or pipe them from another Actor or an uploaded file via `startUrls`. No key or login required — only an Apify account.

#### How much data can I get / how many domains per run?

Hundreds of domains per run, parallelized. Raise the `concurrency` input (1–30) to go faster on large lists; the HTTP-only design keeps cost per result low so big prospecting sweeps stay cheap.

#### How do I export website tech-stack data to CSV or JSON?

Run your domain list, then download the dataset as **CSV, Excel, JSON, XML or JSONL** from the Apify console, or pull it via the Apify API. Every detected CMS, framework and tool comes back as structured, filterable fields (`cms`, `ecommerce`, `technologies`, `byCategory`).

#### Can I run it on a schedule?

Yes. Schedule periodic runs to track when target sites **adopt or drop** technologies — a strong buying/selling signal for sales and competitive intelligence.

### 🔗 More website & lead-gen tools by logiover

Pair the tech-stack detector with the rest of the website-intelligence suite — build a domain list, fingerprint it, then enrich and audit:

| Tool | What it does |
|---|---|
| 🌐 [Website Contact Scraper](https://apify.com/logiover/website-contact-scraper) | Add emails, phones & socials to each domain you detect |
| ✉️ [Bulk Email Verifier](https://apify.com/logiover/bulk-email-deliverability-checker) | Clean those contacts before outreach (syntax, MX, disposable, typo) |
| 📈 [Website SEO Audit Crawler](https://apify.com/logiover/website-seo-audit-crawler) | On-page SEO audit for any site |
| 🔗 [Website Link Graph Crawler](https://apify.com/logiover/website-link-graph-crawler) | Map internal/external link structure |
| 🗺️ [Sitemap to URL Crawler](https://apify.com/logiover/sitemap-to-url-crawler) | Expand sitemaps into a full URL list |
| 🏷️ [JSON-LD & Schema Meta-Tag Extractor](https://apify.com/logiover/json-ld-schema-meta-tag-extractor) | Pull structured data & meta tags per page |
| 🧭 [Bulk DNS Records Lookup](https://apify.com/logiover/bulk-dns-records-lookup) | Bulk A/MX/TXT/NS records for any domain list |
| 🔐 [Bulk SSL Certificate Checker](https://apify.com/logiover/bulk-ssl-certificate-checker) | Certificate validity & expiry in bulk |
| 🛡️ [Bulk HTTP Security Headers](https://apify.com/logiover/bulk-http-security-headers) | Audit security headers across domains |
| 🚦 [Bulk URL Status Checker](https://apify.com/logiover/bulk-url-status-checker) | Bulk HTTP status / uptime checks |
| 🛰️ [Subdomain Finder](https://apify.com/logiover/subdomain-finder) | Discover subdomains for any root domain |
| 🏢 [B2B Lead Scraper](https://apify.com/logiover/b2b-lead-scraper) | Company + person + email B2B leads by sector & country |

👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to track your target list's technology changes weekly or monthly and catch adoption/churn signals early. Export results to JSON, CSV or Excel, sync to Google Sheets, or push enriched rows to your CRM, database, BI tools and webhooks through the Apify API. Connect it to **Make, n8n or Zapier** to build an automated "collect domains → detect stack → enrich → route to sales" pipeline.

### ⭐ Support & feedback

Found a bug or need an extra field or detection? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves you research time, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏

### ⚖️ Legal

This Actor fetches publicly served pages and reads publicly available headers, cookies and HTML for technology fingerprinting, and is intended for legitimate research, competitive-intelligence and lead-generation use. You are responsible for complying with the target sites' terms of service and any applicable local laws.

***

This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by the website or data publisher it reads from; all trademarks and brand names are the property of their respective owners.

### 📝 Changelog

#### 2026-11-01

- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: 1 link to renamed Actors updated; independence disclaimer added; documented 1 additional input field; documented 4 additional output fields.

#### 2026-10-15

- Every request now has a hard time limit, so a proxy connection that stalls can no longer hold up the run or push it past its timeout.
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Runs with a short timeout (API and AI-agent calls) now finish inside it with what they collected, instead of being cut off.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.

#### 2026-09-23

- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Output verified on a live run: 14 columns returned, 82.1% of cells populated.
- Run reliability reviewed: 100.0% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.

#### 2026-09-01

- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs — unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.

#### 2026-08-11

- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Fixed the run Output link from `{{links.apiDefaultDatasetUrl}}` to `{{links.apiDefaultDatasetUrl}}/items` so the results table opens the dataset items endpoint.

#### 2026-08-01 — Health-check remediation

- August 2026 monthly health-check remediation is in progress; this build contains fixes verified from empty/default, Console-default, targeted live probes, or field-level semantic review.
- Fixed the run Output link from `{{links.apiDefaultDatasetUrl}}` to `{{links.apiDefaultDatasetUrl}}/items` so the results table opens the dataset items endpoint.
- The final four-input matrix verdict will be appended after post-build cloud revalidation.

#### 2026-07-06

- ✨ README overhaul: full field reference, three ready-to-run example scenarios, website-intelligence suite links, expanded high-intent FAQ, and clearer quick-start.

#### 2026-07-01

- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.

#### 2026-06-15

- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.

#### 2026-06-07

- Docs: added coverage for BuiltWith API alternative, exporting website tech stack to CSV/JSON, and bulk CMS detection.

#### 2026-06-05

- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.

#### 2026-06-04

- Verified live & refreshed build — reliability/maintenance pass.

***

\*Maintained: last verified 2026-11-01 — checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).

# Changelog

This Actor's version history is a separate document: https://apify.com/logiover/website-tech-stack-detector/changelog.md

# Actor input Schema

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

Domains or URLs to analyze (e.g. shopify.com, https://www.bbc.com). With or without https://. Leave empty to fingerprint a default set of popular websites.

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

Alternative URL list input (e.g. from another Actor or an uploaded file).

## `maxResults` (type: `integer`):

Maximum number of sites to fingerprint in one run. Keeps empty/large runs fast and cheap; raise it to analyze more.

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

Parallel requests (1-30).

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

Optional proxy. Apify Proxy (automatic) works for most sites.

## Actor input object example

```json
{
  "domains": [
    "shopify.com",
    "wordpress.org",
    "vercel.com",
    "stripe.com"
  ],
  "maxResults": 1000,
  "concurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with detected CMS, frameworks, analytics, hosting and more 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 = {
    "domains": [
        "shopify.com",
        "wordpress.org",
        "vercel.com",
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/website-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 = { "domains": [
        "shopify.com",
        "wordpress.org",
        "vercel.com",
        "stripe.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/website-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 '{
  "domains": [
    "shopify.com",
    "wordpress.org",
    "vercel.com",
    "stripe.com"
  ]
}' |
apify call logiover/website-tech-stack-detector --silent --output-dataset

```

## MCP server setup

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