# BuiltWith Alternative — Tech Stack Leads & Lookup (60M) (`apivault_labs/tech-stack-lookup`) Actor

BuiltWith alternative and tech stack lookup across 60M+ websites. Find Shopify and Klaviyo leads, stack gaps, lookalike companies and technology monitoring alerts. Export contacts, opportunity scores and migration signals for B2B sales.

- **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
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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?

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

## 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 **tech stack lookup**, **Shopify and Klaviyo leads**, lookalike companies and **technology monitoring** across **60 million websites**. Find companies using **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.

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 a short
`columns` 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,
  "columns": [
    "Root Domain", "Company", "Emails", "Matched Technologies",
    "Contactability Score", "Lead Tier", "Why This Lead"
  ]
}
```

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, company size or
freshness to create a sales-ready 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.

#### 📚 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 across 60M technology profiles. 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
- **Dates** — First Detected, Last Found, First Indexed, Last Indexed
- **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.

Leave **Output columns** empty to get all source and intelligence fields, or pick
only the ones you need. 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. Actor start and platform usage may still apply. 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.
> Leave **Output columns** empty for all 59 source fields.

***

### 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 full 60M-site 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

#### 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 |
| `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 | Select output fields; leave empty for all available fields |

#### 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. 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; Actor start and platform usage may still apply. 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. Use `Last Found` /
  `Last Indexed` when recency matters.
- 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 60M-site 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 60M-site database. 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 score, traffic,
employees, revenue or technology spend.

#### 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. Use `Last Found`, `Last Indexed` and related date fields when
available, and independently verify high-value accounts before outreach or
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**.

# 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 for detect, lookalike and monitor. Accepts hostnames or URLs. Unknown domains are skipped, so a successful run can return an empty dataset.

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

Used in Monitor mode. Reuse the same name and domain list on scheduled runs to compare the current profile with the saved baseline.

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

Detect common technologies from the current public homepage and return confidence/evidence alongside the stored profile. Detect mode only; capped at 100 domains per run.

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

Optional shortcut for a commonly requested technology. It is combined with custom Technologies below.

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

Optional ready-made stack-gap campaign. It automatically adds the required and missing technologies and produces an opportunity score plus suggested pitch.

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

Used in Find websites mode. Type each technology and press Enter. Examples: Klaviyo, Stripe, Shopify Plus, HubSpot, Cloudflare, PayPal, Mailchimp, Attentive, Yotpo, Gorgias. Use complete product names for precise results.

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

How to combine the technologies above. 'Any' = uses at least one of them (OR). 'All' = uses every one of them (AND, e.g. Shopify + Klaviyo).

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

Sites using ANY of these are removed from the results. Example: find Klaviyo users that do NOT use Yotpo. Type each one and press Enter.

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

Which part of the stack to search in. 'Any layer' searches all of them (recommended — a tool can appear in more than one, e.g. HubSpot as CRM and marketing).

## `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.

## `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`):

Upper limit on returned rows per run (across all platforms combined). Max 250000. Need more than one run's worth? There is no total cap — use Offset to page through unlimited results across runs.

## `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`):

Choose the fields to export. Leave empty for all 59 available fields. Each website is returned as one result row.

## Actor input object example

```json
{
  "mode": "find",
  "monitorName": "my-tech-monitor",
  "verifyLive": false,
  "technologies": [
    "Klaviyo"
  ],
  "matchMode": "any",
  "category": "any",
  "hasEmail": false,
  "hasPhone": false,
  "newWithinDays": 0,
  "lastIndexedWithinDays": 0,
  "lastFoundWithinDays": 0,
  "sortDesc": true,
  "dedupeByDomain": true,
  "countOnly": false,
  "maxItems": 50,
  "offset": 0
}
```

# 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.

# 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 = {
    "technologies": [
        "Klaviyo"
    ]
};

// 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 = { "technologies": ["Klaviyo"] }

# 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 '{
  "technologies": [
    "Klaviyo"
  ]
}' |
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/NzvSDtaC42fIAPFms/openapi.json