# Website Technology Detector — Wappalyzer Alternative (`khadinakbar/wappalyzer-alternative`) Actor

Detect technologies on known websites using catalog data and live page evidence. Export CMS, ecommerce, analytics, hosting, and other stack findings with source and freshness details for qualification or technical research.

- **URL**: https://apify.com/khadinakbar/wappalyzer-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** SEO tools, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $60.00 / 1,000 technology reports

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

# README

## Website Technology Detector — Wappalyzer Alternative

Detect technologies on known websites using catalog data and live page evidence. Export CMS, ecommerce, analytics, hosting, and other stack findings with source and freshness details for qualification or technical research. For account and technology researchers, each dataset record describes the technology snapshot for a supplied website.

### Workflow: put the results to work

Submit the known websites you want to segment or review. Compare catalog findings with current HTML and header evidence, paying attention to provider freshness. Use the resulting technology groups for account qualification or migration research, then inspect the source for decision-critical detections.

### Best fit for this Actor

Use this Actor when you already have website URLs and want a machine-readable technology snapshot with both broad catalog coverage and a current-page check. It works especially well when the next step is account qualification, stack segmentation, migration research, or a technical review using `technologies`, `dataSources`, `providerLastVisited`, `finalUrl`, and `collectedAt`.

Wappalyzer remains the broader choice for its browser extensions, large commercial fingerprint catalog, lead lists, enrichment, historical data, and product-specific integrations. Start with a domain-discovery or company-data workflow when the URLs are still unknown, then pass the resulting public domains into this Actor.

### How this workflow compares with Wappalyzer

This Actor is a workflow alternative for a bounded, one-page public technology check. Wappalyzer provides a wider website-intelligence product, while this Actor concentrates on transparent Apify dataset output for caller-supplied URLs.

| Decision | This Actor | Wappalyzer | Best fit |
| --- | --- | --- | --- |
| Workflow scope | Profiles supplied public URLs using managed catalog data plus current HTML and response headers. | Offers technology lookup plus broader website-intelligence products. | Choose by whether the job is a focused structured URL report or a wider intelligence workflow. |
| Billing and cost | Uses Pay per event for each persisted report plus Apify platform usage. | Uses its own account, credits, and plan structure. | Compare the live pricing surfaces for the workload and volume you expect. |
| Usable-output efficiency | Returns one deduplicated record per accepted URL with catalog freshness and live-source evidence. | Returns technology data through its supported products and API plans. | Use the output shape that fits the next system with the least transformation. |
| Integrations and automation | Runs through Apify Console and API, with datasets, schedules, and webhooks available in the Apify workflow. | Provides its documented product and integration paths. | Choose the ecosystem already used by the team operating the workflow. |
| Evidence and freshness | Separates provider `last visited` time from the current Actor collection time and live-page evidence. | Provides its own live and stored lookup options. | Use the provenance model that matches the decision being made. |
| Broader product fit | Concentrates on known-URL technology reports while excluding provider contact fields from storage. | Adds extension, lead, enrichment, history, and wider catalog capabilities. | Wappalyzer fits teams that need those wider product capabilities. |

Wappalyzer is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by Wappalyzer.

### From website URLs to a stack decision

A sales-operations analyst starts with the public domains already present in a prospect list. They submit those URLs, then review `technologyCount`, all categories for each technology, the provider's `providerLastVisited`, current source excerpts, and `collectedAt`. Next, they segment accounts by ecommerce, analytics, or framework signals and send only the selected records into their CRM review or research process.

### Output data you receive

One dataset row represents one accepted domain report. A row can be hybrid, provider-catalog-only when the current page is inaccessible, or live-page-only when the catalog is disabled or temporarily unavailable.

| Field | Meaning | Example |
| --- | --- | --- |
| `requestedUrl` | Normalized URL supplied for the run. | `https://www.shopify.com/` |
| `finalUrl` | Public URL reached after validated redirects. | `https://www.shopify.com/` |
| `statusCode` | Current public-page HTTP status, or `null` for a catalog-only report. | `200` |
| `fetchRoute` | Direct, Apify Residential Proxy, or catalog-only route. | `direct` |
| `pageTitle` | Public HTML title when present. | `Shopify: The All-in-One Commerce Platform` |
| `technologies` | Technology name, primary category, all categories, confidence, evidence, and source route. | `Next.js`, `Web frameworks`, `high` |
| `technologyCount` | Number of unique supported technologies in the report. | `4` |
| `headersObserved` | Names of response headers observed during analysis; header values stay out of this field. | `content-type`, `server` |
| `dataSources` | Evidence surfaces that contributed to the report. | `dataforseo_domain_technologies`, `public_html_and_response_headers` |
| `providerStatus` | Whether the managed catalog contributed, was unavailable, lacked configuration, or was skipped. | `success` |
| `providerLastVisited` | Catalog observation time, kept separate from the current run time. | Provider timestamp or `null` |
| `providerCostUsd` | Provider-reported cost for the domain lookup. | Numeric USD value |
| `collectedAt` | ISO 8601 collection time for freshness decisions. | UTC timestamp |
| `provenance` | Hybrid, catalog-only, or live-page-only evidence scope. | `hybrid_dataforseo_and_public_page` |

```json
{
  "requestedUrl": "https://www.shopify.com/",
  "finalUrl": "https://www.shopify.com/",
  "statusCode": 200,
  "fetchRoute": "direct",
  "pageTitle": "Shopify: The All-in-One Commerce Platform",
  "technologies": [
    {
      "name": "Next.js",
      "category": "JavaScript frameworks",
      "categories": ["JavaScript frameworks", "Web frameworks"],
      "confidence": "high",
      "evidence": "/_next/static/",
      "source": "hybrid_public_and_dataforseo"
    }
  ],
  "technologyCount": 1,
  "headersObserved": ["content-type", "server"],
  "dataSources": ["dataforseo_domain_technologies", "public_html_and_response_headers"],
  "providerName": "DataForSEO",
  "providerStatus": "success",
  "providerTaskId": "provider request identifier",
  "providerCostUsd": 0.012,
  "providerLastVisited": "provider catalog timestamp",
  "providerDomainRank": 571,
  "collectedAt": "ISO-8601 UTC timestamp",
  "provenance": "hybrid_dataforseo_and_public_page",
  "limitations": "Provider catalog observations can predate this run; public-page evidence is current but may miss client-side, authenticated, obfuscated, or non-public technologies."
}
```

### Quick start input

Provide up to 25 public HTTP or HTTPS website URLs. Bare domains are normalized to HTTPS, duplicates are removed, and redirects are accepted only while they continue to resolve to public network addresses.

```json
{
  "startUrls": [
    "https://apify.com",
    "https://www.shopify.com"
  ],
  "maxUrls": 2,
  "requestTimeoutSecs": 25,
  "useProviderCatalog": true,
  "useApifyProxyFallback": true
}
```

Run it through the Apify API:

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~wappalyzer-alternative/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":["https://example.com"],"maxUrls":1}'
```

After execution finishes, read the default dataset for the complete report rows and read `OUTPUT` for the compact outcome summary.

### AI agent and MCP prompt

> Profile these known public website URLs. Return the dataset records with technology names, categories, confidence, source evidence, final URLs, collection times, and the run outcome. Keep the scope to these URLs, state the Pay per event cost boundary, and use dataset pagination if the full result is larger than the first readback page.

The required starting information is a list of public website URLs. The operation reads managed catalog observations and public pages, stores only technology-report fields, and performs no changes on target websites. Provider email and phone fields are intentionally discarded. `OUTPUT` and `RUN_SUMMARY` provide outcome, provider cost, margin telemetry, and warning context for workflow branching.

### Practical guidance for best results

- Provide canonical public homepages or specific public pages that carry the technology signals relevant to the decision.
- Keep `useProviderCatalog` enabled for broader catalog coverage. Disable it when a current-page-only observation is the intended job.
- Keep `useApifyProxyFallback` enabled when consistent public-page reachability matters; residential traffic becomes part of Apify platform usage only when that route is used.
- Compare `providerLastVisited` with `collectedAt`. Catalog-only technologies can be broader but older, while live-source excerpts reflect the page fetched during this run.
- Interpret every finding with its categories, confidence, and evidence source. A hybrid finding means the catalog and current page agreed on the technology name.
- Use repeated scheduled runs when technology-change monitoring is the goal, and compare records using `requestedUrl` plus `collectedAt`.
- Treat browser-runtime, authenticated, certificate, DNS, cookie, and site-wide observations as a broader research scope that can be paired with an appropriate browser or intelligence workflow.

### Builder's note

I designed the current-page detector conservatively after finding that short generic patterns create convincing-looking false positives. The hybrid merge uses the provider catalog for breadth, prefers inspectable live evidence when both sources identify the same technology, and keeps provider freshness separate from collection time so a person or agent can judge each finding before using it downstream.

### Responsible use

Analyze public pages you are authorized to access. Apply relevant site terms, intellectual-property rules, privacy obligations, and applicable law to collection, storage, and downstream use. Technology observations are research signals rather than security assurances or proof of current software versions.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/wappalyzer-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `technology-report` | Technology report | One validated website technology report persisted from managed catalog data, current public-page evidence, or both. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

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

Public website URLs or domains to profile. Enter a hostname such as apify.com or a complete http(s) URL. The Actor follows normal redirects and records the final URL. Use only URLs you are authorized to analyze.

## `maxUrls` (type: `integer`):

Hard cap for this run after invalid URLs and duplicates are removed. Defaults to 10 and can never exceed 25. Lower this value to keep a pilot run tightly bounded.

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

Maximum wait for each current public website response. Defaults to 25 seconds and can never exceed 60 seconds. A timed-out live page becomes a source warning while provider catalog evidence can still return a report.

## `useProviderCatalog` (type: `boolean`):

Combine DataForSEO's domain technology catalog with current public-page evidence. Defaults to true for broader coverage and keeps provider credentials owner-managed. Turn it off for a live-page-only observation that makes no provider request; the report event price is unchanged.

## `useApifyProxyFallback` (type: `boolean`):

Retry through Apify Residential Proxy after a direct request is clearly blocked or temporarily unavailable. Defaults to true to improve current public-page reachability. Apify proxy traffic is platform usage paid by the caller; catalog evidence can still return when live access is unavailable.

## Actor input object example

```json
{
  "startUrls": [
    "https://apify.com",
    "https://www.shopify.com"
  ],
  "maxUrls": 10,
  "requestTimeoutSecs": 25,
  "useProviderCatalog": true,
  "useApifyProxyFallback": true
}
```

# Actor output Schema

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

Default dataset with one source-aware technology report per usable public URL.

## `OUTPUT` (type: `string`):

Terminal outcome and compact run result.

## `RUN_SUMMARY` (type: `string`):

Detailed source-route, provider-cost, margin, charge, and warning telemetry.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/wappalyzer-alternative").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": ["https://apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/wappalyzer-alternative").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://apify.com"
  ]
}' |
apify call khadinakbar/wappalyzer-alternative --silent --output-dataset

```

## MCP server setup

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

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/d2R7wTDKZYk1ekBfh/builds/PF1uM3b7y8BZSR3tE/openapi.json