Job Posting Monitor Clay-Ready Hiring Signal Discovery

📋 What can Job Posting Monitor do?

Give it role keywords and it returns the companies hiring for that role right now, one clean row per posting, with each company enriched with its domain, LinkedIn URL, employee count and industry.

This is the reverse of a domain-level ATS checker. You do not give it a company and ask "are they hiring?" You give it a role and ask "who is hiring for this?"

📦 What you get	⚙️ Features and integrations
🏢 Hiring companies, deduplicated to one row per posting 🔗 Domain and LinkedIn URL resolved per company 🧹 Staffing agencies and freelance marketplaces filtered out 🧾 16 flat fields, snake_case, Clay-native	🔍 Google Jobs discovery via your own SerpAPI key 🏷️ Company type classification on every row 🔄 Cross-run delta detection, only new postings ⬇️ Export to JSON, CSV, Excel, HTML or XML

Bought by anyone running role-triggered outbound: recruiters, staffing-adjacent vendors, and sellers whose buying signal is a specific role opening.

🚫 The keyword list is fully generic, and the editorial default is just a preset. It ships with proofreader, copy editor and content editor because that was the first use case, but the same actor tracks engineering, sales, marketing, operations or finance by changing the keywords.

💡 Why use Job Posting Monitor?

If you want	Read these fields
The hiring company	company_name, company_domain
An outreach target	company_linkedin_url
To size the account	employee_count, industry
To drop the wrong kind of company	company_type
The role and where to apply	job_title, job_url, location, is_remote
Recency and novelty	posting_date, is_new_posting
Why this row matched	matched_keyword, job_description_snippet

🧹 Filtering out the noise is most of the value

Raw job search results are dominated by staffing agencies and freelance marketplaces reposting the same roles. This actor filters both.

Staffing and recruitment agencies are filtered on both the company name and the job description text, because plenty of agencies do not have "recruitment" in their name. Freelance marketplaces (Upwork, Fiverr, Freelancer, Toptal and similar) are excluded by name, and the list is yours to extend.

Everything that survives is classified: direct_employer, staffing_agency, government or unknown. If you disagree with the filter, turn it off and filter on company_type yourself.

🔄 Re-runs only return what is new

is_new_posting and the built-in delta cache mean a scheduled run does not re-emit everything it already showed you. Pass previous_run_date if you would rather control the window yourself.

📋 What data can Job Posting Monitor extract?

16 fields per posting.

Field	What it holds
company_name	The hiring company
company_domain	Resolved canonical domain, or null
company_linkedin_url	Company LinkedIn page, the primary outreach field
employee_count, industry	Firmographics, where the company exposes them
company_type	direct_employer, staffing_agency, government or unknown
job_title	The role title
job_url	Direct apply or posting URL
posting_date	Normalized to ISO, best effort
source_board	google_jobs, greenhouse, lever or ashby
location, is_remote	Where the role is
job_description_snippet	First 500 characters of the description
matched_keyword	Which of your keywords this posting matched
is_new_posting	true when not seen in a prior run
run_date	When the run happened

⚠️ employee_count and industry are frequently null, because the firmographic source only reports them when a company exposes them. The company_size_min and company_size_max filters therefore apply only when a size is known, and will silently keep companies of unknown size. company_linkedin_url, the field most people actually act on, resolves for the large majority.

🛠️ How to find companies hiring for a role

1. Open the Input tab and put your role titles in keywords.
2. Paste a SerpAPI key into serpapi_key, or set a SERPAPI_KEY environment variable on the actor.
3. Set country and lookback_days to scope the search.
4. Leave the staffing and freelance filters on.
5. Click Start, then work the rows where company_type is direct_employer.

🧪 Using it in Clay

Point a Clay table at this actor's dataset, one Clay row per output row. The key columns are company_name, company_domain, company_linkedin_url, job_title and posting_date.

Use company_linkedin_url as the input to a LinkedIn step, and posting_date plus is_new_posting to prioritize fresh signals.

Schedule the actor and rely on the built-in delta cache, or pass previous_run_date, so each refresh only ingests new postings.

🔑 The SerpAPI key

Discovery runs on the SerpAPI google_jobs engine, which covers Indeed, LinkedIn, Glassdoor, ZipRecruiter and company career pages. You bring your own key; the free tier covers 250 searches per month.

The actor reads the key from the serpapi_key input first, then falls back to the SERPAPI_KEY environment variable. Without either, discovery returns nothing.

💵 How much does it cost to monitor job postings?

A result is one deduplicated, firmographic-enriched job posting.

Plan	Per posting	Per 1,000 postings
Free	$0.020	$20.00
Bronze	$0.019	$19.00
Silver	$0.018	$18.00
Gold	$0.017	$17.00

There is also an Actor start event at $0.00005, charged once per run per GB of memory.

💳 Two other costs sit outside this price, and you should budget for both. Enrichment sub-actors bill through your own Apify account at each sub-actor's own rate, standard for a fleet orchestrator. Google Jobs discovery is billed by SerpAPI against your own key. Free Apify plans include 25 result rows per month. max_companies is the lever that bounds the sub-actor spend.

🧾 What a run really costs, measured end to end

Sub-actor charges are usually larger than people expect, so here is a real run rather than an estimate. Measured 2026-08-12 on a run that returned 27 postings.

Charged to your Apify account	Sub-actor runs	Cost
This actor, 27 results plus the start event	n/a	$0.5401
company-identity-resolver, one run per company, $0.007 each	40	$0.2820
company-firmographic-enricher, 39 domains in one run, $0.004 each	1	$0.1560
domain-to-linkedin-url-resolver, one run per company, $0.006 each	11	$0.0665
Total for that run	52	$1.0446

The three sub-actors were 48% of that bill. The effective price was $0.039 per posting, not the $0.020 in the table above.

The ratio is not fixed. One enrichment run is started per unique company discovered, so a search that finds many companies with one posting each costs proportionally more than a search that finds a few companies hiring heavily. max_companies bounds the sub-actor spend directly and is the first input to reach for if the bill matters more than the coverage.

⌨️ Input

Everything is on the Input tab. The options worth explaining:

Field	Type	Default	What it does
keywords	array	editorial preset	Role titles to search for. Any role works.
serpapi_key	string	none	Your SerpAPI key. Required unless SERPAPI_KEY is set on the actor.
country	string	United States	Geographic filter.
lookback_days	integer	30	Only return postings newer than this.
company_size_min, company_size_max	integer	none	Drop companies outside the range, when size is known.
exclude_staffing_agencies	boolean	true	Filter staffing and recruitment postings.
exclude_freelance_marketplaces	boolean	true	Filter Upwork, Fiverr and similar.
freelance_marketplaces	array	7 defaults	Override or extend the marketplace list.
remote_only	boolean	false	Only return remote postings.
previous_run_date	string	none	ISO date; only emit postings newer than this.
max_results	integer	100	Raw postings scanned before filtering.
max_companies	integer	40	Cap on unique companies enriched per run. Bounds sub-actor cost.

📤 Output

One flat row per posting, exportable as JSON, CSV, Excel, HTML or XML.

{
  "company_name": "Stripe",
  "company_domain": "stripe.com",
  "company_linkedin_url": "https://www.linkedin.com/company/stripe",
  "employee_count": 8000,
  "industry": "Financial Services",
  "company_type": "direct_employer",
  "job_title": "Senior Software Engineer",
  "job_url": "https://boards.greenhouse.io/example/jobs/123",
  "posting_date": "2026-06-25",
  "source_board": "google_jobs",
  "location": "San Francisco, CA",
  "is_remote": true,
  "job_description_snippet": "We are seeking a backend engineer to...",
  "matched_keyword": "software engineer",
  "is_new_posting": true,
  "run_date": "2026-07-01T14:06:22.297Z"
}

💡 Tips

• Work company_type: "direct_employer" first. It is the reason the filtering exists.
• Tighten lookback_days before raising max_results. Fresh postings convert better than deep ones.
• max_companies is your cost control. It bounds how much enrichment a run can trigger.
• Schedule it and filter on is_new_posting to turn this into a standing feed rather than a one-time list.
• Extend freelance_marketplaces with whatever else clutters your vertical.

⚠️ Known limits

Discovery depth is bounded by max_results. Very high-volume keywords may need multiple runs or a tighter lookback_days.

Company enrichment is capped per run by max_companies, deliberately, to bound sub-actor cost.

Enrichment depends on name-to-domain resolution. Ambiguous or very small companies may not resolve, and those rows come back with a null domain and null firmographics rather than being dropped.

employee_count and industry coverage varies and is frequently null. The size filters apply only when a size is known.

Google Jobs coverage excludes some regions where the widget is disabled, including the EU.

Posting dates from aggregated boards are often relative, for example "25 days ago", and are normalized to a best-effort ISO date.

A SerpAPI key is required. Without one, discovery returns nothing.

❓ FAQ

Do I need a SerpAPI key?

Yes. Discovery runs on the SerpAPI google_jobs engine. The free tier covers 250 searches per month.

Why did a run return nothing?

Usually no key, or a keyword and country combination Google Jobs does not serve. The run logs a warning, emits zero rows and exits cleanly rather than erroring.

Are staffing agencies really filtered out?

They are filtered on both company name and job description text, and anything that survives is labeled in company_type. If you would rather judge for yourself, turn the filter off and filter on that field.

Will a scheduled run keep showing me the same postings?

No. Cross-run delta detection means re-runs only emit postings you have not seen. is_new_posting carries the flag.

What happens if the enrichment sub-actors fail?

The row is still emitted with null enrichment fields and a structured error is logged. Discovery is never lost to an enrichment failure.

🧩 Want other GTM data?

Mamba Labs builds custom actors for B2B go-to-market teams. The public versions of that work live here on the Store, so our users get the same tooling we build under contract.

🧑‍💼 GTM Hiring Signal Scraper	🧱 Tech Stack Detector
📡 B2B Buying Signals Aggregator	🔑 Job Board Keyword Scanner
🔗 Domain to LinkedIn URL Resolver	🎯 ICP Fit Scorer
📬 Domain Deliverability Checker	🏢 Company Firmographic Enricher
🌐 Company Social Presence Mapper	🪪 Company Identity Resolver
💰 Funding and Press Signal Scanner	🔄 Company Change-Event Feed
👤 People Finder and Email Verifier	🚀 Prospect Engine
🤖 AI Tooling Detector	📮 Outbound Stack Detector
📝 Publishing Frequency Tracker	✉️ Work Email Waterfall Finder
⏩ Sequencer Lead Push	🏅 Workplace Program Detector
👥 Team Page People Extractor	🧭 Company Discovery List Builder

Every actor in the suite takes a domain or a company and returns one flat row, so they stack in the same Clay table without reshaping anything.

🛠️ Need something custom built for you or your team? Tell us what you are trying to find and we will build it. Talk to Mamba Labs.

🆘 Support

Something wrong, or a company misclassified? Open an issue on the Issues tab with the keyword and the row, and we will look at it.

ℹ️ Sourcing and legal. Job postings come from the SerpAPI google_jobs engine against your own key, and from public job board APIs. Company enrichment comes from Mamba Labs fleet actors reading public company data. The actor stores no personal data: it returns companies, roles and postings, not people. You are responsible for how you use the output.

Built by Mamba Labs.