Domains by Technology Analyzer

Domains by Technology Analyzer — find sites by stack with auto-pagination

✨ What you get

Search 5,000+ technologies (Shopify, WordPress, nginx, Google Analytics, jQuery, React…) and pull a clean list of domains that use them, with optional country filtering and automatic cursor pagination up to 1,000 results per run.

💼 Use cases

• Building a prospect list of every store on one platform — search Shopify with country: US and the run returns US domains running that stack, already de-duplicated and ordered.
• Scoping where a technology is deployed — combine WordPress, WooCommerce and Google Analytics in one run, or drop the country filter to search worldwide, to size a market before you sell into it.
• Getting contact details off the detected sites — each row carries phoneNumbers, emails and socialGraphUrls scraped from the page, plus domainRank so the biggest properties surface first.
• Resuming a large extraction — _lastOffsetToken in the SUMMARY is an opaque cursor you paste into the next run to continue from where the last one stopped.

✅ Who this is for

• B2B prospecting and lead-generation teams — who need a list of domains running a specific platform as a qualification signal.
• Competitive intelligence analysts — sizing how many sites in a market run a given CMS, framework or analytics tool.
• Web development and ecommerce agencies — building a target list of shops on the platform they build for.
• SEO outreach teams — looking for technically relevant sites where a link or a pitch would make sense, using domainRank to order them.

❌ Who this is NOT for

• You need more than 100 domains per run — each run returns exactly 100 domains and the hard cap per run is 100, so anything larger is a paging exercise with offset, not a single export.
• You need the exhaustive footprint of one technology — the upstream enforces offset + limit <= 10000, which puts the ceiling at 9,900 items per (technologies, country, last_visited) query. Beyond that you must add a country filter or split technologies across runs.
• You need every site a technology runs on, stack by stack — up to 10 technologies can be combined in one run and they are OR'd together, so a mixed query returns domains using any of them. The technologies object shows what was detected per domain, but the result set is a union, not a breakdown.
• You need a list of sites currently running the technology — lastVisited is restricted to the current calendar year by default and the filter is hardcoded, so older results need a different filter that this Actor does not expose. Check lastVisited before treating a domain as live.
• You need traffic, revenue, or market-size numbers — the output carries domainRank (a rank score where lower is more popular), title, description and metaKeywords. That is a popularity ordering, not a traffic estimate or an audience figure.

🚀 Quick start

1. Run with Example Input

{
  "technologies": "Shopify\nWordPress",
  "country": "US",
  "limit": 250
}

Returns up to 250 US domains using Shopify OR WordPress.

2. Export Your Results

• Open the run in Apify Console.
• Click the Dataset tab → Export → JSON / CSV / Excel.
• Or fetch the API: GET https://api.apify.com/v2/acts/<ACTOR_ID>/runs/<RUN_ID>/dataset/items

📥 Input parameters

Top-Level Structure

{
  "technologies": "Shopify\nWordPress\nWooCommerce",
  "country": "US",
  "limit": 500,
  "offset_token": ""
}

technologies — Technologies

Required	Type	Default	Description
Yes	string (textarea)	—	One technology per line, or comma-separated. Case-insensitive (normalized via the built-in alias table). Up to 10 per run.

Examples:

Shopify
WordPress
Google Analytics
nginx
WooCommerce, jQuery, React

country — Country Filter

Required	Type	Default	Description
No	string	empty (all countries)	ISO-3166-1 alpha-2 code: US, GB, DE, CN, JP, BR, etc. Leave empty to search worldwide.

limit — Result Limit

Required	Type	Default	Min	Max	Description
No	integer	100	1	1000	How many domains to collect. The Actor cursor-paginates the provider results automatically — setting limit: 500 will fetch 5 the provider pages if needed.

offset_token — Resume From Cursor

Required	Type	Default	Description
No	string	empty	Opaque base64 cursor returned by a previous run. Paste the value of _lastOffsetToken from a SUMMARY record to resume that run from where it left off. Leave empty to start fresh.

📤 Output

Domain Object — one row per matched domain

Field	Type	Description
domain	string	The root domain, e.g. example-store.com.
title	string|null	<title> tag content.
description	string|null	<meta name="description"> content.
metaKeywords	string|null	<meta name="keywords"> content.
domainRank	number|null	Rank score (lower = more popular).
lastVisited	string|null	ISO timestamp of last crawl visit.
countryIsoCode	string|null	ISO-3166-1 alpha-2 country of the IP.
languageCode	string|null	Detected site language.
contentLanguageCode	string|null	<meta http-equiv="content-language"> value.
phoneNumbers	string[]	Phone numbers scraped from the page.
emails	string[]	Email addresses scraped from the page.
socialGraphUrls	string[]	URLs to the site's social profiles.
technologies	object	Map of detected technologies on this domain.
_query	object	Echo of the input that produced this row (technologies, limit, offset, country).
_totalCount	number	Total matching domains (may be > _collected).
_pagesFetched	number	How many pages this run pulled.
_collected	number	Items actually pushed in this run (= limit, or fewer if the provider had less).
_lastOffsetToken	string|null	Opaque cursor to pass into the next run's offset_token to continue paginating. null when the provider has no more pages.

Run Summary

Stored under the SUMMARY key in the default key-value store. Shape:

{
  "ok": true,
  "query": { "technologies": ["..."], "normalizedTechs": ["..."], "limit": 500, "offset": 0, "country": "US" },
  "result": { "totalCount": 12834, "collected": 500, "pagesFetched": 5, "lastOffsetToken": "eyJ...", "hasMore": true },
  "paying": false,
  "freeRunsToday": 2,
  "apiRequests": 5,
  "completedAt": "2026-07-20T12:00:00.000Z"
}

⚙️ How it works

Each run returns exactly 100 domains. To get the next 100, run again with offset = previous_nextOffset.

Run 1: offset=0   → 100 items (1-100),  _nextOffset: 100
Run 2: offset=100 → 100 items (101-200), _nextOffset: 200
Run 3: offset=200 → 100 items (201-300), _nextOffset: 300
...
Run 99: offset=9800 → 100 items (9801-9900), _nextOffset: null (exhausted)

When _nextOffset is null, the provider has no more matches and you've finished.

Hard ceiling: 9900 items per query

The provider enforces offset + limit <= 10000 and rejects anything above (Invalid Field: 'limit'). With limit locked at 100, the maximum reachable offset is 9900 — that's 99 pages × 100 = 9,900 domains per (technologies, country, last_visited) query.

To go deeper:

• Refine your query: add a country filter to scope results to a single market.
• Split technologies: search Shopify in run 1, WooCommerce in run 2, etc.
• Tighten last_visited: the Actor defaults to "visited this calendar year"; older results need a different filter (currently hardcoded — let us know if you need a date range input).

Empty-page handling

If a run returns 0 items (offset past the end), the Actor returns an empty dataset with _nextOffset: null and hasMore: false. No the provider call is made when offset > 9900.

💰 Billing

• Limits: no daily run cap — runs draw on your Apify plan.
• Hard cap per run: 100 domains.
• Hard cap on technologies per run: 10.
• Max pages per query: 99 (offset 0 → 9800, yielding 9,900 items total). Beyond that, refine your query.
• Filter: lastVisited is restricted to the current calendar year by default (results stay fresh).

❓ FAQ

Q: Why do I get fewer results than limit? A: The provider simply does not have that many matches for your query. Check _totalCount in the output or result.totalCount in SUMMARY — that's the real the provider count.

Q: How do I get more than 100 results? A: Run the Actor again with offset set to the value of _nextOffset from the previous run's SUMMARY (or any dataset row's _nextOffset field). Example: run 1 returns 100 items with _nextOffset: 100. Run 2 uses offset: 100 to get items 101-200. Repeat until _nextOffset is null.

Q: Does case matter in technologies? A: No. Input is lowercased and looked up in the alias table (800+ entries). wordpress, WordPress, and WORDPRESS all resolve to canonical WordPress.

Q: Is there a daily run limit? A: No. The Actor keeps no daily quota of its own — a run only stops when your Apify account's spending limit is reached. Raise the limit or upgrade at https://apify.com/pricing.

Q: Why is _collected < limit even though _totalCount > limit? A: The provider returned a page shorter than limit, which means you have reached the end of that result set. Follow _nextOffset rather than assuming each page is full.

📚 Resources

• Console run page: open the run for live logs + retry options.
• Email: sam.wang0420@gmail.com (errors auto-notified via Resend).

MIT License — free to use and modify.

📜 Notes & caveats

Why Use This Actor

Problem	How This Actor Solves It
Need a prospect list of every Shopify store in the US?	Search Shopify + filter country: US in one run.
Need more than 100 results?	Set limit up to 1,000 — the Actor cursor-paginates the provider results automatically so you get a single, de-duplicated, ordered list.
Don't know the exact casing of a technology?	Case is normalized via an 800+ alias table: wordpress → WordPress, GA → Google Analytics.
Need to resume a previous run?	Use offset to skip the first N items.