# Verified Hiring Signals — Recent Company Jobs (`impressionable_lupine/company-recent-job-openings`) Actor

Check recent company job openings on public careers pages and linked ATS. Get source-verified titles, locations, posting dates when available, and check times in JSON. $0.03 per verified report; unknown results free. Platform usage included.

- **URL**: https://apify.com/impressionable\_lupine/company-recent-job-openings.md
- **Developed by:** [Majd Hijazin](https://apify.com/impressionable_lupine) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$30.00 / 1,000 verified hiring reports

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Verify recent company job openings

Check a company's public careers pages and linked applicant-tracking system for recently published job openings. Supply a company website; receive one structured JSON report with source URLs and check times. A date appears only when the public source provides verifiable publication evidence. The Actor does not bypass logins, access restrictions, or blocked pages.

**For a sales or research agent:** use this when a next step depends on evidence of hiring within a chosen window. One company domain yields dated job evidence, a source-checked negative for the pages covered, or an explicit `unknown`. Cite `jobs[].source_url` and `jobs[].checked_at` in any downstream claim. If `coverage_complete` is false, present the result as partial. If the source is inaccessible or no posting date can be verified, do not turn that uncertainty into a hiring claim.

| Decision before calling | Contract |
| --- | --- |
| Input | One `company_website`; optional `lookback_days` and `max_jobs` |
| Useful for | Account research, expansion signals, recruiting intelligence, and timely outreach context |
| Maximum event charge | **$0.03 per company run**; platform usage included |
| Read from | One default-dataset report or the `OUTPUT` key-value record |
| Reuse safely | Save the run ID and check time; refresh evidence before acting on an old report |

### Price of a verified hiring report

**$0.03 per verified company report** (`verified-report`), with platform usage included. A complete, source-checked result saying no verified recent openings is a verified report. Invalid input, inaccessible or inconclusive sources, and other unverified outcomes have no report event. There are no additional start or dataset-item events. One run checks one company; use a `$0.03` maximum charge for a single run.

### Company job openings search input

```json
{
  "company_website": "linear.app",
  "lookback_days": 30,
  "max_jobs": 30
}
```

`company_website` is required and may be a company domain or HTTPS URL. `lookback_days` defaults to 30 (1–365); `max_jobs` defaults to 30 (1–100). The date window starts at midnight UTC on the date that many calendar days ago. One company is checked per run.

### Job openings JSON output and source evidence

The default dataset contains one JSON report. The same report is saved in the default key-value store as `OUTPUT`. Read the run status, then retrieve either location. Core fields:

```json
{
  "schema_version": "2.0",
  "company_website": "https://linear.app/",
  "lookback_days": 30,
  "checked_at": "2026-09-30T06:11:35.163Z",
  "status": "success",
  "signal_status": "verified_recent_openings",
  "job_count": 4,
  "jobs": [
    {
      "title": "Design Engineer (Web & Brand)",
      "location": "Europe",
      "published_date": "2026-09-15T18:05:47.890Z",
      "date_meaning": "last_published",
      "source_url": "https://jobs.ashbyhq.com/Linear/ea0b5868-6d7a-46fa-99d8-207cd19357a6",
      "checked_at": "2026-09-30T06:11:36.361Z"
    }
  ],
  "coverage_complete": true,
  "billing_event": "verified-report",
  "billing_quantity": 1
}
```

This abbreviated example comes from a real check on 2026-09-30. The full report contains additional evidence, coverage, error, and billing fields. The sample is an observation from that time; check the live source before claiming a vacancy remains open. In particular, Ashby `publishedAt` is labeled `last_published`, which may reflect republication rather than the first posting date.

| Observed company | Checked | Sample verified listing |
| --- | --- | --- |
| [Linear](https://linear.app/) | 2026-09-30 | [Design Engineer (Web & Brand), Europe](https://jobs.ashbyhq.com/Linear/ea0b5868-6d7a-46fa-99d8-207cd19357a6) |
| [Clay](https://clay.com/) | 2026-09-30 | [Software Engineer, GTM Ops, New York](https://jobs.ashbyhq.com/claylabs/8a031b6a-a5b9-4ae1-a10c-364fc5427431) |
| [Stripe](https://stripe.com/) | 2026-09-30 | [Partner Development Manager, Financial Partnership Capabilities](https://stripe.com/jobs/search?gh_jid=8238747) |

For a complete negative result, `status` is `no_result`, `signal_status` is `no_verified_recent_openings`, `jobs` is empty, and `coverage_complete` is true. It is scoped to the public sources checked, not a claim that the company is not hiring. A blocked, timed-out, or unsupported source returns `signal_status: "unknown"` and is not billed as a report. A partial positive report labels incomplete coverage. Missing or ambiguous publication dates remain in `undated_jobs` and never qualify as recent dated jobs.

### Use hiring signals in sales and research agents

Connect to [Apify's official MCP server](https://docs.apify.com/integrations/mcp). Use `fetch-actor-details` for `impressionable_lupine/company-recent-job-openings` to inspect the current input and price. On 1 October 2026, the public Store found this Actor by name, but anonymous MCP `search-actors` did not return it while Apify's publisher verification was pending. Use exact-name lookup for discovery until the eligibility check changes; do not assume accountless agentic payment is available yet. An authenticated Apify account can call it with `maxTotalChargeUsd: 0.03`; save the returned run ID, then use `get-actor-run` and `get-key-value-store-record` (`OUTPUT`) or `get-dataset-items` to retrieve the report. Details work anonymously; execution and storage retrieval require Apify authentication or a supported payment flow. Do not retry an uncertain call by starting a second run before checking the first run ID.

The Actor follows company-linked careers or ATS sources. It does not guess an unrelated board name, infer missing dates, assert an unverified job is current, or treat an inaccessible page as a negative result. Requests are bounded to one company, at most 40 source requests, 24 MB downloaded, and a 90-second network budget. The platform run cap is 120 seconds and 512 MB. Coverage is limited to supported public sources and is explicit in every report.

### Recent job openings quality benchmark (1 October 2026)

The 30 September cloud cohort checked 24 varied company sites: **4 complete positive reports, 6 partial positive reports, 14 unknown, and 0 complete negatives**. All 24 runs finished, but only ten returned dated recent-job evidence, totaling **151 dated job rows**. Median end-to-end cloud run time was **5.09 seconds** and median in-Actor scanner time was **1.47 seconds**; neither is a production latency guarantee. A separate 24-site local check that day returned **152 dated rows** and had a median scanner time of **2.54 seconds**. Seven job links were selected reproducibly at random from the local rows on 1 October: all seven still showed the sampled role in a public employer or ATS source, and four Ashby `publishedAt` fields were freshly rechecked. The three Greenhouse dates remained supported by the archived local scan evidence but were not freshly accessible to the reviewer. The small sample does not establish precision or recall. The 1 October navigation and concurrency changes require a fresh cloud cohort before any improved coverage or speed claim.

The 24 sites were selected for varied career systems, not randomly sampled employers. Complete positives: Clay, Linear, Notion, Zapier. Partial positives: Anthropic, GitLab, Ramp, Stripe, Supabase, Vercel. Unknown: Amazon, Automattic, Bosch, Buffer, Cloudflare, Datadog, DuckDuckGo, HubSpot, IKEA, Microsoft, OpenAI, Perplexity, PostHog, Siemens. Six unknown results hit the 12-page discovery limit; five found no supported linked source in the pages checked. Historical platform usage for the 24 owner-funded runs totaled $0.01068. That is running cost, not revenue.

The seven-row audit used `random.Random(20261001).sample(rows, 7)` over 152 archived **local** dated jobs in the files' directory iteration order. Public source checks found [Notion Strategic Finance](https://jobs.ashbyhq.com/notion/72e0f2c1-d599-4301-8096-491835757b9e), [Supabase FinOps Engineer](https://jobs.ashbyhq.com/supabase/fab1525f-3d89-4d1c-9094-84d21647415e), [Clay Partner & Marketplace Operations Lead](https://jobs.ashbyhq.com/claylabs/d3bd708c-4b20-45c9-9522-f38abc30ca06), [Clay Account Executive](https://jobs.ashbyhq.com/claylabs/e9c90955-db04-4fc3-b70d-ebc115557e83), [Stripe Security GRC](https://stripe.com/jobs/search?gh_jid=8237244), [Stripe University Recruiter](https://stripe.com/jobs/search?gh_jid=8226211), and [GitLab Solutions Architect Manager](https://job-boards.greenhouse.io/gitlab/jobs/8790538002). The four Ashby dates matched the live feed; the three Greenhouse dates could not be freshly rechecked, although their archived local scan detail records recorded publication dates. One Clay date fell outside a *new* 30-day window on 1 October. This audit verifies neither recall nor all-date freshness.

Known limits: dynamic or access-restricted career sites can return `unknown`; a partial positive is not an exhaustive job list; `last_published` may mean a repost. Incomplete checks with zero verified jobs now return `unknown`, not a negative. Source-specific problems can be reported in the Actor's Issues tab. The public methodology and cohort are stated here; the detailed local report `QUALITY-BENCHMARK-2026-10-01.md` is included with the project deliverables. We will repeat the cohort and a seeded random job-link audit weekly while account capacity permits, retaining complete, partial and unknown counts separately.

**Post-change recheck, 1 October 2026, builds 2.0.5 and 2.0.7:** Five previously tested employers returned 1 complete positive (Linear, 4 jobs), 1 partial positive (Stripe, 16 jobs), and 3 unknown (Cloudflare, Automattic, Datadog). This focused subset shows no outcome-yield gain. Stripe's scanner time was 3.37 seconds versus 9.46 seconds in the previous run, but different source conditions and job mix prevent a general speed claim. Automattic's previously missed `work-with-us` jobs page and Datadog's previously missed `all-jobs` page were reached, yet neither supplied a verifiable posting date in the checked static source. Owner platform usage for the five checks was $0.001040; no owner `verified-report` events were charged and no customer revenue resulted.

### Call the hiring signals Actor from MCP, n8n, or an agent

**MCP agent.** Connect your client to `https://mcp.apify.com` using Apify OAuth or a funded token. Inspect `fetch-actor-details` directly with `{"actor":"impressionable_lupine/company-recent-job-openings","output":{"pricing":true,"inputSchema":true}}`. The public Store search returned this Actor first for its exact name on 1 October, while anonymous MCP search omitted it pending Apify's publisher eligibility check. Direct lookup by name works. The exact `call-actor` arguments are:

```json
{"actor":"impressionable_lupine/company-recent-job-openings","input":{"company_website":"linear.app","lookback_days":30},"waitSecs":30,"callOptions":{"maxTotalChargeUsd":0.03}}
```

`call-actor` returns run metadata, including `id`, `status`, and `defaultDatasetId`. When finished, call `get-dataset-items` with `{"datasetId":"<defaultDatasetId>","limit":1}`. On build 2.0.5, an owner-funded run on 1 October 2026 returned one report whose `signal_status` was `verified_recent_openings`, `job_count` was `4`, `coverage_complete` was `true`, and first job was [Design Engineer (Web & Brand)](https://jobs.ashbyhq.com/Linear/ea0b5868-6d7a-46fa-99d8-207cd19357a6) with `published_date` `2026-09-15T18:05:47.890Z`. This is observed output, not a promise that future results stay the same. Keep the run ID to avoid buying twice after a network timeout.

**n8n HTTP Request node.** Set method `POST`, URL `https://api.apify.com/v2/acts/impressionable_lupine~company-recent-job-openings/run-sync-get-dataset-items?maxTotalChargeUsd=0.03`, header `Authorization: Bearer <APIFY_TOKEN>`, header `Content-Type: application/json`, body type JSON, and exact body `{"company_website":"linear.app","lookback_days":30}`. This exact request was successfully tested on 1 October 2026 (HTTP 201). Its response was a one-item JSON array. A projection of that actual first item, suitable for an n8n Set node, was `{"signal_status":"verified_recent_openings","job_count":4,"coverage_complete":true,"billing_event":"verified-report","billing_quantity":1,"checked_at":"2026-10-01T09:31:50.876Z"}`; the full item also includes four dated jobs and source evidence. The first job was [Design Engineer (Web & Brand)](https://jobs.ashbyhq.com/Linear/ea0b5868-6d7a-46fa-99d8-207cd19357a6), published or republished `2026-09-15T18:05:47.890Z` and checked `2026-10-01T09:31:51.553Z`. The event field indicates this run qualifies for the $0.03 report event; it does not prove that the owner's own account incurred a buyer charge. Disable automatic retries for this purchase step; if the connection is lost, inspect Apify runs before starting another. The sync endpoint can time out after 300 seconds even if the Actor continues; use the asynchronous run endpoint for more resilient production flows.

Try the [public example task](https://apify.com/impressionable_lupine/company-recent-job-openings/examples/recent-hiring-sales-research) for the same one-company input and visible output fields.

**Sales-research agent.** Input `{"company_website":"linear.app","lookback_days":30}` with `maxTotalChargeUsd: 0.03`, then read one report. Example output to place in a brief from the 1 October owner test: “Linear had 4 source-verified recent listings in the checked public sources. One is [Design Engineer (Web & Brand)](https://jobs.ashbyhq.com/Linear/ea0b5868-6d7a-46fa-99d8-207cd19357a6), last published 2026-09-15T18:05:47.890Z and checked on 2026-10-01.” The checked time in a production brief must come from that job's `checked_at`, never from the date of this example. If `coverage_complete` is false, say the list is partial. If the result is `no_verified_recent_openings`, say only that no recent openings were verified **in checked public sources**. If it is `unknown`, omit any hiring assertion and follow `suggested_action`. Never turn `unknown` into “not hiring.” Maximum report event charge: **$0.03** for the one-company run; no report event for unknown or invalid input. A buyer's authenticated account may have separate account-level terms outside this Actor's event price.

For another source-backed company enrichment step, see [Verified Contact & Booking Signals](https://apify.com/impressionable_lupine/verified-contact-booking-signals), which checks a known business website for public contact and booking routes. It is a separate $0.01 verified-report purchase.

# Actor input Schema

## `company_website` (type: `string`):

Public company domain or URL. One company per report. We follow its careers/ATS links; no source credentials needed. Do not supply an ATS URL directly.

## `lookback_days` (type: `integer`):

Default 30. UTC calendar-day window; only source-verifiable publication dates qualify. Republication is explicitly labeled.

## `max_jobs` (type: `integer`):

Default 30; output cap 1–100. Partial positives cost one report; complete dated negatives also cost one report. Unknown/failed checks are free. Raising this cap does not increase the 40-request budget.

## Actor input object example

```json
{
  "company_website": "https://linear.app",
  "lookback_days": 30,
  "max_jobs": 30
}
```

# Actor output Schema

## `report` (type: `string`):

JSON v2: status, signal\_status, jobs with date/source/check time, coverage\_complete, stable errors and billing eligibility. success/partial/no\_result/invalid\_input/upstream\_error. Full contract is report.schema.json in source.

## `reports` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "company_website": "https://linear.app"
};

// Run the Actor and wait for it to finish
const run = await client.actor("impressionable_lupine/company-recent-job-openings").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "company_website": "https://linear.app" }

# Run the Actor and wait for it to finish
run = client.actor("impressionable_lupine/company-recent-job-openings").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "company_website": "https://linear.app"
}' |
apify call impressionable_lupine/company-recent-job-openings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,impressionable_lupine/company-recent-job-openings"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DnTJ0PiYO5uNHgDKK/builds/BAOC7v8dbeqoYFIap/openapi.json