# Tech Stack Checker (`arched_friend/tech-stack-checker`) Actor

See which technologies any website runs. Turns a list of domains into a structured profile of each company's ecommerce platform, CMS, analytics, payments, marketing and support tools, with the evidence behind every match.

- **URL**: https://apify.com/arched\_friend/tech-stack-checker.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 website 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?

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

## Tech Stack Checker: Find Out What Technology Any Website Uses

**Give it a list of domains. Get back the software each company actually runs.**

Ecommerce platform, CMS, analytics, payment providers, email and SMS tools, chat widgets, ad pixels, CDN and more. Every match comes with the evidence that proved it, so you can check the answer instead of trusting it.

Built for sales teams qualifying accounts, agencies finding companies on a platform they specialise in, and researchers sizing up who uses what.

### How it works

```mermaid
flowchart LR
    A[Your domain list] --> B[Load the page in a real browser]
    B --> C[Watch every request it makes]
    B --> D[Read headers, cookies, markup]
    C & D --> E{Match against<br/>162 fingerprints}
    E --> F[(One profile per company)]
```

Most of a modern stack is injected by a tag manager after the page loads, so it never appears in the raw HTML. Reading the page the way a browser does is what turns three detections into fifteen.

### What it detects

```mermaid
flowchart TD
    A[Website] --> B[Selling]
    A --> C[Marketing]
    A --> D[Support]
    A --> E[Infrastructure]
    B --> B1[Shopify, WooCommerce, Magento, BigCommerce, Squarespace]
    C --> C1[Klaviyo, HubSpot, Marketo, Attentive, Meta and TikTok pixels]
    D --> D1[Intercom, Zendesk, Gorgias, Drift, Trustpilot]
    E --> E1[Cloudflare, Vercel, Next.js, Contentful, Stripe]
```

162 technologies across 24 categories: ecommerce platforms, CMS, web frameworks, analytics, tag managers, marketing automation, email and SMS, live chat, advertising, payments, ecommerce apps, reviews, CDN, hosting, web servers, consent management, security, monitoring, site search, video, scheduling and forms, A/B testing, fonts and authentication.

### Input

```json
{
  "websites": ["allbirds.com", "gymshark.com", "huel.com"],
  "renderJavaScript": true,
  "maxPagesPerSite": 1
}
```

| Option | Does |
| --- | --- |
| `websites` | Required. Bare domains or full URLs both work. |
| `renderJavaScript` | Runs the page like a browser. On by default, and worth it. |
| `includeTechnologies` | Keep only sites using these, for example Shopify. |
| `matchMode` | Whether that list means any of them or all of them. |
| `excludeTechnologies` | Drop sites already running a tool you compete with. |
| `categories` | Report only the kinds of technology you care about. |
| `minConfidence` | Set to high to keep only proof from scripts, headers and cookies. |
| `onlyMatching` | Off returns every site with a `matchesFilter` flag. |
| `maxPagesPerSite` | Also read pricing, product or contact pages. |
| `maxRequestsPerCrawl` | Hard cap across the run, for cost control. |

### Output

One row per website, with the flat fields a spreadsheet can filter on and the full detail underneath.

```json
{
  "domain": "gymshark.com",
  "companyName": "Gymshark",
  "ecommercePlatform": "Shopify",
  "cms": "Contentful",
  "analytics": ["Google Analytics 4"],
  "liveChat": ["Intercom"],
  "search": ["Algolia"],
  "advertising": ["Meta Pixel", "TikTok Pixel", "Pinterest Tag", "Reddit Pixel"],
  "technologyCount": 15,
  "technologies": [
    {
      "name": "Shopify",
      "category": "Ecommerce platform",
      "confidence": "high",
      "evidence": "script: https://cdn.shopify.com/s/files/1/assets/theme.js"
    }
  ],
  "matchesFilter": true,
  "checkedAt": "2026-09-02T10:14:22.117Z"
}
```

Export to JSON, CSV or Excel, or push it straight into your CRM.

### Build a list of companies using one specific tool

This is the part people buy it for. Feed in a few hundred domains, name the technology, and keep only the companies that run it.

```json
{
  "websites": ["allbirds.com", "monzo.com", "huel.com", "deliveroo.co.uk"],
  "includeTechnologies": ["Shopify"],
  "onlyMatching": true
}
```

Returns Allbirds and Huel, drops the other two. Swap Shopify for Klaviyo, HubSpot, Intercom or any of the other 162 names. Use `excludeTechnologies` for the mirror image: everyone who has not adopted your competitor yet.

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~tech-stack-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"websites": ["gymshark.com"], "includeTechnologies": ["Shopify"]}'
```

Schedule it monthly against your account list and diff the results. A company that just added Klaviyo or dropped Zendesk is a company with budget moving.

### Two modes

| Mode | Speed | Sees |
| --- | --- | --- |
| Rendered, the default | About 5 seconds a site | Everything a browser loads, tag manager injections included |
| Fast, `renderJavaScript: false` | Under a second a site | Only what is in the raw HTML |

Rendered mode found 15 technologies on Gymshark where fast mode found 3. Use fast mode when you are scanning tens of thousands of domains and only need the platform.

### Pricing

You pay per website checked, whether or not it passes your filters, because that is where the work goes.

| Option | Cost |
| --- | --- |
| Tech Stack Checker | $5 per 1,000 websites |
| BuiltWith | From about $295 a month |
| Store Leads | From about $250 a month for exports |
| Checking by hand | Roughly 3 minutes a site |

A thousand companies qualified for the price of a coffee. New Apify accounts get free monthly credits, so the first runs cost nothing.

### Common questions

**How accurate is it?**
Every detection names its evidence: the script that loaded, the response header, the cookie, or the generator tag. High confidence means a vendor fingerprint that nothing else emits. Medium means a markup pattern. Set `minConfidence` to high when you need certainty over coverage.

**Why did a site come back with almost nothing?**
Some companies genuinely run their own stack and load almost no third party code. That is a real answer, not a failure. Basecamp returns one detection because Basecamp is built that way.

**Can it find every company using Shopify?**
It checks the domains you give it. Bring your list, from a CRM export or another Actor, and this tells you which ones qualify.

**Does it need an API key from a data vendor?**
No. It reads the live site itself, so results reflect what is running today rather than whenever a database was last refreshed.

**Is this legal?**
It reads publicly served pages the same way any browser does. No logins, no personal data, no private information.

### Related products

- **Website Lead Extractor** to pull emails, phones and social profiles for the companies that qualify
- **Hiring Signals Tracker** to see which of them are hiring and for which roles
- Chain all three and you have a qualified account list with contacts and timing, in one pass

# Actor input Schema

## `websites` (type: `array`):

One entry per company. Bare domains such as allbirds.com or full URLs both work.

## `renderJavaScript` (type: `boolean`):

On, each page is rendered and every network request it makes is inspected, which catches the analytics, ad and marketing tools that a tag manager injects at runtime. Off is faster and cheaper on platform usage but only sees what is in the raw HTML.

## `includeTechnologies` (type: `array`):

Return a site only when it uses these technologies, for example Shopify or Klaviyo. Leave empty to return every site. Names are matched loosely, so googleanalytics4 and Google Analytics 4 both work.

## `matchMode` (type: `string`):

How to treat the list above. Any means the site uses at least one. All means it uses every one of them.

## `excludeTechnologies` (type: `array`):

Drop any site running one of these. Useful for finding companies who have not yet adopted a competing tool.

## `categories` (type: `array`):

Limit the report to certain kinds of technology. Leave empty to report everything found.

## `minConfidence` (type: `string`):

High keeps only matches proven by a vendor script, a response header, a cookie or a generator tag. Medium also keeps matches found in page markup.

## `onlyMatching` (type: `boolean`):

On, sites that fail the technology filters are left out. Off, every site is returned with a matchesFilter flag so you can see what was rejected.

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

The homepage is always checked. Raise this to also read pages such as pricing, products or contact, where payment and booking tools usually appear.

## `maxRequestsPerCrawl` (type: `integer`):

Hard cap on requests across the whole run, for cost control. Leave empty for no cap.

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

Optional proxy for larger runs or sites that rate limit by IP.

## Actor input object example

```json
{
  "websites": [
    "allbirds.com"
  ],
  "renderJavaScript": true,
  "includeTechnologies": [
    "Shopify"
  ],
  "matchMode": "any",
  "excludeTechnologies": [
    "Klaviyo"
  ],
  "minConfidence": "medium",
  "onlyMatching": true,
  "maxPagesPerSite": 1
}
```

# Actor output Schema

## `technologyProfiles` (type: `string`):

One row per website, listing every technology detected with its category, confidence and the evidence that proved it.

## `runSummary` (type: `string`):

Counts of websites checked, returned and filtered out, plus any websites that could not be reached.

# 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 = {
    "websites": [
        "allbirds.com",
        "monzo.com",
        "gymshark.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/tech-stack-checker").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 = { "websites": [
        "allbirds.com",
        "monzo.com",
        "gymshark.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/tech-stack-checker").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 '{
  "websites": [
    "allbirds.com",
    "monzo.com",
    "gymshark.com"
  ]
}' |
apify call arched_friend/tech-stack-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/tech-stack-checker"
        }
    }
}

```

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/xhLGx3Bz9HvlQFAAq/builds/VjMy23wLCHAVQQAEe/openapi.json