# BuiltWith Alternative — Tech Stack, Emails & Phones API (`apivault_labs/tech-stack-lookup`) Actor

Look up website technologies or discover indexed technology leads; distinguish indexed evidence from live checks. Bulk export: JSON, CSV, Excel and API. PPE: $3/1K website results; start fee extra.

- **URL**: https://apify.com/apivault_labs/tech-stack-lookup.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Lead generation, Developer tools, Marketing
- **Features:** Limited permissions
- **Stats:** 54 total users, 31 monthly users, 98.8% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 website records

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

## BuiltWith Alternative — Tech Stack Leads & Domain Lookup

![Find websites using technology — B2B lead finder and technology lead lists](https://api.apify.com/v2/key-value-stores/u4YZtIlXXYEybGzl4/records/tech-stack-lookup-hero-v1.png)

Use this **BuiltWith alternative** for **technology leads**, **tech stack lookup**, **Shopify and Klaviyo leads**, lookalike companies and **technology monitoring** using a large historical website index. Find websites by technology such as **HubSpot, Stripe, WordPress, PayPal or Mailchimp**, or paste domains to retrieve their known stack, contacts and firmographics.

> **1 site = 1 result.** A fast, no-subscription **BuiltWith alternative** and **Wappalyzer alternative** for technographics, lead generation and CRM enrichment.

#### Source health and safe monitoring

Open **SUMMARY** and **ERRORS** in the run Key-Value Store to check source
coverage. `partial=true` means some sources were unavailable: useful returned
rows remain available, but coverage and counts are incomplete. If every selected
segment fails, the run fails with no result rows; an empty match from healthy
sources is a valid result. Temporary source failures are reported separately
from matching results.

Monitor preserves its baseline and emits no changes when any source fails.
When a run charge limit stops change output, only delivered changes advance
the baseline. Undelivered changes remain pending for the next run. A failed
dataset write does not advance the baseline.
Lookalike suppresses results if seed lookup is incomplete. This prevents a
missing source from being interpreted as a technology removal or migration.
`verified` still describes a homepage fetch, not validation of every historical
field. Invalid inputs remain errors: Find needs a technology or preset;
Detect, Lookalike and Monitor need domains. SUMMARY/ERRORS explain missing input.

#### Recent homepage observations

Homepage-observation fields are available where a check has been recorded.
Coverage is incomplete, and newly collected profiles may not yet be included in
this Actor. A stored observation is not a guarantee of a current verification.
`Tech Checked At`, `Tech Verification Status` and `Tech Detected Stack` describe
the latest public-homepage attempt. `Tech Evidence` includes its scope and
positive detection evidence. Untouched segments return null for these fields.

Use `techCheckedWithinDays: 7` and `observedTechnologies: ["Shopify"]` alongside
your normal search to require a recent positive homepage observation. The
**Recent homepage observations** view separates those observations from the
historical stack. These filters may return few or no results while coverage
accumulates. A `verified` status means a homepage was fetched; it does not
validate every historical stack field. Failed checks preserve historical data.
Absent homepage signals do not prove a technology was removed. General
The derived `Data Age Days` metric retains its original meaning; the historical date fields themselves are not exported.

For immediate verification of a specific domain list, use the existing
`mode=detect` with `verifyLive=true` (maximum 100 domains). Stored observations and live-on-run checks have separate dates and output
fields. There is no guaranteed refresh interval across the full database; use a
targeted live check for current homepage evidence.

Unlike a plain website database, the Actor can also explain the sales opportunity:
which capability is missing, how strong the lead is, what changed and what to pitch.

![From tech stack search to a scored sales opportunity](https://api.apify.com/v2/key-value-stores/u4YZtIlXXYEybGzl4/records/tech-stack-opportunity-demo-v1.png)

**Example opportunity result (synthetic):**

```json
{
  "Root Domain": "example-store.com",
  "Matched Technologies": "Shopify",
  "Missing Technologies": "Klaviyo",
  "Opportunity Score": 84,
  "Signal Strength": "high",
  "Suggested Pitch": "Offer Klaviyo setup, lifecycle flows or email revenue optimization."
}
```

#### [Start with 10 Shopify-without-Klaviyo leads →](https://apify.com/apivault_labs/tech-stack-lookup/examples/try-shopify-without-klaviyo-10-leads)

***

### AI agent quick start

**Actor tool ID:** `apivault_labs/tech-stack-lookup`

**Agent security:** the Actor requires `LIMITED_PERMISSIONS`. It can use its own
run storages and persistent monitor state but does not request access to unrelated
datasets, tasks or account resources.

For reliable autonomous calls, always send `mode`, `maxItems` and
`outputPreset: "essential"` unless the user asks for specialized fields. Use
`columns` only for an exact custom field list. Keep `dedupeByDomain: true`. Treat an empty dataset as a valid
result: the filter may have no matches, a domain may be unknown, a monitor may
have no changes, or the selected workflow may intentionally use Key-Value Store.

Choose the workflow deterministically:

| User intent | Input contract | Primary output |
|---|---|---|
| Find companies using a technology | `mode=find` + `technologies` | One lead per website |
| Find a sales-ready stack gap | `mode=find` + `opportunityPreset` | Leads with score and pitch |
| Enrich known domains | `mode=detect` + `domains` | Known profiles; unknown domains omitted |
| Verify current homepage signals | `mode=detect` + `domains` + `verifyLive=true` | Stored profile plus live evidence; max 100 |
| Find similar companies | `mode=lookalike` + seed `domains` | Similar leads; seeds excluded |
| Track technology changes | `mode=monitor` + `domains` + stable `monitorName` | Changed domains only; first run is baseline |
| Discover technology names | `mode=catalog` | `TECHNOLOGY_CATALOG`, no dataset rows |
| Estimate segment size | `mode=find` + target + `countOnly=true` | `COUNT_SUMMARY`, no dataset rows |

Minimal agent-safe lead request:

```json
{
  "mode": "find",
  "technologies": [
    "Shopify",
    "Klaviyo"
  ],
  "matchMode": "all",
  "hasEmail": true,
  "dedupeByDomain": true,
  "maxItems": 25,
  "outputPreset": "essential"
}
```

Agent rules:

- Do not invent technology names; use `mode=catalog` when uncertain.
- Do not call a stack gap a migration. Only monitor output with
  `Buying Signal=technology_migration` confirms a change between snapshots.
- Reuse the exact same `monitorName` to continue a monitor baseline.
- Request small batches first. Increase `maxItems` only after checking a sample.
- Semicolon-separated technology/contact fields are strings, not JSON arrays.
- Preserve exact output field capitalization, including spaces.

#### Use through Apify MCP

Expose only this Actor to an MCP-compatible agent:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=apivault_labs/tech-stack-lookup"
    }
  }
}
```

OAuth is recommended. Then ask the agent: *Run
`apivault_labs/tech-stack-lookup` in find mode and return 25 US Shopify websites
using Klaviyo with business emails.*

***

### Five workflows in one Actor

#### 🔎 Find websites by technology

Start with a technology and reverse-find matching domains. Combine required and
excluded tools, then filter by country, industry, contacts or freshness and
sort by company-size signals to create a prospect list.

#### 🧰 Check the tech stack of my domains

Paste domains or URLs you already have. The Actor looks up each known website
and returns its technology profile plus available emails, phones, company data,
social profiles and rankings. Unknown domains are skipped and are not charged.

#### 🧬 Find lookalike companies

Paste a few customer or competitor domains. The Actor identifies their strongest
shared technology signature, then finds other companies with a similar stack.
Seed domains are excluded from the result and each lead includes a similarity
score plus the technologies it shares with the seed profile.

#### 🔔 Monitor technology changes

Give a monitor a stable name and rerun it with the same domains. The first run
saves a private baseline. Later runs return only domains where a technology was
added or removed, so unchanged checks create no per-result charge. Missing
domains do not erase their previous baseline.

The baseline is per domain. Adding a domain to an existing monitor, or finding
a previously unknown domain for the first time, saves its initial stack without
a result charge. Its existing technologies are not reported as new adoptions.
`SUMMARY` reports `requestedDomains`, `knownDomains`, `unknownDomains`,
`newBaselineDomains` and `comparedDomains` after a healthy source lookup. Unknown
domains have no readable indexed profile; this does not mean their stack is empty.
Comparison dates describe observations of the index, not a verified installation
date or a live check of the website. Partial source failures suppress comparisons
and preserve all domain baselines.

#### 📚 Browse the technology catalog

Use **Browse technology catalog** when you are unsure how a product is named or
which stack category to search. The catalog is written to `TECHNOLOGY_CATALOG`
in Key-Value Store and creates no dataset rows.

***

### Find websites using any technology

Give it one or more **technologies** and the Actor finds matching websites in the historical technology index. Instead of checking domains one by one, start with the technology and receive matching companies — ready for lead generation, market research or competitor campaigns.

Combine technologies exactly how your campaign needs:

- **Any (OR)** — sites using at least one, e.g. `Stripe` or `Braintree`
- **All (AND)** — sites using every one, e.g. `Shopify` + `Klaviyo`
- **Exclude** — drop sites using a tool, e.g. Klaviyo users that do **not** use Yotpo

Optionally narrow to one stack layer:

| Stack layer | Examples |
|-------------|----------|
| **Ecommerce platform** | Shopify, WooCommerce, Magento, BigCommerce, PrestaShop |
| **CMS** | WordPress, Wix, Squarespace, Joomla, GoDaddy |
| **CRM** | HubSpot, Salesforce, Brevo, ActiveCampaign, Zoho |
| **Marketing automation** | Klaviyo, Omnisend, Mailchimp, MailerLite, Brevo |
| **Payments** | PayPal, Stripe, Shop Pay, Apple Pay, Google Pay |
| **Hosting** | Cloudflare, AWS, Google Cloud, Vercel, Hostinger |
| **AI tools** | OpenAI, ChatGPT, Google Gemini, chatbots |

Leave the layer on **Any** (default) to match the technology anywhere in the stack — useful because a tool (e.g. HubSpot) can show up as both CRM and marketing automation.

### Technology opportunity leads

Choose a **Sales opportunity preset** to turn a stack gap into an outreach-ready
lead list. The preset automatically configures required and missing technologies.

Available campaigns include:

- Shopify stores without Klaviyo
- Klaviyo users without Yotpo
- Mailchimp replacement prospects
- WooCommerce migration prospects
- HubSpot companies without Klaviyo
- Stripe websites without PayPal

Each result can include `Missing Technologies`, `Opportunity Score`,
`Signal Strength` and `Suggested Pitch`. A stack gap is labelled as a prospecting
opportunity, not as a confirmed migration.

```json
{
  "mode": "find",
  "opportunityPreset": "shopify_without_klaviyo",
  "hasEmail": true,
  "lastFoundWithinDays": 30,
  "maxItems": 50
}
```

### Buying signals from technology changes

Scheduled monitor runs classify real snapshot differences as:

- `technology_adopted`
- `technology_removed`
- `stack_changed`
- `technology_migration` — only when a technology was removed and another was
  added in the same category, such as Mailchimp → Klaviyo

Change rows include migration from/to, opportunity score, signal strength and a
suggested pitch. The first run only establishes the baseline; historical
migrations from before monitoring began cannot be reconstructed.

***

### What you get per site

- **Domain & company** — Root Domain, Primary Domain, Company, Vertical
- **Contact data** — Emails, Telephones, Owner/People
- **Full tech stack** — eCommerce Platform, CMS, CRM, Marketing Automation, Payment Platforms, Hosting Provider, AI tools
- **Firmographics** — Sales Revenue, Employees, Technology Spend, Ticker
- **Social profiles** — LinkedIn, X/Twitter, Facebook, Instagram, and more
- **Rankings** — Tranco, Page Rank, Majestic, Overall Score, Performance, SEO
- **Geo** — City, State, Zip, Country
- **Lead intelligence** — matched technologies and categories, fit score,
  contactability score, lead tier, data age and a plain-language reason
- **Lookalike intelligence** — similarity score and shared technologies

For domain checks, enable **Verify live website** to fetch the current public
homepage and add HTTP status, final URL, live technology signals, confidence,
evidence and technologies found live but missing from the stored profile. Live
verification is intentionally capped at 100 domains per run.

Use **Essential lead fields** for a readable table and efficient AI/MCP calls.
Choose Contacts, Technology stack, Sales opportunity or Full export when needed.
Custom **Output columns** override the preset. Dedicated dataset views make lead
intelligence, live verification and monitor changes easier to scan.

***

### Filters, sorting & limits

- **Countries** — one or more ISO-2 codes (US, DE, GB…)
- **Industry / vertical** — keep only sites in an industry (Fashion, Technology…)
- **Only with email / phone** — keep only sites with contact data (great for outreach lists)
- **Freshness windows** — first indexed, re-indexed or last confirmed within N days
- **Sort by** — Overall Score, Tranco, Sales Revenue, Employees… to get the top accounts first
- **Deduplicate by domain** — enabled by default; no repeated normalized Root Domain values across data segments
- **Max rows** — up to 250,000 per run (no total cap — use offset to page through more across runs)
- **Count only** — preview in `COUNT_SUMMARY` without per-result charges, with counts per data segment and a raw total. The Actor start event may still apply; platform usage is included under the active pricing configuration. Because a domain can occur in several segments, the total is an upper bound for unique websites.

***

### Example

**Input:** `technologies = ["Klaviyo"]`, `excludeTechnologies = ["Yotpo"]`, `country = ["US"]`, `hasEmail = true`

Returns US sites running Klaviyo but **not** Yotpo, with a contact email — ideal for agencies and SaaS teams selling a Yotpo alternative to Klaviyo users.

```json
[
  {
    "Root Domain": "example-store.com",
    "Company": "Example Store",
    "Country": "US",
    "Emails": "hello@example-store.com",
    "eCommerce Platform": "Shopify",
    "Marketing Automation Platform": "Klaviyo",
    "Payment Platforms": "PayPal;Shop Pay;Apple Pay",
    "_platform": "Shopify"
  }
]
```

> `_platform` appears only when several data segments are queried. It identifies
> the segment that supplied the row, not the site's only detected technology.
> Choose **Full export** for all exported source and homepage-observation fields. The default Essential preset
> keeps interactive and AI responses compact.

***

### Use cases

- **Technology lead lists** — build targeted prospect lists from the software companies use
- **SaaS sales** — find websites using a competitor and pitch a replacement
- **Agencies** — find Shopify, WordPress, WooCommerce or HubSpot websites that need your services
- **Market research** — measure technology adoption by country or industry
- **Partnerships & integrations** — find companies using complementary platforms

#### Need a broad ecommerce or CMS lead export?

Use our [Shopify & Ecommerce Store Finder — Emails, Phones & Tech](https://apify.com/apivault_labs/website-leads-database)
to browse the historical website catalog by platform, country, company attributes and
any of 59 fields. Use this Actor when the technology itself defines your target
audience or when you need domain-to-tech lookup.

***

### Quick start

**Bulk search in Apify Console.** Open **Find websites by technology**, choose a technology preset, and set **Maximum websites**. The first-run form starts with Shopify and 5,000 websites. Reduce the number for a trial or set a run spending limit. You can request up to 250,000 websites and use the returned continuation for additional pages. Narrow filters may return fewer matches.

To target one custom stack, clear the preselected Shopify preset before entering your technologies. For example, choose **Every technology (AND)** to find sites using both Shopify and Klaviyo. API calls can send an explicit limit for predictable billing.

#### Check the technology stack of domains

```json
{
  "mode": "detect",
  "domains": [
    "shopify.com",
    "hubspot.com"
  ],
  "maxItems": 50
}
```

Use this workflow for CRM enrichment, competitor research and bulk website
technology checks without a BuiltWith or Wappalyzer subscription.

To confirm current public signals for a small list:

```json
{
  "mode": "detect",
  "domains": [
    "shopify.com",
    "hubspot.com"
  ],
  "verifyLive": true,
  "maxItems": 2
}
```

#### Find companies similar to your customers

```json
{
  "mode": "lookalike",
  "domains": [
    "example-customer.com",
    "another-customer.com"
  ],
  "country": [
    "US"
  ],
  "hasEmail": true,
  "maxItems": 50
}
```

#### Monitor a portfolio for technology changes

```json
{
  "mode": "monitor",
  "monitorName": "agency-clients",
  "domains": [
    "client-one.com",
    "client-two.com"
  ]
}
```

Schedule the same input from Apify Console. The initial run creates the baseline;
subsequent runs output only detected additions or removals.

#### Browse supported examples and aliases

```json
{
  "mode": "catalog"
}
```

#### Find websites using Shopify

```json
{
  "technologies": [
    "Shopify"
  ],
  "country": [
    "US"
  ],
  "hasEmail": true,
  "maxItems": 50
}
```

Use this search to create a Shopify website list for ecommerce services,
development, migration, payments, retention marketing or app partnerships.

#### Find Shopify stores using Klaviyo

```json
{
  "technologies": [
    "Shopify",
    "Klaviyo"
  ],
  "matchMode": "all",
  "hasEmail": true,
  "sortBy": "Overall Score",
  "sortDesc": true,
  "maxItems": 5000
}
```

This creates a technology lead list where every result matches both products.
It is useful for agencies, integrations and SaaS companies with a clearly
defined ideal customer profile.

#### Find competitor users but exclude your customers

```json
{
  "technologies": [
    "Klaviyo"
  ],
  "excludeTechnologies": [
    "Yotpo"
  ],
  "country": [
    "US",
    "GB"
  ],
  "hasEmail": true,
  "maxItems": 10000
}
```

Use exclusions to create replacement campaigns, identify whitespace or remove
companies already using a complementary product.

#### Measure a market before exporting

```json
{
  "technologies": [
    "HubSpot"
  ],
  "country": [
    "DE"
  ],
  "vertical": "Technology",
  "countOnly": true
}
```

Count-only mode helps size an audience before requesting rows. It is a practical
first step for market research and campaign budgeting.

***

### Complete input reference

| Field | Type | What it controls |
|---|---|---|
| `mode` | `find` / `detect` | Reverse-find websites by technology or check a supplied domain list |
| `domains` | string list | Domains or URLs used by the detect workflow |
| `technologies` | string list | Products or tools that websites must use |
| `matchMode` | `any` / `all` | Match at least one technology or every technology |
| `excludeTechnologies` | string list | Remove websites using any listed technology |
| `category` | select | Search any layer or focus on ecommerce, CMS, CRM, marketing, payments, hosting or AI |
| `country` | ISO-2 list | Include selected countries, such as `US`, `GB`, `DE` |
| `vertical` | text | Focus on an industry such as Fashion, Health, Food or Technology |
| `hasEmail` | boolean | Return only rows with an available email |
| `hasPhone` | boolean | Return only rows with an available phone |
| `sortBy` | select | Rank results by score, traffic rank, revenue, employees, spend or recency |
| `sortDesc` | boolean | Return the highest values first when enabled |
| `dedupeByDomain` | boolean | Remove repeated normalized root domains globally; enabled by default |
| `outputPreset` | select | Essential (recommended), contacts, tech stack, opportunity or full export |
| `countOnly` | boolean | Write a raw-row preview to `COUNT_SUMMARY` without per-result charges |
| `newWithinDays` | integer | Keep records first indexed within N calendar days; 0 disables |
| `lastIndexedWithinDays` | integer | Keep records re-indexed within N calendar days; 0 disables |
| `lastFoundWithinDays` | integer | Keep records last confirmed within N calendar days; 0 disables |
| `maxItems` | integer | Maximum rows to return per run, from 1 to 250,000 |
| `offset` | integer | Skip matching rows for paginated exports |
| `columns` | string list | Optional exact field list; overrides `outputPreset` |

#### Choosing Any or All

Use **Any** when several technologies describe the same audience. For example,
`Stripe`, `Braintree` and `PayPal` with Any finds websites using at least one of
those payment tools.

Use **All** when the combination defines your ideal customer. For example,
`Shopify`, `Klaviyo` and `Gorgias` with All finds companies matching the whole
stack combination.

#### Choosing a stack layer

Keep **Any layer** when you care whether a technology is present anywhere in a
company's known stack. Select a specific layer when the product name is broad or
when your analysis requires a particular role:

- **Ecommerce:** Shopify, WooCommerce, Magento, BigCommerce
- **CMS:** WordPress, Wix, Squarespace, Joomla
- **CRM:** HubSpot, Salesforce, Zoho, ActiveCampaign
- **Marketing:** Klaviyo, Mailchimp, Omnisend, Attentive
- **Payments:** Stripe, PayPal, Braintree, Shop Pay
- **Hosting:** Cloudflare, AWS, Vercel, Google Cloud
- **AI:** recognized AI products and website tools

Use complete technology names for precise results. Wildcard characters
(`%`, `_`) are treated literally, rather than as broad search patterns. Product naming can differ
between vendors, editions and integrations, so review a small sample before a
large export.

#### Sorting the best prospects first

For sales prospecting, set `sortBy` to **Overall Score**, **Sales Revenue**,
**Employees** or **Technology Spend** and keep `sortDesc` enabled. For research,
traffic-rank or recency fields may be more useful. Sorting is applied globally
across the selected data segments before `maxItems`, so the result is not biased
toward whichever segment happens to be scanned first. Numeric metrics are
ordered numerically, and Root Domain is used as a stable tie-breaker.

#### Building a recurring fresh-lead feed

Use `newWithinDays` to select recently indexed records and
`lastFoundWithinDays` to require recent confirmation. Save the input as an
Apify Task, inspect its result, and then attach a weekly Schedule if the source
index is being refreshed frequently enough for your audience. Future-dated
source anomalies are ignored by freshness filters and date sorting.

***

### Technology lead-generation playbooks

#### SaaS competitor-user prospecting

Search for websites using a competing product, require an email, select target
countries and sort by company size or score. The resulting B2B lead list can
support personalized outreach based on a relevant, observable technology signal.

Example segments:

- Klaviyo users that do not use your review platform
- HubSpot websites that do not use your integration
- Shopify Plus stores in the United States with contact information
- WordPress businesses in a chosen industry and country
- Stripe users with high traffic or estimated revenue

#### Web-development and migration agencies

Find websites using a platform your agency supports. A WooCommerce agency can
build a WooCommerce website list; a Shopify migration consultancy can identify
Magento or legacy ecommerce users; a CRM consultancy can target HubSpot or
Salesforce accounts by geography and industry.

#### Partnerships and integrations

Use **All** to identify companies whose stack makes them a good integration or
channel partner. Use **Exclude** to remove incompatible products, current
customers or technologies outside your campaign criteria.

#### Account-based marketing

Combine technology, country, industry, contact availability and company signals
to create a focused ABM segment. Select only the columns your CRM needs, export
the results and keep the technology fields for personalization and routing.

#### Market sizing and technology adoption

Run `countOnly` to compare technology audiences without per-result charges. The
result is written to the `COUNT_SUMMARY` key-value record rather than the paid
dataset; The Actor start event may still apply; platform usage is included under the active pricing configuration. Repeat the
same query with different countries or industries to study geographic and
vertical coverage. Counts are raw segment rows and can include the same domain
more than once, so treat the total as an upper bound. Coverage and freshness can vary, so they
should not be treated as audited market-share figures.

***

### More search examples

#### Websites using Shopify or WooCommerce

```json
{
  "technologies": [
    "Shopify",
    "WooCommerce"
  ],
  "matchMode": "any",
  "category": "ecommerce",
  "country": [
    "US",
    "CA"
  ],
  "maxItems": 5000
}
```

#### HubSpot companies in technology

```json
{
  "technologies": [
    "HubSpot"
  ],
  "vertical": "Technology",
  "hasEmail": true,
  "columns": [
    "Root Domain",
    "Company",
    "Country",
    "Emails",
    "LinkedIn",
    "CRM Platform",
    "Marketing Automation Platform",
    "Employees"
  ],
  "maxItems": 2500
}
```

#### Payment technology prospect list

```json
{
  "technologies": [
    "Stripe",
    "Braintree",
    "PayPal"
  ],
  "matchMode": "any",
  "category": "payments",
  "hasEmail": true,
  "sortBy": "Sales Revenue",
  "sortDesc": true,
  "maxItems": 10000
}
```

#### Companies using Shopify and Klaviyo but not Yotpo

```json
{
  "technologies": [
    "Shopify",
    "Klaviyo"
  ],
  "matchMode": "all",
  "excludeTechnologies": [
    "Yotpo"
  ],
  "hasEmail": true,
  "dedupeByDomain": true,
  "maxItems": 10000
}
```

***

### Output views

The default dataset includes views for common workflows:

- **Overview:** domain, company, country and major technology fields
- **Tech Stack:** ecommerce, CMS, CRM, marketing, payments, hosting and AI
- **Contacts:** company, email, phone and social profiles
- **Location:** company, city, state, postal code and country
- **Freshness:** first seen, indexed and last confirmed dates
- **Lead Intelligence:** match, fit, contactability, tier and explanation
- **Stack Gap Opportunities:** missing technology, score, strength and pitch
- **Buying Signals:** monitored adoption, removal and migration events
- **Live Verification:** current homepage signals and evidence

You can download the full dataset or open a focused view in Apify Console. When
calling the Actor through the API, use the `columns` input to keep payloads small
and map output directly into your application or CRM.

***

### Export

Every run stores results in a dataset — download as CSV, JSON, XML or Excel, or pull via API:
`https://api.apify.com/v2/datasets/{datasetId}/items?format=csv`

#### Run through the Apify API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/apivault_labs~tech-stack-lookup/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "technologies": ["Shopify", "Klaviyo"],
    "matchMode": "all",
    "country": ["US"],
    "hasEmail": true,
    "maxItems": 100
  }'
```

For larger exports, start an asynchronous Actor run and read its default dataset
after completion. You can also save a configured input as an Apify Task, call it
from a workflow, or connect the dataset to your preferred integration.

#### Pagination

Use `offset` to request later result windows. Set `sortBy` when stable pagination
is required; without it, the Actor favors a fast balanced mix of data segments.
Keep the same technologies, filters, sorting direction and selected columns
between runs. Duplicate removal is applied before offset pagination. Technology
records can change over time, so export related pages within a reasonably short period.

#### Controlling spend

Start with `countOnly`, then select a practical `maxItems`. This Actor is pay per
result: website rows are the billable output. Your Apify maximum total charge can
stop a run before `maxItems`; increase it only when you intentionally want a
larger export.

***

### Data quality and limitations

- Use complete product names (for example `Shopify Plus`, not `Plus`) for the
  most precise technology matches.
- Coverage and freshness vary by technology and field.
- Rare or very short search terms can take longer than common ones.
- Contact, company, revenue, employee and technology fields may be missing for
  individual websites. Enable contact filters when those fields are required.
- Revenue, spend, rankings and scores are third-party or derived business signals,
  not audited financial statements or guaranteed performance indicators.
- A technology can be renamed, removed, obscured or deployed only on selected
  pages. Validate important accounts before making time-sensitive decisions.
- Counts describe available coverage for the selected query; they are not an
  official census or audited market-share measurement.

***

### Frequently asked questions

#### Is this a BuiltWith or Wappalyzer alternative?

Yes. Use Find mode for reverse technographics — technology to matching websites
— and Detect mode for domain-to-tech-stack lookup. Results can also include
contacts, company data, rankings and geo, with pay-per-result pricing instead of
a monthly subscription.

#### Can I check the technology stack of my own domain list?

Yes. Select **Check the tech stack of my domains**, paste domains or URLs, and
run the Actor. It returns records found in the historical index; unknown domains
are skipped and are not charged.

#### How do I find websites using a specific technology?

Add the technology name, such as `Shopify`, `Klaviyo`, `HubSpot` or `Stripe`, and run the Actor. It returns matching domains from the historical index. Add country, industry, email and phone filters to turn the results into a targeted lead list.

#### Can I find companies using several technologies together?

Yes. Choose **All** to find a specific combination such as Shopify + Klaviyo, or **Any** to find companies using at least one tool from a list. Use **Exclude technologies** to remove sites using a competitor or incompatible product.

#### How is this different from checking websites one by one?

It reverses the usual workflow: start with a technology and export matching websites and company data in bulk. Large technology lead lists are fast and pay per result. Coverage and freshness can vary by field and technology.

#### Can I create a B2B email list by technology?

Yes. Enable **Only with email**, then filter by country or industry. Results can include business emails, phone numbers, company details, social profiles, rankings and the full known technology stack.

#### Can I find websites using Shopify?

Yes. Add `Shopify` to Technologies. You can narrow the Shopify website list by
country, industry, email or phone availability, then sort by supported score, ranking,
employee, revenue or technology-spend fields. Traffic sorting is not an input
to this Actor; use a traffic-enabled lead export when visits are required.

#### Can I find websites using Klaviyo or HubSpot?

Yes. Search for `Klaviyo`, `HubSpot` or both. Choose Any to include either tool,
or All to require both. Add another technology such as Shopify to create a more
specific prospect segment.

#### Can I exclude companies using a competing product?

Yes. Add unwanted products to **Exclude technologies**. A site is removed when
it matches any technology in that list.

#### Does it support bulk exports?

Yes. A run can return up to 250,000 rows, and there is no total cap — use offset
with sorting to page through additional result windows across runs. Start with a
count and choose the fields you need.

#### Which export formats are available?

Apify datasets support JSON, CSV, Excel, XML and additional formats. Results are
also accessible through the Apify API and integrations.

#### Why does a result have an empty field?

Field availability differs by website. A domain may have technology information
without a known email, phone, company name or revenue signal. Use `hasEmail` and
`hasPhone` when those contacts are mandatory.

#### How current are the results?

Freshness varies; historical source dates are not exported.
time-sensitive analysis.

#### Is this an independent technology lead finder?

Yes. This is an independent Apify Actor for reverse technology lookup, market
research and technology-based B2B prospecting.

#### Do I pay for empty searches?

The product uses pay-per-result billing for website rows. Use count-only mode to
size a segment before exporting and review the active Pricing tab for current
event prices and platform-usage terms.

***

### Is it legal, and how should I use this data?

This Actor returns **publicly available business (B2B) information** — it does not
access private, paywalled, or login-protected data.

Some fields (an email, phone, or a person's name tied to a small business) can
qualify as **personal data** under laws such as the EU/UK **GDPR** and the
California **CCPA/CPRA**. When you export and use results, **you** act as the data
controller and are responsible for:

- having a **lawful basis** (for B2B outreach this is usually *legitimate interest*);
- honoring **data-subject rights** (access, correction, deletion, opt-out);
- following **marketing rules** (GDPR/ePrivacy, CAN-SPAM, CASL) before contacting anyone;
- keeping the data secure and using it only for the stated purpose.

#### Responsible use

- Intended for **B2B lead generation, sales, and market research** — prefer business contacts (e.g. `info@`, `contact@`).
- Do not use the data for spam, harassment, or any purpose prohibited by law.

This section is general information, **not legal advice**.

### Ready-to-import n8n workflow

Route technology matches into a sales or migration workflow with the maintained
[Tech Stack Lookup n8n connector](https://github.com/apivault-labs/n8n-nodes-apivault-tech-stack-lookup).
Download the [quickstart workflow](https://github.com/apivault-labs/n8n-nodes-apivault-tech-stack-lookup/blob/main/examples/quickstart-workflow.json),
import it into n8n, add your Apify API credential, and set the technologies you want to find.

Previous 60M/69M headlines describe historical coverage estimates, not a verified count of unique current websites. Counts are segment rows, not unique websites.

### Choose a technology research workflow

This Actor already supports several jobs, but they answer different questions.
Choose the mode first so a historical lookup, live homepage observation and
monitored change do not become interchangeable claims in your CRM.

| Your question | Mode | Evidence you receive | What it does not establish |
| --- | --- | --- | --- |
| Which websites match my technology combination? | find | Stored stack matches and available company/contact fields | Current installation across every page |
| What is known about these domains? | detect | Indexed domain profiles; optional homepage verification | Complete coverage of an unknown domain |
| Which accounts resemble my seed customers? | lookalike | Shared technology signature and similarity signals | Commercial affiliation or buying intent |
| What changed since my saved baseline? | monitor | Differences observed between successful snapshots | Changes before the baseline existed |
| Which technology names should I search? | catalog | A technology catalog in Key-Value Store | A paid website lead list |

#### Start with ten technology-qualified leads

This small AND query is suitable for a Shopify app agency researching
Klaviyo-compatible accounts. Contact availability is required; a match remains
a prospecting record, not confirmation that the business wants a new app.

```json
{
  "mode": "find",
  "technologies": [
    "Shopify",
    "Klaviyo"
  ],
  "matchMode": "all",
  "hasEmail": true,
  "maxItems": 10,
  "dedupeByDomain": true,
  "outputPreset": "contacts"
}
```

#### Research stored profiles before requesting live checks

Use Detect for domains you already know. Unknown domains may be skipped.
Enabling `verifyLive` adds a bounded homepage observation; it does not turn
every indexed technology, email or revenue field into a newly verified fact.

```json
{
  "mode": "detect",
  "domains": [
    "apify.com"
  ],
  "verifyLive": false,
  "maxItems": 3,
  "outputPreset": "tech_stack"
}
```

#### Estimate a technology audience without exporting lead rows

Keep the same technology and geography filters for the subsequent export.
Count diagnostics may contain overlapping segment rows and partial-source
coverage. They are not an audited measure of technology market share.

```json
{
  "mode": "find",
  "technologies": [
    "WordPress"
  ],
  "country": [
    "GB"
  ],
  "countOnly": true,
  "maxItems": 10,
  "outputPreset": "essential"
}
```

#### Build a focused replacement or integration research list

Exclusion means the stored profile did not match the excluded technology. It
does not prove the company has never used it or currently has no private,
server-side or checkout-only integration. Review an account before presenting
the inferred stack gap as a confirmed need.

```json
{
  "mode": "find",
  "technologies": [
    "Shopify",
    "Klaviyo"
  ],
  "matchMode": "all",
  "excludeTechnologies": [
    "Yotpo"
  ],
  "hasEmail": true,
  "maxItems": 10,
  "outputPreset": "opportunity"
}
```

### Cost and result handling for technology research

Active configuration checked 8 November 2026: **$0.003 per delivered website
record ($3 per 1,000)** and **$0.00005 per Actor Start memory unit**, minimum
one unit. Ten delivered website rows at standard memory have event fees of
**$0.03005**. This Actor's active configuration includes platform usage in
the event-price arrangement rather than charging it separately to the user.
Check the [current Pricing tab](https://apify.com/apivault_labs/tech-stack-lookup/pricing)
before a large job. These are event calculations, not a run-time guarantee.

Catalog and count-only jobs write diagnostic records rather than paid website
rows; a start event can still apply. A monitor's first run establishes its
baseline. Read SUMMARY to distinguish baseline creation, no change, missing
coverage and an actual change row. Do not turn a source failure into a
technology-removal alert.

For integrations, store the run ID, dataset ID, query and observation dates.
Re-reading a completed dataset avoids another Actor start. Keep a separate
account-level deduplication key when combining lead searches and domain lookup.
Exporting the same domain in another run is a new delivered result.

### An agency handoff checklist

1. Define the technology combination and country that makes the account useful.
2. Count or inspect a small sample before increasing the output limit.
3. Review stored dates and optional live evidence independently.
4. Keep match reason, contact availability and company-size estimates in
   separate columns; none proves purchase intent.
5. Save a reproducible input or use one of the existing public examples.

This gives sales and migration teams a documented technology prospect list
without requiring them to treat a heuristic score as a verified business fact.

### n8n and developer integrations

Use this Actor in your automation or application with the existing community integrations below. An Apify account and API token are required; Actor and platform charges follow the [current pricing](https://apify.com/apivault_labs/tech-stack-lookup/pricing).

- **n8n community node:** [n8n-nodes-apivault-tech-stack-lookup](https://www.npmjs.com/package/n8n-nodes-apivault-tech-stack-lookup). Install package name `n8n-nodes-apivault-tech-stack-lookup` in a self-hosted n8n instance that permits community packages.
- **n8n source and usage:** [GitHub](https://github.com/apivault-labs/n8n-nodes-apivault-tech-stack-lookup).
- **Python client and examples:** [GitHub](https://github.com/apivault-labs/tech-stack-lookup-python).
- **n8n source and usage:** [GitHub](https://github.com/apivault-labs/apivault-labs/tree/main/community-nodes/n8n-nodes-apivault-tech-stack-lookup).

These are community packages. Publication on npm does not establish n8n verification or availability in n8n Cloud. Review the linked package README for supported inputs and setup.

### Source selection

Fresh database lookups use the warmed source pool. `dataSource: "standard"` uses the previous index. Keep `sourceSession` together with the original filters when continuing a paged query; `EXPORT_SOURCE_SELECTION` stores its token. Source selection pins a live copy, not an immutable snapshot. `parallelReaders: "7"` allows bounded bulk fan-out; `"1"` keeps standard concurrency. Existing lookup, matching and charging rules are preserved. Coverage and speed depend on the selected query and available fields.

### Exported source dates

The historical `First Detected`, `Last Found`, `First Indexed`, and `Last Indexed` fields are omitted from all exported rows and CSV files, including Full output and continuation pages. Existing source-date filters and sorting still operate internally. Other observation dates, such as technology, audit and traffic checks, retain their existing behavior. Source records and stored databases are unchanged.

Legacy date column selections in saved Tasks or API inputs remain accepted for compatibility; those date values are omitted from the resulting rows.

# Changelog

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

# Actor input Schema

## `mode` (type: `string`):

find requires technologies, technologyPreset or opportunityPreset; detect requires domains; lookalike requires seed domains; monitor requires domains and a stable monitorName; catalog needs no other input.

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

Required when mode is detect, lookalike or monitor; ignored otherwise. Accepts hostnames or URLs. Unknown domains are skipped without a result charge.

## `monitorName` (type: `string`):

Used only when mode=monitor. Reuse the same name to compare saved domain baselines. Each newly included or newly found domain establishes its own free baseline; its existing stack is not a new adoption. Changes stopped by the run charge limit remain pending for the next run.

## `verifyLive` (type: `boolean`):

Used only when mode=detect. Check the public homepage and add current technology evidence; capped at 100 domains per run.

## `technologyPreset` (type: `string`):

Used only when mode=find. Choose one popular technology. Clear this selection if you want to search only for custom technologies.

## `opportunityPreset` (type: `string`):

Used only when mode=find. Returns matching leads, missing technology, opportunity score and suggested pitch.

## `technologies` (type: `array`):

Used only when mode=find. Enter complete product names such as Klaviyo, Stripe, Shopify Plus, HubSpot or Cloudflare. AI agents should prefer technologyPreset for one popular technology and technologies for custom or multiple values.

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

Used only when mode=find. any = at least one technology (OR); all = every technology (AND).

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

Used only when mode=find. Exclude sites using any listed technology; e.g. Klaviyo leads without Yotpo.

## `category` (type: `string`):

Used only when mode=find. Limit matching to one stack layer; any is recommended because a product may appear in multiple layers.

## `country` (type: `array`):

One or more ISO-2 country codes, e.g. US, DE, GB. Type each code and press Enter. Empty — no country filter.

## `vertical` (type: `string`):

Keep only sites in this industry, e.g. Fashion, Technology, Health, or Food. Leave empty to include every industry.

## `hasEmail` (type: `boolean`):

Keep only sites where the Emails field is not empty.

## `hasPhone` (type: `boolean`):

Keep only sites where the Telephones field is not empty.

## `newWithinDays` (type: `integer`):

Return websites first added to the index within the last N days. Use 7 for a weekly new-lead feed. Set 0 to disable.

## `lastIndexedWithinDays` (type: `integer`):

Keep websites whose record was indexed within the last N days. Useful for recently refreshed data. Set 0 to disable.

## `lastFoundWithinDays` (type: `integer`):

Keep websites last observed within the previous N days. Use this to prefer recently confirmed leads. Set 0 to disable.

## `sortBy` (type: `string`):

Order rows by this column before applying the limit, so you get the top leads instead of an arbitrary slice. Empty — no ordering.

## `sortDesc` (type: `boolean`):

Highest values first (recommended for scores/traffic/revenue).

## `dedupeByDomain` (type: `boolean`):

Return each normalized Root Domain only once across all data segments. Recommended for lead exports.

## `outputPreset` (type: `string`):

essential is recommended for AI and most lead exports; contacts returns contact fields; tech_stack returns technology fields; opportunity returns sales-gap fields; full returns all source and derived fields. Ignored when columns is provided.

## `countOnly` (type: `boolean`):

Preview stored in COUNT_SUMMARY without per-result charges. Actor start and platform usage may still apply. Counts matching segment rows; the same domain may occur in multiple segments, so this is an upper bound for unique websites.

## `maxItems` (type: `integer`):

The Console starts at 5,000 websites. Choose a smaller limit for a trial or a larger limit for a bulk export. Fewer websites may match your filters or fit your run budget. AI/MCP calls should normally request 5–50 websites.

## `offset` (type: `integer`):

Skip the first N matching rows, then return the next batch. Use it to export more than one run allows: run 1 with Offset 0, run 2 with Offset = the rows you already got, and so on. Set a Sort by column for stable pagination.

## `columns` (type: `array`):

Optional exact field list. When provided, it overrides Output detail. Leave empty to use outputPreset; each website remains one result row. Historical First/Last date selections are accepted for compatibility but are omitted from every exported row.

## `techCheckedWithinDays` (type: `integer`):

Optional: only rows with a server homepage check in this date window. Coverage is gradual. A check does not validate every historical technology; use observedTechnologies for positive recent detections.

## `observedTechnologies` (type: `array`):

Require ALL listed names in the latest successful server homepage observation, for example Shopify. Combine with Homepage checked within days. Unknown or inaccessible pages do not match; absent signals do not prove a technology was removed.

## `dataSource` (type: `string`):

Fresh exports use the warmed source pool when this field is omitted. Older offset-only inputs without sourceSession use the standard index. Keep the sourceSession from the complete continuation input to stay on the same live copy. Platform eligibility and stored field availability are enforced separately; source records can overlap.

## `sourceSession` (type: `string`):

Leave empty for a new export. Keep the opaque value from EXPORT_CONTINUATION.resumeInput unchanged to continue the same source copy. A warmed continuation may reconnect to an older copy that is no longer kept warm.

## `parallelReaders` (type: `string`):

Large exports read more source segments at the same time inside this single run. Results go to one Dataset and each accepted result is charged once. Your spending limit still applies. Small exports keep standard reading; available memory and source performance affect speed. You may switch this setting when continuing an export.

## `exportCursor` (type: `string`):

Optional signed checkpoint from EXPORT_CONTINUATION.resumeInput. Copy the complete resumeInput unchanged except maxItems. Valid for 24 hours, tied to your account, source and filters. Reads saved segment positions without replaying the prefix; live source changes can still affect positions. Omit for a fresh export or legacy offset. Traffic filtering/sorting uses legacy offset.

## Actor input object example

```json
{
  "mode": "find",
  "monitorName": "my-tech-monitor",
  "verifyLive": false,
  "technologyPreset": "Shopify",
  "matchMode": "any",
  "category": "any",
  "hasEmail": false,
  "hasPhone": false,
  "newWithinDays": 0,
  "lastIndexedWithinDays": 0,
  "lastFoundWithinDays": 0,
  "sortDesc": true,
  "dedupeByDomain": true,
  "outputPreset": "essential",
  "countOnly": false,
  "maxItems": 5000,
  "offset": 0,
  "techCheckedWithinDays": 0,
  "sourceSession": "",
  "parallelReaders": "7"
}
```

# Actor output Schema

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

Primary structured output. Contains website leads for find, detect and lookalike workflows, stack-gap opportunities for opportunity presets, or changed domains for monitor runs. An empty dataset is a valid successful result. Catalog and count-only workflows intentionally write no dataset rows.

## `countSummary` (type: `string`):

COUNT_SUMMARY contains raw match counts per data segment. It is written only in count-only mode and has no per-result dataset charge; Actor start and platform usage may still apply.

## `technologyCatalog` (type: `string`):

Popular supported technology names grouped by category, plus naming guidance.

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

SUMMARY reports attempted/successful/failed segments, partial result and row count. Healthy monitor runs also report requestedDomains, knownDomains, unknownDomains, newBaselineDomains and comparedDomains. Newly found domains establish free baselines, not adoption events. All-source failure is FAILED; complete empty match is valid.

## `sourceErrors` (type: `string`):

ERRORS contains affected source categories and stable error codes. Check SUMMARY for incomplete coverage.

# 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 = {
    "mode": "find",
    "technologyPreset": "Shopify",
    "maxItems": 5000
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/tech-stack-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 = {
    "mode": "find",
    "technologyPreset": "Shopify",
    "maxItems": 5000,
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/tech-stack-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 '{
  "mode": "find",
  "technologyPreset": "Shopify",
  "maxItems": 5000
}' |
apify call apivault_labs/tech-stack-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/tech-stack-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/GgG3Xran5X3zZxpRZ/builds/vi5vxBdg8spWvJheh/openapi.json