# Website Technology Lookup: Tech Stack, DNS & Email (`planetlinux98/website-technology-lookup`) Actor

Find out what any website runs on: CMS, e-commerce platform, analytics, ad pixels, hosting and CDN, plus email provider, DNS host, SaaS tools from DNS records, SSL expiry and security headers. One row per domain, ready for lead lists.

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

## Pricing

from $1.00 / 1,000 domain checkeds

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 Technology Lookup** tells you what a website runs on and which business tools the company behind it uses. Give it a list of domains and get one tidy row per domain covering:

- the **CMS or e-commerce platform**, **analytics and ad pixels**, **hosting and CDN**, and **JavaScript frameworks**;
- the **email provider** and **email-sending services**;
- the **DNS host**;
- **SaaS tools found in public DNS records** (Google Workspace, Microsoft 365, Atlassian, Stripe, HubSpot, Zendesk and many more);
- **SSL certificate expiry** and **security headers**.

It's built for lead qualification, competitor research, agency prospecting and IT audits. It works fast: each domain needs one homepage request plus a few DNS lookups, with no browser.

### What can this website technology lookup do?

- **Detect 1,100+ web technologies** from a site's homepage: CMS, site builders, e-commerce platforms, analytics, tag managers, ad pixels, live chat, cookie banners, accessibility overlays, CDNs, frameworks, web servers and more. Versions are included when the site shows them.
- **Read public DNS records** to find:
  - who hosts the company's email (Google Workspace, Microsoft 365, Zoho...);
  - which services send email for it (HubSpot, SendGrid, Mailchimp, Zendesk...);
  - its DMARC policy and DNS host;
  - the SaaS tools it has verified in DNS. This often reveals Atlassian, Slack, Stripe, Adobe, DocuSign, Zoom, OpenAI and others, even when they're not on the website.
- **Check the SSL certificate:** issuer, expiry date, days left, and whether browsers trust it.
- **Score the security headers:** HSTS, Content Security Policy, clickjacking protection, nosniff, Referrer-Policy and Permissions-Policy.
- **Spot AI and SEO files:** whether the site has robots.txt, sitemap.xml and llms.txt.
- **Stay polite:** respects robots.txt, so if a site asks automated tools not to load its pages, we only check DNS and SSL.

### What data does it return?

| Field | What it is |
| --- | --- |
| `domain`, `url`, `statusCode`, `title`, `language` | The domain, its final homepage address, HTTP status, page title and language |
| `technologyNames`, `technologies` | Every technology found, plus details (categories, version, confidence, and whether it came from the website or DNS) |
| `cms`, `ecommerce`, `analytics`, `advertising`, `marketing`, `hostingCdn`, `javascriptFrameworks`, `accessibilityOverlays` | Handy summary columns for filtering |
| `emailProvider`, `emailServices`, `dmarcPolicy`, `dnsProvider`, `verifiedServices`, `mxRecords`, `nameservers`, `wwwCname` | What the DNS records reveal |
| `sslIssuer`, `sslValidTo`, `sslDaysLeft`, `sslValid`, `sslError` | SSL certificate details |
| `securityHeadersScore` and the `has...` fields | Security headers present (0 to 6), plus robots.txt, sitemap.xml and llms.txt |
| `error`, `blockedByRobotsTxt` | What couldn't be checked, and why |

### How to look up a website's technology stack

1. Click **Try for free** (you'll need a free Apify account).
2. Paste your domains, one per line. Plain domains (`shopify.com`) and full addresses (`https://www.example.ca/about`) both work.
3. Click **Start**. A list of 100 domains usually takes a minute or two.
4. Download the results as CSV, Excel or JSON, or send them to Google Sheets, HubSpot, Make, Zapier or n8n with Apify's integrations.

### Input example

```json
{
    "domains": ["allbirds.com", "wordpress.org", "https://www.toronto.ca"],
    "checkDns": true,
    "checkSsl": true,
    "checkFiles": true
}
```

### Output example

![Table of sample results from a real run for three online stores, kyliecosmetics.com, gymshark.com and allbirds.com: all built on Shopify, with each one's email provider, DMARC policy, days until the SSL certificate expires, and some technologies found, such as Cloudflare, Klaviyo and Google Tag Manager.](https://api.apify.com/v2/key-value-stores/Q61NH7quzCxD8IodC/records/website-technology-lookup-results.png)

One result as JSON:

```json
{
    "domain": "allbirds.com",
    "url": "https://www.allbirds.com/",
    "statusCode": 200,
    "title": "Allbirds",
    "language": "en",
    "technologyNames": ["Shopify", "CloudFlare", "Google Tag Manager", "Microsoft Clarity", "Google Workspace", "Klaviyo"],
    "cms": null,
    "ecommerce": "Shopify",
    "analytics": ["Google Tag Manager", "Microsoft Clarity"],
    "hostingCdn": ["CloudFlare"],
    "emailProvider": "Google Workspace",
    "emailServices": ["Google Workspace", "Klaviyo"],
    "dmarcPolicy": "reject",
    "dnsProvider": "Cloudflare",
    "verifiedServices": ["Google Search Console", "Meta Business"],
    "sslIssuer": "Google Trust Services",
    "sslDaysLeft": 61,
    "sslValid": true,
    "securityHeadersScore": 3,
    "hasRobotsTxt": true,
    "hasSitemapXml": true,
    "hasLlmsTxt": false,
    "technologies": [
        { "name": "Shopify", "categories": ["Ecommerce"], "version": null, "confidence": 100, "source": "website" }
    ]
}
```

The example is shortened, and the values are illustrative.

### How much does it cost?

You pay **$1.00 per 1,000 domains** (a tenth of a cent each), plus a tiny start fee of $0.00005 per run. You aren't charged for domains that don't exist.

- 100 domains: about $0.10
- 5,000 domains: about $5

Apify's free plan includes $5 of monthly credit, which covers about 5,000 domains. To cap any single run, set a maximum cost when you start it.

### Limits and good to know

- **Homepage only.** We look at the homepage (after redirects). Technology used only deeper in the site, or loaded later by JavaScript, may not show up. This tool doesn't run a browser, which keeps it fast and cheap.
- **Some sites block automated visitors** (with a 403 page, for example). We still read what their headers reveal (often the CDN or hosting) and everything in DNS.
- **Detection is based on known fingerprints,** so very new or custom-built tools may be missed. DNS-based findings are reliable because they come straight from the domain's own records.
- **Very long lists:** a run stops by itself about a minute before its time limit (one hour by default), so it still finishes successfully. Domains not reached are listed under `notChecked` in RUN_SUMMARY. For big lists, raise the run's timeout or split the list.
- **No personal data is collected.** We don't extract emails, phone numbers or names, only technology and infrastructure facts.
- **robots.txt is respected.** If a site asks automated tools to stay away, `blockedByRobotsTxt` is true and only DNS and SSL are checked.

### FAQ

#### How is this different from BuiltWith or Wappalyzer?

It uses the same kind of fingerprint matching for the website, and adds what DNS records reveal, which browser extensions don't show. You pay per domain with no subscription, and you can run thousands of domains through the API.

#### Can I use it through the API or with AI agents?

Yes. Start runs and read results through the Apify API (JavaScript and Python clients are available), call it from AI agents through Apify's MCP server, or connect it to Make, Zapier, n8n, Google Sheets or HubSpot.

#### Is it legal?

It reads public information: a website's public homepage, as any browser would, and public DNS records. It respects robots.txt and doesn't collect personal data. As always, use the results in line with the laws that apply to you.

#### Something's wrong or missing?

Please open an issue on the **Issues** tab with the domain and what you expected to see. Missing technologies are usually quick to add.

### Credits

Technology fingerprints include data from Wappalyzer 5.9.34, used under the MIT License (copyright Elbert Alias and Wappalyzer contributors), plus our own additions.

# Actor input Schema

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

One domain or website address per line, for example <code>shopify.com</code> or <code>https://www.example.ca/about</code>. We look at the domain's homepage and its public DNS records. Duplicates are looked up once.

## `checkDns` (type: `boolean`):

Find the email provider, email-sending services, DNS host, DMARC policy and SaaS tools that the domain has verified (Google, Microsoft, Atlassian, Stripe and more). No website request is needed for this.

## `checkSsl` (type: `boolean`):

Read the certificate's issuer and expiry date, and whether browsers trust it.

## `checkFiles` (type: `boolean`):

See whether the site publishes these files. Adds two small requests per domain.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "wordpress.org",
    "allbirds.com"
  ],
  "checkDns": true,
  "checkSsl": true,
  "checkFiles": true
}
```

# Actor output Schema

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

One row per domain with its technologies, DNS, email and SSL findings.

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

How many domains were looked up, and any entries skipped as invalid.

# 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": [
        "apify.com",
        "wordpress.org",
        "allbirds.com"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("planetlinux98/website-technology-lookup").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": [
    "apify.com",
    "wordpress.org",
    "allbirds.com"
  ]
}' |
apify call planetlinux98/website-technology-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,planetlinux98/website-technology-lookup"
        }
    }
}
```

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/qYQNmNeGjv1EpyQOM/builds/dGEg5DrIoXmNbf8Hz/openapi.json