DEV Community: Zakaria Blefkih

How to build a creator emails pipeline in one Python call

Zakaria Blefkih — Mon, 21 Sep 2026 03:37:47 +0000

Assembling a list of creator emails by hand means three browser tabs, three different column layouts and a lot of copy-paste. None of TikTok, Instagram or YouTube publishes a contact email field, so every address has to be read out of a bio or found on the website the creator links to. And once you have it, you still do not know whether the domain behind it accepts mail at all.

Running three single-platform scrapers is not much better: you get three exports with three different column sets, three separate crawls over the same websites, and no way to see that a brand's TikTok row and its YouTube row are the same business. This post walks through Creator Leads Scraper, an Apify actor by flash_scraper that scrapes TikTok, Instagram and YouTube profiles in a single run, with one row per creator and the same 54 columns on every row, and shows how to pull YouTube creator emails by keyword with one Python call. YouTube is the discovery platform here; TikTok and Instagram enrich the handles you supply.

What you get

Every row has the same 54 columns whichever platform it came from — 48 builder columns plus 6 derived ones appended at the end, so a header-mapped import never shifts. A column a platform cannot supply is null, never missing and never an empty string. The eight columns you will filter on most:

Column	Label	What it holds
`platform`	Platform	`tiktok`, `instagram` or `youtube`
`followers`	Followers	Followers or subscribers — the column every follower filter uses
`followers_estimated`	Followers rounded	`true` when the platform rounds the number (YouTube always does)
`email`	Email	The best address found for the creator, from bio text or the linked website
`email_source`	Email source	Whether the address came from `bio` or `website`
`email_status`	Email status	The verification grade of the best address: `deliverable` / `risky` / `undeliverable` / `unknown` when an email exists, `missing` when none does
`lead_score`	Lead score	0–100 score, computed as points earned divided by the platform's maximum
`discovered_via`	Found via	`input`, `youtube_search`, `youtube_link` or `instagram_related`

A few more are worth knowing. also_on_platforms (Also on) names every other platform this creator was found on, matched_keyword records the searchKeywords entry whose search returned a YouTube channel, and six social URL columns (instagram_url through linkedin_url) form a complete social card. Every run downloads as CSV, JSON or Excel with five saved views.

The verification behind email_status is four checks over DNS and none over SMTP: syntax, an MX record on the domain, a role-address check (a role alias grades risky), and a bundled list of about 8,000 disposable domains that grades undeliverable. No mailbox is ever probed, so read deliverable as "the domain accepts mail and the address is not a known-bad shape", not as proof that the mailbox exists.

A real run

Here is the receipt from a throwaway run on 2026-09-21, using the actor's own "paste and run" input:

input:   { "platforms": ["youtube"], "searchKeywords": ["home barista"], "maxCreators": 10 }
run:     SUCCEEDED 38.0s
status:  Done — 10 creator leads delivered for "home barista" (YouTube 10); 5 carry an email.

Ten creators asked for, ten delivered, five of them with an email, in 38.0 seconds. maxCreators counts creators delivered, not scraped: filters run before the count, and with an email filter set the run keeps discovering in waves (at most 3 extra) until the number you asked for is delivered or every candidate was tried. A blocked or empty platform is reported in the status message by name, never silently skipped, and every run also writes a machine-readable RUN_SUMMARY record to its key-value store.

The Python call

This is the "smallest useful call" from the README, using the apify-client package. The same JSON works in the Console, the REST API and n8n/Make/Zapier.

from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("flash_scraper/creator-leads-scraper").call(run_input={"platforms": ["youtube"], "searchKeywords": ["home barista"], "maxCreators": 5, "enrichEmails": False})
rows = client.dataset(run["defaultDatasetId"]).list_items().items

rows is a list of dicts, one per creator, with all 54 keys present. Two knobs turn this into a pipeline:

enrichEmails is False above to keep the call minimal. Its default is true, and it is the main email source on all three platforms: every creator's linked site is visited (home, /contact, /about) for emails and social profiles.
onlyWithEmail: true drops creators with no email found, before billing. The README's keyword recipe is { "platforms": ["youtube"], "searchKeywords": ["vegan meal prep"], "maxCreators": 30, "onlyWithEmail": true }.

To run it as a monitor, schedule it in Apify Console and set onlyNewCreators: true. The first run is your baseline; every run after it delivers, and bills, only the creators that have appeared since, and a quiet week returns zero rows and charges nothing.

What it costs

You are charged per creator lead delivered after filtering. At the live free-plan rate (measured 2026-08-29) that is $0.002 per lead — $2 per 1,000 creator leads, so $5 buys 2,500 leads. The only other billable event is $0.002 per AI opener, which exists only when you turn writeOpeners on with your own LLM key.

A free Apify account's $5 monthly platform credit therefore covers up to 2,500 creator leads at this rate, less the run's own compute usage. Rows removed by your filters cost nothing, handles that were blocked or do not exist cost nothing, and a run that delivers zero rows charges nothing. The Store Pricing tab is authoritative if the rate changes, and paid plans pay less.

Honest limits

The README has a section called "What this Actor does not do". Its points, in short:

No TikTok or Instagram keyword/hashtag search. Logged-out HTTP exposes no /tag/ data on TikTok and Instagram's search endpoints answer 302/401 (probed 2026-08-09). You supply the handles; YouTube keyword search is the discovery path, optionally hopping to the Instagram/TikTok profiles those channels link to via crossPlatformDiscovery.
No phone numbers, on any platform. None of the three publishes one, so no phone column exists.
No engagement rate on TikTok or YouTube rows. TikTok's public payload carries no play counts (28 of 28 profiles probed) and YouTube's About page carries no per-video likes or comments. Instagram rows carry real engagement metrics from ~12 recent posts; YouTube rows carry lifetime avg_views_per_video instead, plus an approximate posting cadence.
No guaranteed email per row. Emails exist only where the creator published one (bio or linked site). In the 2026-08-09 verification runs, 3 of 9 TikTok creators, 1 of 5 Instagram creators and 6 of 9 YouTube channels on one keyword (4 of 8 on another) ended up with an email after enrichment. Those are small samples; read them as an order of magnitude.
No audience demographics, follower lists, post scraping or DM sending. One row per creator profile is the entire product.

One more caveat from the same README: the email behind YouTube's "View email address" button is not read. That button needs a Google login, a reCAPTCHA and a small daily reveal quota, and the actor stays keyless and logged-out. The row does say whether the button exists, in has_business_email.

Try it

If you want to see the output before writing any code, the example task Find fitness YouTube creators with emails runs a ready-made input. The actor page and pricing are at apify.com/flash_scraper/creator-leads-scraper.

How to scrape local business leads with MX-verified emails in Python

Zakaria Blefkih — Mon, 21 Sep 2026 03:37:10 +0000

Building a table of local business leads usually means chaining several tools: one to discover the businesses in a city, one to find each business's website, one to pull an email off that site, and a verifier so you are not loading dead mailboxes into your CRM. Each category tends to need its own scraper, each scraper needs a proxy budget, and the output columns shift every time one link in the chain changes.

This post walks through one Apify actor, Local Business Leads Scraper by flash_scraper, that collapses that stack into a single actor call. It discovers businesses on OpenStreetMap, crawls each business's own public website, MX-verifies the email it finds and scores every row 0-100, with no API key, no proxy and no login. Used as a business email finder it returns not just the address but whose mailbox that address is. Everything below comes from the actor's README, its dataset schema and one real throwaway run; nothing is estimated.

What you get

One row per business, 73 stable columns wide, exported as CSV, JSON or Excel. The dataset schema describes a row as "identity, location, phone, MX-verified email, socials, website platform and marketing tech, a 0-100 lead score with an A-F grade, and the OpenStreetMap provenance of the row." It covers 95 curated categories (220+ terms) in any city on earth. The eight columns you will read first:

Column	Title	What the schema says it holds
`name`	Name	Business name
`phone`	Phone	Primary phone — the OSM tag, and only the OSM tag; never filled from the site
`email`	Email	Primary contact email, chosen by mailbox ownership then deliverability
`email_status`	Email status	`deliverable` / `risky` / `undeliverable` when verification is on and a candidate exists; `missing` when no email was found
`email_type`	Mailbox owner	`own_domain` / `free_mail` / `third_party` / `unknown` — `third_party` means the address belongs to the business's marketing agency or web designer
`website_platform`	Website platform	CMS / site builder: WordPress, Wix, Shopify, Squarespace, Webflow, GoDaddy, Weebly, Duda and more
`lead_score`	Lead score	0-100 completeness/reachability score
`lead_grade`	Grade	`A` ≥80, `B` ≥65, `C` ≥50, `D` ≥35, else `F`

Two of those deserve a note. email_type decides whether a lead is usable at all: the schema says a third_party address "is deliverable but does not reach the business, and it is scored at half weight." email_status is the result of four checks that run over DNS and never over SMTP: syntax, a mail-server lookup on the domain, a role-address check and a disposable-domain list. No mailbox is ever probed, which is what keeps verification proxy-free and included in the price.

Every row also carries google_maps_url (a constructed search link; nothing is scraped from Google to build it), osm_url pointing at the source OpenStreetMap element, and attribution, the ODbL string the licence requires you to keep with an exported CSV.

A real run

A throwaway run from 2026-09-21, minimal input, no filters:

input:  category 'dentist', location 'Austin, Texas', maxItems 10
run:    SUCCEEDED 16.9s
STATUS MESSAGE: Done — 10 leads delivered for dentists in Austin, Texas. 1 with email (10%), 2 with phone (20%), 2 contactable (20%). 8 of these 10 row(s) have no phone, no email and no social profile — add requireAnyContact: true to drop them before they are charged.

The status message is the honest part. A bare API call keeps every mapped location, including the ones with nothing to contact, and the actor says so and names the switch that fixes it. The README's filter-off benchmark reports the same at larger scale: on a bare {} run of 100 Austin dentists, "50 of the 52 rows with no website had no phone, no email and no social profile either." The Console form pre-fills onlyWithWebsite and pre-ticks requireAnyContact; API calls and schedules leave both off so existing inputs are unchanged.

With onlyWithWebsite: true, the README's reference run (dentist / Austin, Texas, 2026-08-08, n=55) measured a phone on 96% of rows, an MX-verified email on 55%, a detected website platform on 71% and a website on 100%. With every filter off (n=100) the same city measured 48% phone, 26% email and 34% platform.

The Python call

Copied from the README's "Smallest useful call"; the same JSON works in the Console, the REST API and n8n/Make/Zapier:

from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("flash_scraper/local-business-leads").call(run_input={"category": "dentist", "location": "Austin, Texas", "maxItems": 10, "crawlEmails": False})
rows = client.dataset(run["defaultDatasetId"]).list_items().items

The sample sets crawlEmails: False, which the README measured locally on 2026-08-29 at 10 rows in 17 s for $0.03 at the free-plan rate. For a normal run, remove that key or set it to True as the README's fuller input examples do; the defaults are website crawling on, email verification on and 3 pages per website. An API call that sends no maxItems gets 100; the Console form starts at 25.

From there the pipeline is filters. onlyWithWebsite, onlyWithoutWebsite, excludeKeywords, excludeChains and skipClosed are decided from the map data alone, before any website is crawled; onlyWithEmail, onlyVerifiedEmail, requirePhone, requireSocial and requireAnyContact are applied as sites are crawled. Every one drops the row before it is pushed and before it is charged, so maxItems means "this many rows I can use", and the run log names each filter and how many rows it removed. outputFields narrows the columns; name and attribution are always included.

What it costs

From the README's pricing section: "$5 per 1,000 delivered leads, which is $0.005 per lead on the free plan and less on paid plans." Read from the live pricing on 2026-09-14: $0.005 per delivered lead on the free plan and $0.0045 (Bronze) down to $0.0025 (Diamond) on paid plans. You are charged for delivered businesses only, not for API calls or compute, there is no subscription, and the Pricing tab is authoritative. MX verification, mailbox-ownership classification and lead scoring are included in the single per-lead rate; filtered rows are dropped before billing; a run that finds nothing charges nothing.

The README's own arithmetic: the Console form as it opens (cap 25) costs at most $0.125 in leads, and 500 delivered rows cost $2.50; on the website-filtered reference run about 55% carried an email, so 500 rows is roughly 275 with an email. Since filters run before billing, onlyWithEmail: true keeps the bill to rows that carry an email.

What it does not do

Copied from the README's own limits section:

It does not scrape Google Maps. Listings come from OpenStreetMap, so there are no Google star ratings and no Google review counts.
The rating and review_count columns are sparse. They exist only when a business publishes a rating in its own website markup, measured at about 7% of rows (4 of 55 on the 2026-08-08 reference run), and they are never a Google rating. Set minRating or minReviewCount and rows with no rating are dropped, not kept.
Van-based trades are thinly mapped. OpenStreetMap held 171 dentists in the Austin bounding box but 9 plumbers and 5 electricians. A metro of a million people can return single digits for those categories.
A guessed email is never sold as a verified one. A pattern-guessed address stays in email_guess and is never promoted into email.

Three more constraints to script around. A multi-search run is capped at 25 category x location combinations; above it the run fails before any network request and before any charge. Verification never contacts a mail server, so read deliverable as "the domain accepts mail and the address is not a known-bad shape": a catch-all domain, or a mailbox deleted while the domain kept its mail servers, can still grade deliverable. And the listings are ODbL data, so keep the source and attribution columns if you redistribute or publish the rows.

Try it

One quick way to see the columns is the README's "Try it" example task, capped at 25 leads since 2026-09-01: Find local business leads with emails by category. The actor itself, with its Pricing tab, is at https://apify.com/flash_scraper/local-business-leads. Start at the form's cap of 25, read the status message, then raise maxItems once the first run looks right.

How to build a remote jobs scraper across 10 boards in one API call

Zakaria Blefkih — Mon, 21 Sep 2026 03:36:30 +0000

Anyone who has written a remote jobs scraper by hand knows the shape of the work. RemoteOK serves JSON from remoteok.com/api. We Work Remotely publishes an all-jobs RSS feed plus 13 category feeds, and no feed paginates. The Hacker News "Who is hiring?" thread is community-formatted posts (Company | Role | Location | Salary) that you parse yourself. Ten sources, ten shapes, and the same posting often appears on more than one of them.

This post walks through one way to skip that: remote-job-aggregator by flash_scraper, an Apify actor that sweeps 10 keyless remote job boards in one run (RemoteOK, We Work Remotely, Working Nomads, DevITjobs US + UK, The Muse, Remotive, Jobicy, Himalayas and the Hacker News "Who is hiring?" thread) and returns one deduplicated feed with no API key, no proxy and no login. One opt-in board, Arbeitnow, joins only when you add it to boards. Below: the columns, a real run receipt, the Python call, the price, and the limits the README lists about itself.

What you get

One row per remote job, the same columns on every row. The actor is a remote jobs aggregator rather than a single-board scraper: rows are merged across boards by canonical job URL and by (title, company), so the same role listed on two boards ships once. Eight of the columns, with titles and descriptions from the actor's dataset schema:

Column	Schema title	What it holds
`location`	Location	Exactly what the board provides, often a country restriction like "USA Only" or "Anywhere in the World".
`salary_text`	Salary	Derived, always present: one readable string built from `salary_min` / `salary_max` / `salary_currency` / `salary_interval`, e.g. `$90,000–$175,000 / year`; `""` when the board published no figure.
`posted_at`	Posted	Posting date, `YYYY-MM-DD`, when the board provides one.
`source_board`	Source	Which board this (first) copy of the job came from.
`url`	Link	Direct link to the posting (for Remote OK rows this is the job's Remote OK page, as their API terms require).
`seniority`	Seniority	Derived: `entry`, `junior`, `mid`, `senior`, `lead`, `staff`, `principal`, `manager`, `director` or `unknown`.
`also_on_boards`	Also on boards	The other board ids this same posting was found on and merged away (`["remotive"]`; `[]` when none).
`job_id`	Job ID	16-hex fingerprint of the job's canonical URL; stable across runs and the same identity `onlyNewJobs` bills on, so use it as the upsert key.

Hourly, daily, weekly, fortnightly and monthly salary figures are annualized (×2080 / ×260 / ×52 / ×26 / ×12); currency is left null when the board doesn't state it.

A real run

The receipt from a throwaway run on 2026-09-20 that ended up on the default input: all 10 boards, no keywords. Leaving searchTerms empty is valid and returns up to maxItems (default 100) of the current remote jobs across every board.

input: the schema defaults (all 10 boards, no keywords; the keys sent were not in the input schema and were ignored)
run: SUCCEEDED 6.648s
STATUS MESSAGE: Done — 100 remote job(s) delivered for all remote jobs (no keywords) from 10/10 boards (remoteok 10/99 · weworkremotely 10/100 · working_nomads 10/53 · devitjobs_us 10/72 · devitjobs_uk 10/45 · muse 10/100 · remotive 10/20 · jobicy 10/100 · himalayas 10/100 · hn_hiring 10/100); 11 cross-board duplicate(s) merged.

How to read remoteok 10/99: rows delivered from that board over the remote rows it offered before the keyword gate. Results are interleaved round-robin across boards, which is why each board contributed 10 rows to a 100-row order. The 11 cross-board duplicates were merged before the cap and before billing.

The Python call

The README's "Smallest useful call", with apify-client. The same JSON works in the Console, the REST API and n8n / Make / Zapier:

from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("flash_scraper/remote-job-aggregator").call(run_input={"searchTerms": ["python"], "maxItems": 20, "boards": ["remoteok", "jobicy", "remotive", "working_nomads"]})
rows = client.dataset(run["defaultDatasetId"]).list_items().items

Two details before you change the input. boards here is restricted to the four single-request boards: the README measured 20 rows in 2 s on a local run on 2026-08-29, against 84 s across all ten boards that day, because Himalayas and The Muse are paginated feeds. And an API input that omits matchDescriptions matches titles only; send "matchDescriptions": true to also match tags and the first 500 characters of the description. searchTerms is capped at 10 terms per run; maxItems accepts 1–4000 and defaults to 100.

To turn the call into a pipeline, set onlyNewJobs: true and schedule it. Every later run delivers, and bills, only postings this exact search has never delivered before; a run where nothing is new finishes SUCCEEDED with zero rows and zero cost. Memory lives in a named key-value store in your own Apify account (remote-job-monitor), pruned after 90 days. A ready-made example task: Daily new remote data analyst jobs alert (only new postings).

What it costs

$0.003 per deduplicated job, $3 per 1,000, with no per-run start fee. That is the actor's live pricing record read on 2026-09-14; the Pricing tab on the Store page is always authoritative. So 500 jobs = $1.50, and $5 buys 1,666 jobs (1,666 × $0.003 = $4.998). Apify's free plan needs no card, and its monthly usage credit ($5 at the time of writing) covers about 1,666 deduplicated jobs from this actor if spent on it alone. Paid plans pay less per row: $0.0027 on Bronze down to $0.0015 on Diamond.

Duplicates merge before billing, filtered rows are never charged, and a nothing-new monitoring run or zero-match run charges nothing at all. The four-board call above is at most $0.06 (20 rows × $0.003).

Honest limits

Taken from the README's own limits section and FAQ:

No LinkedIn, Indeed or Glassdoor. Those aren't remote-only boards, and this actor does not cover them.
Feed-limited depth. These are public feeds, not archives: RemoteOK serves its ~100 newest rows, WeWorkRemotely ~100 per feed, Working Nomads ~50 curated rows, Jobicy 200 per call. The Muse and Himalayas paginate deeply (~1,980 and ~2,000 rows, measured 2026-08-19). A run cannot paginate years back; the ceiling is 4,000 deduplicated jobs per run.
Keyword matching is client-side. In title-only mode a Python job titled "Backend Engineer" won't match "python".
Salary coverage varies by board: 35% of rows on the measured 2026-08-15 default run. DevITjobs ~100% of its rows, RemoteOK ~3%, The Muse and Working Nomads none.
DevITjobs contributes remote rows only (~8% of its inventory). Boards change: a board that is down or blocked on a given run is named in that run's status message, never silently, its rows are never billed, and its failure never poisons the other nine.
HN rows are parsed from community-formatted posts. Expect the occasional imperfect company/title split; only posts that explicitly say "remote" are included.
Arbeitnow is opt-in for a reason. A German city board; only rows it flags remote are delivered (34 remote among its first 450 rows, measured 2026-08-25) and it publishes no salary field. Jobspresso is not offered (HTTP 403 to Apify IPs, measured 2026-08-27).
Schedule at most hourly; daily is what the boards justify. Jobicy asks for at most one automated poll an hour and Remotive advises at most 4 requests a day.
The boards' data terms pass through to you. Remotive and Himalayas ask that listings not be resubmitted to third-party job sites or aggregators; Jobicy asks you to keep it as the source; Remote OK asks for a link back. Every row links to the board's own posting in url.

Where to run it

Paste { "searchTerms": ["python"], "maxItems": 100 } or the four-board call above, and you have a deduplicated remote jobs feed without writing ten parsers.

How to build a multi job board scraper feed in one Python call

Zakaria Blefkih — Mon, 21 Sep 2026 03:35:53 +0000

If you have ever tried to assemble a jobs dataset by hand, you know the shape of the problem. LinkedIn, Indeed and Glassdoor each have their own search page, their own paging and their own idea of what a "location" or a "salary" field looks like. Running three scrapers and reconciling them is glue work, and the same role posted on all three lands in your table three times. A multi job board scraper that does the merge for you is the obvious answer, as long as it is honest about what it can and cannot reach.

This article walks through one such tool: the Apify actor flash_scraper/multi-jobboard-scraper. Its README states the pitch plainly: "One search. Up to twelve job boards. One deduplicated row per role — so a job posted to LinkedIn, Indeed and Glassdoor bills you once, not three times." Everything below comes from that README, the actor's dataset schema and one logged run. Where the README says a board is blocked or a column is blank, this article says so too.

What you get: the same 65 columns on every row

Per the README, every row carries "the same 65 columns on every row of every run — a field a board did not publish is null, never a missing column." Eight of them, with the titles and notes from the dataset schema:

Column	Title in the Output tab	What the schema says
`title`	Title	example: `Software Development Engineer, ML Systems, Annapurna Labs`
`company`	Company	Filled from: all boards
`location`	Location	Filled from: all boards
`salary_text`	Salary	example: `$158,100–$213,800 / year`
`salary_min_annual`	Salary min (yearly)	example: `158100`
`found_on_sites`	Found on boards	example: `glassdoor`
`duplicate_count`	Listings for this role	example: `1`
`description`	Description	Filled from: Indeed + Glassdoor always; LinkedIn only with detail fetching

found_on_sites and duplicate_count are the dedup evidence. Company names are normalized before matching, so Wipro and Wipro Limited collapse together, and the merge works across boards only: "five genuinely different openings one employer posted to one board stay five rows."

Hourly, weekly and monthly pay is normalized into salary_min_annual / salary_max_annual (hourly ×2080, weekly ×52, monthly ×12), and salary_text renders the raw salary columns as one readable string.

Seven saved Output views ship with it (Overview, Salary, Cross-board, Remote & location, Company info, Standard table, All columns), exports are CSV, JSON or Excel, and every run writes a RUN_SUMMARY record to its key-value store naming each board's outcome.

A real run

The log of a throwaway run from 2026-09-20, reproduced as written:

## multi-jobboard-scraper — throwaway run 2026-09-20 13:07 UTC, input: searchTerm 'software engineer', location 'New York, NY', boards linkedin+indeed+glassdoor+muse (other keys sent were not in the input schema and were ignored, so the run used the default cap of 20 per board)
Total: 59 jobs - indeed: 20, linkedin: 19, glassdoor: 20
9 of 59 delivered rows mention none of ['software engineer'] in their title or description: {'indeed': 3, 'glassdoor': 6}. LinkedIn in particular never answers 'nothing matched' - it returns loosely related postings. Set strictKeywordMatch=true to drop them before they are billed.
Pushed 59 items to Apify dataset
Done. 59 jobs delivered to the dataset.

Read it honestly: three boards hit or nearly hit the default cap of 20, and The Muse, the fourth board in the input, returned no rows for this search and is absent from the per-board line. The log is shown as written, not tidied. The middle line is the actor's own off-topic warning, and the fix it names, strictKeywordMatch, is "opt-in, off by default" and removes rows before billing, so a filtered row is never charged.

The Python call

The README's "Smallest useful call", copied verbatim:

from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("flash_scraper/multi-jobboard-scraper").call(run_input={"searchTerm": "data analyst", "location": "New York, NY"})
rows = client.dataset(run["defaultDatasetId"]).list_items().items

That is a complete run. Per the README, everything else has a working default: LinkedIn + Indeed + Glassdoor + The Muse, 20 job postings per board, full LinkedIn job details on, Apify datacenter proxy. The same JSON works in the Console, the REST API and n8n/Make/Zapier.

To make it a pipeline, tighten the input with the README's own example:

{
  "searchTerm": "data analyst",
  "location": "Austin, TX",
  "sites": ["linkedin", "indeed", "glassdoor"],
  "maxResults": 50,
  "hoursOld": 168,
  "requireSalary": true,
  "excludeTitleKeywords": ["senior", "intern"]
}

hoursOld is a board-side recency filter. requireSalary and excludeTitleKeywords run inside the actor after scraping and before billing, and RUN_SUMMARY.filter_removed records how many rows each one took. maxResults accepts 1–500 per board.

For a recurring feed, the README's recipe is onlyNewJobs: the actor "remembers every job this exact search has already delivered (in a private named store in your own account) and delivers — and bills — only postings it has not seen before. Identical reruns bill zero (measured: 15 rows, then 0)." Memory is kept per search for 90 days. Add a webhookUrl and each run that delivers rows POSTs a digest to Slack, Discord or any JSON catch hook; quiet runs send nothing.

What it costs

The README's pricing table, with its own caveat that the Store page's Pricing tab is always authoritative:

Event	Free plan	Paid plans
Deduplicated job delivered	$0.005 ($5 per 1,000)	$0.0045 on Bronze down to $0.0035 on Diamond (live pricing record read 2026-08-29)
Run start	$0.00005	$0.00005

Two worked costs at the free-plan rate, from the same section: an untouched form (the four default boards, up to 20 rows each) delivers at most 80 deduplicated jobs for at most $0.40, and a 500-job sweep costs $2.50. A job found on three boards bills once, rows removed by a filter bill nothing, and a failed or empty run bills only the $0.00005 start. Apify's free plan needs no card on file, and its monthly usage credit covers several default-size searches.

Honest limits

Copied from the README's own "What it does not do" section: it never logs in anywhere and never auto-applies; every row is public data. It cannot reach behind login walls. For LinkedIn it reads the pay span on the public search card when a posting carries one, plus posting text; the fuller base-pay block that LinkedIn's public job page shows on some postings (measured 2 of 6 on 2026-08-29) is not parsed yet. It is not a historical archive: each run reads the boards' current listings. And five selectable boards, Google Jobs, ZipRecruiter, Bayt, BDJobs and Naukri, are blocked at the source today.

From the Board status table and the field notes: Glassdoor "403s some runs entirely" and "tops out around ~28-30 rows per query — a board-side cap, not a bug." The Muse carries no salary data: 0 salary fields in 220 measured rows. DevITjobs UK was "discontinued upstream (2026-08-29)", so eleven of the twelve working boards deliver rows today. The seven remote-only boards join remote searches automatically but are deliberately not added to location searches. Three columns, experience_range, vacancy_count and company_reviews_count, are only ever published by Naukri, so expect them blank. And the keyless boards carry licensing terms: Remotive rows "must not be republished on another job board", and Remote OK requires a visible dofollow link back naming Remote OK.

Where to start

If you want a job board scraper that is a single API call away and tells you per board what it actually returned, the actor page carries the live pricing, the Board status table and the full 65-column field list: apify.com/flash_scraper/multi-jobboard-scraper. Run the Python call above once, open RUN_SUMMARY, and decide from the counts whether the feed is worth scheduling.

12 job boards, one table, no API key

Zakaria Blefkih — Sat, 05 Sep 2026 21:06:37 +0000

The short answer

You can query 12 job boards in one run without an API key by using a single Apify Actor that searches LinkedIn, Indeed, Glassdoor and The Muse by default and merges eight keyless boards on request. It returns one row per role, deduplicated across boards, with 54 identical columns every run. A measured run on 8 Aug 2026 turned 90 raw listings into 89 billed rows in 39 seconds.

That is the whole article in one paragraph. The rest is the paste-ready input, the numbers behind it, and the parts that do not work.

Why "one table" is the hard part

Scraping one job board is a solved problem — there are dozens of single-board scrapers. The pain starts at board number two:

The same job appears on three boards. A "Senior Data Analyst" at one company is on LinkedIn, on Indeed and on Glassdoor. Naively concatenating three scrapers' output gives you three rows, three CSV lines, three cold emails to the same recruiter.
Every board names its fields differently. postedDate vs date_posted vs created_at; salary as a string on one board, as min/max integers on another, absent on a third.
Company names do not match. Wipro on one board is Wipro Limited on the next, so a naive group by company never collapses them.

Deduplication has to happen across boards, on normalised company names, before you are charged for the rows.

The input, copy-paste

This is a complete run. Every other field has a working default:

{
  "searchTerm": "data analyst",
  "location": "New York, NY"
}

Defaults you are getting for free: boards ["linkedin","indeed","glassdoor","muse"], 20 results per board, full LinkedIn job details on, Apify's datacenter proxy.

Same thing from the shell:

curl -X POST "https://api.apify.com/v2/acts/flash_scraper~multi-jobboard-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerm":"data analyst","location":"New York, NY","maxResults":30}'

Pass the token as a header, not a query parameter — query strings end up in server logs, proxy logs, stack traces and your own shell history. The Apify API accepts Authorization: Bearer on every endpoint.

The HTTP response body is the rows. No second call to fetch a dataset.

From Python:

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])   # never hardcode the token
run = client.actor("flash_scraper/multi-jobboard-scraper").call(run_input={
    "searchTerm": "data analyst",
    "location": "New York, NY",
    "maxResults": 30,
})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(len(rows), "jobs")
print(rows[0]["title"], "|", rows[0]["company"], "|", rows[0]["found_on_sites"])

maxResults is per board, not per run — the single most common surprise. Four boards at 30 is up to 120 raw listings before deduplication.

What the deduplication is worth, measured

From the Actor's own README, with the dates it publishes:

Run	Result
`data analyst` / New York, NY, 30 per board, 3 boards — 8 Aug 2026	90 raw listings -> 89 billed rows in 39 s, 1 duplicate merged across boards
Untouched form, then-default 3 boards at 20 each — 8 Aug 2026	60 rows in 27 s
Same run, salary coverage	`salary_min_annual` filled on 74 of 89 rows (83%)
Two identical runs a day apart, before only-new mode existed	47% of rows were the same job — a daily schedule was re-buying half its data

Two columns show the merge instead of hiding it:

{
  "title": "Senior Data Analyst",
  "company": "Acme Corp",
  "site": "linkedin",
  "found_on_sites": ["linkedin", "indeed", "glassdoor"],
  "duplicate_count": 3,
  "salary_min": 158100.0,
  "salary_max": 213800.0,
  "salary_interval": "yearly",
  "date_posted": "2026-08-06",
  "job_url": "https://..."
}

One row, one charge, and you can still see which three boards carried it. Salary fields are filled on 59-70% of rows on a default run and 56-60% with LinkedIn detail fetching off (README's own fill table, measured 2026-08-07 and re-checked across all 5,936 delivered rows on 2026-08-23) — Glassdoor publishes pay on 95-100% of its rows, Indeed on 50-80%, LinkedIn on about 35% and only with detail fetching.

The board list, including the ones that do not work

Default: LinkedIn, Indeed, Glassdoor, The Muse.
Optional keyless boards: Remotive, Jobicy, Himalayas, Hacker News "Who is hiring?", Remote OK, We Work Remotely, Working Nomads, DevITjobs US — the remote-only ones join automatically when you tick remote. DevITjobs UK is still selectable but was discontinued upstream on 2026-08-29 (re-probed 2026-09-05: its public endpoint redirects to a signup page), so 11 of the 12 selectable working boards return rows today.

Blocked at the source today and reported as blocked rather than silently returning nothing: Google Jobs, ZipRecruiter, Bayt, BDJobs, Naukri. Glassdoor also tops out at roughly 28-30 rows per query no matter what cap you set — a board-side limit, not a bug in the scraper.

This matters more than it looks: a scraper that returns 0 rows for a board and calls the run a success is indistinguishable from "there are no jobs". Check that whatever tool you use writes a per-board outcome somewhere. This one writes a RUN_SUMMARY record naming each board's result.

Remote-only searches: use the leaner Actor

If your query has no city in it, the big three boards mostly get in the way. There is a separate Actor for that shape — Remote Jobs Aggregator — which sweeps 10 keyless remote boards (RemoteOK, We Work Remotely, Working Nomads, DevITjobs US and UK, The Muse, Remotive, Jobicy, Himalayas, HN "Who is hiring?") with no key, no proxy and no login — DevITjobs UK has been dead upstream since 2026-08-29, so nine deliver rows today, and the run says so:

{ "searchTerms": ["python"], "maxItems": 100 }

Measured default run on 15 Aug 2026: 100 deduplicated jobs from 9 boards, 6 cross-board duplicates merged, 35% of rows carrying a salary, 88% a description snippet, 100% a posting date.

One switch is worth knowing before you run it. matchDescriptions also matches your keyword inside the first 500 characters of the posting, not just the title. Measured on 15 Aug 2026 with ["python"]: 194 rows wide vs 28 title-only — roughly 7x the recall, and a marketing role whose blurb mentions "our Python stack" now matches too. Wide by default in the form, title-only over the API.

Every row carries job_id, a 16-hex fingerprint of the canonical URL — that is your upsert key for Sheets, Airtable or a CRM.

Turn it into a daily alert (the part people actually keep)

Both Actors have an only-new mode that remembers what a given search has already delivered, in a private store in your own account, for 90 days:

{
  "searchTerm": "data analyst",
  "location": "New York, NY",
  "onlyNewJobs": true,
  "webhookUrl": "https://hooks.slack.com/services/T000/B000/XXXX"
}

First run seeds the memory. Every run after that delivers — and bills — only postings it has not seen. A measured pair: 15 rows on the first run, 0 on an identical rerun. Schedule it from the run page (Actions -> Schedule), point webhookUrl at Slack, Discord, or an n8n/Make/Zapier catch hook, and you have a job alert feed you own.

Remember the 47% number above: without only-new mode, a daily schedule pays twice for half its rows.

What it costs

Pay-per-result, $0.005 per delivered row for the multi-board Actor and $0.002 for the remote one (free-plan rates, read from the Store on 5 Sep 2026 — the Pricing tab on each Actor page is always authoritative). The remote Actor has a pricing record scheduled for 14 Sep 2026 that raises it to $0.003 per row, so if you are reading this after that date, take the figure off the Pricing tab, not off this paragraph. Deduplicated and filtered rows are never billed, and a run that delivers nothing bills only a $0.00005 run start.

Practical maths: a 4-board search at 20 per board is at most 80 rows = $0.40. Apify's free plan needs no card and its monthly credit covers several runs of that size.

What neither Actor does

No login, anywhere. Only public data. Nothing behind a login wall, no auto-apply.
No historical archive. Each run reads what the boards are showing today.
No guessed salary. A salary column is empty when the board published no figure — it is never inferred.
Five boards are blocked (listed above), and the run says so instead of pretending.

FAQ

Can I scrape LinkedIn and Indeed jobs without an API key?

Yes. Neither board offers a public jobs API to most developers, but both publish their search results as public pages, and the Actor above reads them without logging in — you only need an Apify API token to call the platform, not a key from LinkedIn or Indeed.

How do I remove duplicate jobs across job boards?

Match on the canonical job URL first, then on (normalised company name, title, location). Normalising the company is the step most home-made pipelines skip, which is why Wipro and Wipro Limited stay two rows. The Actor above does both and exposes the result in found_on_sites and duplicate_count.

How many rows can one run deliver?

A measured stress run on 7 Aug 2026 returned 258 rows from 3 boards at 120 per board in 226 seconds (that run predates a 29 Aug 2026 LinkedIn paging fix, so its 118 LinkedIn rows were not the newest 118; it has not been re-measured since). Per-board inventory, not the cap, is usually the binding limit — Glassdoor stops near 30 per query.

Is there a free way to try it?

Apify's free plan needs no card and carries a monthly usage credit; a default 4-board run costs about $0.40 of it. Both Actors also publish example tasks you can open and run as-is.

Which is the right one for remote work?

If your query has a city, use the multi-board Actor and tick remote — it applies each big board's own remote filter and enforces LinkedIn's client-side (LinkedIn's public search accepts a remote flag and ignores it, so the Actor filters those rows itself before billing). If your query has no city at all, the remote aggregator is cheaper and quieter.

Disclosure: I build and maintain both Actors (Multi Job Board Scraper, Remote Jobs Aggregator, publisher flash_scraper on Apify). Every figure in this post is published in the Actors' own READMEs with the date it was measured; Store user and run counts were read from the public Apify Store API on 5 Sep 2026. If you reproduce a run and get different numbers, tell me in the comments and I will update the post.

Local business emails without scraping Google Maps

Zakaria Blefkih — Sat, 05 Sep 2026 21:00:43 +0000

The short answer

You do not need Google Maps to build a local B2B list. OpenStreetMap gives you the businesses in any city for free, each business's own website gives you the email and phone, and a DNS MX lookup tells you whether the address can receive mail. Measured on 8 Aug 2026: 55 dentists in Austin, 96% with a phone, 55% with an MX-verified email.

Why not Google Maps

Google Maps is the default answer, and for star ratings and review counts it is still the only answer. But it costs you three things:

A proxy bill. Maps is aggressive about datacenter IPs, so most Maps scrapers need residential proxies, which is usually more expensive than the data.
Terms-of-service exposure. Whatever your view of scraping public pages, using Google's own listing data is a policy question you have to answer to your client.
A separate verification step. A Maps listing carries a phone and a website. It does not carry an email, so you end up bolting a crawler and then a verification API onto the pipeline, each with its own bill.

The alternative pipeline is three keyless steps: OpenStreetMap -> the business's own site -> MX check.

Step 1: discovery on OpenStreetMap

OpenStreetMap tags businesses by type (amenity=dentist, shop=hairdresser, office=lawyer, …). Overpass, the query API, is public and keyless. This is the part that surprises people who have only used Maps: for premises-based businesses the coverage is genuinely good.

It is also the part that fails honestly, and you should know the shape of the failure before you sell a list to anyone. Measured in the Austin bounding box on 8 Aug 2026:

Category	Records in OpenStreetMap
dentist	171
plumber	9
electrician	5

Premises get mapped; vans do not. If your niche is trades that drive to the customer, OpenStreetMap alone will not fill a list, and no amount of retrying changes that. Dentists, gyms, salons, law firms, restaurants, clinics, hotels, real-estate offices: dense. Plumbers, roofers, mobile locksmiths: thin.

Step 2: crawl the business's own site

The email is almost never in the map data. It is on the business's contact page. So the crawl is: fetch the homepage, follow the obvious contact/about links, pull mailto: addresses, tel: numbers, social profile links, and the meta generator tag that tells you the site is WordPress or Wix or Squarespace.

Two things worth building in from the start:

Whose mailbox is it? An address on the business's own domain is worth more than a @gmail.com, and both are worth more than the address of the marketing agency that built the site — that one is deliverable and still never reaches the business. On the reference run, 12% of all harvested addresses were third-party (agency) addresses, but only 10% of the ones promoted to primary, because candidates get ranked by mailbox ownership before one is picked.
A blocked site is not a missing business. Some sites refuse datacenter IPs: 8 of the 55 website-bearing rows in the reference run. Record that as site_blocked rather than shipping an empty row that looks like "this business has no email".

Step 3: MX verification, which is a DNS lookup

You do not need a paid verification API to catch the majority of dead addresses. Resolve the domain's MX records (over DNS-over-HTTPS if you are running in a sandbox), and grade the address deliverable / risky / undeliverable. It will not catch a valid domain with a dead mailbox — nothing short of SMTP probing will, and that has its own problems — but it removes typo domains, parked domains and expired domains before you pay for the row.

Never promote a guessed address. info@<domain> is a guess. If you produce one, put it in its own column and never let it satisfy a "has email" filter. On the reference run, the full-enrichment preset produced 100 rows plus 23 guessed addresses — kept in email_guess, never billed as verified.

The whole pipeline as one input

I package the three steps as an Apify Actor, so this is the paste-and-run version:

{
  "category": "dentist",
  "location": "Austin, Texas",
  "maxItems": 25,
  "onlyWithWebsite": true
}

25 delivered rows at the free-plan rate of $0.003 each = $0.075 (a pricing record scheduled for 14 Sep 2026 raises that to $0.005 a row, so $0.125; the Pricing tab on the Actor page is authoritative). No API key, no proxy, no login; discovery, crawl, MX verification and a 0-100 lead score all happen inside that one run.

From the shell:

curl -X POST "https://api.apify.com/v2/acts/flash_scraper~local-business-leads/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"category":"dentist","location":"Austin, Texas","maxItems":25,"onlyWithWebsite":true}'

From Python, keeping only the columns a CRM import wants:

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])   # never hardcode the token
run = client.actor("flash_scraper/local-business-leads").call(run_input={
    "category": "dentist",
    "location": "Austin, Texas",
    "maxItems": 25,
    "onlyWithWebsite": True,
    "onlyVerifiedEmail": True,
    "outputFields": ["name", "email", "email_status", "phone", "website", "lead_grade"],
})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(len(rows), "leads;", sum(r["email_status"] == "deliverable" for r in rows), "deliverable")

Already have a list of company websites and only need the contacts? Skip discovery entirely by passing websiteList — those rows come back marked source: "user_supplied".

A row looks like this:

{
  "name": "Example Family Dental",
  "category": "dentist",
  "address": "123 Example St, Austin, TX",
  "phone": "+1 512 555 0100",
  "website": "https://example-dental.com",
  "email": "hello@example-dental.com",
  "email_status": "deliverable",
  "email_type": "own_domain",
  "website_platform": "WordPress",
  "lead_score": 78,
  "lead_grade": "B",
  "osm_url": "https://www.openstreetmap.org/node/...",
  "attribution": "© OpenStreetMap contributors (ODbL)"
}

The measured fill rates, including the ones I would rather not publish

All from dentist / Austin, Texas, 8 Aug 2026:

Run	Result
Website required, cap 100	55 businesses, 100% contactable — 96% phone, 55% MX-verified email, 71% detected platform. Under the cap because OpenStreetMap holds 171 dentists in Austin and 55 of them are crawlable with a website
Bare `{}`, no filters at all	100 businesses, 50% contactable — 48% phone, 26% email, 34% platform
Cold-email preset	31 rows, 100% with an MX-verified email, 94% with a phone
Call-list preset, cap 100	56 rows, 100% with a phone
Web-design-prospect preset, cap 100	7 rows — 68 Austin businesses met the low-score ceiling, but only 7 of them publish any contact channel at all

The gap between line 1 and line 2 is the honest story of this kind of pipeline: filter for "has a website" and you get a contactable list; ask for everything mapped and roughly half the rows have nothing to contact. Both numbers are published, because a vendor who shows you only the first one is showing you a filter, not a capability.

One more sparse column worth naming: rating fills on about 7% of rows (4 of 55), and only where the business publishes a rating in its own site markup. It is never a Google rating. If you need Google's review data, scrape Google — this pipeline deliberately does not.

Making it a weekly new-business alert

Discovery is idempotent enough to schedule. Turn on only-new mode and the run remembers what this exact search already delivered (90-day memory, stored in your own account), so a weekly schedule delivers and bills only businesses that were not there last week:

{
  "category": "dentist",
  "location": "Austin, Texas",
  "onlyNewBusinesses": true,
  "webhookUrl": "https://hooks.slack.com/services/T000/B000/XXXX"
}

Set expectations honestly: new businesses appear at the speed of OpenStreetMap, which is the speed of volunteer mappers. Weekly or monthly is the right cadence; hourly will mostly report "nothing new" (and bill nothing for it).

Two legal points, not legal advice

OpenStreetMap data is ODbL. Attribution has to travel with the data — that is why every discovered row carries an attribution string, and why you should keep the column in your export rather than stripping it on import.
Cold email has rules that differ by country. In the US, CAN-SPAM makes commercial email opt-out rather than opt-in, but each message still needs a real physical postal address and a working unsubscribe. In the EU and UK, check the ePrivacy/GDPR position for B2B before you send. Verifying that an address exists is not the same as being allowed to mail it.

FAQ

Can I get local business emails without scraping Google Maps?

Yes. Use OpenStreetMap (public, keyless) for discovery, then crawl each business's own website for the address. You give up Google star ratings and review counts, and you gain emails, mailbox ownership, website platform and no proxy bill.

How much does 1,000 local business leads cost this way?

$3 at the Actor's free-plan rate of $0.003 per delivered row (read from the Apify Store on 5 Sep 2026), MX verification included — $5 from 14 Sep 2026, when a scheduled pricing record takes the rate to $0.005 per row. Read the Pricing tab rather than this sentence. Filtered rows are dropped before billing, so a run that finds nothing charges nothing.

Why did my category return so few rows?

Almost always OpenStreetMap density, not a scraping failure. Premises-based businesses are mapped; van-based trades are not. Compare 171 dentists with 9 plumbers in the same Austin bounding box (8 Aug 2026). A run that cannot reach your cap should tell you which of the two happened — a truncation or the whole city.

Is an MX check the same as email verification?

No. An MX check proves the domain can receive mail. It does not prove the specific mailbox exists. It removes typo, parked and expired domains cheaply, which is most of the dead addresses in a scraped list, and it is honest about the rest by grading them risky rather than deliverable.

Can I run this from an AI agent?

Yes, through the Apify MCP server. A minimal input measured locally on 29 Aug 2026 returned 10 rows in 17 seconds for about $0.03: { "category": "dentist", "location": "Austin, Texas", "maxItems": 10, "crawlEmails": false } (that particular input skips the email crawl, so use it for a smoke test, not for a list).

Disclosure: I build and maintain the Actor used in the examples (Local Business Leads Scraper, publisher flash_scraper on Apify). Every fill rate quoted here is published in its README with the date it was measured; the price was read from the public Apify Store API on 5 Sep 2026. The three-step pipeline itself is not proprietary — Overpass, a contact crawler and a DNS MX lookup will get you there yourself, and this post is meant to be enough to build it.

Creator and Influencer Email Scrapers on Apify Compared (September 2026)

Zakaria Blefkih — Sat, 05 Sep 2026 18:35:29 +0000

Almost every creator email scraper on Apify does one platform. dataovercoffee/Youtube-Channel-Business-Email-Scraper is the most used (3,644 users) and reads the login-gated email button, at $120 per 1,000. flash_scraper/creator-leads-scraper is the only Actor in this comparison covering TikTok, Instagram and YouTube in one 51-column schema, at $2 per 1,000.

Every figure below was read from Apify's public Store API on 2026-09-05. Prices here vary by a factor of sixty, so read the Pricing tab before you run anything.

Disclosure: I publish flash_scraper/creator-leads-scraper, one of the actors compared here. Its two biggest limitations are stated below, and one of them is a hard no for influencer discovery on TikTok and Instagram.

Why the prices differ by 60x

Two different products are sold under the same words. One reads what a creator published in public (About text, bio, linked website) and charges cents. The other uses logged-in accounts and CAPTCHA solving to reveal the address behind YouTube's "View email address" button, which is gated by a Google login and a daily reveal quota, and charges dollars. The second returns more emails and carries account and terms-of-service exposure the first does not.

The comparison table

Actor	Users	Rating (reviews)	Price per 1,000	Platforms and coverage	What to watch
dataovercoffee/Youtube-Channel-Business-Email-Scraper	3,644	4.40 (30)	$120.00 per 1,000 emails	YouTube, using logged-in accounts and CAPTCHA solving to reach the gated address	Plus a $280 per 1,000 force-fresh-scrape surcharge; highest price here, and the only one whose listing claims it reaches the login-gated address
exporter24/youtube-email-bulk-scraper	964	5.0 (3)	$30.00 per 1,000 results	YouTube channel emails from public data	Listing names no keyword discovery, so bring your own channel list
lurkapi/youtube-channel-email-scraper	644	5.0 (3)	$5.00 per 1,000 emails found	YouTube About pages: business emails, contact info, social links; accepts @handles, URLs or IDs	Keyword discovery is billed at $0.05 per search query and validation at $1 per 1,000; a discovery-heavy run costs far more than the headline
automation-lab/youtube-channel-email-scraper	203	none yet (0)	$2.30 per 1,000 channels	YouTube About pages: emails, subscriber counts, video counts, all linked socials, no proxy needed	Emails found are billed again at $23 per 1,000, plus a $0.005 run start
haketa/youtube-contact-scraper	92	5.0 (1)	$3.00 per 1,000 results	YouTube keyword search or channel URLs: name, subscribers, views, country, business email, website, all socials	Cheapest keyword-driven YouTube option here; one review
afanasenko/instagram-influencer-search	78	none yet (0)	$10.00 per 1,000 profiles	Instagram hashtag and keyword discovery with follower range, minimum engagement rate, emails, phone, bio links, business category, Reels views	The only real Instagram discovery option in this comparison
funny_ground/tiktok-influencer-finder	6	none yet (0)	$5.00 per 1,000 results	TikTok niche search with country, language and follower filters, exporting only profiles with a public contact	Only TikTok keyword-search actor here; six users
flash_scraper/creator-leads-scraper	16	5.0 (2)	$2.00 per 1,000 leads	TikTok, Instagram and YouTube in one run, 51 identical columns, MX-verified email, 0-100 lead score, only-new monitoring	No TikTok or Instagram keyword search (handles only). Optional AI cold opener is a second $2 per 1,000 event

When to pick which

Pick dataovercoffee if reveal rate is the only thing that matters and the budget is real. It is the most used and most reviewed of the creator email actors a Store search surfaced on 2026-09-05, 30,093 of 30,390 runs succeeded in the 30 days to 2026-09-05, and its listing is the only one here that claims the address keyless scrapers cannot reach. At $0.12 per email, 1,000 addresses is $120, and the force-fresh surcharge can take a run to $400 per 1,000.

Pick haketa/youtube-contact-scraper for cheap YouTube discovery. Keyword search plus contact details at $3 per 1,000 is the best value in the YouTube-only column, and 3,908 of 3,934 runs succeeded in the 30 days to 2026-09-05.

Pick lurkapi if you already have the channel list. Paying only for emails actually found ($0.005 each) is the fairest structure here for enrichment work. The $0.05 per search query makes it expensive for discovery, so use it as an enricher, not a finder.

Pick afanasenko/instagram-influencer-search for Instagram discovery. Nothing else in this comparison does it, and engagement rate plus follower range is exactly what influencer-marketing buyers filter on.

Pick funny_ground/tiktok-influencer-finder to find TikTok creators by niche rather than enrich handles you already have. Six users means unproven, so test small.

Pick flash_scraper/creator-leads-scraper when you already have handles across more than one platform and want one spreadsheet rather than three. Every row has the same 51 columns whichever platform it came from, every email is MX-verified with a status, and filters run before billing. onlyNewCreators on a schedule delivers only creators that appeared since the last run. At $0.002 per lead it is the cheapest per row here — 1.15x under the next cheapest headline rate ($2.30 per 1,000, automation-lab, which then bills emails found again at $23 per 1,000 on top) and 60x under the most used ($120).

What ours does not do, stated plainly

There is no TikTok or Instagram keyword or hashtag search. For those two platforms you supply usernames and the actor enriches them. YouTube is the only discovery platform: a keyword search returns roughly 30 channels, and their published links then give you TikTok and Instagram handles to feed back in. If your job is "find me TikTok beauty creators in Spain with 50k followers", this actor cannot start that job, and funny_ground or afanasenko can.

It does not read the email behind YouTube's "View email address" button. That button needs a Google login, a reCAPTCHA and a daily reveal quota. This actor stays keyless and logged out, so YouTube emails come from About text, published channel links and the linked website instead. That is the whole reason it costs $2 per 1,000 and dataovercoffee costs $120.

Email fill is a fraction, measured on small samples. In the 2026-08-09 verification runs, all after website enrichment: 6 of 9 YouTube channels on one keyword and 4 of 8 on a second, 3 of 9 TikTok creators, 1 of 5 Instagram creators. Read those as an order of magnitude, not a guarantee. Most addresses come from the creator's linked website, not the bio: a standalone measurement found an email in the TikTok bio itself on 1 of 28 profiles.

Instagram delivers partially at volume. Measured off-platform on 2026-09-03, Instagram's JSON endpoint refused every residential exit for 12 of 12 handles while the public profile page served 16 of 16 on the same exits, so the actor falls back to the page. A handle refused on both paths is reported by name and never billed.

No phone numbers, and no engagement rate outside Instagram. And 16 users with 2 reviews is a small footprint next to 3,644.

What a real run costs

At $0.002 per creator lead, 1,000 leads is $2.00 and a 30-lead test is $0.06. maxCreators counts creators delivered, not scraped: filters run before the count, and with an email filter set the run keeps discovering in up to three extra waves. Filtered-out, blocked and nonexistent handles are never billed. The AI cold opener is opt-in at a second $0.002 per row.

Short answers

Can I find a TikTok or Instagram creator's email by username? Yes, on flash_scraper/creator-leads-scraper, lurkapi (YouTube), automation-lab (YouTube) and the enrichment mode of the TikTok actors. It works only when the creator published an address somewhere public, usually on their linked website rather than in the bio. In the 2026-08-09 measurements that was 3 of 9 TikTok creators and 1 of 5 Instagram creators.

What percentage of creators actually have a public email? Between roughly a fifth and two thirds, depending on platform and keyword, on the measurements above. Any actor promising a full sheet of verified influencer emails from a keyless, logged-out scrape is describing something the public data does not contain.

Which actor covers all three platforms in one run? As read on 2026-09-05, flash_scraper/creator-leads-scraper is the only one in this comparison whose listing names TikTok, Instagram and YouTube with one output schema. The trade for that breadth is the missing TikTok and Instagram keyword search.

Data source: Apify public Store API, read 2026-09-05. Author: Flash Scrape (flash_scraper on Apify), publisher of one of the actors listed. Corrections welcome.

Remote Job Aggregators on Apify Compared (September 2026)

Zakaria Blefkih — Sat, 05 Sep 2026 18:29:58 +0000

Eight Actors compared here aggregate remote job boards into one feed. flash_scraper/remote-job-aggregator sweeps the most boards (10 keyless boards plus one opt-in) at $2 per 1,000 deduplicated jobs. nivlekk/remote-jobs-aggregator is the cheapest per row at $0.50 per 1,000, and memo23 is the cheapest that merges six boards at $1.99 and adds employer emails. benthepythondev has the largest user base at 738.

Every figure below was read from Apify's public Store API on 2026-09-05. This category churns fast, so the Pricing tab on each actor page is authoritative, not this article.

Disclosure: I publish flash_scraper/remote-job-aggregator, one of the actors compared here. It has zero reviews, and that is stated in the table rather than hidden.

Why board count is the metric that matters here

All of these actors read the same public, keyless feeds: RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy, Working Nomads, Arbeitnow, the Hacker News "Who is hiring?" thread, and a few smaller boards. Board health is a shared risk rather than an actor-specific one: Jobspresso itself answered HTTP 403 to our own direct board probe on 2026-08-27, and DevITjobs UK went dead upstream on 2026-08-29 (re-probed 2026-09-05: devitjobs.uk/api/jobsLight 302s to a signup page) — either would affect any actor reading them, ours included. None of them can reach LinkedIn, Indeed or Glassdoor remote listings, because those are a different scraping problem entirely. So the honest differentiators are: how many of those feeds an actor merges, whether it deduplicates a role that appears on three of them, whether it can run as a scheduled alert that only delivers new postings, and price per unique row.

The comparison table

Actor	Users	Rating (reviews)	Price per 1,000	Boards covered	What to watch
benthepythondev/remote-jobs-aggregator	738	5.0 (1)	$15.00 per 1,000 results	Arbeitnow, Jobicy, Himalayas, RemoteOK, Remotive, Working Nomads (6)	Salary extraction is a separate $10 per 1,000 event; most-used but by far the most expensive per row
inlifeprojects/himalayas-jobs-scraper	608	none yet (0)	$1.00 per 1,000 results	Himalayas only (1)	Single board, nothing to deduplicate; filters by seniority and country
sync-network/multi-site-remote-job-finder	282	3.0 (1)	$3.00 per 1,000 results	RemoteOK, Remotive, We Work Remotely, Jobspresso (4)	Four boards; the listing does not name cross-board deduplication
memo23/remote-jobs-aggregator	87	5.0 (2)	$1.99 per 1,000 results	RemoteOK (full depth), We Work Remotely, Remotive, Himalayas, Jobicy, Arbeitnow (6)	Adds opt-in employer contact emails and geo eligibility; claims 2,000 to 3,000 unique jobs per run
get_anything/remote-jobs-aggregator	34	5.0 (2)	$2.00 per 1,000 job records	Remotive, RemoteOK, Arbeitnow, Himalayas, Jobicy, We Work Remotely (6)	Deduplicated and normalised from official public feeds; no run-start fee
nivlekk/remote-jobs-aggregator	21	none yet (0)	$0.50 per 1,000 results	RemoteOK, We Work Remotely, Remotive named in the title; 7 selectable in its input schema (`remoteok`, `weworkremotely`, `remotive`, `arbeitnow`, `jobicy`, `himalayas`, `workingnomads`)	Cheapest per row anywhere in this category, plus a $0.001 run start
delightful_unicorn/remote-jobs-aggregator	17	none yet (0)	$1.00 per 1,000 results	RemoteOK, We Work Remotely, Working Nomads (3)	Positioned as a unified API, no proxy; deduplication is not named in the listing
flash_scraper/remote-job-aggregator	18	none yet (0)	$2.00 per 1,000 deduplicated jobs	RemoteOK, We Work Remotely, Working Nomads, DevITjobs US, DevITjobs UK, The Muse, Remotive, Jobicy, Himalayas, HN "Who is hiring?" (10) plus opt-in Arbeitnow	devitjobs.uk is down upstream and is reported per run, never billed. A change to $3 per 1,000 is scheduled for 2026-09-14

When to pick which

Pick nivlekk/remote-jobs-aggregator if you want the absolute floor on price. Fifty cents per 1,000 rows is half the price of the next cheapest ($1.00 per 1,000, inlifeprojects and delightful_unicorn) and a quarter of the $2 tier. Its title names three boards but its input schema offers seven, and there are no reviews yet; for a hobby feed or a first prototype the price is hard to argue with.

Pick memo23/remote-jobs-aggregator if you want depth plus employer contacts. RemoteOK's public feed returns the 100 newest listings by default, and an actor that pages past that returns jobs the others never see. Opt-in employer emails turn a job feed into a lead list.

Pick benthepythondev/remote-jobs-aggregator if user count is your proxy for reliability. At 738 users it is the most-used aggregator here, ahead of inlifeprojects (608) and 2.6x the next multi-board actor (sync-network, 282), and 747 of 748 runs succeeded in the 30 days to 2026-09-05. Do the arithmetic first: at $15 per 1,000 results plus $10 per 1,000 salary extractions, 1,000 jobs with salaries costs $25, against $2 to $2.50 from most of this table.

Pick inlifeprojects/himalayas-jobs-scraper if Himalayas alone is enough. Buying an aggregator to read one board is overhead you do not need.

Pick flash_scraper/remote-job-aggregator if you want the widest keyless board sweep in one run, or if you want the same search to run daily and deliver only what is new. Ten boards by default is the largest count in the table, and the two DevITjobs boards, The Muse and the Hacker News "Who is hiring?" thread are sources no other actor here names. Rows are merged across boards by canonical job URL and by (title, company), so a role on two boards ships and bills once. With onlyNewJobs on a schedule, a run where nothing is new delivers zero rows and bills only the $0.00005 start. Hourly, weekly and monthly pay is converted to annual (times 2080, 52, 12) with a magnitude guard, so salary_min sorts across every board on one axis.

What ours does not do, stated plainly

It has no reviews. Zero, from 18 users, at the time of writing. Four of the eight actors in this table are in the same position, but it should be the first thing you weigh, not something you discover later.

It covers no LinkedIn, Indeed or Glassdoor remote listings. Ten keyless boards is ten public feeds. If you need the big three, that is a different actor and a different price bracket.

Salary is on a minority of rows. On the 2026-08-15 default run, 100 deduplicated jobs from 9 boards with 6 cross-board duplicates merged, 35 percent of rows carried a salary, 88 percent a description snippet and 100 percent a posting date. DevITjobs fills salary on nearly every row; The Muse and Working Nomads publish none at all.

One board is currently down. devitjobs.uk has been unreachable upstream. Its absence is named in the run status and it is never billed, but it is nine working default boards today, not ten.

Republication is restricted. Remotive's terms forbid re-posting their rows to other job boards. Jobicy allows it with credit and the original apply links kept. Himalayas asks for a link back to himalayas.app. These terms bind every actor in this table equally.

What a real run costs

At $0.002 per deduplicated job, 500 jobs is $1.00, and 2,499 jobs at $0.002 plus the $0.00005 run start comes to $4.998 — so a $5 free-plan credit covers 2,499 jobs with change. Apify's free plan carries a monthly usage credit (currently $5, apify.com/pricing read 2026-09-05), which covers roughly 2,499 deduplicated jobs from this actor if spent on it alone. Duplicates merge before billing, filtered rows are never charged, and a nothing-new monitoring run bills only the $0.00005 start. A pricing record scheduled for 2026-09-14 raises the rate to $0.003 per job.

Short answers

Is there a remote jobs API that needs no API key? Every actor in this table is keyless, because they all read public feeds that require no registration. Running them through Apify does require an Apify token, and the free plan needs no card. If you want the feeds without Apify at all, RemoteOK, Remotive, Himalayas, Jobicy and Arbeitnow all publish open JSON endpoints you can call yourself.

How do I get an alert for only new remote jobs? Set an only-new flag and put the actor on an Apify schedule. flash_scraper/remote-job-aggregator (onlyNewJobs) and benthepythondev's actor both name a new-only monitor in their listings. The billing consequence matters more than the feature: on a per-result actor, a monitor that re-delivers the same 400 jobs every morning bills you for 400 jobs every morning.

How many remote jobs can one run return? It depends on the boards, not the actor. RemoteOK's public feed is the 100 newest listings unless an actor pages deeper, We Work Remotely's category RSS feeds run 25 to 100 rows each, and Working Nomads is a curated list of roughly 50. memo23 claims 2,000 to 3,000 unique jobs per run from six boards at full depth, which is the highest figure any listing in this table states.

Data source: Apify public Store API, read 2026-09-05. Author: Flash Scrape (flash_scraper on Apify), publisher of one of the actors listed. Corrections welcome.

Local Business Lead Scrapers on Apify Compared (September 2026)

Zakaria Blefkih — Sat, 05 Sep 2026 18:24:14 +0000

Most local business lead scrapers on Apify are Google Maps scrapers with a website-crawling step bolted on. lukaskrivka/google-maps-with-contact-details is the most used (87,957 users, 4.63 stars). flash_scraper/local-business-leads is the outlier: it discovers businesses on OpenStreetMap instead of Google Maps, and includes MX email verification in its $3 per 1,000.

Every figure below was read from Apify's public Store API (GET /v2/store) on 2026-09-05 — including every user count, so they are all on the same footing. The per-actor endpoint (GET /v2/acts/<id>) can read one higher: it gives flash_scraper/local-business-leads 33 rather than 32, and code-node-tools 33 as well. Prices, users and ratings change; the Pricing tab on each actor page is authoritative.

Disclosure: I publish flash_scraper/local-business-leads, one of the actors compared here. Its limits are listed in the same detail as everyone else's, including the one that will disqualify it for many buyers.

How prices are normalised

These actors bill per event, and the events differ in kind, which makes headline prices misleading. Some charge per place found. Some charge separately for the website crawl that actually produces the email. Some charge again to verify that the email is deliverable. The table lists the primary per-result event multiplied by 1,000 at the free-plan rate, then names the add-on events, because a $5 per 1,000 place price with a $100 per 1,000 email-verification add-on is not a $5 tool.

Paid Apify plans get tiered discounts on several of these actors, ours included — and on the add-on events the discount can be enormous. lukaskrivka's three $100-per-1,000 add-ons fall to $4.00 (email verification), $7.50 (lead enrichment) and $10.00 (social-profile enrichment) per 1,000 on Bronze, and lower again above it (Store pricing record read 2026-09-05). Our own free-plan-to-Diamond spread is about 30 percent. So if you are on a paid plan, re-read every figure below off the Pricing tab: the free-plan column overstates the gap by a factor of 25 on those particular add-ons.

The comparison table

Every row shows the same 30-day run-success figure, taken from the Store API on 2026-09-05, so the comparison is symmetrical rather than pointed at one actor.

Actor	Users	Rating (reviews)	Price per 1,000	30-day run success	What it covers	What to watch
lukaskrivka/google-maps-with-contact-details	87,957	4.63 (221)	$5.00 per 1,000 places	70,296 / 76,404 (92%)	Google Maps places plus website crawl for emails, phones, socials, address, zipcode	Add-ons are billed separately: contact enrichment $2.50/1k, place details $3.00/1k, filters $1.50/1k, and email verification, lead enrichment and social-profile enrichment at $100 per 1,000 each on Apify's free plan, falling to $4.00, $7.50 and $10.00 per 1,000 on Bronze and lower above it
s-r/google-maps-contact-details	166	none yet (0)	$4.00 per 1,000 places	1,165 / 1,177 (99%)	Google Maps places enriched from the business website: email, phone, Facebook, Instagram, LinkedIn, X, YouTube, TikTok	$2.00/1k contact-enrichment event on top, plus a $0.002 run start
santhej/nowebsite-lead-finder	220	none yet (0)	$8.00 per 1,000 leads	412 / 438 (94%)	Google Maps businesses without a website, opportunity-scored, for web-design and marketing agencies	Deliberately excludes businesses with sites, so no email crawl is possible; $0.001 run start
faisalrjbd/google-maps-phone-email-extractor	170	4.14 (4)	$5.00 per 1,000 results	66 / 66 (100%)	Google Maps phones, emails, websites, socials, addresses, ratings, reviews	Email verification is not named in the listing
jurassic_jove/google-maps-lead-generator	99	none yet (0)	$20.00 per 1,000 leads	59 / 64 (92%)	Google Maps leads with a full Playwright visit to each business site for higher extraction accuracy	Highest per-lead price in this table — 2.5x the next highest ($8) and 18x the cheapest ($1.10)
leadharbor/google-maps-verified-email-scraper	40	none yet (0)	$3.00 per 1,000 leads	127 / 143 (89%)	Google Maps leads with MX-checked emails tagged valid / risky / invalid, CSV out	Verification method is not detailed in the listing; no reviews yet
code-node-tools/google-maps-lead-scraper	33	none yet (0)	$1.10 per 1,000 results	155 / 160 (97%)	Google Maps search plus website, phone, email and socials, streamed to the dataset	Cheapest here; uses Apify residential proxy; verification not named
flash_scraper/local-business-leads	32	5.0 (3)	$3.00 per 1,000 delivered leads, MX verification included	166 / 173 (96%)	OpenStreetMap discovery, own-website crawl for MX-verified email, phone, socials, site platform, 0-100 lead score, 73 stable columns, Google Maps link on every row	Does not scrape Google Maps, so no Google star ratings or review counts. A change to $5 per 1,000 is scheduled in its pricing record for 2026-09-14

When to pick which

Pick lukaskrivka/google-maps-with-contact-details if you want the most-reviewed option and you are buying places, not verified emails. 221 reviews at 4.63 is the strongest social proof in local lead generation on Apify. Budget carefully: at $5 per 1,000 places plus $2.50 per 1,000 contact enrichments you are near $7.50 per 1,000 before verification, and the verification add-on is priced at $100 per 1,000 on the free plan (it drops to $4 per 1,000 on Bronze, so on a paid plan this is a much smaller consideration than the free-plan sticker suggests).

Pick santhej/nowebsite-lead-finder if you sell websites. Filtering Google Maps down to businesses with no site is a different job from lead scraping, and $8 per lead is reasonable when every row is a qualified pitch. It is the wrong tool for email outreach: a business with no website usually has no email to find.

Pick code-node-tools/google-maps-lead-scraper if price per row is the whole decision. At $1.10 per 1,000 it is a third of the next cheapest. No reviews yet, so run a small batch and check the email column first.

Pick leadharbor or flash_scraper if bounce rate is what you actually care about. Both include MX checking in the per-lead price rather than charging for it separately. leadharbor grades each address valid / risky / invalid from Google Maps discovery. flash_scraper grades them deliverable / risky / undeliverable, adds a mailbox-ownership classification (own domain, free inbox, or the business's marketing agency), and never promotes a pattern-guessed address into the email column: guesses stay in email_guess.

Pick flash_scraper/local-business-leads specifically when you want one flat price with the crawl, the verification, the scoring and the socials all inside it, and you do not need Google's star ratings. On the reference run (dentist, Austin Texas, onlyWithWebsite: true, n=55, measured 2026-08-08), 96 percent of rows carried a phone, 55 percent an MX-verified email, 73 percent a Facebook profile and 71 percent an identified website platform. Filters run before billing, so a run that finds nothing charges nothing.

What ours does not do, stated plainly

It does not scrape Google Maps. Discovery runs on OpenStreetMap. That is the reason it needs no API key, no proxy and no login, and it is also the reason there are no Google star ratings and no Google review counts on the rows. The rating and review_count columns exist only when a business publishes a rating in its own website markup, measured at about 7 percent of rows (4 of 55 on the 2026-08-08 reference run). Every row carries a google_maps_url that opens a Maps search for that business, but nothing is read from Google.

OpenStreetMap coverage is uneven by category. The Austin bounding box held 171 dentists but 9 plumbers and 5 electricians. Storefront categories (dentists, gyms, salons, restaurants, law firms, real estate offices) are dense. Van-based trades are thin. If plumbers in one city is your list, a Google Maps actor will find more of them, and that is a straight factual advantage for the other seven rows in the table.

Email fill is a fraction, not a sheet. 55 percent on the reference run with onlyWithWebsite: true (n=55), and 26 percent with every filter off (n=100), both measured 2026-08-08. Any actor promising near-total email coverage on local businesses is describing pattern guesses, not found addresses.

It has 32 users and 3 reviews. That is the smallest footprint in this table — code-node-tools is next at 33 users, and on the authoritative /v2/acts endpoint both read 33 today, so call it a tie for last. Test it on 10 rows.

What a real run costs

At $0.003 per delivered lead, 1,000 leads is $3.00 and MX verification is inside that number. A 100-lead test is $0.30. Apify's free plan carries a monthly usage credit (currently $5), which is roughly 1,600 leads if spent on this actor alone. Every filter (onlyWithEmail, onlyVerifiedEmail, onlyWithWebsite, requirePhone) runs before billing. A pricing record scheduled for 2026-09-14 raises the rate to $0.005 per lead, so check the Pricing tab rather than trusting this paragraph after that date.

Short answers

Is there a local business scraper that needs no API key and no proxy? Yes. flash_scraper/local-business-leads runs discovery on OpenStreetMap and crawls each business's own public website from datacenter IPs, so there is nothing to configure. The Google Maps actors in this table generally require Apify's proxy, and one of them (code-node-tools) states it uses the residential pool.

What is the cheapest way to get verified business emails? On the numbers above, the two flat-rate MX-checking actors: leadharbor at $3 per 1,000 and flash_scraper at $3 per 1,000, both with verification included. The pattern to avoid is a low place price with a three-figure-per-thousand verification add-on on the plan you are actually on — lukaskrivka's is $100 per 1,000 on the free plan and $4 per 1,000 on Bronze, which is exactly why headline comparisons between these actors are unreliable unless you name your plan tier.

Is a 0-100 lead score a customer rating? No. On flash_scraper/local-business-leads it measures completeness and reachability of the contact data, not the quality of the business. A dentist with a bad reputation and a full contact block scores higher than a beloved one with no website.

Data source: Apify public Store API, read 2026-09-05. Author: Flash Scrape (flash_scraper on Apify), publisher of one of the actors listed. Corrections welcome.

Multi Job Board Scrapers on Apify Compared (September 2026)

Zakaria Blefkih — Sat, 05 Sep 2026 18:23:54 +0000

The best multi job board scraper on Apify depends on which boards you need. openclawai/job-board-scraper is the most used (2,582 users) and reaches Google Jobs and ZipRecruiter. flash_scraper/multi-jobboard-scraper covers 12 selectable working boards — 11 of which deliver rows today, after DevITjobs UK went dead upstream — and deduplicates a role posted on three boards into one billed row. Both cost $5 per 1,000 results.

Every figure below was read from Apify's public Store API (https://api.apify.com/v2/store) on 2026-09-05. User counts, ratings, review counts and prices on Apify change without notice, so treat this as a dated snapshot and check the Pricing tab on each actor page before you budget a run.

Disclosure: I publish flash_scraper/multi-jobboard-scraper, one of the actors in the table. I have not put it first, and its limits are stated below in the same detail as everyone else's.

How prices are normalised

Apify actors bill per event, and most job scrapers charge one primary event per delivered job. The "Price per 1,000" column is that primary event multiplied by 1,000, at the free-plan rate. Paid Apify plans get tiered discounts on several of these actors. Where an actor also charges a meaningful run-start fee or a second event, it is named in the same cell, because a $0.10 run start changes the economics of a 20-row test run.

The comparison table

Actor	Users	Rating (reviews)	Price per 1,000	What it covers	What its Store listing does not name
openclawai/job-board-scraper	2,582	5.0 (3)	$5.00 (+ $0.01/1k dataset items, $0.00005 start)	LinkedIn, Indeed, Glassdoor, Google Jobs and ZipRecruiter in one run	Cross-board deduplication, only-new monitoring, keyless remote boards
doggo/uk-jobs-board-scraper	368	5.0 (2)	$5.00 (+ $0.10 per run start)	Indeed, Reed, Totaljobs, CV-Library, Adzuna, RemoteOK, Arbeitnow across UK, US and Europe	LinkedIn, Glassdoor, deduplication, alert mode
khadinakbar/jobs-scraper	353	none yet (0)	$3.00 (+ $0.00005 start)	Indeed, LinkedIn, Glassdoor; MCP and API ready	Deduplication, remote boards, ATS boards, monitoring
vero-api/multi-job-board-scraper-linkedin-indeed-glassdoor-more	208	5.0 (1)	$5.00 (+ $0.00005 start)	LinkedIn, Indeed, Glassdoor plus Bayt, Naukri and BDJobs for Gulf and South Asia	Deduplication, remote boards, alert mode
curious_coder/linkedin-jobs-scraper	148,567	4.59 (140)	$2.00 (+ $0.00005 start)	LinkedIn only, with full job details, job poster and company data	Any second board
misceres/indeed-scraper	30,224	2.86 (66)	$6.00	Indeed only, organic and sponsored listings	Any second board
memo23/apify-indeed-cheerio-ppr	704	4.51 (8)	$1.49 (+ $0.007 start)	Indeed only, plus employer firmographics (CEO, revenue, industry) and optional contact emails	Any second board
flash_scraper/multi-jobboard-scraper	42	5.0 (3)	$5.00 (+ $0.00005 start)	LinkedIn, Indeed, Glassdoor plus 9 keyless public boards including The Muse — 12 selectable working boards, of which DevITjobs UK has been discontinued upstream since 2026-08-29 (re-probed 2026-09-05), so 11 deliver rows today — cross-board dedup, only-new alerts, Greenhouse/Lever/Ashby ATS	Google Jobs, ZipRecruiter, Bayt, BDJobs, Naukri (blocked at source)

The last column is deliberately narrow in scope: it lists what an actor's own Apify Store title and description did not claim on 2026-09-05. It is not a test result. An actor may well do something its listing never mentions, and the only way to know is to run it.

When to pick which

Pick openclawai/job-board-scraper if Google Jobs or ZipRecruiter is non-negotiable. It is the only actor in this group whose listing names both, and with 2,582 users it is the most battle-tested multi-board option here. Google Jobs in particular has no keyless route that I have been able to reproduce, so an actor that claims it is worth trying on a small run first.

Pick curious_coder/linkedin-jobs-scraper if you only ever need LinkedIn. At 148,567 users and 4.59 stars from 140 reviews, it is the most reviewed of the job scrapers a Store search surfaced on 2026-09-05, and $2 per 1,000 is less than half what any multi-board actor charges. Buying a multi-board tool to scrape one board is paying for plumbing you will not use.

Pick memo23/apify-indeed-cheerio-ppr if you want Indeed rows that double as sales leads. At $1.49 per 1,000 it is the cheapest per-row option in the table, and employer firmographics plus optional contact-email enrichment is a combination the other Indeed actors do not advertise.

Pick vero-api or doggo for regional depth. Bayt, Naukri and BDJobs (vero-api) cover the Gulf and South Asia; Reed, Totaljobs, CV-Library and Adzuna (doggo) cover the UK. If your search is regional, board coverage beats every other consideration. Watch doggo's $0.10 run start if you plan many small scheduled runs: 30 daily runs is $3 per month before a single row is delivered.

Pick flash_scraper/multi-jobboard-scraper if duplicates are your actual problem, or if you want the same search to run daily and deliver only what is new. A role posted on LinkedIn, Indeed and Glassdoor arrives as one row carrying found_on_sites and duplicate_count, and it bills once rather than three times. With onlyNewJobs on a schedule, a run where nothing is new delivers zero rows and bills only the $0.00005 start. On a measured run of 90 raw rows on 2026-08-08, 89 were billed after the merge. It also reaches Greenhouse, Lever and Ashby, so company career pages come through the same schema as the big boards.

What ours does not do, stated plainly

Five selectable boards are blocked at the source: Google Jobs serves a bot-check page, ZipRecruiter returns HTTP 403, Naukri demands a CAPTCHA, and Bayt and BDJobs also refuse. That was checked on 2026-08-07 and re-measured on 2026-08-11. If Google Jobs is your requirement, this actor is the wrong tool and openclawai's is the one to try.

It never logs in and never auto-applies, so nothing behind a login wall is reachable. It is not a historical archive; each run reads what the boards are showing now. LinkedIn pay comes from the public search card and the posting text, not from the fuller base-pay block LinkedIn shows on some job pages (present on 2 of 6 postings measured 2026-08-29). Glassdoor tops out around 28 to 30 rows per query, which is a board-side cap, and it returns HTTP 403 on some runs entirely, in which case the run status names the board and the missing board bills nothing.

One of the twelve selectable boards is also dead at source rather than blocked: DevITjobs UK was discontinued upstream on 2026-08-29 — a direct probe of devitjobs.uk/api/jobsLight on 2026-09-05 returns a 302 to a signup page — so eleven boards deliver rows today. Its absence is reported in the run status and it is never billed.

And the honest commercial caveat: at 42 users it is the smallest multi-board actor in this table — a fifth of vero-api's 208 and under 2% of openclawai's 2,582. Three reviews averaging 5.0 is three reviews, not a track record. Run it on 20 rows before you trust it with 2,000.

What a real run costs

At the free-plan rate of $0.005 per deduplicated job, an untouched form (four default boards, up to 20 rows each) delivers at most 80 rows for at most $0.40. A 500-job sweep is $2.50. Filtered-out rows are never billed, and a failed or empty run bills only the $0.00005 start. Apify's free plan carries a monthly usage credit (currently $5), which covers roughly 1,000 deduplicated jobs from this actor if spent on it alone.

Short answers

Which job board scrapers on Apify need no API key? All eight in this table are keyless. None of their Store listings asks for a LinkedIn, Indeed or Glassdoor login — they describe reading public search pages. (That is a reading of eight listings, not a test of eight actors: we have not run the seven we do not publish.) Keyless does not mean unblockable: Glassdoor intermittently 403s across every actor here, and Google Jobs refuses everyone.

Does salary data actually come through? More often than most people expect. On flash_scraper/multi-jobboard-scraper's measured runs, salary_min and friends were filled on 59 to 70 percent of rows with LinkedIn detail fetching on (the default) and 56 to 60 percent with it off — Glassdoor 95 to 100 percent, Indeed 50 to 80 percent depending on query, LinkedIn roughly 35 percent and only with detail fetching. Measured 2026-08-07 and re-checked across all 5,936 delivered rows on 2026-08-23. Any actor claiming near-total salary coverage across LinkedIn is worth checking on a small run.

Can I republish the rows on my own job board? Not universally. Remotive's terms forbid re-posting to other job boards. Jobicy allows it with credit and the original apply links kept. Himalayas asks for a link back to himalayas.app. LinkedIn, Indeed and Glassdoor terms do not contemplate republication at all. Read each board's terms before building a job site on scraped rows.

Data source: Apify public Store API, read 2026-09-05. Author: Flash Scrape (flash_scraper on Apify), publisher of one of the actors listed. Corrections welcome.