# Jobvite Jobs Scraper (`jobsapi/jobvite-jobs-search-scraper`) Actor

Scrape public Jobvite-hosted company career sites into structured job records with descriptions, salary when published, job IDs, locations, employment type, and apply links.

- **URL**: https://apify.com/jobsapi/jobvite-jobs-search-scraper.md
- **Developed by:** [Jobs API](https://apify.com/jobsapi) (community)
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 jobvite career roles

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Jobvite Jobs Search Scraper

This Actor reads ordinary public listings and job details hosted on Jobvite career sites. It does not sign in, submit applications, read candidate data, use cookies, or alter browser/network fingerprints. The default board is [Reveal Careers](https://jobs.jobvite.com/reveal/jobs).

The Actor requests board and detail pages sequentially, with a minimum 250 ms gap. If an ordinary public request receives HTTP 401, 403, 429, or 451, or a visible source-authored access-denial/CAPTCHA/security challenge, it stops immediately, discards buffered job rows, and records `resultStatus: SKIPPED`, the diagnostic, and request receipts in the key-value store. It does not retry a blocked request, switch identities/routes/browsers, or solve challenges. A generic transport failure or proxy-auth response is recorded as `DEFERRED`, not treated as proof the site blocked access.

`status` and `runStatus` describe the Apify platform outcome (`SUCCEEDED` or `FAILED`); `resultStatus` describes the data outcome (`COMPLETE`, `LIMITED`, `SKIPPED`, `DEFERRED`, `NO_DATA`, or `FAILED`). A confirmed source barrier is a successfully handled run, so the platform status remains `SUCCEEDED` while the result is `SKIPPED`. Fatal zero-row processing failures use `FAILED` and call `Actor.fail`. If later processing or persistence fails after dataset writes succeeded, those rows remain stored and the result is `LIMITED`.

### Modes and inputs

Search a public board and enrich results from their detail pages:

```json
{
  "mode": "search",
  "companySlugs": ["reveal"],
  "maxItems": 2,
  "includeDetails": true,
  "maxRequests": 20,
  "requestDelayMs": 1000
}
```

Fetch one page verified in Chrome, [Director, Customer Success](https://jobs.jobvite.com/reveal/job/o9BrAfwv):

```json
{
  "mode": "single",
  "jobUrl": "https://jobs.jobvite.com/reveal/job/o9BrAfwv"
}
```

For several explicit public details, use `mode: "multiple"` and `jobUrls` as objects such as `{ "url": "https://jobs.jobvite.com/reveal/job/o9BrAfwv" }`. The `jobUrl` alias accepts one URL string. Search mode accepts listing URLs and company slugs, not detail URLs. Single mode requires exactly one valid Jobvite detail URL; multiple mode requires at least one. Unknown fields are rejected. In particular, there are no public `userAgent` or concurrency controls.

`query`, `locations`, and `categories` are case-insensitive filters. `includeDetails` defaults to true; set it to false only when listing links are sufficient. `maxItems` limits emitted records, and `maxRequests` caps explicit page-fetch attempts, including transient retries. Fetch automatically follows redirects, so redirect hops may add network requests outside this cap and are not receipted individually. The Actor retries only HTTP 408, 425, and 5xx responses; it does not retry proxy-auth responses or transport exceptions. Developer options are bounded: `requestDelayMs` (250–5000; default 500), `maxRetries` (0–4; default 2 for those transient HTTP responses), `timeoutMs` (5–120 seconds), `maxResponseBytes` (100 KB–50 MB), and `maxDescriptionChars` (1,000–500,000). HTTP 401, 403, 429, 451 and visible source-authored challenges are never retried.

### Dataset fields

Detail records use public JobPosting JSON-LD and visible page markup when present. Extracted facts include the stable job ID, title, company and published organization details, category, structured location parts, employment/workplace type, full description and sectioned responsibilities/requirements/benefits, keywords, published salary, application link, dates, public media, and page title/description. Fields absent from a particular public posting are omitted, not fabricated. Each emitted posting reports `dataQuality.meaningfulSourceFieldCount`; only detail-enriched `job-posting` records with at least 21 distinct meaningful source facts are emitted. Listing-only links, summary rows, and diagnostics never enter the dataset. Request receipts belong in the `REQUEST_RECEIPTS` key-value record (also summarized as `sourceCalls`); diagnostics belong in `RUN_DIAGNOSTICS`.

Run evidence is written to `OUTPUT` and `OUTPUT_SUMMARY`; access/request diagnostics are in `RUN_DIAGNOSTICS`, request receipts are in `REQUEST_RECEIPTS`, the source policy is in `SOURCE_METADATA`, and health information is in `RUN_HEALTH`. Setting `includeDetails: false` prevents detail verification, so no listing-only rows are emitted and the result is `DEFERRED`. Application URLs are reported but never followed or submitted.

### Local development

```powershell
npm ci
npm test
npm run check
apify validate-schema
```

The checked-in `INPUT.json`, `INPUT-single.json`, and `INPUT-multiple.json` are bounded public examples. For each local run, choose a new actor-relative storage directory that does not already exist; never reuse an existing dataset directory or use `--purge`:

```powershell
Test-Path .\storage-jobvite-run-01
$env:APIFY_LOCAL_STORAGE_DIR = 'storage-jobvite-run-01'
apify run --resurrect --input-file .\INPUT.json
npm run validate -- .\storage-jobvite-run-01
```

If `Test-Path` reports `True`, choose a different fresh relative directory before running. Local results do not qualify or imply an Apify Cloud run; this repository has not been Cloud-qualified.

This independent Actor is not affiliated with Jobvite or Reveal. Use it only for public job information and in accordance with the source site's terms and applicable law.

# Actor input Schema

## `mode` (type: `string`):

Search public boards, fetch one direct public job page, or fetch multiple direct public job pages.

## `companySlugs` (type: `array`):

Public Jobvite career-site names used at https://jobs.jobvite.com/{slug}/jobs. Do not include private or authenticated sites.

## `startUrls` (type: `array`):

Optional HTTPS jobs.jobvite.com board URLs such as https://jobs.jobvite.com/reveal/jobs. These are combined with companySlugs and deduplicated.

## `jobUrls` (type: `array`):

Public Jobvite job detail pages. Use one for single mode or several for multiple mode.

## `jobUrl` (type: `string`):

Alias for one direct public Jobvite job URL.

## `urls` (type: `array`):

Alias for direct public Jobvite job URLs.

## `query` (type: `string`):

Optional case-insensitive all-terms filter applied to the public title, category, location, and description.

## `locations` (type: `array`):

Optional case-insensitive terms matched against public job locations.

## `categories` (type: `array`):

Optional case-insensitive terms matched against public Jobvite category headings.

## `maxItems` (type: `integer`):

Hard cap on job records emitted across all supplied boards.

## `includeDetails` (type: `boolean`):

Fetch each bounded public detail page sequentially to recover full description, JobPosting metadata, salary when published, and the Jobvite apply URL. When disabled, search results are emitted as listing links only.

## `maxRequests` (type: `integer`):

Cap on explicit board/detail fetch attempts and transient retries. Automatic redirects are followed and may add network hops outside this count and individual receipts.

## `requestDelayMs` (type: `integer`):

Minimum delay between public Jobvite requests.

## `maxRetries` (type: `integer`):

Retries for transient public HTTP failures only.

## `timeoutMs` (type: `integer`):

Timeout for one public Jobvite HTML request.

## `maxResponseBytes` (type: `integer`):

Safety cap for one public board or detail response.

## `maxDescriptionChars` (type: `integer`):

Bound the stored plain-text description while preserving the start of the public JobPosting description.

## `emitOnlyChanged` (type: `boolean`):

When enabled, compare stable recordId and contentHash values with knownRecordHashes and skip unchanged public postings.

## `knownRecordHashes` (type: `object`):

Optional object mapping prior recordId values to contentHash values for incremental monitoring.

## Actor input object example

```json
{
  "mode": "search",
  "companySlugs": [
    "reveal"
  ],
  "startUrls": [],
  "jobUrls": [],
  "urls": [],
  "query": "",
  "locations": [],
  "categories": [],
  "maxItems": 25,
  "includeDetails": true,
  "maxRequests": 100,
  "requestDelayMs": 500,
  "maxRetries": 2,
  "timeoutMs": 30000,
  "maxResponseBytes": 10000000,
  "maxDescriptionChars": 100000,
  "emitOnlyChanged": false,
  "knownRecordHashes": {}
}
```

# Actor output Schema

## `output` (type: `string`):

No description

## `dataset` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `sourceMetadata` (type: `string`):

No description

## `runHealth` (type: `string`):

No description

## `runDiagnostics` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("jobsapi/jobvite-jobs-search-scraper").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("jobsapi/jobvite-jobs-search-scraper").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 '{}' |
apify call jobsapi/jobvite-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jobsapi/jobvite-jobs-search-scraper"
        }
    }
}
```

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/S9GcXLjREvxrQBWKw/builds/VywwJXkhrinslyOtI/openapi.json
