# Wappalyzer Technology Lookup (`rl1987/wappalyzer-tech-lookup`) Actor

Detect the technology stack (frameworks, CDNs, analytics, CMS and more) behind any website using the Wappalyzer API.

- **URL**: https://apify.com/rl1987/wappalyzer-tech-lookup.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 output rows

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Wappalyzer Technology Lookup

**Wappalyzer Technology Lookup** detects the **technology stack behind any website** — JavaScript frameworks, CMSs, CDNs, analytics tools, e-commerce platforms, web servers, and hundreds of other categories. Give it a list of URLs or domains and it returns the technologies each site uses, powered by the [Wappalyzer](https://www.wappalyzer.com/) API.

Run it on the [Apify platform](https://apify.com/) to get scheduling, a REST API, webhooks, and integrations with Make, Zapier, Google Sheets, and more — no infrastructure to manage.

### What does Wappalyzer Technology Lookup do?

For every URL or domain you provide, the Actor queries the Wappalyzer lookup API and stores the detected technologies, including each technology's name, category, version (when known), traffic rank, and icon. It's the fastest way to **profile the tech stack of any website** in bulk and export the results.

### Why use Wappalyzer Technology Lookup?

- **Lead generation & sales intelligence** — find sites running a specific platform (e.g. Shopify, HubSpot) to target prospects.
- **Competitive analysis** — see what frameworks and tools competitors rely on.
- **Market research** — measure technology adoption across a list of domains.
- **Security & compliance** — inventory the software exposed by your own web properties.

### How to use Wappalyzer Technology Lookup

1. Open the Actor in [Apify Console](https://console.apify.com/).
2. In the **Input** tab, add the URLs or domains you want to analyze (one per line). Full URLs (`https://example.com`) and bare domains (`example.com`) both work.
3. Click **Start**.
4. When the run finishes, open the **Output** tab to view results, or download them in JSON, CSV, Excel, or HTML.

### Input

The only input is a list of websites to analyze:

```json
{
    "urls": [
        "https://nike.com",
        "example.com",
        "https://github.com"
    ]
}
````

| Field | Type | Description |
| --- | --- | --- |
| `urls` | array of strings | URLs or domains to look up. A missing scheme defaults to `https://`. Invalid entries are skipped. |

### Output

The output is **flat — one row per detected technology** — so it maps cleanly to a spreadsheet. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
[
    {
        "domain": "nike.com",
        "technologyName": "Next.js",
        "trafficRank": 8603,
        "confirmedAt": 1781234485,
        "iconUrl": "https://www.wappalyzer.com/images/icons/converted/Next.js.png",
        "categories": "JavaScript frameworks, Web frameworks, Web servers, Static site generator"
    },
    {
        "domain": "nike.com",
        "technologyName": "React",
        "trafficRank": 8388,
        "confirmedAt": 1781234485,
        "iconUrl": "https://www.wappalyzer.com/images/icons/converted/React.png",
        "categories": "JavaScript frameworks"
    }
]
```

#### Data fields

| Field | Description |
| --- | --- |
| `domain` | The looked-up website's domain (scheme and leading `www.` stripped). |
| `technologyName` | Technology name (e.g. *React*). |
| `trafficRank` | Wappalyzer traffic rank signal. |
| `confirmedAt` | Unix timestamp of when the detection was last confirmed. |
| `iconUrl` | Direct URL to the technology's PNG icon. |
| `categories` | Comma-separated category names the technology belongs to (e.g. *CDN, Analytics*). |
| `error` | Present only on a row when the lookup failed for that domain (e.g. invalid URL). |

### Pricing

This Actor uses the **pay-per-event** pricing model:

| Event | Price | When it's charged |
| --- | --- | --- |
| **Output row** | **$0.50 per 1,000 rows** ($0.0005 each) | Once for every technology row written to the dataset. |

You're billed purely per result — there are no separate compute-unit or proxy charges to reason about. For example, a run that produces 2,000 technology rows costs `2,000 × $0.0005 = $1.00`. Domains that return no technologies (or fail) produce at most one row each.

You can cap a run's total cost with the **maximum cost per run** setting in the Console; the Actor stops writing rows once that limit is reached.

### Tips

- Deduplication is automatic — repeated URLs are looked up only once.
- Bare domains are fine; the Actor normalizes them to `https://`.
- Requests rotate through datacenter proxy IPs automatically; failed lookups are retried on a fresh IP with backoff. Any URL that still fails is recorded with an `error` field instead of stopping the run.

### FAQ, disclaimers, and support

**Is this affiliated with Wappalyzer?** No. This Actor uses the public Wappalyzer API and is not an official Wappalyzer product.

**Is web technology detection legal?** The Actor only queries the Wappalyzer API for publicly available technology fingerprints. As with any data tool, ensure your use complies with applicable laws and the target services' terms.

Found a bug or have a feature request? Open an issue on the Actor's **Issues** tab. Custom solutions are available on request.

# Actor input Schema

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

List of websites to analyze. You can enter full URLs (https://example.com) or bare domains (example.com) - a missing scheme defaults to https://.

## Actor input object example

```json
{
  "urls": [
    "https://nike.com"
  ]
}
```

# 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://nike.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/wappalyzer-tech-lookup").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://nike.com"] }

# Run the Actor and wait for it to finish
run = client.actor("rl1987/wappalyzer-tech-lookup").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 '{
  "urls": [
    "https://nike.com"
  ]
}' |
apify call rl1987/wappalyzer-tech-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wappalyzer Technology Lookup",
        "description": "Detect the technology stack (frameworks, CDNs, analytics, CMS and more) behind any website using the Wappalyzer API.",
        "version": "1.0",
        "x-build-id": "3d1pfpo8t1j2UVKwh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rl1987~wappalyzer-tech-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rl1987-wappalyzer-tech-lookup",
                "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/rl1987~wappalyzer-tech-lookup/runs": {
            "post": {
                "operationId": "runs-sync-rl1987-wappalyzer-tech-lookup",
                "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/rl1987~wappalyzer-tech-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-rl1987-wappalyzer-tech-lookup",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "URLs / domains",
                        "type": "array",
                        "description": "List of websites to analyze. You can enter full URLs (https://example.com) or bare domains (example.com) - a missing scheme defaults to https://.",
                        "default": [
                            "https://nike.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
