DEV Community: Hapol Data

Get daily Greenhouse, Lever and Ashby job alerts in n8n

Hapol Data — Mon, 12 Oct 2026 14:08:17 +0000

Disclosure: I make the Apify actor linked at the end, as Hapol Data. The workflow below doesn't need it.

Greenhouse, Lever and Ashby each publish a free, public JSON API for every company job board: the same data their own careers pages load. This post builds an n8n workflow that runs every morning, calls all three, puts the jobs into one shape, and returns only jobs that are new since the last run. You can add Slack, email or Google Sheets at the end.

Everything below was tested in a self-hosted n8n 2.42.7 on Oct 12, 2026; the numbers are from those runs.

1. The three endpoints

curl -s "https://boards-api.greenhouse.io/v1/boards/gitlab/jobs"
curl -s "https://api.lever.co/v0/postings/palantir?mode=json"
curl -s "https://api.ashbyhq.com/posting-api/job-board/ashby"

On Oct 12 these returned 221 (GitLab), 309 (Palantir) and 68 (Ashby) jobs. You don't need a key for any of them. To use another company, change the slug, which is the part after greenhouse.io/, jobs.lever.co/ or jobs.ashbyhq.com/ in its careers URL.

The three responses use different shapes:

	Greenhouse	Lever	Ashby
Jobs live in	`jobs` array	top-level array	`jobs` array
Title	`title`	`text`	`title`
Link	`absolute_url`	`hostedUrl`	`jobUrl`
Location	`location.name`	`categories.location`	`location`
Posted	`first_published` (ISO)	`createdAt` (epoch ms)	`publishedAt` (ISO)

2. The workflow

Schedule Trigger → Greenhouse jobs → Lever jobs → Ashby jobs → Code

Each HTTP Request node is a plain GET with Execute Once turned on. That setting matters: Lever returns a top-level array, so n8n turns it into 309 items, and without Execute Once the Ashby node would run 309 times. In our runs, with Execute Once on, the Ashby node ran once and output 1 item.
The Code node reads all three responses with $('Node name'), normalizes them, filters by title keyword, and uses $getWorkflowStaticData('global') to remember the job IDs it has already seen.

The Code node:

// Normalize Greenhouse, Lever and Ashby responses into one job list,
// then keep only jobs not seen in a previous production run.
const KEYWORDS = ['engineer'];            // empty array = keep all titles
const jobs = [];

for (const j of $('Greenhouse jobs').first().json.jobs ?? []) {
  jobs.push({ key: `greenhouse:gitlab:${j.id}`, company: 'GitLab', title: j.title,
    location: j.location?.name ?? '', url: j.absolute_url, postedAt: j.first_published ?? null });
}
for (const item of $('Lever jobs').all()) {
  const j = item.json;
  if (!j.id) continue;
  jobs.push({ key: `lever:palantir:${j.id}`, company: 'Palantir', title: j.text,
    location: j.categories?.location ?? '', url: j.hostedUrl,
    postedAt: j.createdAt ? new Date(j.createdAt).toISOString() : null });
}
for (const j of $('Ashby jobs').first().json.jobs ?? []) {
  jobs.push({ key: `ashby:ashby:${j.id}`, company: 'Ashby', title: j.title,
    location: j.location ?? '', url: j.jobUrl, postedAt: j.publishedAt ?? null });
}

const matches = jobs.filter(j => !KEYWORDS.length ||
  KEYWORDS.some(k => (j.title ?? '').toLowerCase().includes(k.toLowerCase())));

// Static data is only saved for production (active, trigger-started) executions.
const state = $getWorkflowStaticData('global');
const seen = new Set(state.seen ?? []);
const fresh = matches.filter(j => !seen.has(j.key));
state.seen = matches.map(j => j.key);   // only remember jobs still listed

return fresh.map(j => ({ json: j }));

The seen-list keeps only jobs that are still listed, so it doesn't grow forever.

3. Import it

Copy this JSON and paste it onto an empty n8n canvas (Ctrl/Cmd+V). On self-hosted n8n you can also save it as a file and run n8n import:workflow --input=workflow.json, which is how we tested it:

{
  "name": "Daily Greenhouse/Lever/Ashby job alerts",
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "triggerAtHour": 8
            }
          ]
        }
      },
      "name": "Every day at 8:00",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.2,
      "position": [
        0,
        0
      ],
      "id": "trigger"
    },
    {
      "parameters": {
        "url": "https://boards-api.greenhouse.io/v1/boards/gitlab/jobs",
        "options": {}
      },
      "name": "Greenhouse jobs",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        220,
        0
      ],
      "executeOnce": true,
      "id": "greenhouse-jobs"
    },
    {
      "parameters": {
        "url": "https://api.lever.co/v0/postings/palantir?mode=json",
        "options": {}
      },
      "name": "Lever jobs",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        440,
        0
      ],
      "executeOnce": true,
      "id": "lever-jobs"
    },
    {
      "parameters": {
        "url": "https://api.ashbyhq.com/posting-api/job-board/ashby",
        "options": {}
      },
      "name": "Ashby jobs",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        660,
        0
      ],
      "executeOnce": true,
      "id": "ashby-jobs"
    },
    {
      "parameters": {
        "jsCode": "// Normalize Greenhouse, Lever and Ashby responses into one job list,\n// then keep only jobs not seen in a previous production run.\nconst KEYWORDS = ['engineer'];            // empty array = keep all titles\nconst jobs = [];\n\nfor (const j of $('Greenhouse jobs').first().json.jobs ?? []) {\n  jobs.push({ key: `greenhouse:gitlab:${j.id}`, company: 'GitLab', title: j.title,\n    location: j.location?.name ?? '', url: j.absolute_url, postedAt: j.first_published ?? null });\n}\nfor (const item of $('Lever jobs').all()) {\n  const j = item.json;\n  if (!j.id) continue;\n  jobs.push({ key: `lever:palantir:${j.id}`, company: 'Palantir', title: j.text,\n    location: j.categories?.location ?? '', url: j.hostedUrl,\n    postedAt: j.createdAt ? new Date(j.createdAt).toISOString() : null });\n}\nfor (const j of $('Ashby jobs').first().json.jobs ?? []) {\n  jobs.push({ key: `ashby:ashby:${j.id}`, company: 'Ashby', title: j.title,\n    location: j.location ?? '', url: j.jobUrl, postedAt: j.publishedAt ?? null });\n}\n\nconst matches = jobs.filter(j => !KEYWORDS.length ||\n  KEYWORDS.some(k => (j.title ?? '').toLowerCase().includes(k.toLowerCase())));\n\n// Static data is only saved for production (active, trigger-started) executions.\nconst state = $getWorkflowStaticData('global');\nconst seen = new Set(state.seen ?? []);\nconst fresh = matches.filter(j => !seen.has(j.key));\nstate.seen = matches.map(j => j.key);   // only remember jobs still listed\n\nreturn fresh.map(j => ({ json: j }));\n"
      },
      "name": "Normalize and keep new",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        880,
        0
      ],
      "id": "code"
    }
  ],
  "connections": {
    "Every day at 8:00": {
      "main": [
        [
          {
            "node": "Greenhouse jobs",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Greenhouse jobs": {
      "main": [
        [
          {
            "node": "Lever jobs",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Lever jobs": {
      "main": [
        [
          {
            "node": "Ashby jobs",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Ashby jobs": {
      "main": [
        [
          {
            "node": "Normalize and keep new",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1"
  }
}

Then activate (publish) the workflow. The seen-list is workflow static data, and n8n does not save it when you run the workflow manually from the editor, so test runs from the editor keep returning every match. Once the workflow is active and started by its schedule, the seen-list sticks between runs (see the test below).

4. What we actually tested

We imported the JSON above with n8n import:workflow into a local n8n 2.42.7 and ran it. For the schedule test we used a copy whose trigger fired every minute instead of daily at 8:00; nothing else changed. Output of the last node, per execution:

execution  how it started                    "Normalize and keep new" items
1          n8n execute (CLI)                 318
2          n8n execute (CLI)                 0
3          manual run (editor, seen-list cleared first)   318, seen-list not saved
4          schedule trigger (active)         318
5          schedule trigger, 1 min later     0
6          schedule trigger, 2 min later     0

318 is the number of the 598 jobs with "engineer" in the title that day. So: the first production run returns everything that matches, later runs return only new jobs, and editor test runs don't touch the seen-list. One thing we didn't expect: runs started with n8n execute from the CLI do save it (execution 2 returned 0).

The first item it returned:

{"key":"greenhouse:gitlab:8843512002","company":"GitLab","title":"Backend Engineer, Create: Repository Management","location":"Remote, United Kingdom","url":"https://job-boards.greenhouse.io/gitlab/jobs/8843512002","postedAt":"2026-09-24T17:59:06-04:00"}

5. Send the alert

Connect a Slack, Gmail or Google Sheets node after the Code node. Each new job arrives as one item, with {{ $json.title }}, {{ $json.company }}, {{ $json.location }} and {{ $json.url }} available. If you want a single digest message, put an Aggregate node in front.

6. When you have many companies

Adding a company means adding a node and a few lines of mapping, and you need to know which ATS it uses. If you'd rather not maintain that, I also publish a Greenhouse, Lever & Ashby Jobs API actor on Apify that takes a list of boards and returns one normalized schema. (Disclosure: I make this actor.) The workflow above works fine without it.

Hapol Data: Web Data. Automated.

How to track new jobs from Greenhouse, Lever and Ashby (daily alerts, no HTML scraping)

Hapol Data — Sat, 10 Oct 2026 02:10:42 +0000

Many startups and tech companies host their careers pages on Greenhouse, Lever or Ashby. All three publish a free, public job-board API: the JSON their own careers pages load. So you don't need to scrape HTML to watch a company's openings. You need to:

find each company's board,
call the right endpoint,
remember what you've seen, so you're alerted only to new jobs.

We'll do it by hand first, then with Hapol Data's Greenhouse, Lever & Ashby Jobs API actor on Apify.

Disclosure: I build these actors as Hapol Data.

Who this is for: job seekers ("new roles at my favourite companies, every morning"), recruiters and sourcers, job boards and newsletters, and sales teams that treat new openings as a buying signal.

Step 1: Find the company's board (the "slug")

Open the company's careers page and click a job. The URL tells you the ATS and the board name:

URL looks like…	ATS	Slug
`boards.greenhouse.io/gitlab` or `job-boards.greenhouse.io/gitlab`	Greenhouse	`gitlab`
`jobs.lever.co/palantir`	Lever	`palantir`
`jobs.ashbyhq.com/ashby`	Ashby	`ashby`

If the board is embedded on the company's own domain, look for greenhouse, lever or ashbyhq in the page source or the "Apply" link.

Step 2: Call the public APIs yourself

curl -s "https://boards-api.greenhouse.io/v1/boards/gitlab/jobs"
curl -s "https://api.lever.co/v0/postings/palantir?mode=json"        # EU boards: api.eu.lever.co
curl -s "https://api.ashbyhq.com/posting-api/job-board/ashby?includeCompensation=true"

When we ran these on Oct 9, 2026, they returned 221, 309 and 68 jobs. Each call returns the whole board. But the three responses look nothing alike. These are the top-level fields of one job from each:

Greenhouse: absolute_url, company_name, first_published, id, location, title, updated_at, ...
Lever:      applyUrl, categories, country, createdAt, hostedUrl, id, text, workplaceType, ...
Ashby:      applyUrl, compensation, department, isRemote, jobUrl, location, publishedAt, team, title, ...

The title is title in two APIs and text in Lever. Dates are ISO strings in Greenhouse and Ashby, and epoch milliseconds in Lever. Salary exists only in Ashby (and in some Lever boards). To get new jobs, you also have to store every ID and diff on each run. That's easy for one company and a chore for fifty.

Step 3: One schema across all three, without code

The Jobs API actor calls the same official endpoints and normalizes the results. Here's the input we used. Note the deliberately fake board at the end:

{
  "boards": ["greenhouse:gitlab", "https://jobs.lever.co/palantir", "ashby:ashby", "notarealboard-xyz123"],
  "onlyNew": true,
  "stateKey": "article-demo",
  "maxJobs": 2000
}

The run log:

Board greenhouse:gitlab: 221 jobs
Board lever:palantir: 309 jobs
Board ashby:ashby: 68 jobs
WARN  Board notarealboard-xyz123: no Greenhouse, Lever or Ashby board named "notarealboard-xyz123"
Done: 598 jobs saved from 3/4 boards (598 matched filters, 598 new since last run).

The missing board appears in the Board status output (BOARDS) with every ATS it tried, and it costs nothing:

{ "input": "notarealboard-xyz123", "exists": false, "triedAts": ["greenhouse", "lever", "ashby"] }

Here's the same job shape from each ATS. These are real rows, trimmed only where marked:

{
  "jobId": "greenhouse:gitlab:8860302002",
  "ats": "greenhouse", "board": "gitlab", "company": "GitLab",
  "title": "Account Executive - France",
  "location": "Remote, France", "workplaceType": "remote", "isRemote": true,
  "postedAt": "2026-10-02T15:31:50.000Z",
  "jobUrl": "https://job-boards.greenhouse.io/gitlab/jobs/8860302002",
  "isNew": true
}

{
  "jobId": "lever:palantir:6ed76ce8-4156-4b60-b120-403538bd66cd",
  "ats": "lever", "board": "palantir",
  "title": "Administrative Business Partner",
  "team": "Administrative",
  "location": "Singapore, Singapore", "country": "SG",
  "workplaceType": "hybrid", "isRemote": false, "employmentType": "Full-time",
  "postedAt": "2026-08-11T17:38:11.368Z",
  "jobUrl": "https://jobs.lever.co/palantir/6ed76ce8-4156-4b60-b120-403538bd66cd",
  "applyUrl": "https://jobs.lever.co/palantir/6ed76ce8-4156-4b60-b120-403538bd66cd/apply",
  "isNew": true
}

{
  "jobId": "ashby:ashby:7458d4e9-da2e-47bd-98cb-adfda43d42b2",
  "ats": "ashby", "board": "ashby",
  "title": "Engineering Manager - EU",
  "department": "Engineering", "team": "EMEA Engineering",
  "location": "Remote - European Union",
  "locations": ["Remote - European Union", "Spain", "Italy", "Germany", "… 16 more"],
  "workplaceType": "remote", "isRemote": true, "employmentType": "FullTime",
  "postedAt": "2024-03-04T14:29:08.532Z",
  "compensationSummary": "€110K – €185K • Offers Equity • Offers Bonus",
  "salaryMin": 110000, "salaryMax": 185000, "salaryCurrency": "EUR", "salaryInterval": "1 YEAR",
  "jobUrl": "https://jobs.ashbyhq.com/ashby/7458d4e9-da2e-47bd-98cb-adfda43d42b2",
  "isNew": true
}

Things to notice:

company is filled only for Greenhouse, because Lever's and Ashby's public APIs don't return a company name. Use board as the identifier.
Salary showed up only on the Ashby rows (all 68 in this run). Greenhouse's public jobs list has no pay, and Lever has it only when a company publishes a range. Palantir's board had none.
postedAt is each ATS's own date. Some postings stay open a long time; the Ashby example above was first published in March 2024.

Step 4: New jobs only (the alert part)

We ran the exact same input again a few seconds later:

New-since-last-run: 598 jobs seen before (state "seen-article-demo", ...).
Done: 0 jobs saved from 3/4 boards (598 matched filters, 0 new since last run).

That's the behavior you want from a daily alert. The first run records everything; later runs output (and bill) only jobs that weren't there before. Each job carries isNew. If a run stops early (max jobs or your spending cap), the saved state isn't advanced, so nothing gets skipped. Use a different stateKey for each separate watchlist. The state lives in a key-value store named job-boards-state in your own Apify account.

Step 5: Narrow it down with filters

A second real run, with bare company names (the actor tries Greenhouse, then Lever, then Ashby) and filters:

{
  "boards": ["gitlab", "palantir", "ashby"],
  "titleKeywords": ["engineer"],
  "remoteOnly": true,
  "postedWithinDays": 30,
  "includeDescription": true
}

Result: 30 jobs out of 598 fetched. 28 came from GitLab and 2 from Ashby. Palantir contributed none, because all 309 of its Lever postings were marked isRemote: false. A few of the matches:

GitLab | Backend Engineer, Create: Repository Management      | Remote, United Kingdom                  | 2026-09-24
GitLab | Engineering Manager, Dedicated Infrastructure          | Remote, Canada; Remote, United States   | 2026-10-05
GitLab | Manager, Support Engineering (AMER)                    | Remote, Canada; Remote, United States   | 2026-10-08
Ashby  | Product Support Engineer - NAMER  ($75K – $140K)       | Remote - US                              | 2026-10-06

With includeDescription, each row also gets descriptionHtml and a clean descriptionText.

Step 6: Schedule it and get notified

In Apify Console, create a Schedule (for example, daily at 07:00) that runs the actor with your saved input and onlyNew: true. To be notified, add an integration on the actor (Console → the actor → Integrations; options include Slack, email, Zapier, Make, n8n and webhooks; check the list in your Console) so each finished run passes on its new rows.

Or start a run and read the results with the Python API client (pip install apify-client). Note that this starts a billed run on your account:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("hapol/job-boards").call(run_input={
    "boards": ["greenhouse:gitlab", "lever:palantir", "ashby:ashby"],
    "onlyNew": True,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    # Lever/Ashby rows have no "company" field; fall back to the board slug
    print(job.get("company", job["board"]), "|", job["title"], "|", job["jobUrl"])

What it costs

The actor charges per job saved, with an optional add-on charge for full descriptions. Missing boards, filtered-out jobs and already-seen jobs are free, so a repeat run with onlyNew that finds nothing new adds no job charges. Check current pricing on the actor page.

Limits and good manners

It supports only Greenhouse, Lever and Ashby boards. Workday, iCIMS and SmartRecruiters aren't supported.
Job descriptions can contain people's names (one Ashby posting in our run opens with the hiring manager introducing herself). If you store descriptions, handle them under the privacy laws that apply to you.
If you republish postings, link back to the original jobUrl/applyUrl, don't present them as your own, and remove them once they close. Check each ATS's terms for your use case.

Summary

Greenhouse, Lever and Ashby already give the data away. The work is in finding the boards, reconciling three formats and remembering what you've seen. Do it with three curl calls and a small database, or schedule Hapol Data's Jobs API actor with onlyNew and get a clean daily list of new roles.

Hapol Data: Web Data. Automated.

How to find WooCommerce, Wix, Squarespace and BigCommerce stores in any niche

Hapol Data — Sat, 10 Oct 2026 02:10:17 +0000

If you sell plugins, migrations, design work or wholesale products to small online shops, you start by building a list of real stores in your niche, on the platform you serve. Most tools and tutorials cover Shopify. Lists of WooCommerce, Wix, Squarespace and BigCommerce stores are harder to put together.

This guide covers:

The manual method (free): search footprints, then a check of each site's public endpoints. You can reproduce every check below with curl.
The automated method: Hapol Data's WooCommerce, Wix, Squarespace & BigCommerce Store Leads actor on Apify, which runs the same checks on a whole list.

Disclosure: I build these actors as Hapol Data.

Step 1: Pick narrow niche keywords

Broad terms ("clothing") return marketplaces, blogs and directories. Narrow ones ("handmade ceramics", "beeswax candles", "dog treats") are more likely to surface small independent stores. Write down 5–10 narrow variations before you start.

Step 2: Find candidates with platform footprints

Each platform leaves traces in its URLs. Combine your keyword with a footprint in a search engine:

Platform	Footprint	Why
WooCommerce	`"handmade ceramics" "add to cart" inurl:/product/`	WooCommerce product pages live under `/product/` by default
Wix	`"handmade ceramics" inurl:/product-page/`	Wix Stores product pages use `/product-page/`
Squarespace	`"handmade ceramics" inurl:/p/`	Squarespace product URLs look like `/shop/p/<product>` (see the real example below). It's a noisy footprint.
BigCommerce	`"handmade ceramics" "bigcommerce"`	Weak footprint, so verification matters most here

Footprints are noisy. Expect blogs, marketplaces and sites that only mention a platform. Step 3 filters those out.

A note on free alternatives: when our actor searched Bing for "handmade ceramics" (1 results page per query), it found 8 candidate sites and 0 confirmed stores. Plain keyword searches without footprints mostly surface non-stores.

Step 3: Verify the platform, and that it's really a store

These checks are all public: the same requests a browser makes. We ran each one against a real store while writing this guide (Oct 9, 2026).

WooCommerce: the public Store API. If this returns product JSON, it's a live WooCommerce store:

curl -s "https://coraandspink.com/wp-json/wc/store/v1/products?per_page=2"

Trimmed result:

Leamington Elephant T-Shirt   price "3200"  GBP  (minor unit 2 → £32.00)
Pouch Potato                  price "2200"  GBP  (→ £22.00)

Tip: prices come in minor units (pence or cents). Divide by 10^currency_minor_unit.

Wix: a response header, then the store sitemap.

curl -sI "https://259-283-2952.wixsite.com/website" | grep -i x-wix-request-id
#  x-wix-request-id: 1791592598.0131...
curl -s -o /dev/null -w "%{http_code}\n" "https://259-283-2952.wixsite.com/website/store-products-sitemap.xml"
#  200  → Wix Stores is publishing products

Squarespace: assets, then product pages in the sitemap.

curl -s https://www.shopmemor.com | grep -o static1.squarespace.com | head -1
#  static1.squarespace.com
curl -s https://www.shopmemor.com/sitemap.xml | grep -o "<loc>[^<]*/p/[^<]*" | head -1
#  <loc>https://www.shopmemor.com/shop/p/christian-casas-x-memor-phone-case-...

BigCommerce: the CDN, then the XML sitemap.

curl -s https://www.bulkapothecary.com | grep -o cdn11.bigcommerce.com | head -1
#  cdn11.bigcommerce.com
curl -s -o /dev/null -w "%{http_code}\n" https://www.bulkapothecary.com/xmlsitemap.php
#  200

A site on the right platform with no public products is a website, not a store. Drop it if you only want merchants.

This is fine for a dozen sites. Past that, it's slow.

Step 4: Automate it with the Store Leads actor

The Store Leads actor runs steps 2–3 for every site:

Open the actor on Apify Store and click Try for free (free Apify account).
Add keywords, a list of domains, or both.
Choose Platforms (e.g. only wix).
Set Max stores, and optionally a max cost per run.
Start the run.

Here's the exact domain-list input we ran for this guide:

{
  "domains": ["coraandspink.com", "www.bulkapothecary.com", "www.shopmemor.com",
              "https://259-283-2952.wixsite.com/website", "cipherskincare.com",
              "brodo.com", "ugmonk.com", "example.com"],
  "platforms": ["woocommerce", "bigcommerce", "wix", "squarespace"],
  "roleEmailsOnly": true,
  "includeNonStores": true
}

The run summary it produced:

Done: 6 stores saved; 6/8 checked sites were confirmed stores (0 blocked, 1 Shopify skipped).

Domain	Platform	Confirmed store?	Evidence	Products
coraandspink.com	WooCommerce	yes	Store API	15
cipherskincare.com	WooCommerce	yes	Store API	16
brodo.com	WooCommerce	yes	Store API	53
bulkapothecary.com	BigCommerce	yes	product sitemap	3,134
shopmemor.com	Squarespace	yes	product pages in sitemap	35
259-283-2952.wixsite.com/website	Wix	yes	store-products sitemap	82
ugmonk.com	Shopify	not charged (Shopify is handled by a separate actor)	–	–
example.com	none	no	–	–

(Run locally from the actor's source code on Oct 9, 2026. Store data changes, so your numbers will differ.)

Choosing a discovery method (keyword mode):

Your own domain list gives the best hit rate. Export one from a directory, an exhibitor list or your CRM.
Google (default) uses the footprint queries above through Apify's Google Search Scraper, billed to your own Apify account. Check current pricing on the Google Search Scraper page.
Bing is free but best-effort. In our run above it found 0 stores.

Step 5: Read the results

A real WooCommerce record from that run:

{
  "domain": "coraandspink.com",
  "platform": "woocommerce",
  "platformSignals": ["html:wc-plugin-assets", "html:woocommerce-class", "html:wc-blocks", "api:wc-store-v1"],
  "storeConfirmed": true,
  "storeEvidence": "woocommerce-store-api",
  "storeName": "Cora + Spink",
  "productCount": 15,
  "currency": "GBP",
  "priceMin": 17,
  "priceMax": 89,
  "priceAvg": 38.07,
  "priceSampleSize": 15,
  "topCategories": ["Utility Bags", "Best Sellers", "New Stuff", "Tote Bags", "T-Shirts"],
  "socials": {
    "facebook": "https://facebook.com/coraandspink",
    "instagram": "https://instagram.com/coraandspink",
    "tiktok": "https://tiktok.com/@coraandspink",
    "youtube": "https://youtube.com/coraandspink"
  },
  "emails": ["info@coraandspink.com"],
  "phones": [],
  "checkedAt": "2026-10-10T00:35:58.250Z"
}

And a real BigCommerce record. Notice it has no price fields, because BigCommerce doesn't publish prices through a public endpoint we use:

{
  "domain": "bulkapothecary.com",
  "platform": "bigcommerce",
  "platformSignals": ["html:cdn11.bigcommerce", "header:link-bigcommerce", "html:stencil"],
  "storeConfirmed": true,
  "storeEvidence": "bigcommerce-products-sitemap",
  "storeName": "Bulk Apothecary",
  "productCount": 3134,
  "productCountSource": "sitemap",
  "socials": { "facebook": "https://facebook.com/BApothecary", "instagram": "https://instagram.com/bulkapothecary",
               "pinterest": "https://pinterest.com/BulkApothecary", "tiktok": "https://tiktok.com/@bulk_apothecary" },
  "emails": [],
  "phones": ["+18887287612"]
}

What you get depends on the platform:

Field	WooCommerce	BigCommerce	Wix	Squarespace
Product count	exact (Store API)	from sitemap	from sitemap	from sitemap
Currency, price range, top categories	yes	–	–	–
Socials, public emails/phones	yes	yes	yes	yes

In our 6-store run, only 1 store published an email address on the pages checked (base mode). Many small stores offer only a contact form. enriched: true also reads up to two contact/about pages (extra per-store charge).

What it costs

The actor charges per confirmed store, with an extra per-store charge in enriched mode. Non-stores, other platforms, Shopify and blocked sites are free. With Google discovery, the Google Search Scraper pages are billed separately on your own account. Check current pricing on the actor page.

What about Shopify?

Shopify has its own public endpoints (/products.json, /meta.json), so I publish a separate actor for it: Shopify Store Leads. The two don't overlap. In the run above, ugmonk.com was detected as Shopify, and the record says so, but it wasn't charged.

Use the data responsibly

This method collects only what stores publish on their own pages, and by default keeps only role addresses (info@, hello@, sales@). Before contacting anyone, check the rules for you and your recipients: GDPR/UK GDPR and PECR in Europe, CAN-SPAM in the US, CASL in Canada. You may need a lawful basis or consent, a clear sender identity and an easy opt-out. This isn't legal advice.

Summary

Narrow keywords plus platform footprints give you candidates.
Public endpoints (the WooCommerce Store API, Wix/Squarespace/BigCommerce sitemaps) tell you whether a candidate is a real store. Every check above can be reproduced with curl.
For more than a handful of sites, Hapol Data's Store Leads actor runs both steps, and you're charged only for confirmed stores.

Hapol Data: Web Data. Automated.